38 changed files with 2157 additions and 2494 deletions
--- a/2
+++ b/2
@ -1 +1 @@
-Subproject commit 0116cd68cdfdf383823f74e0f9665a1700cf0500
+Subproject commit 0041ec3d9a174955383836bba02caf79f3961072
--- a/dependencies.lock
+++ b/dependencies.lock
@ -4,6 +4,6 @@ dependencies:
    source:
      type: idf
    version: 4.4.7
-manifest_hash: 1d4ef353a86901733b106a1897b186dbf9fc091a4981f0560ea2f6899b7a3d44
+manifest_hash: cd2f3ee15e776d949eb4ea4eddc8f39b30c2a7905050850eed01ab4928143cff
 target: esp32s3
 version: 1.0.0
--- a/lib/btclock/bitaxe_handler.cpp
+++ b/lib/btclock/bitaxe_handler.cpp
@ -1,20 +1,14 @@
 #include "bitaxe_handler.hpp"

-std::array<std::string, NUM_SCREENS> parseBitaxeHashRate(uint64_t hashrate)
+std::array<std::string, NUM_SCREENS> parseBitaxeHashRate(std::string text)
 {
    std::array<std::string, NUM_SCREENS> ret;
    ret.fill(""); // Initialize all elements to empty strings

-    // Convert hashrate to GH/s and round to nearest integer
-    double hashRateGH = static_cast<double>(hashrate) / std::pow(10, getHashrateMultiplier('G'));
-    std::string hashRateStr = std::to_string(static_cast<uint64_t>(std::round(hashRateGH)));
-
-    // Place the icons
-    ret[0] = "mdi:bitaxe";
-    ret[NUM_SCREENS - 1] = "GH/S";
+    std::size_t textLength = text.length();

    // Calculate the position where the digits should start
-    std::size_t textLength = hashRateStr.length();
+    // Account for the position of the "mdi:pickaxe" and the "GH/S" label
    std::size_t startIndex = NUM_SCREENS - 1 - textLength;

    // Insert the "mdi:pickaxe" icon just before the digits
@ -23,64 +17,34 @@ std::array<std::string, NUM_SCREENS> parseBitaxeHashRate(uint64_t hashrate)
        ret[startIndex - 1] = "mdi:pickaxe";
    }

-    // Place each digit
+    // Place the digits
    for (std::size_t i = 0; i < textLength; ++i)
    {
-        ret[startIndex + i] = std::string(1, hashRateStr[i]);
+        ret[startIndex + i] = text.substr(i, 1);
    }

+    ret[NUM_SCREENS - 1] = "GH/S";
+    ret[0] = "mdi:bitaxe";
+
    return ret;
 }

-std::array<std::string, NUM_SCREENS> parseBitaxeBestDiff(uint64_t difficulty)
+std::array<std::string, NUM_SCREENS> parseBitaxeBestDiff(std::string text)
 {
    std::array<std::string, NUM_SCREENS> ret;
-    ret.fill("");
+    std::uint32_t firstIndex = 0;

-    // Add icons at the start
-    ret[0] = "mdi:bitaxe";
-    ret[1] = "mdi:rocket";
-
-    if (difficulty == 0) {
-        ret[NUM_SCREENS - 1] = "0";
-        return ret;
-    }
-
-    // Find the appropriate suffix and format the number
-    const std::pair<char, int> suffixes[] = {
-        {'Q', 15}, {'T', 12}, {'G', 9}, {'M', 6}, {'K', 3}
-    };
-
-    std::string text;
-    for (const auto& suffix : suffixes) {
-        if (difficulty >= std::pow(10, suffix.second)) {
-            double value = difficulty / std::pow(10, suffix.second);
-            char buffer[32];
-            snprintf(buffer, sizeof(buffer), "%.1f", value);
-            text = buffer;
-            // Remove trailing zeros and decimal point if not needed
-            if (text.find('.') != std::string::npos) {
-                text = text.substr(0, text.find_last_not_of('0') + 1);
-                if (text.back() == '.') {
-                    text.pop_back();
-                }
-            }
-            text += suffix.first;
-            break;
-        }
-    }
-
-    if (text.empty()) {
-        text = std::to_string(difficulty);
-    }
-
-    // Calculate start position to right-align the text
-    std::size_t startIndex = NUM_SCREENS - text.length();
-    
-    // Place the formatted difficulty string
-    for (std::size_t i = 0; i < text.length() && (startIndex + i) < NUM_SCREENS; ++i)
+    if (text.length() < NUM_SCREENS)
    {
-        ret[startIndex + i] = std::string(1, text[i]);
+        text.insert(text.begin(), NUM_SCREENS - text.length(), ' ');
+        ret[0] = "mdi:bitaxe";
+        ret[1] = "mdi:rocket";
+        firstIndex = 2;
+    }
+
+    for (std::uint8_t i = firstIndex; i < NUM_SCREENS; i++)
+    {
+        ret[i] = text[i];
    }

    return ret;
--- a/lib/btclock/bitaxe_handler.hpp
+++ b/lib/btclock/bitaxe_handler.hpp
@ -1,7 +1,5 @@
 #include <array>
 #include <string>
-#include <cstdint>
-#include "utils.hpp"

-std::array<std::string, NUM_SCREENS> parseBitaxeHashRate(uint64_t hashrate);
-std::array<std::string, NUM_SCREENS> parseBitaxeBestDiff(uint64_t difficulty);
+std::array<std::string, NUM_SCREENS> parseBitaxeHashRate(std::string text);
+std::array<std::string, NUM_SCREENS> parseBitaxeBestDiff(std::string text);
--- a/lib/btclock/utils.cpp
+++ b/lib/btclock/utils.cpp
@ -243,14 +243,3 @@ int getHashrateMultiplier(char unit) {
    };
    return multipliers.at(unit);
 }
-
-int getDifficultyMultiplier(char unit) {
-    if (unit == '0')
-        return 0;
-
-    static const std::unordered_map<char, int> multipliers = {
-        {'Q', 15}, {'T', 12}, {'B', 9}, {'M', 6}, {'K', 3}, {'G', 9},
-        {'q', 15}, {'t', 12}, {'b', 9}, {'m', 6}, {'k', 3}, {'g', 9}
-    };
-    return multipliers.at(unit);
-}
--- a/lib/btclock/utils.hpp
+++ b/lib/btclock/utils.hpp
@ -16,5 +16,4 @@ std::string formatNumberWithSuffix(std::uint64_t num, int numCharacters = 4);
 std::string formatNumberWithSuffix(std::uint64_t num, int numCharacters, bool mowMode);
 int64_t getAmountInSatoshis(std::string bolt11);
 void parseHashrateString(const std::string& hashrate, std::string& label, std::string& output, unsigned int maxCharacters);
-int getHashrateMultiplier(char unit);
-int getDifficultyMultiplier(char unit);
+int getHashrateMultiplier(char unit);
--- a/platformio.ini
+++ b/platformio.ini
@ -15,7 +15,7 @@ default_envs = lolin_s3_mini_213epd, lolin_s3_mini_29epd, btclock_rev_b_213epd,
 [env]

 [btclock_base]
-platform = espressif32 @ ^6.10.0
+platform = espressif32 @ ^6.9.0
 framework = arduino, espidf
 monitor_speed = 115200
 monitor_filters = esp32_exception_decoder, colorize
@ -30,17 +30,17 @@ build_flags =
 	-DLAST_BUILD_TIME=$UNIX_TIME
 	-DARDUINO_USB_CDC_ON_BOOT
 	-DCORE_DEBUG_LEVEL=0
-	-D CONFIG_ASYNC_TCP_STACK_SIZE=16384
+	-D DEFAULT_BOOT_TEXT=\"BTCLOCK\"
 	-fexceptions
 build_unflags = 
 	-Werror=all
 	-fno-exceptions
 lib_deps = 
-	https://github.com/joltwallet/esp_littlefs.git#v1.16.4
-	bblanchon/ArduinoJson@^7.3.0
-	esp32async/ESPAsyncWebServer @ 3.7.0
-	robtillaart/MCP23017@^0.9.0
-	adafruit/Adafruit NeoPixel@^1.12.4
+	https://github.com/joltwallet/esp_littlefs.git
+	bblanchon/ArduinoJson@^7.2.1
+	mathieucarbou/ESPAsyncWebServer @ 3.3.23
+	robtillaart/MCP23017@^0.8.0
+	adafruit/Adafruit NeoPixel@^1.12.3
 	https://github.com/dsbaars/universal_pin#feature/mcp23017_rt
 	https://github.com/dsbaars/GxEPD2#universal_pin
 	https://github.com/tzapu/WiFiManager.git#v2.0.17
@ -79,10 +79,9 @@ build_flags =
 	-D I2C_SDA_PIN=35
 	-D I2C_SCK_PIN=36
 	-D HAS_FRONTLIGHT
-	-D PCA_OE_PIN=48
+	-D PCA_OE_PIN=45
 	-D PCA_I2C_ADDR=0x42
 	-D IS_HW_REV_B
-
 lib_deps = 
 	${btclock_base.lib_deps}
 	robtillaart/PCA9685@^0.7.1
@ -101,7 +100,6 @@ build_flags =
 	-D USE_QR
 	-D VERSION_EPD_2_13
 	-D HW_REV=\"REV_A_EPD_2_13\"
-	-D CONFIG_ARDUINO_MAIN_TASK_STACK_SIZE=16384
 platform_packages = 
 	platformio/tool-mklittlefs@^1.203.210628
 	earlephilhower/tool-mklittlefs-rp2040-earlephilhower@^5.100300.230216
@ -114,7 +112,6 @@ build_flags =
 	-D USE_QR
 	-D VERSION_EPD_2_13
 	-D HW_REV=\"REV_B_EPD_2_13\"
-	-D CONFIG_ARDUINO_MAIN_TASK_STACK_SIZE=16384
 platform_packages = 
 	platformio/tool-mklittlefs@^1.203.210628
 	earlephilhower/tool-mklittlefs-rp2040-earlephilhower@^5.100300.230216
--- a/src/fonts/sats-symbol.h
+++ b/src/fonts/sats-symbol.h
@ -1,235 +1,201 @@
-#pragma once
-
-#include <Adafruit_GFX.h>
-#include <Arduino.h>
-#include "fonts.hpp"
-
-const uint8_t Satoshi_Symbol90pt7bBitmaps_Gzip[] = {
-  0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x63, 0x60,
-  0x60, 0x60, 0xe0, 0xff, 0xc7, 0x00, 0x05, 0xcc, 0xff, 0x1b, 0x60, 0xcc,
-  0xff, 0x0f, 0x60, 0x2c, 0xfb, 0x1f, 0x30, 0xd6, 0x60, 0x53, 0x38, 0x28,
-  0x81, 0xfd, 0x7f, 0x3a, 0x83, 0x81, 0xf6, 0x30, 0x1a, 0xe0, 0xa7, 0xb7,
-  0xff, 0x0f, 0x0c, 0xb4, 0x8f, 0x51, 0x01, 0x33, 0xbd, 0xfd, 0xff, 0x61,
-  0xa0, 0x7d, 0x8c, 0x17, 0x0c, 0x8e, 0x92, 0x82, 0x44, 0x85, 0x54, 0x8f,
-  0x23, 0x88, 0xe1, 0xec, 0xff, 0xa1, 0x56, 0xf2, 0xff, 0xff, 0x03, 0x61,
-  0xc8, 0xff, 0x87, 0x3a, 0xc7, 0x1e, 0x16, 0x8d, 0xf5, 0x30, 0xa7, 0xc2,
-  0x12, 0x36, 0xe3, 0x7f, 0xa8, 0xeb, 0x98, 0x47, 0x8d, 0x19, 0x35, 0x66,
-  0x78, 0x1b, 0x43, 0x65, 0xf0, 0x00, 0x00, 0xc7, 0x63, 0x9f, 0x4b, 0xde,
-  0x08, 0x00, 0x00
-};
-// unsigned int satoshi_bin_gz_len = 123;
-
-
-// const uint8_t Satoshi_Symbol90pt7bBitmaps[] PROGMEM = {
-//   0x00, 0x00, 0x00, 0x00, 0x0F, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x03, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F,
-//   0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFE, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0x80, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x3F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x0F, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x03, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
-//   0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xF8, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFE, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x3F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x0F, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF,
-//   0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x3F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x0F, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF,
-//   0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xE0, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xF8, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x03, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x3F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFE,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0x80, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xE0, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x0F, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x03, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFE,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFC, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x1F, 0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x3F, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xE0,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x01, 0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-//   0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFE, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFC, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x1F, 0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F,
-//   0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xE0, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x01, 0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF,
-//   0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFE, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x1F, 0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF,
-//   0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xE0, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x01, 0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFE, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x1F, 0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xF0,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xE0, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
-//   0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x0F, 0xFF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F,
-//   0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xF0, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF,
-//   0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x0F, 0xFF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF,
-//   0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xF0, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF,
-//   0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x07, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x0F, 0xFF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xF8,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xF0, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x7F, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0x80,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x07, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F,
-//   0xFF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xF8, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x7F, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
-//   0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0x80, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x07, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF,
-//   0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xF8, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x7F, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF,
-//   0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0x80, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x07, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFC,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xF8, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x3F, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-//   0x7F, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xC0,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x03, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
-//   0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFC, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x00, 0x3F, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F,
-//   0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xC0, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00,
-//   0x00, 0x03, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF,
-//   0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFC, 0x00, 0x00,
-//   0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-//   0xFF, 0xE0 };
+const uint8_t Satoshi_Symbol90pt7bBitmaps[] PROGMEM = {
+  0x00, 0x00, 0x00, 0x00, 0x0F, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x03, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F,
+  0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFE, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0x80, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x3F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x0F, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+  0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xF8, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFE, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x3F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0F, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF,
+  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x3F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0F, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF,
+  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xE0, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xF8, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x03, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x3F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFE,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0x80, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xE0, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x0F, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x03, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFE,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFC, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x1F, 0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x3F, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xE0,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x01, 0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+  0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFE, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFC, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x1F, 0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F,
+  0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xE0, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x01, 0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF,
+  0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFE, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x1F, 0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF,
+  0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xE0, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFE, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x1F, 0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xF0,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xE0, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+  0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x0F, 0xFF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F,
+  0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xF0, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF,
+  0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x0F, 0xFF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF,
+  0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xF0, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF,
+  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x07, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0F, 0xFF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xF8,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xF0, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x7F, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x07, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F,
+  0xFF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xF8, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x7F, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+  0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0x80, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x07, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF,
+  0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xF8, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x7F, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF,
+  0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0x80, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x07, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFC,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xF8, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x3F, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x7F, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xC0,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x03, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+  0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFC, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x3F, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F,
+  0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xC0, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x03, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF,
+  0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFC, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xE0 };

 const GFXglyph Satoshi_Symbol90pt7bGlyphs[] PROGMEM = {
  {     0,  82, 127,  99,    8, -126 },  {  1302,  71, 109,  93,    0, -117 } }; // 0x53 'S'

-// const GFXfont Satoshi_Symbol90pt7b PROGMEM = {
-//   (uint8_t  *)Satoshi_Symbol90pt7bBitmaps,
-//   (GFXglyph *)Satoshi_Symbol90pt7bGlyphs,
-//   0x53, 0x53, 192 };
-
-  // Font properties
-static constexpr FontData Satoshi_Symbol90pt7b_Properties = {
-    Satoshi_Symbol90pt7bBitmaps_Gzip,
-    Satoshi_Symbol90pt7bGlyphs,
-    sizeof(Satoshi_Symbol90pt7bBitmaps_Gzip),
-    2270,  // Original size
-    0x53,   // First char
-    0x53,   // Last char
-    192    // yAdvance
-};
-
+const GFXfont Satoshi_Symbol90pt7b PROGMEM = {
+  (uint8_t  *)Satoshi_Symbol90pt7bBitmaps,
+  (GFXglyph *)Satoshi_Symbol90pt7bGlyphs,
+  0x53, 0x53, 192 };

 // Approx. 2284 bytes
--- a/src/lib/bitaxe_fetch.cpp
+++ b/src/lib/bitaxe_fetch.cpp
@ -1,19 +1,24 @@
 #include "bitaxe_fetch.hpp"

-void BitAxeFetch::taskWrapper(void* pvParameters) {
-    BitAxeFetch::getInstance().task();
+TaskHandle_t bitaxeFetchTaskHandle;
+
+std::string bitaxeHashrate;
+std::string bitaxeBestDiff;
+
+std::string getBitAxeHashRate()
+{
+    return bitaxeHashrate;
 }

-uint64_t BitAxeFetch::getHashRate() const {
-    return hashrate;
+std::string getBitaxeBestDiff()
+{
+    return bitaxeBestDiff;
 }

-uint64_t BitAxeFetch::getBestDiff() const {
-    return bestDiff;
-}
-
-void BitAxeFetch::task() {
-    for (;;) {
+void taskBitaxeFetch(void *pvParameters)
+{
+    for (;;)
+    {
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);

        HTTPClient http;
@ -23,38 +28,34 @@ void BitAxeFetch::task() {

        int httpCode = http.GET();

-        if (httpCode == 200) {
+        if (httpCode == 200)
+        {
            String payload = http.getString();
            JsonDocument doc;
            deserializeJson(doc, payload);
-            
-            // Convert GH/s to H/s (multiply by 10^9)
-            float hashRateGH = doc["hashRate"].as<float>();
-            hashrate = static_cast<uint64_t>(std::round(hashRateGH * std::pow(10, getHashrateMultiplier('G'))));
-            
-            // Parse difficulty string and convert to uint64_t
-            std::string diffStr = doc["bestDiff"].as<std::string>();
-            char diffUnit = diffStr[diffStr.length() - 1];
-            if (std::isalpha(diffUnit)) {
-                float diffValue = std::stof(diffStr.substr(0, diffStr.length() - 1));
-                bestDiff = static_cast<uint64_t>(std::round(diffValue * std::pow(10, getDifficultyMultiplier(diffUnit))));
-            } else {
-                bestDiff = std::stoull(diffStr);
-            }
+            bitaxeHashrate = std::to_string(static_cast<int>(std::round(doc["hashRate"].as<float>())));
+            bitaxeBestDiff = doc["bestDiff"].as<std::string>();

-            if (workQueue != nullptr && (ScreenHandler::getCurrentScreen() == SCREEN_BITAXE_HASHRATE || ScreenHandler::getCurrentScreen() == SCREEN_BITAXE_BESTDIFF)) {
+            if (workQueue != nullptr && (ScreenHandler::getCurrentScreen() == SCREEN_BITAXE_HASHRATE || ScreenHandler::getCurrentScreen() == SCREEN_BITAXE_BESTDIFF))
+            {
                WorkItem priceUpdate = {TASK_BITAXE_UPDATE, 0};
                xQueueSend(workQueue, &priceUpdate, portMAX_DELAY);
            }
-        } else {
-            Serial.print(F("Error retrieving BitAxe data. HTTP status code: "));
+        }
+        else
+        {
+            Serial.print(
+                F("Error retrieving BitAxe data. HTTP status code: "));
            Serial.println(httpCode);
            Serial.println(bitaxeApiUrl);
        }
    }
 }

-void BitAxeFetch::setup() {
-    xTaskCreate(taskWrapper, "bitaxeFetch", (3 * 1024), NULL, tskIDLE_PRIORITY, &taskHandle);
-    xTaskNotifyGive(taskHandle);
+void setupBitaxeFetchTask()
+{
+    xTaskCreate(taskBitaxeFetch, "bitaxeFetch", (3 * 1024), NULL, tskIDLE_PRIORITY,
+                &bitaxeFetchTaskHandle);
+
+    xTaskNotifyGive(bitaxeFetchTaskHandle);
 }
--- a/src/lib/bitaxe_fetch.hpp
+++ b/src/lib/bitaxe_fetch.hpp
@ -2,33 +2,14 @@

 #include <Arduino.h>
 #include <HTTPClient.h>
-#include <utils.hpp>

 #include "lib/config.hpp"
 #include "lib/shared.hpp"

-class BitAxeFetch {
-public:
-    static BitAxeFetch& getInstance() {
-        static BitAxeFetch instance;
-        return instance;
-    }
+extern TaskHandle_t bitaxeFetchTaskHandle;

-    void setup();
-    uint64_t getHashRate() const;
-    uint64_t getBestDiff() const;
-    static void taskWrapper(void* pvParameters);
-    TaskHandle_t getTaskHandle() const { return taskHandle; }
+void setupBitaxeFetchTask();
+void taskBitaxeFetch(void *pvParameters);

-private:
-    BitAxeFetch() = default;
-    ~BitAxeFetch() = default;
-    BitAxeFetch(const BitAxeFetch&) = delete;
-    BitAxeFetch& operator=(const BitAxeFetch&) = delete;
-
-    void task();
-    
-    TaskHandle_t taskHandle = nullptr;
-    uint64_t hashrate = 0;
-    uint64_t bestDiff = 0;
-};
+std::string getBitAxeHashRate();
+std::string getBitaxeBestDiff();
--- a/src/lib/block_notify.cpp
+++ b/src/lib/block_notify.cpp
@ -1,14 +1,13 @@
 #include "block_notify.hpp"

-// Initialize static members
-esp_websocket_client_handle_t BlockNotify::wsClient = nullptr;
-uint32_t BlockNotify::currentBlockHeight = 878000;
-uint16_t BlockNotify::blockMedianFee = 1;
-bool BlockNotify::notifyInit = false;
-unsigned long int BlockNotify::lastBlockUpdate = 0;
-TaskHandle_t BlockNotify::taskHandle = nullptr;
+char *wsServer;
+esp_websocket_client_handle_t blockNotifyClient = NULL;
+uint currentBlockHeight = 873400;
+uint blockMedianFee = 1;
+bool blockNotifyInit = false;
+unsigned long int lastBlockUpdate;

-const char* BlockNotify::mempoolWsCert = R"EOF(
+const char *mempoolWsCert = R"EOF(
 -----BEGIN CERTIFICATE-----
 MIIF3jCCA8agAwIBAgIQAf1tMPyjylGoG7xkDjUDLTANBgkqhkiG9w0BAQwFADCB
 iDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0pl
@ -43,255 +42,256 @@ VXyNWQKV3WKdwrnuWih0hKWbt5DHDAff9Yk2dDLWKMGwsAvgnEzDHNb842m1R0aB
 L6KCq9NjRHDEjf8tM7qtj3u1cIiuPhnPQCjY/MiQu12ZIvVS5ljFH4gxQ+6IHdfG
 jjxDah2nGN59PRbxYvnKkKj9
 -----END CERTIFICATE-----
-
-----BEGIN CERTIFICATE-----
-MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
-TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
-cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
-WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
-ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
-MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
-h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
-0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
-A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
-T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
-B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
-B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
-KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
-OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
-jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
-qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
-rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
-HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
-hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
-ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
-3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
-NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
-ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
-TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
-jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
-oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
-4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
-mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
-emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
-----END CERTIFICATE-----
 )EOF";

-void BlockNotify::onWebsocketEvent(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data) {
-    esp_websocket_event_data_t *data = (esp_websocket_event_data_t *)event_data;
-    BlockNotify& instance = BlockNotify::getInstance();
+void setupBlockNotify()
+{
+  IPAddress result;

-    switch (event_id) {
-        case WEBSOCKET_EVENT_CONNECTED:
-        {
-            notifyInit = true;
-            Serial.print(F("Connected to "));
-            Serial.println(preferences.getString("mempoolInstance", DEFAULT_MEMPOOL_INSTANCE));
+  int dnsErr = -1;
+  String mempoolInstance =
+      preferences.getString("mempoolInstance", DEFAULT_MEMPOOL_INSTANCE);

-            JsonDocument doc;
-            doc["action"] = "want";
-            JsonArray dataArray = doc.createNestedArray("data");
-            dataArray.add("blocks");
-            dataArray.add("mempool-blocks");
-            
-            String sub;
-            serializeJson(doc, sub);
-            esp_websocket_client_send_text(wsClient, sub.c_str(), sub.length(), portMAX_DELAY);
-            break;
-        }
-        case WEBSOCKET_EVENT_DATA:
-            instance.onWebsocketMessage(data);
-            break;
+  while (dnsErr != 1 &&  !strchr(mempoolInstance.c_str(), ':'))
+  {
+    dnsErr = WiFi.hostByName(mempoolInstance.c_str(), result);

-        case WEBSOCKET_EVENT_DISCONNECTED:
-            Serial.println(F("Mempool.space WS Connection Closed"));
-            break;
-
-        case WEBSOCKET_EVENT_ERROR:
-            Serial.println(F("Mempool.space WS Connection Error"));
-            break;
-    }
-}
-
-void BlockNotify::onWebsocketMessage(esp_websocket_event_data_t *data) {
-    JsonDocument doc;
-    JsonDocument filter;
-    filter["block"]["height"] = true;
-    filter["mempool-blocks"][0]["medianFee"] = true;
-
-    deserializeJson(doc, (char*)data->data_ptr, DeserializationOption::Filter(filter));
-
-    if (doc["block"].is<JsonObject>()) {
-        JsonObject block = doc["block"];
-        if (block["height"].as<uint>() != currentBlockHeight) {
-            processNewBlock(block["height"].as<uint>());
-        }
-    }
-    else if (doc["mempool-blocks"].is<JsonArray>()) {
-        JsonArray blockInfo = doc["mempool-blocks"].as<JsonArray>();
-        uint medianFee = (uint)round(blockInfo[0]["medianFee"].as<double>());
-        processNewBlockFee(medianFee);
-    }
-}
-
-void BlockNotify::setup() {
-    IPAddress result;
-    int dnsErr = -1;
-    String mempoolInstance = preferences.getString("mempoolInstance", DEFAULT_MEMPOOL_INSTANCE);
-
-    while (dnsErr != 1 && !strchr(mempoolInstance.c_str(), ':')) {
-        dnsErr = WiFi.hostByName(mempoolInstance.c_str(), result);
-
-        if (dnsErr != 1) {
-            Serial.print(mempoolInstance);
-            Serial.println(F("mempool DNS could not be resolved"));
-            WiFi.reconnect();
-            vTaskDelay(pdMS_TO_TICKS(1000));
-        }
-    }
-
-    // Get current block height through regular API
-    int blockFetch = fetchLatestBlock();
-
-    if (blockFetch > currentBlockHeight)
-        currentBlockHeight = blockFetch;
-
-    if (currentBlockHeight != -1) {
-        lastBlockUpdate = esp_timer_get_time() / 1000000;
-    }
-
-    if (workQueue != nullptr) {
-        WorkItem blockUpdate = {TASK_BLOCK_UPDATE, 0};
-        xQueueSend(workQueue, &blockUpdate, portMAX_DELAY);
-    }
-
-    const bool useSSL = preferences.getBool("mempoolSecure", DEFAULT_MEMPOOL_SECURE);
-    const String protocol = useSSL ? "wss" : "ws";
-    String wsUri = protocol + "://" + mempoolInstance + "/api/v1/ws";
-
-    esp_websocket_client_config_t config = {
-        .task_stack = (6*1024),
-        .user_agent = USER_AGENT
-    };
-
-    if (useSSL) {
-        config.cert_pem = mempoolWsCert;
-    }
-
-    config.uri = wsUri.c_str();
-
-    Serial.printf("Connecting to %s\r\n", mempoolInstance.c_str());
-
-    wsClient = esp_websocket_client_init(&config);
-    esp_websocket_register_events(wsClient, WEBSOCKET_EVENT_ANY, onWebsocketEvent, wsClient);
-    esp_websocket_client_start(wsClient);
-}
-
-
-
-void BlockNotify::processNewBlock(uint32_t newBlockHeight) {
-    if (newBlockHeight <= currentBlockHeight)
+    if (dnsErr != 1)
    {
-        return;
+      Serial.print(mempoolInstance);
+      Serial.println(F("mempool DNS could not be resolved"));
+      WiFi.reconnect();
+      vTaskDelay(pdMS_TO_TICKS(1000));
+    }
+  }
+
+  // Get current block height through regular API
+  int blockFetch = getBlockFetch();
+
+  if (blockFetch > currentBlockHeight)
+    currentBlockHeight = blockFetch;
+
+  if (currentBlockHeight != -1)
+  {
+    lastBlockUpdate = esp_timer_get_time() / 1000000;
+  }
+
+  if (workQueue != nullptr)
+  {
+    WorkItem blockUpdate = {TASK_BLOCK_UPDATE, 0};
+    xQueueSend(workQueue, &blockUpdate, portMAX_DELAY);
+  }
+
+  // std::strcpy(wsServer, String("wss://" + mempoolInstance +
+  // "/api/v1/ws").c_str());
+
+  const String protocol = preferences.getBool("mempoolSecure", DEFAULT_MEMPOOL_SECURE) ? "wss" : "ws";
+
+  String mempoolUri = protocol + "://" + preferences.getString("mempoolInstance", DEFAULT_MEMPOOL_INSTANCE) + "/api/v1/ws";
+  
+  esp_websocket_client_config_t config = {
+     // .uri = "wss://mempool.space/api/v1/ws",
+      .task_stack = (6*1024),
+      .user_agent = USER_AGENT
+  };
+
+  if (preferences.getBool("mempoolSecure", DEFAULT_MEMPOOL_SECURE)) {
+    config.cert_pem = mempoolWsCert;
+  }
+
+  config.uri = mempoolUri.c_str();
+
+  Serial.printf("Connecting to %s\r\n", preferences.getString("mempoolInstance", DEFAULT_MEMPOOL_INSTANCE));
+
+  blockNotifyClient = esp_websocket_client_init(&config);
+  esp_websocket_register_events(blockNotifyClient, WEBSOCKET_EVENT_ANY,
+                                onWebsocketBlockEvent, blockNotifyClient);
+  esp_websocket_client_start(blockNotifyClient);
+}
+
+void onWebsocketBlockEvent(void *handler_args, esp_event_base_t base,
+                      int32_t event_id, void *event_data)
+{
+  esp_websocket_event_data_t *data = (esp_websocket_event_data_t *)event_data;
+  const String sub = "{\"action\": \"want\", \"data\":[\"blocks\", \"mempool-blocks\"]}";
+  switch (event_id)
+  {
+  case WEBSOCKET_EVENT_CONNECTED:
+    blockNotifyInit = true;
+
+    Serial.println(F("Connected to Mempool.space WebSocket"));
+
+    Serial.println(sub);
+    if (esp_websocket_client_send_text(blockNotifyClient, sub.c_str(),
+                                       sub.length(), portMAX_DELAY) == -1)
+    {
+      Serial.println(F("Mempool.space WS Block Subscribe Error"));
    }

-    currentBlockHeight = newBlockHeight;
+    break;
+  case WEBSOCKET_EVENT_DATA:
+    onWebsocketBlockMessage(data);
+    break;
+  case WEBSOCKET_EVENT_ERROR:
+    Serial.println(F("Mempool.space WS Connnection error"));
+    break;
+  case WEBSOCKET_EVENT_DISCONNECTED:
+    Serial.println(F("Mempool.space WS Connnection Closed"));
+    break;
+  }
+}
+
+void onWebsocketBlockMessage(esp_websocket_event_data_t *event_data)
+{
+  JsonDocument doc;
+
+  JsonDocument filter;
+  filter["block"]["height"] = true;
+  filter["mempool-blocks"][0]["medianFee"] = true;
+
+  deserializeJson(doc, (char *)event_data->data_ptr, DeserializationOption::Filter(filter));
+
+  // if (error) {
+  //   Serial.print("deserializeJson() failed: ");
+  //   Serial.println(error.c_str());
+  //   return;
+  // }
+
+  if (doc.containsKey("block"))
+  {
+    JsonObject block = doc["block"];
+
+    if (block["height"].as<uint>() == currentBlockHeight) {
+      return;
+    }
+
+    processNewBlock(block["height"].as<uint>());
+  }
+  else if (doc.containsKey("mempool-blocks"))
+  {
+    JsonArray blockInfo = doc["mempool-blocks"].as<JsonArray>();
+
+    uint medianFee = (uint)round(blockInfo[0]["medianFee"].as<double>());
+
+    processNewBlockFee(medianFee);
+  }
+
+  doc.clear();
+}
+
+void processNewBlock(uint newBlockHeight) {
+  if (newBlockHeight < currentBlockHeight)
+    return;
+
+  currentBlockHeight = newBlockHeight;
+
+    // Serial.printf("New block found: %d\r\n", block["height"].as<uint>());
+    preferences.putUInt("blockHeight", currentBlockHeight);
    lastBlockUpdate = esp_timer_get_time() / 1000000;

    if (workQueue != nullptr)
    {
-        WorkItem blockUpdate = {TASK_BLOCK_UPDATE, 0};
-        xQueueSend(workQueue, &blockUpdate, portMAX_DELAY);
-    }
+      WorkItem blockUpdate = {TASK_BLOCK_UPDATE, 0};
+      xQueueSend(workQueue, &blockUpdate, portMAX_DELAY);
+      // xTaskNotifyGive(blockUpdateTaskHandle);

-    if (ScreenHandler::getCurrentScreen() != SCREEN_BLOCK_HEIGHT &&
-        preferences.getBool("stealFocus", DEFAULT_STEAL_FOCUS))
-    {
+      if (ScreenHandler::getCurrentScreen() != SCREEN_BLOCK_HEIGHT &&
+          preferences.getBool("stealFocus", DEFAULT_STEAL_FOCUS))
+      {
        uint64_t timerPeriod = 0;
        if (isTimerActive())
        {
-            timerPeriod = getTimerSeconds();
-            esp_timer_stop(screenRotateTimer);
+          // store timer periode before making inactive to prevent artifacts
+          timerPeriod = getTimerSeconds();
+          esp_timer_stop(screenRotateTimer);
        }
        ScreenHandler::setCurrentScreen(SCREEN_BLOCK_HEIGHT);
        if (timerPeriod > 0)
        {
-            esp_timer_start_periodic(screenRotateTimer,
+          esp_timer_start_periodic(screenRotateTimer,
                                   timerPeriod * usPerSecond);
        }
        vTaskDelay(pdMS_TO_TICKS(315*NUM_SCREENS)); // Extra delay because of screen switching
-    }
+      }

-    if (preferences.getBool("ledFlashOnUpd", DEFAULT_LED_FLASH_ON_UPD))
-    {
+      if (preferences.getBool("ledFlashOnUpd", DEFAULT_LED_FLASH_ON_UPD))
+      {
        vTaskDelay(pdMS_TO_TICKS(250)); // Wait until screens are updated
-        getLedHandler().queueEffect(LED_FLASH_BLOCK_NOTIFY);
+        queueLedEffect(LED_FLASH_BLOCK_NOTIFY);
+      }
    }
 }

-void BlockNotify::processNewBlockFee(uint16_t newBlockFee) {
-    if (blockMedianFee == newBlockFee)
+void processNewBlockFee(uint newBlockFee) {
+  if (blockMedianFee == newBlockFee)
    {
-        return;
+      return;
    }

+    //  Serial.printf("New median fee: %d\r\n", medianFee);
    blockMedianFee = newBlockFee;

    if (workQueue != nullptr)
    {
-        WorkItem blockUpdate = {TASK_FEE_UPDATE, 0};
-        xQueueSend(workQueue, &blockUpdate, portMAX_DELAY);
+      WorkItem blockUpdate = {TASK_FEE_UPDATE, 0};
+      xQueueSend(workQueue, &blockUpdate, portMAX_DELAY);
    }
 }

-uint32_t BlockNotify::getBlockHeight() const { 
-    return currentBlockHeight; 
-}
+uint getBlockHeight() { return currentBlockHeight; }

-void BlockNotify::setBlockHeight(uint32_t newBlockHeight)
+void setBlockHeight(uint newBlockHeight)
 {
-    currentBlockHeight = newBlockHeight;
+  currentBlockHeight = newBlockHeight;
 }

-uint16_t BlockNotify::getBlockMedianFee() const { 
-    return blockMedianFee; 
-}
+uint getBlockMedianFee() { return blockMedianFee; }

-void BlockNotify::setBlockMedianFee(uint16_t newBlockMedianFee)
+void setBlockMedianFee(uint newBlockMedianFee)
 {
-    blockMedianFee = newBlockMedianFee;
+  blockMedianFee = newBlockMedianFee;
 }

-bool BlockNotify::isConnected() const
+bool isBlockNotifyConnected()
 {
-    if (wsClient == NULL)
-        return false;
-    return esp_websocket_client_is_connected(wsClient);
+  if (blockNotifyClient == NULL)
+    return false;
+  return esp_websocket_client_is_connected(blockNotifyClient);
 }

-bool BlockNotify::isInitialized() const
+bool getBlockNotifyInit()
 {
-    return notifyInit;
+  return blockNotifyInit;
 }

-void BlockNotify::stop()
+void stopBlockNotify()
 {
-    if (wsClient == NULL)
-        return;
+  if (blockNotifyClient == NULL)
+    return;

-    esp_websocket_client_close(wsClient, portMAX_DELAY);
-    esp_websocket_client_stop(wsClient);
-    esp_websocket_client_destroy(wsClient);
-    wsClient = NULL;
+  esp_websocket_client_close(blockNotifyClient, pdMS_TO_TICKS(5000));
+  esp_websocket_client_stop(blockNotifyClient);
+  esp_websocket_client_destroy(blockNotifyClient);
+
+  blockNotifyClient = NULL;
 }

-void BlockNotify::restart()
+void restartBlockNotify()
 {
-    stop();
-    setup();
+  stopBlockNotify();
+  
+  if (blockNotifyClient == NULL) {
+    setupBlockNotify();
+    return;
+  }
+
+  // esp_websocket_client_close(blockNotifyClient, pdMS_TO_TICKS(5000));
+  // esp_websocket_client_stop(blockNotifyClient);
+  // esp_websocket_client_start(blockNotifyClient);
 }

-int BlockNotify::fetchLatestBlock() {
+
+int getBlockFetch() {
    try {
        String mempoolInstance = preferences.getString("mempoolInstance", DEFAULT_MEMPOOL_INSTANCE);
        const String protocol = preferences.getBool("mempoolSecure", DEFAULT_MEMPOOL_SECURE) ? "https" : "http";
@ -314,12 +314,12 @@ int BlockNotify::fetchLatestBlock() {
    return 2203; // B-T-C
 }

-uint BlockNotify::getLastBlockUpdate() const
+uint getLastBlockUpdate()
 {
-    return lastBlockUpdate;
+  return lastBlockUpdate;
 }

-void BlockNotify::setLastBlockUpdate(uint lastUpdate)
+void setLastBlockUpdate(uint lastUpdate)
 {
-    lastBlockUpdate = lastUpdate;
+  lastBlockUpdate = lastUpdate;
 }
--- a/src/lib/block_notify.hpp
+++ b/src/lib/block_notify.hpp
@ -5,6 +5,7 @@
 #include <HTTPClient.h>
 #include <esp_timer.h>
 #include <esp_websocket_client.h>
+
 #include <cstring>
 #include <string>

@ -13,53 +14,28 @@
 #include "lib/timers.hpp"
 #include "lib/shared.hpp"

-class BlockNotify {
-public:
-    static BlockNotify& getInstance() {
-        static BlockNotify instance;
-        return instance;
-    }
+// using namespace websockets;

-    // Delete copy constructor and assignment operator
-    BlockNotify(const BlockNotify&) = delete;
-    void operator=(const BlockNotify&) = delete;
+void setupBlockNotify();

-    // Block notification setup and control
-    void setup();
-    void stop();
-    void restart();
-    bool isConnected() const;
-    bool isInitialized() const;
+void onWebsocketBlockEvent(void *handler_args, esp_event_base_t base,
+                      int32_t event_id, void *event_data);
+void onWebsocketBlockMessage(esp_websocket_event_data_t *event_data);

-    // Block height management
-    void setBlockHeight(uint32_t newBlockHeight);
-    uint32_t getBlockHeight() const;
+void setBlockHeight(uint newBlockHeight);
+uint getBlockHeight();

-    // Block fee management
-    void setBlockMedianFee(uint16_t blockMedianFee);
-    uint16_t getBlockMedianFee() const;
+void setBlockMedianFee(uint blockMedianFee);
+uint getBlockMedianFee();

-    // Block processing
-    void processNewBlock(uint32_t newBlockHeight);
-    void processNewBlockFee(uint16_t newBlockFee);
+bool isBlockNotifyConnected();
+void stopBlockNotify();
+void restartBlockNotify();

-    // Block fetch and update tracking
-    int fetchLatestBlock();
-    uint getLastBlockUpdate() const;
-    void setLastBlockUpdate(uint lastUpdate);
+void processNewBlock(uint newBlockHeight);
+void processNewBlockFee(uint newBlockFee);

-private:
-    BlockNotify() = default;  // Private constructor for singleton
-    
-    void setupTask();
-    static void onWebsocketEvent(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data);
-    void onWebsocketMessage(esp_websocket_event_data_t *data);
-
-    static const char* mempoolWsCert;
-    static esp_websocket_client_handle_t wsClient;
-    static uint32_t currentBlockHeight;
-    static uint16_t blockMedianFee;
-    static bool notifyInit;
-    static unsigned long int lastBlockUpdate;
-    static TaskHandle_t taskHandle;
-};
+bool getBlockNotifyInit();
+uint getLastBlockUpdate();
+int getBlockFetch();
+void setLastBlockUpdate(uint lastUpdate);
--- a/src/lib/config.cpp
+++ b/src/lib/config.cpp
@ -1,5 +1,4 @@
 #include "config.hpp"
-#include "led_handler.hpp"

 #define MAX_ATTEMPTS_WIFI_CONNECTION 20

@ -48,11 +47,10 @@ void setup()
  setupPreferences();
  setupHardware();

-  EPDManager::getInstance().initialize();
+  setupDisplays();
  if (preferences.getBool("ledTestOnPower", DEFAULT_LED_TEST_ON_POWER))
  {
-    auto& ledHandler = getLedHandler();
-    ledHandler.queueEffect(LED_POWER_TEST);
+    queueLedEffect(LED_POWER_TEST);
  }
  {
    std::lock_guard<std::mutex> lockMcp(mcpMutex);
@ -62,8 +60,7 @@ void setup()
      preferences.remove("txPower");

      WiFi.eraseAP();
-      auto& ledHandler = getLedHandler();
-      ledHandler.queueEffect(LED_EFFECT_WIFI_ERASE_SETTINGS);
+      queueLedEffect(LED_EFFECT_WIFI_ERASE_SETTINGS);
    }
  }

@ -79,8 +76,7 @@ void setup()
    else if (mcp1.read1(1) == LOW)
    {
      preferences.clear();
-      auto& ledHandler = getLedHandler();
-      ledHandler.queueEffect(LED_EFFECT_WIFI_ERASE_SETTINGS);
+      queueLedEffect(LED_EFFECT_WIFI_ERASE_SETTINGS);
      nvs_flash_erase();
      delay(1000);

@ -104,53 +100,37 @@ void setup()

  if (preferences.getBool("bitaxeEnabled", DEFAULT_BITAXE_ENABLED))
  {
-    BitAxeFetch::getInstance().setup();
+    setupBitaxeFetchTask();
  }

  if (preferences.getBool("miningPoolStats", DEFAULT_MINING_POOL_STATS_ENABLED))
  {
-    MiningPoolStatsFetch::getInstance().setup();
+    setupMiningPoolStatsFetchTask();
  }

  ButtonHandler::setup();
  setupOTA();

-  EPDManager::getInstance().waitUntilNoneBusy();
+  waitUntilNoneBusy();

 #ifdef HAS_FRONTLIGHT
  if (!preferences.getBool("flAlwaysOn", DEFAULT_FL_ALWAYS_ON))
  {
-    auto& ledHandler = getLedHandler();
-    ledHandler.frontlightFadeOutAll(preferences.getUInt("flEffectDelay"), true);
+    frontlightFadeOutAll(preferences.getUInt("flEffectDelay"), true);
    flArray.allOFF();
  }
 #endif

-  EPDManager::getInstance().forceFullRefresh();
+  forceFullRefresh();
+
 }

 void setupWifi()
 {
  WiFi.onEvent(WiFiEvent);
-  
-  // wifi_country_t country = {
-  //   .cc = "NL",
-  //   .schan = 1,
-  //   .nchan = 13,
-  //   .policy = WIFI_COUNTRY_POLICY_MANUAL
-  // };
-
-  // esp_err_t err = esp_wifi_set_country(&country);
-  // if (err != ESP_OK) {
-  //   Serial.printf("Failed to set country: %d\n", err);
-  // }
-
  WiFi.setAutoConnect(true);
  WiFi.setAutoReconnect(true);
  WiFi.begin();
-
-
-
  if (preferences.getInt("txPower", DEFAULT_TX_POWER))
  {
    if (WiFi.setTxPower(
@ -164,8 +144,7 @@ void setupWifi()
  // if (!preferences.getBool("wifiConfigured", DEFAULT_WIFI_CONFIGURED)
  {

-    auto& ledHandler = getLedHandler();
-    ledHandler.queueEffect(LED_EFFECT_WIFI_WAIT_FOR_CONFIG);
+    queueLedEffect(LED_EFFECT_WIFI_WAIT_FOR_CONFIG);

    bool buttonPress = false;
    {
@ -178,7 +157,8 @@ void setupWifi()

      byte mac[6];
      WiFi.macAddress(mac);
-      String softAP_SSID = getMyHostname();
+      String softAP_SSID =
+          String("BTClock" + String(mac[5], 16) + String(mac[1], 16));
      WiFi.setHostname(softAP_SSID.c_str());
      String softAP_password = replaceAmbiguousChars(
          base64::encode(String(mac[2], 16) + String(mac[4], 16) +
@ -188,7 +168,6 @@ void setupWifi()
      wm.setConfigPortalTimeout(preferences.getUInt("wpTimeout", DEFAULT_WP_TIMEOUT));
      wm.setWiFiAutoReconnect(false);
      wm.setDebugOutput(false);
-      wm.setCountry("NL");
      wm.setConfigPortalBlocking(true);

      wm.setAPCallback([&](WiFiManager *wifiManager)
@ -198,14 +177,13 @@ void setupWifi()
        wifiManager->getConfigPortalSSID().c_str(),
        softAP_password.c_str());
        // delay(6000);
-        EPDManager::getInstance().setForegroundColor(GxEPD_BLACK);
-        EPDManager::getInstance().setBackgroundColor(GxEPD_WHITE);
+        setFgColor(GxEPD_BLACK);
+        setBgColor(GxEPD_WHITE);
        const String qrText = "qrWIFI:S:" + wifiManager->getConfigPortalSSID() +
                              ";T:WPA;P:" + softAP_password.c_str() + ";;";
        const String explainText = "*SSID: *\r\n" +
                                   wifiManager->getConfigPortalSSID() +
-                                   "\r\n\r\n*Password:*\r\n" + softAP_password +
-                                   "\r\n\r\n*Hostname*:\r\n" + getMyHostname();
+                                   "\r\n\r\n*Password:*\r\n" + softAP_password;
        // Set the UNIX timestamp
        time_t timestamp = LAST_BUILD_TIME; // Example timestamp: March 7, 2021 00:00:00 UTC

@ -215,36 +193,67 @@ void setupWifi()
        // Format the date
        char formattedDate[20];
        strftime(formattedDate, sizeof(formattedDate), "%y-%m-%d\r\n%H:%M:%S", timeinfo);
-        String hwStr = String(HW_REV);
-        hwStr.replace("_EPD_", "\r\nEPD_");
+  
        std::array<String, NUM_SCREENS> epdContent = {
            "Welcome!",
            "Bienvenidos!",
            "To setup\r\nscan QR or\r\nconnect\r\nmanually",
            "Para\r\nconfigurar\r\nescanear QR\r\no conectar\r\nmanualmente",
            explainText,
-           "*HW version:*\r\n" + hwStr +
-#ifdef GIT_TAG
-            "\r\n\r\n*SW Version:*\r\n" + GIT_TAG +
-#endif
-            "\r\n\r\n*FW build date:*\r\n" + formattedDate,
+            "*Hostname*:\r\n" + getMyHostname() + "\r\n\r\n" + "*FW build date:*\r\n" + formattedDate,
            qrText};
-      
-        EPDManager::getInstance().setContent(epdContent); });
+        setEpdContent(epdContent); });

      wm.setSaveConfigCallback([]()
                               {
        preferences.putBool("wifiConfigured", true);

        delay(1000);
-        // just restart after success
+        // just restart after succes
        ESP.restart(); });

      bool ac = wm.autoConnect(softAP_SSID.c_str(), softAP_password.c_str());
+
+      // waitUntilNoneBusy();
+      // std::array<String, NUM_SCREENS> epdContent = {"Welcome!",
+      // "Bienvenidos!", "Use\r\nweb-interface\r\nto configure", "Use\r\nla
+      // interfaz web\r\npara configurar", "Or
+      // restart\r\nwhile\r\nholding\r\n2nd button\r\r\nto start\r\n QR-config",
+      // "O reinicie\r\nmientras\r\n mantiene presionado\r\nel segundo
+      // botón\r\r\npara iniciar\r\nQR-config", ""}; setEpdContent(epdContent);
+      //  esp_task_wdt_init(30, false);
+      //  uint count = 0;
+      //  while (WiFi.status() != WL_CONNECTED)
+      //  {
+      //      if (Serial.available() > 0)
+      //      {
+      //          uint8_t b = Serial.read();
+
+      //         if (parse_improv_serial_byte(x_position, b, x_buffer,
+      //         onImprovCommandCallback, onImprovErrorCallback))
+      //         {
+      //             x_buffer[x_position++] = b;
+      //         }
+      //         else
+      //         {
+      //             x_position = 0;
+      //         }
+      //     }
+      //     count++;
+
+      //     if (count > 2000000) {
+      //         queueLedEffect(LED_EFFECT_HEARTBEAT);
+      //         count = 0;
+      //     }
+      // }
+      // esp_task_wdt_deinit();
+      // esp_task_wdt_reset();
    }

-    EPDManager::getInstance().setForegroundColor(preferences.getUInt("fgColor", isWhiteVersion() ? GxEPD_BLACK : GxEPD_WHITE));
-    EPDManager::getInstance().setBackgroundColor(preferences.getUInt("bgColor", isWhiteVersion() ? GxEPD_WHITE : GxEPD_BLACK));
+
+
+    setFgColor(preferences.getUInt("fgColor", isWhiteVersion() ? GxEPD_BLACK : GxEPD_WHITE));
+    setBgColor(preferences.getUInt("bgColor", isWhiteVersion() ? GxEPD_WHITE : GxEPD_BLACK));
  }
  // else
  // {
@ -265,8 +274,6 @@ void syncTime()

  while (!getLocalTime(&timeinfo))
  {
-    auto& ledHandler = getLedHandler();
-    ledHandler.queueEffect(LED_EFFECT_CONFIGURING);
    configTime(preferences.getInt("gmtOffset", DEFAULT_TIME_OFFSET_SECONDS), 0,
               NTP_SERVER);
    delay(500);
@ -280,9 +287,9 @@ void setupPreferences()
 {
  preferences.begin("btclock", false);

-  EPDManager::getInstance().setForegroundColor(preferences.getUInt("fgColor", DEFAULT_FG_COLOR));
-  EPDManager::getInstance().setBackgroundColor(preferences.getUInt("bgColor", DEFAULT_BG_COLOR));
-  BlockNotify::getInstance().setBlockHeight(preferences.getUInt("blockHeight", INITIAL_BLOCK_HEIGHT));
+  setFgColor(preferences.getUInt("fgColor", DEFAULT_FG_COLOR));
+  setBgColor(preferences.getUInt("bgColor", DEFAULT_BG_COLOR));
+  setBlockHeight(preferences.getUInt("blockHeight", INITIAL_BLOCK_HEIGHT));
  setPrice(preferences.getUInt("lastPrice", INITIAL_LAST_PRICE), CURRENCY_USD);

  if (!preferences.isKey("enableDebugLog")) {
@ -361,7 +368,7 @@ void setupPreferences()
  if (preferences.getBool("miningPoolStats", DEFAULT_MINING_POOL_STATS_ENABLED))
  {
    addScreenMapping(SCREEN_MINING_POOL_STATS_HASHRATE, "Mining Pool Hashrate");
-    if (MiningPoolStatsFetch::getInstance().getPool()->supportsDailyEarnings()) {
+    if (getMiningPool()->supportsDailyEarnings()) {
      addScreenMapping(SCREEN_MINING_POOL_STATS_EARNINGS, "Mining Pool Earnings");
    }
  }
@ -390,7 +397,7 @@ void setupWebsocketClients(void *pvParameters)
  }
  else if (dataSource == THIRD_PARTY_SOURCE)
  {
-    BlockNotify::getInstance().setup();
+    setupBlockNotify();
    setupPriceNotify();
  }

@ -407,14 +414,13 @@ void setupTimers()

 void finishSetup()
 {
-  auto& ledHandler = getLedHandler();
  if (preferences.getBool("ledStatus", DEFAULT_LED_STATUS))
  {
-    ledHandler.restoreLedState();
+    restoreLedState();
  }
  else
  {
-    ledHandler.clear();
+    clearLeds();
  }
 }

@ -463,9 +469,22 @@ void setupHardware()
    Serial.println(F("Error loading WebUI"));
  }

-  // Initialize LED handler
-  auto& ledHandler = getLedHandler();
-  ledHandler.setup();
+  // {
+  //   File f = LittleFS.open("/qr.txt", "w");
+
+  //   if(f) {
+  //     if (f.print("Hello")) {
+  //     Serial.println(F("Written QR to FS"));
+  //     Serial.printf("\nLittleFS free: %zu\n", LittleFS.totalBytes() - LittleFS.usedBytes()); 
+  //     }
+  //   } else {
+  //     Serial.println(F("Can't write QR to FS"));
+  //   }
+
+  //   f.close();
+  // }
+
+  setupLeds();

  WiFi.setHostname(getMyHostname().c_str());
  if (!psramInit())
@ -523,8 +542,7 @@ void setupHardware()
 #endif

 #ifdef HAS_FRONTLIGHT
-  // Initialize frontlight through LedHandler
-  ledHandler.initializeFrontlight();
+  setupFrontlight();

  Wire.beginTransmission(0x5C);
  byte error = Wire.endTransmission();
@ -546,7 +564,6 @@ void setupHardware()
 void WiFiEvent(WiFiEvent_t event, WiFiEventInfo_t info)
 {
  static bool first_connect = true;
-  auto& ledHandler = getLedHandler();  // Get ledHandler reference once at the start

  Serial.printf("[WiFi-event] event: %d\n", event);

@ -572,7 +589,7 @@ void WiFiEvent(WiFiEvent_t event, WiFiEventInfo_t info)
    if (!first_connect)
    {
      Serial.println(F("Disconnected from WiFi access point"));
-      ledHandler.queueEffect(LED_EFFECT_WIFI_CONNECT_ERROR);
+      queueLedEffect(LED_EFFECT_WIFI_CONNECT_ERROR);
      uint8_t reason = info.wifi_sta_disconnected.reason;
      if (reason)
        Serial.printf("Disconnect reason: %s, ",
@ -588,13 +605,13 @@ void WiFiEvent(WiFiEvent_t event, WiFiEventInfo_t info)
    Serial.print("Obtained IP address: ");
    Serial.println(WiFi.localIP());
    if (!first_connect)
-      ledHandler.queueEffect(LED_EFFECT_WIFI_CONNECT_SUCCESS);
+      queueLedEffect(LED_EFFECT_WIFI_CONNECT_SUCCESS);
    first_connect = false;
    break;
  }
  case ARDUINO_EVENT_WIFI_STA_LOST_IP:
    Serial.println(F("Lost IP address and IP address is reset to 0"));
-    ledHandler.queueEffect(LED_EFFECT_WIFI_CONNECT_ERROR);
+    queueLedEffect(LED_EFFECT_WIFI_CONNECT_ERROR);
    WiFi.reconnect();
    break;
  case ARDUINO_EVENT_WIFI_AP_START:
@ -644,6 +661,29 @@ uint getLastTimeSync()
 }

 #ifdef HAS_FRONTLIGHT
+void setupFrontlight()
+{
+  if (!flArray.begin(PCA9685_MODE1_AUTOINCR | PCA9685_MODE1_ALLCALL, PCA9685_MODE2_TOTEMPOLE))
+  {
+    Serial.println(F("FL driver error"));
+    return;
+  }
+  Serial.println(F("FL driver active"));
+
+  if (!preferences.isKey("flMaxBrightness"))
+  {
+    preferences.putUInt("flMaxBrightness", DEFAULT_FL_MAX_BRIGHTNESS);
+  }
+  if (!preferences.isKey("flEffectDelay"))
+  {
+    preferences.putUInt("flEffectDelay", DEFAULT_FL_EFFECT_DELAY);
+  }
+
+  if (!preferences.isKey("flFlashOnUpd"))
+  {
+    preferences.putBool("flFlashOnUpd", DEFAULT_FL_FLASH_ON_UPDATE);
+  }
+}

 float getLightLevel()
 {
--- a/src/lib/config.hpp
+++ b/src/lib/config.hpp
@ -52,10 +52,10 @@ void setupTimers();
 void finishSetup();
 void setupMcp();
 #ifdef HAS_FRONTLIGHT
-extern BH1750 bh1750;
-extern bool hasLuxSensor;
+void setupFrontlight();
 float getLightLevel();
 bool hasLightLevel();
+extern PCA9685 flArray;
 #endif

 String getMyHostname();
@ -98,10 +98,6 @@ extern MCP23017 mcp1;
 extern MCP23017 mcp2;
 #endif

-#ifdef HAS_FRONTLIGHT
-extern PCA9685 flArray;
-#endif
-
 // Expose DataSourceType enum
 extern DataSourceType getDataSource();
 extern void setDataSource(DataSourceType source);
--- a/src/lib/defaults.hpp
+++ b/src/lib/defaults.hpp
@ -46,8 +46,8 @@
 #define DEFAULT_LUX_LIGHT_TOGGLE 128
 #define DEFAULT_FL_OFF_WHEN_DARK true   

-#define DEFAULT_FL_ALWAYS_ON true
-#define DEFAULT_FL_FLASH_ON_UPDATE true
+#define DEFAULT_FL_ALWAYS_ON false
+#define DEFAULT_FL_FLASH_ON_UPDATE false

 #define DEFAULT_LED_STATUS false
 #define DEFAULT_TIMER_ACTIVE true
@ -60,7 +60,6 @@
 #define DEFAULT_MINING_POOL_STATS_ENABLED false
 #define DEFAULT_MINING_POOL_NAME "ocean"
 #define DEFAULT_MINING_POOL_USER "38Qkkei3SuF1Eo45BaYmRHUneRD54yyTFy"  // Random actual Ocean hasher
-#define DEFAULT_LOCAL_POOL_ENDPOINT "umbrel.local:2019"

 #define DEFAULT_ZAP_NOTIFY_ENABLED false
 #define DEFAULT_ZAP_NOTIFY_PUBKEY "b5127a08cf33616274800a4387881a9f98e04b9c37116e92de5250498635c422"
--- a/src/lib/epd.cpp
+++ b/src/lib/epd.cpp
--- a/src/lib/epd.hpp
+++ b/src/lib/epd.hpp
@ -9,8 +9,6 @@
 #include <mutex>
 #include <native_pin.hpp>
 #include <regex>
-#include <array>
-#include <memory>

 #include "fonts/fonts.hpp"
 #include "lib/config.hpp"
@ -34,102 +32,39 @@
 #include "qrcodegen.h"
 #endif

-struct UpdateDisplayTaskItem {
-    char dispNum;
-};
+typedef struct {
+  char dispNum;
+} UpdateDisplayTaskItem;

-struct FontFamily {
-    GFXfont* big;
-    GFXfont* medium;
-    GFXfont* small;
-};
+void forceFullRefresh();
+void setupDisplays();
+void loadFonts(const String& fontName);

-class EPDManager {
-public:
-    static EPDManager& getInstance();
+void splitText(const uint dispNum, const String &top, const String &bottom,
+               bool partial);

-    // Delete copy constructor and assignment operator
-    EPDManager(const EPDManager&) = delete;
-    EPDManager& operator=(const EPDManager&) = delete;
+void showDigit(const uint dispNum, char chr, bool partial, const GFXfont *font);
+void showChars(const uint dispNum, const String &chars, bool partial,
+               const GFXfont *font);

-    void initialize();
-    void forceFullRefresh();
-    void loadFonts(const String& fontName);
-    void setContent(const std::array<String, NUM_SCREENS>& newContent, bool forceUpdate = false);
-    void setContent(const std::array<std::string, NUM_SCREENS>& newContent);
-    std::array<String, NUM_SCREENS> getCurrentContent() const;
+extern "C" void updateDisplay(void *pvParameters) noexcept;
+void updateDisplayAlt(int epdIndex);
+void prepareDisplayUpdateTask(void *pvParameters);

-    int getBackgroundColor() const { return bgColor; }
-    int getForegroundColor() const { return fgColor; }
-    void setBackgroundColor(int color) { bgColor = color; }
-    void setForegroundColor(int color) { fgColor = color; }
-    void waitUntilNoneBusy();
+int getBgColor();
+int getFgColor();
+void setBgColor(int color);
+void setFgColor(int color);

-private:
-    EPDManager();  // Private constructor for singleton
-    ~EPDManager(); // Private destructor
+bool renderIcon(const uint dispNum, const String &text, bool partial);
+void renderText(const uint dispNum, const String &text, bool partial);
+void renderQr(const uint dispNum, const String &text, bool partial);

-    void setupDisplay(uint dispNum, const GFXfont* font);
-    void splitText(uint dispNum, const String& top, const String& bottom, bool partial);
-    void showDigit(uint dispNum, char chr, bool partial, const GFXfont* font);
-    void showChars(uint dispNum, const String& chars, bool partial, const GFXfont* font);
-    bool renderIcon(uint dispNum, const String& text, bool partial);
-    void renderText(uint dispNum, const String& text, bool partial);
-    void renderQr(uint dispNum, const String& text, bool partial);
-    int16_t calculateDescent(const GFXfont* font);
+void setEpdContent(std::array<String, NUM_SCREENS> newEpdContent,
+                   bool forceUpdate);
+void setEpdContent(std::array<String, NUM_SCREENS> newEpdContent);

-    static void updateDisplayTask(void* pvParameters) noexcept;
-    static void prepareDisplayUpdateTask(void* pvParameters);
+void setEpdContent(std::array<std::string, NUM_SCREENS> newEpdContent);

-    // Member variables
-    std::array<String, NUM_SCREENS> currentContent;
-    std::array<String, NUM_SCREENS> content;
-    std::array<uint32_t, NUM_SCREENS> lastFullRefresh;
-    std::array<TaskHandle_t, NUM_SCREENS> tasks;
-    QueueHandle_t updateQueue;
-
-    FontFamily antonioFonts;
-    FontFamily oswaldFonts;
-    const GFXfont* fontSmall;
-    const GFXfont* fontBig;
-    const GFXfont* fontMedium;
-    const GFXfont* fontSatsymbol;
-
-    int bgColor;
-    int fgColor;
-
-    std::mutex updateMutex;
-    std::array<std::mutex, NUM_SCREENS> displayMutexes;
-
-    // Pin configurations based on board version
-    #ifdef IS_BTCLOCK_REV_B
-    static Native_Pin EPD_DC;
-    static std::array<Native_Pin, NUM_SCREENS> EPD_CS;
-    static std::array<Native_Pin, NUM_SCREENS> EPD_BUSY;
-    static std::array<MCP23X17_Pin, NUM_SCREENS> EPD_RESET;
-    #elif defined(IS_BTCLOCK_V8)
-    static Native_Pin EPD_DC;
-    static std::array<MCP23X17_Pin, NUM_SCREENS> EPD_BUSY;
-    static std::array<MCP23X17_Pin, NUM_SCREENS> EPD_CS;
-    static std::array<MCP23X17_Pin, NUM_SCREENS> EPD_RESET;
-    #else
-    static Native_Pin EPD_DC;
-    static std::array<Native_Pin, NUM_SCREENS> EPD_CS;
-    static std::array<Native_Pin, NUM_SCREENS> EPD_BUSY;
-    static std::array<MCP23X17_Pin, NUM_SCREENS> EPD_RESET;
-    #endif
-
-    // Display array
-    std::array<GxEPD2_BW<EPD_CLASS, EPD_CLASS::HEIGHT>, NUM_SCREENS> displays;
-
-    static constexpr size_t UPDATE_QUEUE_SIZE = 14;
-    static constexpr uint32_t BUSY_TIMEOUT_COUNT = 200;
-    static constexpr TickType_t BUSY_RETRY_DELAY = pdMS_TO_TICKS(10);
-    static constexpr size_t EPD_TASK_STACK_SIZE = 
-        #ifdef IS_BTCLOCK_V8
-            4096
-        #else
-            2048
-        #endif
-    ;
-};
+std::array<String, NUM_SCREENS> getCurrentEpdContent();
+void waitUntilNoneBusy();
--- a/src/lib/led_handler.cpp
+++ b/src/lib/led_handler.cpp
--- a/src/lib/led_handler.hpp
+++ b/src/lib/led_handler.hpp
@ -4,7 +4,6 @@
 #include <Arduino.h>
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
-#include <memory>

 #include "lib/shared.hpp"
 #include "lib/webserver.hpp"
@ -16,120 +15,71 @@
 #define NEOPIXEL_COUNT 4
 #endif

-// LED effect constants
 const int LED_FLASH_ERROR = 0;
 const int LED_FLASH_SUCCESS = 1;
 const int LED_FLASH_UPDATE = 2;
-const int LED_EFFECT_CONFIGURING = 10;
-const int LED_FLASH_BLOCK_NOTIFY = 4;
-const int LED_EFFECT_START_TIMER = 5;
-const int LED_EFFECT_PAUSE_TIMER = 6;
-const int LED_EFFECT_HEARTBEAT = 7;
+const int LED_FLASH_BLOCK_NOTIFY = 3;
+const int LED_EFFECT_START_TIMER = 4;
+const int LED_EFFECT_PAUSE_TIMER = 5;
+const int LED_EFFECT_HEARTBEAT = 6;
 const int LED_EFFECT_WIFI_WAIT_FOR_CONFIG = 100;
 const int LED_EFFECT_WIFI_CONNECTING = 101;
 const int LED_EFFECT_WIFI_CONNECT_ERROR = 102;
 const int LED_EFFECT_WIFI_CONNECT_SUCCESS = 103;
 const int LED_EFFECT_WIFI_ERASE_SETTINGS = 104;
+
+
 const int LED_PROGRESS_25 = 200;
 const int LED_PROGRESS_50 = 201;
 const int LED_PROGRESS_75 = 202;
 const int LED_PROGRESS_100 = 203;
+
 const int LED_DATA_PRICE_ERROR = 300;
 const int LED_DATA_BLOCK_ERROR = 301;
+
 const int LED_EFFECT_NOSTR_ZAP = 400;
+
 const int LED_FLASH_IDENTIFY = 990;
 const int LED_POWER_TEST = 999;
+extern TaskHandle_t ledTaskHandle;
+extern Adafruit_NeoPixel pixels;

-// Do Not Disturb mode settings
-struct DNDTimeRange {
-    uint8_t startHour;
-    uint8_t startMinute;
-    uint8_t endHour;
-    uint8_t endMinute;
-};
-
-class LedHandler {
-public:
-    static LedHandler& getInstance();
-    
-    // Delete copy constructor and assignment operator
-    LedHandler(const LedHandler&) = delete;
-    LedHandler& operator=(const LedHandler&) = delete;
-
-    void setup();
-    void setupTask();
-    bool queueEffect(uint effect);
-    void clear();
-    void setLights(int r, int g, int b);
-    void setLights(uint32_t color);
-    void saveLedState();
-    void restoreLedState();
-    QueueHandle_t getTaskQueue() const { return ledTaskQueue; }
-    Adafruit_NeoPixel& getPixels() { return pixels; }
-
-    // DND methods
-    void setDNDEnabled(bool enabled);
-    void setDNDTimeBasedEnabled(bool enabled);
-    void setDNDTimeRange(uint8_t startHour, uint8_t startMinute, uint8_t endHour, uint8_t endMinute);
-    bool isDNDActive() const;
-    bool isTimeInDNDRange(uint8_t hour, uint8_t minute) const;
-    
-    // DND getters
-    bool isDNDEnabled() const { return dndEnabled; }
-    bool isDNDTimeBasedEnabled() const { return dndTimeBasedEnabled; }
-    uint8_t getDNDStartHour() const { return dndTimeRange.startHour; }
-    uint8_t getDNDStartMinute() const { return dndTimeRange.startMinute; }
-    uint8_t getDNDEndHour() const { return dndTimeRange.endHour; }
-    uint8_t getDNDEndMinute() const { return dndTimeRange.endMinute; }
-
-    // Effect methods
-    void rainbow(int wait);
-    void theaterChase(uint32_t color, int wait);
-    void theaterChaseRainbow(int wait);
-    void lightningStrike();
-    void blinkDelay(int d, int times);
-    void blinkDelayColor(int d, int times, uint r, uint g, uint b);
-    void blinkDelayTwoColor(int d, int times, const uint32_t& c1, const uint32_t& c2);
+void ledTask(void *pvParameters);
+void setupLeds();
+void setupLedTask();
+void blinkDelay(int d, int times);
+void blinkDelayColor(int d, int times, uint r, uint g, uint b);
+void blinkDelayTwoColor(int d, int times, const uint32_t& c1, const uint32_t& c2);
+void clearLeds();
+void saveLedState();
+void restoreLedState();
+QueueHandle_t getLedTaskQueue();
+bool queueLedEffect(uint effect);
+void setLights(int r, int g, int b);
+void setLights(uint32_t color);
+void ledRainbow(int wait);
+void ledTheaterChaseRainbow(int wait);
+void ledTheaterChase(uint32_t color, int wait);
+Adafruit_NeoPixel getPixels();
+void lightningStrike();

 #ifdef HAS_FRONTLIGHT
-    void frontlightFlash(int flDelayTime);
-    void frontlightFadeInAll();
-    void frontlightFadeOutAll();
-    void frontlightFadeIn(uint num);
-    void frontlightFadeOut(uint num);
-    std::vector<uint16_t> frontlightGetStatus();
-    void frontlightSetBrightness(uint brightness);
-    bool frontlightIsOn() const { return frontlightOn; }
-    void frontlightFadeInAll(int flDelayTime, bool staggered = false);
-    void frontlightFadeOutAll(int flDelayTime, bool staggered = false);
-    void frontlightFadeIn(uint num, int flDelayTime);
-    void frontlightFadeOut(uint num, int flDelayTime);
-    void initializeFrontlight();
-#endif
+void frontlightFlash(int flDelayTime);
+void frontlightFadeInAll();
+void frontlightFadeOutAll();
+void frontlightFadeIn(uint num);
+void frontlightFadeOut(uint num);

-private:
-    LedHandler();  // Private constructor for singleton
-    void loadDNDSettings();
-    static void ledTask(void* pvParameters);
+std::vector<uint16_t> frontlightGetStatus();

-    Adafruit_NeoPixel pixels;
-    TaskHandle_t ledTaskHandle;
-    QueueHandle_t ledTaskQueue;
-    uint ledTaskParams;
+void frontlightSetBrightness(uint brightness);
+bool frontlightIsOn();

-    // DND members
-    bool dndEnabled;
-    bool dndTimeBasedEnabled;
-    DNDTimeRange dndTimeRange;
+void frontlightFadeInAll(int flDelayTime);
+void frontlightFadeInAll(int flDelayTime, bool staggered);
+void frontlightFadeOutAll(int flDelayTime);
+void frontlightFadeOutAll(int flDelayTime, bool staggered);

-#ifdef HAS_FRONTLIGHT
-    static constexpr uint16_t FL_FADE_STEP = 25;
-    bool frontlightOn;
-    bool flInTransition;
-#endif
-};
-
-// Global accessor function
-inline LedHandler& getLedHandler() {
-    return LedHandler::getInstance();
-}
+void frontlightFadeIn(uint num, int flDelayTime);
+void frontlightFadeOut(uint num, int flDelayTime);
+#endif
--- a/src/lib/mining_pool/pool_factory.cpp
+++ b/src/lib/mining_pool/pool_factory.cpp
@ -5,7 +5,6 @@ const char* PoolFactory::MINING_POOL_NAME_NODERUNNERS = "noderunners";
 const char* PoolFactory::MINING_POOL_NAME_BRAIINS = "braiins";
 const char* PoolFactory::MINING_POOL_NAME_SATOSHI_RADIO = "satoshi_radio";
 const char* PoolFactory::MINING_POOL_NAME_PUBLIC_POOL = "public_pool";
-const char* PoolFactory::MINING_POOL_NAME_LOCAL_PUBLIC_POOL = "local_public_pool";
 const char* PoolFactory::MINING_POOL_NAME_GOBRRR_POOL = "gobrrr_pool";
 const char* PoolFactory::MINING_POOL_NAME_CKPOOL = "ckpool";
 const char* PoolFactory::MINING_POOL_NAME_EU_CKPOOL = "eu_ckpool";
@ -18,7 +17,6 @@ std::unique_ptr<MiningPoolInterface> PoolFactory::createPool(const std::string&
        {MINING_POOL_NAME_BRAIINS, []() { return std::make_unique<BraiinsPool>(); }},
        {MINING_POOL_NAME_SATOSHI_RADIO, []() { return std::make_unique<SatoshiRadioPool>(); }},
        {MINING_POOL_NAME_PUBLIC_POOL, []() { return std::make_unique<PublicPool>(); }},
-        {MINING_POOL_NAME_LOCAL_PUBLIC_POOL, []() { return std::make_unique<LocalPublicPool>(); }},
        {MINING_POOL_NAME_GOBRRR_POOL, []() { return std::make_unique<GoBrrrPool>(); }},
        {MINING_POOL_NAME_CKPOOL, []() { return std::make_unique<CKPool>(); }},
        {MINING_POOL_NAME_EU_CKPOOL, []() { return std::make_unique<EUCKPool>(); }}
--- a/src/lib/mining_pool/pool_factory.hpp
+++ b/src/lib/mining_pool/pool_factory.hpp
@ -10,7 +10,6 @@
 #include "ocean/ocean_pool.hpp"
 #include "satoshi_radio/satoshi_radio_pool.hpp"
 #include "public_pool/public_pool.hpp"
-#include "public_pool/local_public_pool.hpp"
 #include "gobrrr_pool/gobrrr_pool.hpp"
 #include "ckpool/ckpool.hpp"
 #include "ckpool/eu_ckpool.hpp"
@ -29,7 +28,6 @@ class PoolFactory {
            MINING_POOL_NAME_SATOSHI_RADIO,
            MINING_POOL_NAME_BRAIINS,
            MINING_POOL_NAME_PUBLIC_POOL,
-            MINING_POOL_NAME_LOCAL_PUBLIC_POOL,
            MINING_POOL_NAME_GOBRRR_POOL,
            MINING_POOL_NAME_CKPOOL,
            MINING_POOL_NAME_EU_CKPOOL
@ -57,7 +55,6 @@ class PoolFactory {
        static const char* MINING_POOL_NAME_BRAIINS;
        static const char* MINING_POOL_NAME_SATOSHI_RADIO;
        static const char* MINING_POOL_NAME_PUBLIC_POOL;
-        static const char* MINING_POOL_NAME_LOCAL_PUBLIC_POOL;
        static const char* MINING_POOL_NAME_GOBRRR_POOL;
        static const char* MINING_POOL_NAME_CKPOOL;
        static const char* MINING_POOL_NAME_EU_CKPOOL;
--- a/src/lib/mining_pool/public_pool/local_public_pool.cpp
+++ b/src/lib/mining_pool/public_pool/local_public_pool.cpp
@ -1,11 +0,0 @@
-#include "local_public_pool.hpp"
-#include "lib/shared.hpp"
-#include "lib/defaults.hpp"
-
-std::string LocalPublicPool::getEndpoint() const {
-    return preferences.getString("localPoolEndpoint", DEFAULT_LOCAL_POOL_ENDPOINT).c_str();
-}
-
-std::string LocalPublicPool::getApiUrl() const {
-    return "http://" + getEndpoint() + "/api/client/" + poolUser;
-} 
--- a/src/lib/mining_pool/public_pool/local_public_pool.hpp
+++ b/src/lib/mining_pool/public_pool/local_public_pool.hpp
@ -1,11 +0,0 @@
-#pragma once
-
-#include "public_pool.hpp"
-
-class LocalPublicPool : public PublicPool {
-public:
-    std::string getApiUrl() const override;
-    std::string getDisplayLabel() const override { return "LOCAL/POOL"; }
-private:
-    std::string getEndpoint() const;
-}; 
--- a/src/lib/mining_pool_stats_fetch.cpp
+++ b/src/lib/mining_pool_stats_fetch.cpp
@ -1,98 +1,95 @@
 #include "mining_pool_stats_fetch.hpp"

-void MiningPoolStatsFetch::taskWrapper(void* pvParameters) {
-    MiningPoolStatsFetch::getInstance().task();
+TaskHandle_t miningPoolStatsFetchTaskHandle;
+
+std::string miningPoolName;
+std::string miningPoolStatsHashrate;
+int miningPoolStatsDailyEarnings;
+
+std::string getMiningPoolStatsHashRate()
+{
+    return miningPoolStatsHashrate;
 }

-void MiningPoolStatsFetch::downloadLogoTaskWrapper(void* pvParameters) {
-    MiningPoolStatsFetch::getInstance().downloadLogoTask();
+int getMiningPoolStatsDailyEarnings()
+{
+    return miningPoolStatsDailyEarnings;
 }

-std::string MiningPoolStatsFetch::getHashRate() const {
-    return hashrate;
-}
-
-int MiningPoolStatsFetch::getDailyEarnings() const {
-    return dailyEarnings;
-}
-
-MiningPoolInterface* MiningPoolStatsFetch::getPool() {
-    if (!currentPool) {
-        std::string poolName = preferences.getString("miningPoolName", DEFAULT_MINING_POOL_NAME).c_str();
-        currentPool = PoolFactory::createPool(poolName);
-    }
-    return currentPool.get();
-}
-
-const MiningPoolInterface* MiningPoolStatsFetch::getPool() const {
-    return currentPool.get();
-}
-
-LogoData MiningPoolStatsFetch::getLogo() const {
-    if (const auto* pool = getPool()) {
-        return pool->getLogo();
-    }
-    return LogoData{};
-}
-
-void MiningPoolStatsFetch::task() {
+void taskMiningPoolStatsFetch(void *pvParameters)
+{
    std::string poolName = preferences.getString("miningPoolName", DEFAULT_MINING_POOL_NAME).c_str();
-    auto* poolInterface = getPool();
-    if (!poolInterface) return;
+    auto poolInterface = PoolFactory::createPool(poolName);
    
    std::string poolUser = preferences.getString("miningPoolUser", DEFAULT_MINING_POOL_USER).c_str();

    // Main stats fetching loop
-    for (;;) {
+    for (;;)
+    {
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);

        HTTPClient http;
        http.setUserAgent(USER_AGENT);
-        
+
+
+     
        poolInterface->setPoolUser(poolUser);
        std::string apiUrl = poolInterface->getApiUrl();
        http.begin(apiUrl.c_str());
-        if (debugLogEnabled()) {
+        if (debugLogEnabled())
+        {
            Serial.printf("Fetching mining pool stats from %s\r\n", apiUrl.c_str());
        }
        poolInterface->prepareRequest(http);
        int httpCode = http.GET();
-        if (httpCode == 200) {
+        if (httpCode == 200)
+        {
            String payload = http.getString();
            JsonDocument doc;
            deserializeJson(doc, payload);

-            if (debugLogEnabled()) {
+            if (debugLogEnabled())
+            {
                Serial.printf("Mining pool stats response: %s\r\n", payload.c_str());
            }

            PoolStats stats = poolInterface->parseResponse(doc);
-            hashrate = stats.hashrate;

-            if (debugLogEnabled()) {
+            miningPoolStatsHashrate = stats.hashrate;
+
+            if (debugLogEnabled())
+            {
                Serial.printf("Mining pool stats parsed hashrate: %s\r\n", stats.hashrate.c_str());
            }

-            dailyEarnings = stats.dailyEarnings ? *stats.dailyEarnings : 0;
+            if (stats.dailyEarnings)
+            {
+                miningPoolStatsDailyEarnings = *stats.dailyEarnings;
+            }
+            else
+            {
+                miningPoolStatsDailyEarnings = 0; // or any other default value
+            }

-            if (workQueue != nullptr && (ScreenHandler::getCurrentScreen() == SCREEN_MINING_POOL_STATS_HASHRATE || 
-                ScreenHandler::getCurrentScreen() == SCREEN_MINING_POOL_STATS_EARNINGS)) {
+            if (workQueue != nullptr && (ScreenHandler::getCurrentScreen() == SCREEN_MINING_POOL_STATS_HASHRATE || ScreenHandler::getCurrentScreen() == SCREEN_MINING_POOL_STATS_EARNINGS))
+            {
                WorkItem priceUpdate = {TASK_MINING_POOL_STATS_UPDATE, 0};
                xQueueSend(workQueue, &priceUpdate, portMAX_DELAY);
            }
-        } else {
-            Serial.print(F("Error retrieving mining pool data. HTTP status code: "));
+        }
+        else
+        {
+            Serial.print(
+                F("Error retrieving mining pool data. HTTP status code: "));
            Serial.println(httpCode);
        }
    }
 }

-void MiningPoolStatsFetch::downloadLogoTask() {
+void downloadMiningPoolLogoTask(void *pvParameters) {
    std::string poolName = preferences.getString("miningPoolName", DEFAULT_MINING_POOL_NAME).c_str();
-    auto* poolInterface = getPool();
-    if (!poolInterface) return;
-    
-    PoolFactory::downloadPoolLogo(poolName, poolInterface);
+    auto poolInterface = PoolFactory::createPool(poolName);
+    PoolFactory::downloadPoolLogo(poolName, poolInterface.get());

    // If we're on the mining pool stats screen, trigger a display update
    if (ScreenHandler::getCurrentScreen() == SCREEN_MINING_POOL_STATS_HASHRATE) {
@ -100,22 +97,41 @@ void MiningPoolStatsFetch::downloadLogoTask() {
        xQueueSend(workQueue, &priceUpdate, portMAX_DELAY);
    }

-    xTaskNotifyGive(taskHandle);
+    xTaskNotifyGive(miningPoolStatsFetchTaskHandle);
    vTaskDelete(NULL);
 }

-void MiningPoolStatsFetch::setup() {
-    xTaskCreate(downloadLogoTaskWrapper, 
+void setupMiningPoolStatsFetchTask()
+{
+    xTaskCreate(downloadMiningPoolLogoTask, 
                "logoDownload", 
                (6 * 1024),  
                NULL, 
                tskIDLE_PRIORITY,
                NULL);

-    xTaskCreate(taskWrapper, 
+    xTaskCreate(taskMiningPoolStatsFetch, 
                "miningPoolStatsFetch", 
                (6 * 1024), 
                NULL, 
                tskIDLE_PRIORITY,
-                &taskHandle);
+                &miningPoolStatsFetchTaskHandle);
+}
+
+std::unique_ptr<MiningPoolInterface>& getMiningPool()
+{
+   static std::unique_ptr<MiningPoolInterface> currentMiningPool;
+    
+    if (!currentMiningPool) {
+        std::string poolName = preferences.getString("miningPoolName", DEFAULT_MINING_POOL_NAME).c_str();
+        currentMiningPool = PoolFactory::createPool(poolName);
+    }
+
+    return currentMiningPool;
+}
+
+LogoData getMiningPoolLogo()
+{
+    LogoData logo =  getMiningPool()->getLogo();
+    return logo;
 }
--- a/src/lib/mining_pool_stats_fetch.hpp
+++ b/src/lib/mining_pool_stats_fetch.hpp
@ -2,44 +2,18 @@

 #include <Arduino.h>
 #include <HTTPClient.h>
-#include <utils.hpp>
-#include <memory>
+#include "mining_pool/pool_factory.hpp"

 #include "lib/config.hpp"
 #include "lib/shared.hpp"
-#include "lib/mining_pool/mining_pool_interface.hpp"
-#include "mining_pool/pool_factory.hpp"

-class MiningPoolStatsFetch {
-public:
-    static MiningPoolStatsFetch& getInstance() {
-        static MiningPoolStatsFetch instance;
-        return instance;
-    }
+extern TaskHandle_t miningPoolStatsFetchTaskHandle;

-    void setup();
-    std::string getHashRate() const;
-    int getDailyEarnings() const;
-    TaskHandle_t getTaskHandle() const { return taskHandle; }
-    static void taskWrapper(void* pvParameters);
-    static void downloadLogoTaskWrapper(void* pvParameters);
-    
-    // Pool interface methods
-    MiningPoolInterface* getPool();
-    const MiningPoolInterface* getPool() const;
-    LogoData getLogo() const;
+void setupMiningPoolStatsFetchTask();
+void taskMiningPoolStatsFetch(void *pvParameters);

-private:
-    MiningPoolStatsFetch() = default;
-    ~MiningPoolStatsFetch() = default;
-    MiningPoolStatsFetch(const MiningPoolStatsFetch&) = delete;
-    MiningPoolStatsFetch& operator=(const MiningPoolStatsFetch&) = delete;
+std::string getMiningPoolStatsHashRate();
+int getMiningPoolStatsDailyEarnings();

-    void task();
-    void downloadLogoTask();
-    
-    TaskHandle_t taskHandle = nullptr;
-    std::string hashrate;
-    int dailyEarnings = 0;
-    std::unique_ptr<MiningPoolInterface> currentPool;
-};
+std::unique_ptr<MiningPoolInterface>& getMiningPool();
+LogoData getMiningPoolLogo();
--- a/src/lib/nostr_notify.cpp
+++ b/src/lib/nostr_notify.cpp
@ -1,5 +1,4 @@
 #include "nostr_notify.hpp"
-#include "led_handler.hpp"

 std::vector<nostr::NostrPool *> pools;
 nostr::Transport *transport;
@ -41,7 +40,7 @@ void setupNostrNotify(bool asDatasource, bool zapNotify)
                {relay},
                {// First filter
                 {
-                     {"kinds", {"12203"}},
+                     {"kinds", {"1"}},
                     {"since", {String(getMinutesAgo(60))}},
                     {"authors", {pubKey}},
                 }},
@ -79,9 +78,8 @@ void nostrTask(void *pvParameters)
 {
    DataSourceType dataSource = getDataSource();
    if(dataSource == NOSTR_SOURCE) {
-        auto& blockNotify = BlockNotify::getInstance();
-        int blockFetch = blockNotify.fetchLatestBlock();
-        blockNotify.processNewBlock(blockFetch);
+        int blockFetch = getBlockFetch();
+        processNewBlock(blockFetch);
    }

    while (1)
@ -146,7 +144,6 @@ void handleNostrEventCallback(const String &subId, nostr::SignedNostrEvent *even
    // Use direct value access instead of multiple comparisons
    String typeValue;
    uint medianFee = 0;
-    uint blockHeight = 0;
    
    for (JsonArray tag : tags) {
        if (tag.size() != 2) continue;
@ -167,11 +164,6 @@ void handleNostrEventCallback(const String &subId, nostr::SignedNostrEvent *even
                    medianFee = tag[1].as<uint>();
                }
                break;
-            case 'b':  // blockHeight
-                if (strcmp(key, "block") == 0) {
-                    blockHeight = tag[1].as<uint>();
-                }
-                break;
        }
    }
    
@ -179,19 +171,13 @@ void handleNostrEventCallback(const String &subId, nostr::SignedNostrEvent *even
    if (!typeValue.isEmpty()) {
        if (typeValue == "priceUsd") {
            processNewPrice(obj["content"].as<uint>(), CURRENCY_USD);
-            if (blockHeight != 0) {
-                auto& blockNotify = BlockNotify::getInstance();
-                blockNotify.processNewBlock(blockHeight);
-            }
        }
        else if (typeValue == "blockHeight") {
-            auto& blockNotify = BlockNotify::getInstance();
-            blockNotify.processNewBlock(obj["content"].as<uint>());
+            processNewBlock(obj["content"].as<uint>());
        }

        if (medianFee != 0) {
-            auto& blockNotify = BlockNotify::getInstance();
-            blockNotify.processNewBlockFee(medianFee);
+            processNewBlockFee(medianFee);
        }
    }
 }
@ -296,31 +282,15 @@ void handleNostrZapCallback(const String &subId, nostr::SignedNostrEvent *event)
    }
    ScreenHandler::setCurrentScreen(SCREEN_CUSTOM);

-    EPDManager::getInstance().setContent(textEpdContent);
+    setEpdContent(textEpdContent);
    vTaskDelay(pdMS_TO_TICKS(315 * NUM_SCREENS) + pdMS_TO_TICKS(250));
    if (preferences.getBool("ledFlashOnZap", DEFAULT_LED_FLASH_ON_ZAP))
    {
-        getLedHandler().queueEffect(LED_EFFECT_NOSTR_ZAP);
+        queueLedEffect(LED_EFFECT_NOSTR_ZAP);
    }
    if (timerPeriod > 0)
    {
        esp_timer_start_periodic(screenRotateTimer,
                                timerPeriod * usPerSecond);
    }
-}
-
-// void onNostrEvent(const String &subId, const nostr::Event &event) {
-//     // This is the callback that will be called when a new event is received
-//     if (event.kind == 9735) {
-//         // Parse the zap amount from the event
-//         uint16_t amount = parseZapAmount(event);
-//         if (amount > 0) {
-//             std::array<std::string, NUM_SCREENS> zapContent = parseZapNotify(amount, true);
-//             EPDManager::getInstance().setContent(zapContent);
-            
-//             if (preferences.getBool("ledFlashOnUpd", DEFAULT_LED_FLASH_ON_UPD)) {
-//                 getLedHandler().queueEffect(LED_FLASH_BLOCK_NOTIFY);
-//             }
-//         }
-//     }
-// }
+}
--- a/src/lib/ota.cpp
+++ b/src/lib/ota.cpp
@ -1,5 +1,4 @@
 #include "ota.hpp"
-#include "led_handler.hpp"

 TaskHandle_t taskOtaHandle = NULL;
 bool isOtaUpdating = false;
@ -32,9 +31,6 @@ void setupOTA()
 void onOTAProgress(unsigned int progress, unsigned int total)
 {
  uint percentage = progress / (total / 100);
-  auto& ledHandler = getLedHandler();
-  auto& pixels = ledHandler.getPixels();
-  
  pixels.fill(pixels.Color(0, 255, 0));
  if (percentage < 100)
  {
@ -57,10 +53,10 @@ void onOTAProgress(unsigned int progress, unsigned int total)

 void onOTAStart()
 {
-  EPDManager::getInstance().forceFullRefresh();
+  forceFullRefresh();
  std::array<String, NUM_SCREENS> epdContent = {"U", "P", "D", "A",
                                                "T", "E", "!"};
-  EPDManager::getInstance().setContent(epdContent);
+  setEpdContent(epdContent);
  // Stop all timers
  esp_timer_stop(screenRotateTimer);
  esp_timer_stop(minuteTimer);
@ -74,8 +70,8 @@ void onOTAStart()
  ButtonHandler::suspendTask();

  // stopWebServer();
-  auto& blockNotify = BlockNotify::getInstance();
-  blockNotify.stop();
+  stopBlockNotify();
+  stopPriceNotify();
 }

 void handleOTATask(void *parameter)
@ -88,15 +84,15 @@ void handleOTATask(void *parameter)
    {
      if (msg.updateType == UPDATE_ALL) {
        isOtaUpdating = true;
-        getLedHandler().queueEffect(LED_FLASH_UPDATE);
+        queueLedEffect(LED_FLASH_UPDATE);
        int resultWebUi = downloadUpdateHandler(UPDATE_WEBUI);
-        getLedHandler().queueEffect(LED_FLASH_UPDATE);
+        queueLedEffect(LED_FLASH_UPDATE);
        int resultFw = downloadUpdateHandler(UPDATE_FIRMWARE);

        if (resultWebUi == 0 && resultFw == 0) {
          ESP.restart();
        } else {
-          getLedHandler().queueEffect(LED_FLASH_ERROR);
+          queueLedEffect(LED_FLASH_ERROR);
          vTaskDelay(pdMS_TO_TICKS(3000));
          ESP.restart();
        }
--- a/src/lib/price_notify.cpp
+++ b/src/lib/price_notify.cpp
@ -2,64 +2,103 @@

 const char *wsServerPrice = "wss://ws.coincap.io/prices?assets=bitcoin";

-WebSocketsClient webSocket;
+// WebsocketsClient client;
+esp_websocket_client_handle_t clientPrice = NULL;
+esp_websocket_client_config_t config;
 uint currentPrice = 90000;
 unsigned long int lastPriceUpdate;
 bool priceNotifyInit = false;
 std::map<char, std::uint64_t> currencyMap;
 std::map<char, unsigned long int> lastUpdateMap;
-TaskHandle_t priceNotifyTaskHandle;
-
-void onWebsocketPriceEvent(WStype_t type, uint8_t * payload, size_t length);
+WebSocketsClient priceNotifyWs;

 void setupPriceNotify()
 {
-  webSocket.beginSSL("ws.coincap.io", 443, "/prices?assets=bitcoin");
-  webSocket.onEvent([](WStype_t type, uint8_t * payload, size_t length) {
-    onWebsocketPriceEvent(type, payload, length);
-  });
-  webSocket.setReconnectInterval(5000);
-  webSocket.enableHeartbeat(15000, 3000, 2);
+  config = {.uri = wsServerPrice,
+            .user_agent = USER_AGENT};
+  config.cert_pem = isrg_root_x1cert;

-  setupPriceNotifyTask();
+  config.task_stack = (6*1024);
+
+
+  clientPrice = esp_websocket_client_init(&config);
+  esp_websocket_register_events(clientPrice, WEBSOCKET_EVENT_ANY,
+                                onWebsocketPriceEvent, clientPrice);
+  esp_websocket_client_start(clientPrice);
+
+  // priceNotifyWs.beginSSL("ws.coincap.io", 443, "/prices?assets=bitcoin");
+  // priceNotifyWs.onEvent(onWebsocketPriceEvent);
+  // priceNotifyWs.setReconnectInterval(5000);
+  // priceNotifyWs.enableHeartbeat(15000, 3000, 2);
 }

-void onWebsocketPriceEvent(WStype_t type, uint8_t * payload, size_t length) {
-    switch(type) {
-        case WStype_DISCONNECTED:
-            Serial.println(F("Price WS Connection Closed"));
-            break;
-        case WStype_CONNECTED:
-        {
-            Serial.println("Connected to " + String(wsServerPrice));
-            priceNotifyInit = true;
-            break;
-        }
-        case WStype_TEXT:
-        {
-            JsonDocument doc;
-            deserializeJson(doc, (char *)payload);

-            if (doc["bitcoin"].is<JsonObject>())
-            {
-                if (currentPrice != doc["bitcoin"].as<long>())
-                {
-                    processNewPrice(doc["bitcoin"].as<long>(), CURRENCY_USD);
-                }
-            }
-            break;
-        }
-        case WStype_BIN:
-            break;
-        case WStype_ERROR:            
-        case WStype_FRAGMENT_TEXT_START:
-        case WStype_FRAGMENT_BIN_START:
-        case WStype_FRAGMENT:
-        case WStype_PING:
-        case WStype_PONG:
-        case WStype_FRAGMENT_FIN:
-            break;
+// void onWebsocketPriceEvent(WStype_t type, uint8_t * payload, size_t length) {
+//     switch(type) {
+// 		case WStype_DISCONNECTED:
+// 			Serial.printf("[WSc] Disconnected!\n");
+// 			break;
+// 		case WStype_CONNECTED:
+//         {
+// 			Serial.printf("[WSc] Connected to url: %s\n", payload);
+
+
+// 			break;
+//         }
+// 		case WStype_TEXT:
+//         String message = String((char*)payload);
+//         onWebsocketPriceMessage(message);
+// 		break;
+// 		case WStype_BIN:
+// 			break;
+// 		case WStype_ERROR:			
+// 		case WStype_FRAGMENT_TEXT_START:
+// 		case WStype_FRAGMENT_BIN_START:
+// 		case WStype_FRAGMENT:
+//         case WStype_PING:
+//         case WStype_PONG:
+// 		case WStype_FRAGMENT_FIN:
+// 			break;
+// 	}
+// }
+
+void onWebsocketPriceEvent(void *handler_args, esp_event_base_t base,
+                           int32_t event_id, void *event_data)
+{
+  esp_websocket_event_data_t *data = (esp_websocket_event_data_t *)event_data;
+
+  switch (event_id)
+  {
+  case WEBSOCKET_EVENT_CONNECTED:
+    Serial.println("Connected to " + String(config.uri) + " WebSocket");
+    priceNotifyInit = true;
+
+    break;
+  case WEBSOCKET_EVENT_DATA:
+    onWebsocketPriceMessage(data);
+    break;
+  case WEBSOCKET_EVENT_ERROR:
+    Serial.println(F("Price WS Connnection error"));
+    break;
+  case WEBSOCKET_EVENT_DISCONNECTED:
+    Serial.println(F("Price WS Connnection Closed"));
+    break;
+  }
+}
+
+void onWebsocketPriceMessage(esp_websocket_event_data_t *event_data)
+{
+  JsonDocument doc;
+
+  deserializeJson(doc, (char *)event_data->data_ptr);
+
+  if (doc.containsKey("bitcoin"))
+  {
+    if (currentPrice != doc["bitcoin"].as<long>())
+    {
+      processNewPrice(doc["bitcoin"].as<long>(), CURRENCY_USD);
    }
+  }
 }

 void processNewPrice(uint newPrice, char currency)
@ -136,7 +175,9 @@ void setPrice(uint newPrice, char currency)

 bool isPriceNotifyConnected()
 {
-  return webSocket.isConnected();
+  if (clientPrice == NULL)
+    return false;
+  return esp_websocket_client_is_connected(clientPrice);
 }

 bool getPriceNotifyInit()
@ -146,30 +187,24 @@ bool getPriceNotifyInit()

 void stopPriceNotify()
 {
-  webSocket.disconnect();
-  if (priceNotifyTaskHandle != NULL) {
-    vTaskDelete(priceNotifyTaskHandle);
-    priceNotifyTaskHandle = NULL;
-  }
+  if (clientPrice == NULL)
+    return;
+  esp_websocket_client_close(clientPrice, pdMS_TO_TICKS(5000));
+  esp_websocket_client_stop(clientPrice);
+  esp_websocket_client_destroy(clientPrice);
+
+  clientPrice = NULL;
 }

 void restartPriceNotify()
 {
  stopPriceNotify();
-  setupPriceNotify();
-}
-
-void taskPriceNotify(void *pvParameters)
-{
-  for (;;)
+  if (clientPrice == NULL)
  {
-    webSocket.loop();
-    vTaskDelay(10 / portTICK_PERIOD_MS);
+    setupPriceNotify();
+    return;
  }
-}
-
-void setupPriceNotifyTask()
-{
-  xTaskCreate(taskPriceNotify, "priceNotify", (6 * 1024), NULL, tskIDLE_PRIORITY,
-              &priceNotifyTaskHandle);
+  // esp_websocket_client_close(clientPrice, pdMS_TO_TICKS(5000));
+  // esp_websocket_client_stop(clientPrice);
+  // esp_websocket_client_start(clientPrice);
 }
--- a/src/lib/price_notify.hpp
+++ b/src/lib/price_notify.hpp
@ -2,22 +2,24 @@

 #include <Arduino.h>
 #include <ArduinoJson.h>
-#include <WebSocketsClient.h>
+#include <esp_websocket_client.h>
+#include "block_notify.hpp"
 #include <string>

 #include "lib/screen_handler.hpp"

-extern TaskHandle_t priceNotifyTaskHandle;
-
 void setupPriceNotify();
-void setupPriceNotifyTask();
-void taskPriceNotify(void *pvParameters);

-void onWebsocketPriceEvent(WStype_t type, uint8_t * payload, size_t length);
+void onWebsocketPriceEvent(void *handler_args, esp_event_base_t base,
+                           int32_t event_id, void *event_data);
+//void onWebsocketPriceEvent(WStype_t type, uint8_t * payload, size_t length);
+
+void onWebsocketPriceMessage(esp_websocket_event_data_t *event_data);

 uint getPrice(char currency);
 void setPrice(uint newPrice, char currency);

+//void processNewPrice(uint newPrice);
 void processNewPrice(uint newPrice, char currency);

 bool isPriceNotifyConnected();
--- a/src/lib/screen_handler.cpp
+++ b/src/lib/screen_handler.cpp
@ -203,7 +203,7 @@ void ScreenHandler::showSystemStatusScreen() {
        String((int)round(ESP.getFreeHeap() / 1024)) + "/" +
        (int)round(ESP.getHeapSize() / 1024);
    setCurrentScreen(SCREEN_CUSTOM);
-    EPDManager::getInstance().setContent(sysStatusEpdContent);
+    setEpdContent(sysStatusEpdContent);
 }

 // Keep these as free functions
@ -220,9 +220,9 @@ void workerTask(void *pvParameters) {
                        currentScreenValue != SCREEN_BITAXE_BESTDIFF) break;
                        
                    taskEpdContent = (currentScreenValue == SCREEN_BITAXE_HASHRATE) ?
-                        parseBitaxeHashRate(BitAxeFetch::getInstance().getHashRate()) :
-                        parseBitaxeBestDiff(BitAxeFetch::getInstance().getBestDiff());
-                    EPDManager::getInstance().setContent(taskEpdContent);
+                        parseBitaxeHashRate(getBitAxeHashRate()) :
+                        parseBitaxeBestDiff(getBitaxeBestDiff());
+                    setEpdContent(taskEpdContent);
                    break;
                }

@ -231,11 +231,10 @@ void workerTask(void *pvParameters) {
                        currentScreenValue != SCREEN_MINING_POOL_STATS_EARNINGS) break;
                        
                    taskEpdContent = (currentScreenValue == SCREEN_MINING_POOL_STATS_HASHRATE) ?
-                        parseMiningPoolStatsHashRate(MiningPoolStatsFetch::getInstance().getHashRate(), *MiningPoolStatsFetch::getInstance().getPool()) :
-                        parseMiningPoolStatsDailyEarnings(MiningPoolStatsFetch::getInstance().getDailyEarnings(), 
-                            MiningPoolStatsFetch::getInstance().getPool()->getDailyEarningsLabel(), 
-                            *MiningPoolStatsFetch::getInstance().getPool());
-                    EPDManager::getInstance().setContent(taskEpdContent);
+                        parseMiningPoolStatsHashRate(getMiningPoolStatsHashRate(), *getMiningPool()) :
+                        parseMiningPoolStatsDailyEarnings(getMiningPoolStatsDailyEarnings(), 
+                            getMiningPool()->getDailyEarningsLabel(), *getMiningPool());
+                    setEpdContent(taskEpdContent);
                    break;
                }

@ -251,33 +250,31 @@ void workerTask(void *pvParameters) {
                    } else if (currentScreenValue == SCREEN_SATS_PER_CURRENCY) {
                        taskEpdContent = parseSatsPerCurrency(price, currency, preferences.getBool("useSatsSymbol", DEFAULT_USE_SATS_SYMBOL));
                    } else {
-                        auto& blockNotify = BlockNotify::getInstance();
-                        taskEpdContent = parseMarketCap(blockNotify.getBlockHeight(), price, currency,  preferences.getBool("mcapBigChar", DEFAULT_MCAP_BIG_CHAR));
+                        taskEpdContent =
+                            parseMarketCap(getBlockHeight(), price, currency,
+                                           preferences.getBool("mcapBigChar", DEFAULT_MCAP_BIG_CHAR));
                    }

-                    EPDManager::getInstance().setContent(taskEpdContent);
+                    setEpdContent(taskEpdContent);
                    break;
                }
                case TASK_FEE_UPDATE: {
                    if (currentScreenValue == SCREEN_BLOCK_FEE_RATE) {
-                        auto& blockNotify = BlockNotify::getInstance();
-                        taskEpdContent = parseBlockFees(static_cast<std::uint16_t>(blockNotify.getBlockMedianFee()));
-                        EPDManager::getInstance().setContent(taskEpdContent);
+                        taskEpdContent = parseBlockFees(static_cast<std::uint16_t>(getBlockMedianFee()));
+                        setEpdContent(taskEpdContent);
                    } 
                    break;
                }
                case TASK_BLOCK_UPDATE: {
                    if (currentScreenValue != SCREEN_HALVING_COUNTDOWN) {
-                        auto& blockNotify = BlockNotify::getInstance();
-                        taskEpdContent = parseBlockHeight(blockNotify.getBlockHeight());
+                        taskEpdContent = parseBlockHeight(getBlockHeight());
                    } else {
-                        auto& blockNotify = BlockNotify::getInstance();
-                        taskEpdContent = parseHalvingCountdown(blockNotify.getBlockHeight(), preferences.getBool("useBlkCountdown", DEFAULT_USE_BLOCK_COUNTDOWN));
+                        taskEpdContent = parseHalvingCountdown(getBlockHeight(), preferences.getBool("useBlkCountdown", DEFAULT_USE_BLOCK_COUNTDOWN));
                    }

                    if (currentScreenValue == SCREEN_HALVING_COUNTDOWN ||
                        currentScreenValue == SCREEN_BLOCK_HEIGHT) {
-                        EPDManager::getInstance().setContent(taskEpdContent);
+                        setEpdContent(taskEpdContent);
                    }
                    break;
                }
@ -304,7 +301,7 @@ void workerTask(void *pvParameters) {
                        for (uint i = 1; i < NUM_SCREENS; i++) {
                            taskEpdContent[i] = timeString[i];
                        }
-                        EPDManager::getInstance().setContent(taskEpdContent);
+                        setEpdContent(taskEpdContent);
                    }

                    break;
@ -332,6 +329,8 @@ void setupTasks() {
    xTaskCreate(taskScreenRotate, "rotateScreen", 4096, NULL, tskIDLE_PRIORITY,
                &taskScreenRotateTaskHandle);

+    waitUntilNoneBusy();
+
    if (findScreenIndexByValue(preferences.getUInt("currentScreen", DEFAULT_CURRENT_SCREEN)) != -1)
        ScreenHandler::setCurrentScreen(preferences.getUInt("currentScreen", DEFAULT_CURRENT_SCREEN));
 }
--- a/src/lib/shared.cpp
+++ b/src/lib/shared.cpp
@ -40,39 +40,39 @@
 //     "MrY=\n"
 //     "-----END CERTIFICATE-----\n";

-// const char* isrg_root_x1cert = R"EOF(
-// -----BEGIN CERTIFICATE-----
-// MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
-// TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
-// cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
-// WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
-// ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
-// MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
-// h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
-// 0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
-// A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
-// T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
-// B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
-// B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
-// KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
-// OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
-// jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
-// qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
-// rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
-// HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
-// hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
-// ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
-// 3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
-// NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
-// ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
-// TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
-// jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
-// oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
-// 4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
-// mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
-// emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
-// -----END CERTIFICATE-----
-// )EOF";
+const char* isrg_root_x1cert = R"EOF(
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----
+)EOF";


 #ifdef TEST_SCREENS
@ -179,5 +179,4 @@ void HttpHelper::end(HTTPClient* http) {
        http->end();
        delete http;
    }
-}
-
+}
--- a/src/lib/shared.hpp
+++ b/src/lib/shared.hpp
@ -16,8 +16,6 @@

 #include <mutex>
 #include <utils.hpp>
-#include <array>
-#include <string>

 #include "defaults.hpp"

@ -68,7 +66,7 @@ const int usPerSecond = 1000000;
 const int usPerMinute = 60 * usPerSecond;

 // extern const char *github_root_ca;
-// extern const char *isrg_root_x1cert;
+extern const char *isrg_root_x1cert;

 extern const uint8_t rootca_crt_bundle_start[] asm("_binary_x509_crt_bundle_start");
 // extern const uint8_t ocean_logo_comp[] asm("_binary_ocean_gz_start");
@ -120,5 +118,4 @@ private:
    static WiFiClientSecure secureClient;
    static bool certBundleSet;
    static WiFiClient insecureClient;
-};
-
+};
--- a/src/lib/timers.cpp
+++ b/src/lib/timers.cpp
@ -1,5 +1,4 @@
 #include "timers.hpp"
-#include "led_handler.hpp"

 esp_timer_handle_t screenRotateTimer;
 esp_timer_handle_t minuteTimer;
@ -50,11 +49,11 @@ void setTimerActive(bool status) {
  if (status) {
    esp_timer_start_periodic(screenRotateTimer,
                             getTimerSeconds() * usPerSecond);
-    getLedHandler().queueEffect(LED_EFFECT_START_TIMER);
+    queueLedEffect(LED_EFFECT_START_TIMER);
    preferences.putBool("timerActive", true);
  } else {
    esp_timer_stop(screenRotateTimer);
-    getLedHandler().queueEffect(LED_EFFECT_PAUSE_TIMER);
+    queueLedEffect(LED_EFFECT_PAUSE_TIMER);
    preferences.putBool("timerActive", false);
  }

@ -69,14 +68,12 @@ void IRAM_ATTR minuteTimerISR(void *arg) {
  WorkItem timeUpdate = {TASK_TIME_UPDATE, 0};
  xQueueSendFromISR(workQueue, &timeUpdate, &xHigherPriorityTaskWoken);

-  TaskHandle_t bitaxeHandle = BitAxeFetch::getInstance().getTaskHandle();
-  if (bitaxeHandle != NULL) {
-    vTaskNotifyGiveFromISR(bitaxeHandle, &xHigherPriorityTaskWoken);
+  if (bitaxeFetchTaskHandle != NULL) {
+    vTaskNotifyGiveFromISR(bitaxeFetchTaskHandle, &xHigherPriorityTaskWoken);
  }

-  TaskHandle_t miningPoolHandle = MiningPoolStatsFetch::getInstance().getTaskHandle();
-  if (miningPoolHandle != NULL) {
-    vTaskNotifyGiveFromISR(miningPoolHandle, &xHigherPriorityTaskWoken);
+  if (miningPoolStatsFetchTaskHandle != NULL) {
+    vTaskNotifyGiveFromISR(miningPoolStatsFetchTaskHandle, &xHigherPriorityTaskWoken);
  }

  if (xHigherPriorityTaskWoken == pdTRUE) {
--- a/src/lib/v2_notify.cpp
+++ b/src/lib/v2_notify.cpp
@ -106,11 +106,6 @@ namespace V2Notify
            JsonDocument doc;
            DeserializationError error = deserializeMsgPack(doc, payload, length);

-            if (error) {
-                Serial.println(F("Error deserializing message"));
-                break;
-            }
-
            V2Notify::handleV2Message(doc);
            break;
        }
@ -127,33 +122,24 @@ namespace V2Notify

    void handleV2Message(JsonDocument doc)
    {
-        if (doc["blockheight"].is<uint>())
+        if (doc.containsKey("blockheight"))
        {
            uint newBlockHeight = doc["blockheight"].as<uint>();

-            if (newBlockHeight == BlockNotify::getInstance().getBlockHeight())
+            if (newBlockHeight == getBlockHeight())
            {
                return;
            }

-            if (debugLogEnabled()) {
-                Serial.print(F("processNewBlock "));
-                Serial.println(newBlockHeight);
-            }
-            BlockNotify::getInstance().processNewBlock(newBlockHeight);
+            processNewBlock(newBlockHeight);
        }
-        else if (doc["blockfee"].is<uint>())
+        else if (doc.containsKey("blockfee"))
        {
            uint medianFee = doc["blockfee"].as<uint>();

-            if (debugLogEnabled()) {
-                Serial.print(F("processNewBlockFee "));
-                Serial.println(medianFee);
-            }
-
-            BlockNotify::getInstance().processNewBlockFee(medianFee);
+            processNewBlockFee(medianFee);
        }
-        else if (doc["price"].is<JsonObject>())
+        else if (doc.containsKey("price"))
        {

            // Iterate through the key-value pairs of the "price" object
@ -172,7 +158,7 @@ namespace V2Notify
        for (;;)
        {
            webSocket.loop();
-            vTaskDelay(pdMS_TO_TICKS(10));
+            vTaskDelay(10 / portTICK_PERIOD_MS);
        }
    }

--- a/src/lib/webserver.cpp
+++ b/src/lib/webserver.cpp
@ -1,11 +1,9 @@
 #include "webserver.hpp"
-#include "lib/led_handler.hpp"
-#include "lib/shared.hpp"

 static const char* JSON_CONTENT = "application/json";

 static const char *const PROGMEM strSettings[] = {
-    "hostnamePrefix", "mempoolInstance", "nostrPubKey", "nostrRelay", "bitaxeHostname", "miningPoolName", "miningPoolUser", "nostrZapPubkey", "httpAuthUser", "httpAuthPass", "gitReleaseUrl", "poolLogosUrl", "ceEndpoint", "fontName", "localPoolEndpoint"};
+    "hostnamePrefix", "mempoolInstance", "nostrPubKey", "nostrRelay", "bitaxeHostname", "miningPoolName", "miningPoolUser", "nostrZapPubkey", "httpAuthUser", "httpAuthPass", "gitReleaseUrl", "poolLogosUrl", "ceEndpoint", "fontName"};

 static const char *const PROGMEM uintSettings[] = {"minSecPriceUpd", "fullRefreshMin", "ledBrightness", "flMaxBrightness", "flEffectDelay", "luxLightToggle", "wpTimeout"};

@ -18,7 +16,7 @@ static const char *const PROGMEM boolSettings[] = {"ledTestOnPower", "ledFlashOn
                                                   "mempoolSecure", "bitaxeEnabled",
                                                   "miningPoolStats", "verticalDesc",
                                                   "nostrZapNotify", "httpAuthEnabled",
-                                                   "enableDebugLog", "ceDisableSSL", "dndEnabled", "dndTimeBasedEnabled"};
+                                                   "enableDebugLog", "ceDisableSSL"};

 AsyncWebServer server(80);
 AsyncEventSource events("/events");
@ -30,8 +28,7 @@ TaskHandle_t eventSourceTaskHandle;
 void setupWebserver()
 {
  events.onConnect([](AsyncEventSourceClient *client)
-                   { client->send("welcome", NULL, millis(), 1000);
-                     });
+                   { client->send("welcome", NULL, millis(), 1000); });
  server.addHandler(&events);

  AsyncStaticWebHandler &staticHandler = server.serveStatic("/", LittleFS, "/").setDefaultFile("index.html");
@ -119,10 +116,6 @@ void setupWebserver()
  server.addRewrite(new OneParamRewrite("/api/show/number/{number}",
                                        "/api/show/text?t={text}"));

-  server.on("/api/dnd/status", HTTP_GET, onApiDNDStatus);
-  server.on("/api/dnd/enable", HTTP_POST, onApiDNDEnable);
-  server.on("/api/dnd/disable", HTTP_POST, onApiDNDDisable);
-
  server.onNotFound(onNotFound);

  DefaultHeaders::Instance().addHeader("Access-Control-Allow-Origin", "*");
@ -234,7 +227,6 @@ void asyncFirmwareUpdateHandler(AsyncWebServerRequest *request, String filename,

 JsonDocument getStatusObject()
 {
-  auto& ledHandler = getLedHandler();
  JsonDocument root;

  root["currentScreen"] = ScreenHandler::getCurrentScreen();
@ -242,22 +234,25 @@ JsonDocument getStatusObject()
  root["timerRunning"] = isTimerActive();
  root["isOTAUpdating"] = getIsOTAUpdating();
  root["espUptime"] = esp_timer_get_time() / 1000000;
+  // root["currentPrice"] = getPrice();
+  // root["currentBlockHeight"] = getBlockHeight();
  root["espFreeHeap"] = ESP.getFreeHeap();
  root["espHeapSize"] = ESP.getHeapSize();
+  // root["espFreePsram"] = ESP.getFreePsram();
+  // root["espPsramSize"] = ESP.getPsramSize();

  JsonObject conStatus = root["connectionStatus"].to<JsonObject>();

  conStatus["price"] = isPriceNotifyConnected();
-  auto& blockNotify = BlockNotify::getInstance();
-  conStatus["blocks"] = blockNotify.isConnected();
+  conStatus["blocks"] = isBlockNotifyConnected();
  conStatus["V2"] = V2Notify::isV2NotifyConnected();
+
  conStatus["nostr"] = nostrConnected();

  root["rssi"] = WiFi.RSSI();
  root["currency"] = getCurrencyCode(ScreenHandler::getCurrentCurrency());
-
 #ifdef HAS_FRONTLIGHT
-  std::vector<uint16_t> statuses = ledHandler.frontlightGetStatus();
+  std::vector<uint16_t> statuses = frontlightGetStatus();
  uint16_t arr[NUM_SCREENS];
  std::copy(statuses.begin(), statuses.end(), arr);

@ -270,25 +265,14 @@ JsonDocument getStatusObject()
  }
 #endif

-  // Add DND status
-  root["dnd"]["enabled"] = ledHandler.isDNDEnabled();
-  root["dnd"]["timeBasedEnabled"] = ledHandler.isDNDTimeBasedEnabled();
-  root["dnd"]["startTime"] = String(ledHandler.getDNDStartHour()) + ":" + 
-                           (ledHandler.getDNDStartMinute() < 10 ? "0" : "") + String(ledHandler.getDNDStartMinute());
-  root["dnd"]["endTime"] = String(ledHandler.getDNDEndHour()) + ":" + 
-                         (ledHandler.getDNDEndMinute() < 10 ? "0" : "") + String(ledHandler.getDNDEndMinute());
-  root["dnd"]["active"] = ledHandler.isDNDActive();
-  
  return root;
 }

 JsonDocument getLedStatusObject()
 {
-  auto& ledHandler = getLedHandler();
-  auto& pixels = ledHandler.getPixels();
-  
  JsonDocument root;
  JsonArray colors = root["data"].to<JsonArray>();
+  //    Adafruit_NeoPixel pix = getPixels();

  for (uint i = 0; i < pixels.numPixels(); i++)
  {
@ -298,7 +282,13 @@ JsonDocument getLedStatusObject()
    uint blue = pixColor & 0xFF;
    char hexColor[8];
    snprintf(hexColor, sizeof(hexColor), "#%02X%02X%02X", red, green, blue);
-    colors.add(hexColor);
+
+
+    JsonObject object = colors.add<JsonObject>();
+    object["red"] = red;
+    object["green"] = green;
+    object["blue"] = blue;
+    object["hex"] = hexColor;
  }

  return root;
@ -307,18 +297,14 @@ JsonDocument getLedStatusObject()
 void eventSourceUpdate() {
    if (!events.count()) return;
    
-    static JsonDocument doc;
-    doc.clear();
-    
-    JsonDocument root = getStatusObject();
-    
-    root["leds"] = getLedStatusObject()["data"];
+    JsonDocument doc = getStatusObject();
+    doc["leds"] = getLedStatusObject()["data"];

    // Get current EPD content directly as array
-    std::array<String, NUM_SCREENS> epdContent = EPDManager::getInstance().getCurrentContent();
+    std::array<String, NUM_SCREENS> epdContent = getCurrentEpdContent();
    
    // Add EPD content arrays
-    JsonArray data = root["data"].to<JsonArray>();
+    JsonArray data = doc["data"].to<JsonArray>();
    
    // Copy array elements directly
    for(const auto& content : epdContent) {
@ -326,7 +312,7 @@ void eventSourceUpdate() {
    }

    String buffer;
-    serializeJson(root, buffer);
+    serializeJson(doc, buffer);
    events.send(buffer.c_str(), "status");
 }

@ -342,7 +328,7 @@ void onApiStatus(AsyncWebServerRequest *request)
  JsonDocument root = getStatusObject();
  
  // Get current EPD content directly as array
-  std::array<String, NUM_SCREENS> epdContent = EPDManager::getInstance().getCurrentContent();
+  std::array<String, NUM_SCREENS> epdContent = getCurrentEpdContent();
  
  // Add EPD content arrays
  JsonArray data = root["data"].to<JsonArray>();
@ -384,9 +370,11 @@ void onApiActionTimerRestart(AsyncWebServerRequest *request)
 */
 void onApiFullRefresh(AsyncWebServerRequest *request)
 {
-  EPDManager::getInstance().forceFullRefresh();
-  std::array<String, NUM_SCREENS> newEpdContent = EPDManager::getInstance().getCurrentContent();
-  EPDManager::getInstance().setContent(newEpdContent, true);
+  forceFullRefresh();
+  std::array<String, NUM_SCREENS> newEpdContent = getCurrentEpdContent();
+
+  setEpdContent(newEpdContent, true);
+
  request->send(HTTP_OK);
 }

@ -433,7 +421,7 @@ void onApiShowText(AsyncWebServerRequest *request)
      textEpdContent[i] = t[i];
    }

-    EPDManager::getInstance().setContent(textEpdContent);
+    setEpdContent(textEpdContent);
  }
  ScreenHandler::setCurrentScreen(SCREEN_CUSTOM);
  request->send(HTTP_OK);
@ -451,7 +439,7 @@ void onApiShowTextAdvanced(AsyncWebServerRequest *request, JsonVariant &json)
    i++;
  }

-  EPDManager::getInstance().setContent(epdContent);
+  setEpdContent(epdContent);

  ScreenHandler::setCurrentScreen(SCREEN_CUSTOM);
  request->send(HTTP_OK);
@ -479,13 +467,13 @@ void onApiSettingsPatch(AsyncWebServerRequest *request, JsonVariant &json)
    if (inverted) {
      preferences.putUInt("fgColor", GxEPD_WHITE);
      preferences.putUInt("bgColor", GxEPD_BLACK);
-      EPDManager::getInstance().setForegroundColor(GxEPD_WHITE);
-      EPDManager::getInstance().setBackgroundColor(GxEPD_BLACK);
+      setFgColor(GxEPD_WHITE);
+      setBgColor(GxEPD_BLACK);
    } else {
      preferences.putUInt("fgColor", GxEPD_BLACK);
      preferences.putUInt("bgColor", GxEPD_WHITE);
-      EPDManager::getInstance().setForegroundColor(GxEPD_BLACK);
-      EPDManager::getInstance().setBackgroundColor(GxEPD_WHITE);
+      setFgColor(GxEPD_BLACK);
+      setBgColor(GxEPD_WHITE);
    }
    Serial.printf("Setting invertedColor to %d\r\n", inverted);
    settingsChanged = true;
@ -617,29 +605,10 @@ void onApiSettingsPatch(AsyncWebServerRequest *request, JsonVariant &json)
    settingsChanged = true;
  }

-  // Handle DND settings
-  if (settings["dnd"].is<JsonObject>()) {
-    JsonObject dndObj = settings["dnd"];
-    auto& ledHandler = getLedHandler();
-    
-    if (dndObj["timeBasedEnabled"].is<bool>()) {
-      ledHandler.setDNDTimeBasedEnabled(dndObj["timeBasedEnabled"].as<bool>());
-    }
-    if (dndObj["startHour"].is<uint8_t>() && dndObj["startMinute"].is<uint8_t>() &&
-        dndObj["endHour"].is<uint8_t>() && dndObj["endMinute"].is<uint8_t>()) {
-      ledHandler.setDNDTimeRange(
-          dndObj["startHour"].as<uint8_t>(),
-          dndObj["startMinute"].as<uint8_t>(),
-          dndObj["endHour"].as<uint8_t>(),
-          dndObj["endMinute"].as<uint8_t>());
-    }
-  }
-
  request->send(HTTP_OK);
  if (settingsChanged)
  {
-    auto& ledHandler = getLedHandler();
-    ledHandler.queueEffect(LED_FLASH_SUCCESS);
+    queueLedEffect(LED_FLASH_SUCCESS);
  }
 }

@ -660,8 +629,7 @@ void onApiRestart(AsyncWebServerRequest *request)

 void onApiIdentify(AsyncWebServerRequest *request)
 {
-  auto& ledHandler = getLedHandler();
-  ledHandler.queueEffect(LED_FLASH_IDENTIFY);
+  queueLedEffect(LED_FLASH_IDENTIFY);

  request->send(HTTP_OK);
 }
@ -684,7 +652,7 @@ void onApiSettingsGet(AsyncWebServerRequest *request)

  JsonDocument root;
  root["numScreens"] = NUM_SCREENS;
-  root["invertedColor"] = preferences.getBool("invertedColor", EPDManager::getInstance().getForegroundColor() == GxEPD_WHITE);
+  root["invertedColor"] = preferences.getBool("invertedColor", getFgColor() == GxEPD_WHITE);
  root["timerSeconds"] = getTimerSeconds();
  root["timerRunning"] = isTimerActive();
  root["minSecPriceUpd"] = preferences.getUInt(
@ -701,9 +669,6 @@ void onApiSettingsGet(AsyncWebServerRequest *request)
  root["mempoolInstance"] = preferences.getString("mempoolInstance", DEFAULT_MEMPOOL_INSTANCE);
  root["mempoolSecure"] = preferences.getBool("mempoolSecure", DEFAULT_MEMPOOL_SECURE);
  
-  // Local pool settings
-  root["localPoolEndpoint"] = preferences.getString("localPoolEndpoint", DEFAULT_LOCAL_POOL_ENDPOINT);
-  
  // Nostr settings (used for NOSTR_SOURCE or when zapNotify is enabled)
  root["nostrPubKey"] = preferences.getString("nostrPubKey", DEFAULT_NOSTR_NPUB);
  root["nostrRelay"] = preferences.getString("nostrRelay", DEFAULT_NOSTR_RELAY);
@ -801,15 +766,6 @@ void onApiSettingsGet(AsyncWebServerRequest *request)
  root["ceEndpoint"] = preferences.getString("ceEndpoint", DEFAULT_CUSTOM_ENDPOINT);
  root["ceDisableSSL"] = preferences.getBool("ceDisableSSL", DEFAULT_CUSTOM_ENDPOINT_DISABLE_SSL);

-  // Add DND settings
-  auto& ledHandler = getLedHandler();
-  root["dnd"]["enabled"] = ledHandler.isDNDEnabled();
-  root["dnd"]["timeBasedEnabled"] = ledHandler.isDNDTimeBasedEnabled();
-  root["dnd"]["startHour"] = ledHandler.getDNDStartHour();
-  root["dnd"]["startMinute"] = ledHandler.getDNDStartMinute();
-  root["dnd"]["endHour"] = ledHandler.getDNDEndHour();
-  root["dnd"]["endMinute"] = ledHandler.getDNDEndMinute();
-
  AsyncResponseStream *response =
      request->beginResponseStream(JSON_CONTENT);
  serializeJson(root, *response);
@ -825,7 +781,7 @@ bool processEpdColorSettings(AsyncWebServerRequest *request)
    const AsyncWebParameter *fgColor = request->getParam("fgColor", true);
    uint32_t color = strtol(fgColor->value().c_str(), NULL, 16);
    preferences.putUInt("fgColor", color);
-    EPDManager::getInstance().setForegroundColor(color);
+    setFgColor(color);
    // Serial.print(F("Setting foreground color to "));
    // Serial.println(fgColor->value().c_str());
    settingsChanged = true;
@ -836,7 +792,7 @@ bool processEpdColorSettings(AsyncWebServerRequest *request)

    uint32_t color = strtol(bgColor->value().c_str(), NULL, 16);
    preferences.putUInt("bgColor", color);
-    EPDManager::getInstance().setBackgroundColor(color);
+    setBgColor(color);
    // Serial.print(F("Setting background color to "));
    // Serial.println(bgColor->value().c_str());
    settingsChanged = true;
@ -915,7 +871,7 @@ void onApiStopDataSources(AsyncWebServerRequest *request)
      request->beginResponseStream(JSON_CONTENT);

  stopPriceNotify();
-  BlockNotify::getInstance().stop();
+  stopBlockNotify();

  request->send(response);
 }
@ -926,15 +882,16 @@ void onApiRestartDataSources(AsyncWebServerRequest *request)
      request->beginResponseStream(JSON_CONTENT);

  restartPriceNotify();
-  BlockNotify::getInstance().restart();
+  restartBlockNotify();
+  //  setupPriceNotify();
+  //  setupBlockNotify();

  request->send(response);
 }

 void onApiLightsOff(AsyncWebServerRequest *request)
 {
-  auto& ledHandler = getLedHandler();
-  ledHandler.setLights(0, 0, 0);
+  setLights(0, 0, 0);
  request->send(HTTP_OK);
 }

@ -949,15 +906,13 @@ void onApiLightsSetColor(AsyncWebServerRequest *request)

    if (rgbColor.compareTo("off") == 0)
    {
-      auto& ledHandler = getLedHandler();
-      ledHandler.setLights(0, 0, 0);
+      setLights(0, 0, 0);
    }
    else
    {
      uint r, g, b;
      sscanf(rgbColor.c_str(), "%02x%02x%02x", &r, &g, &b);
-      auto& ledHandler = getLedHandler();
-      ledHandler.setLights(r, g, b);
+      setLights(r, g, b);
    }

    JsonDocument doc;
@ -975,9 +930,6 @@ void onApiLightsSetColor(AsyncWebServerRequest *request)

 void onApiLightsSetJson(AsyncWebServerRequest *request, JsonVariant &json)
 {
-  auto& ledHandler = getLedHandler();
-  auto& pixels = ledHandler.getPixels();
-  
  JsonArray lights = json.as<JsonArray>();

  if (lights.size() != pixels.numPixels())
@ -1026,7 +978,7 @@ void onApiLightsSetJson(AsyncWebServerRequest *request, JsonVariant &json)
  }

  pixels.show();
-  ledHandler.saveLedState();
+  saveLedState();

  request->send(HTTP_OK);
 }
@ -1090,21 +1042,19 @@ void onApiShowCurrency(AsyncWebServerRequest *request)
 #ifdef HAS_FRONTLIGHT
 void onApiFrontlightOn(AsyncWebServerRequest *request)
 {
-  auto& ledHandler = getLedHandler();
-  ledHandler.frontlightFadeInAll();
+  frontlightFadeInAll();

  request->send(HTTP_OK);
 }

 void onApiFrontlightStatus(AsyncWebServerRequest *request)
 {
-  auto& ledHandler = getLedHandler();
  AsyncResponseStream *response =
      request->beginResponseStream(JSON_CONTENT);

  JsonDocument root;

-  std::vector<uint16_t> statuses = ledHandler.frontlightGetStatus();
+  std::vector<uint16_t> statuses = frontlightGetStatus();
  uint16_t arr[NUM_SCREENS];
  std::copy(statuses.begin(), statuses.end(), arr);

@ -1117,8 +1067,7 @@ void onApiFrontlightStatus(AsyncWebServerRequest *request)

 void onApiFrontlightFlash(AsyncWebServerRequest *request)
 {
-  auto& ledHandler = getLedHandler();
-  ledHandler.frontlightFlash(preferences.getUInt("flEffectDelay"));
+  frontlightFlash(preferences.getUInt("flEffectDelay"));

  request->send(HTTP_OK);
 }
@ -1127,8 +1076,7 @@ void onApiFrontlightSetBrightness(AsyncWebServerRequest *request)
 {
  if (request->hasParam("b"))
  {
-    auto& ledHandler = getLedHandler();
-    ledHandler.frontlightSetBrightness(request->getParam("b")->value().toInt());
+    frontlightSetBrightness(request->getParam("b")->value().toInt());
    request->send(HTTP_OK);
  }
  else
@ -1139,123 +1087,8 @@ void onApiFrontlightSetBrightness(AsyncWebServerRequest *request)

 void onApiFrontlightOff(AsyncWebServerRequest *request)
 {
-  auto& ledHandler = getLedHandler();
-  ledHandler.frontlightFadeOutAll();
+  frontlightFadeOutAll();

  request->send(HTTP_OK);
 }
-#endif
-
-void onApiDNDTimeBasedEnable(AsyncWebServerRequest *request) {
-  auto& ledHandler = getLedHandler();
-  ledHandler.setDNDTimeBasedEnabled(true);
-  request->send(200);
-}
-
-void onApiDNDTimeBasedDisable(AsyncWebServerRequest *request) {
-  auto& ledHandler = getLedHandler();
-  ledHandler.setDNDTimeBasedEnabled(false);
-  request->send(200);
-}
-
-void onApiDNDSetTimeRange(AsyncWebServerRequest *request) {
-  if (request->hasParam("startHour") && request->hasParam("startMinute") &&
-      request->hasParam("endHour") && request->hasParam("endMinute")) {
-    auto& ledHandler = getLedHandler();
-    uint8_t startHour = request->getParam("startHour")->value().toInt();
-    uint8_t startMinute = request->getParam("startMinute")->value().toInt();
-    uint8_t endHour = request->getParam("endHour")->value().toInt();
-    uint8_t endMinute = request->getParam("endMinute")->value().toInt();
-    
-    ledHandler.setDNDTimeRange(startHour, startMinute, endHour, endMinute);
-    request->send(200);
-  } else {
-    request->send(400);
-  }
-}
-
-void onApiDNDStatus(AsyncWebServerRequest *request) {
-  auto& ledHandler = getLedHandler();
-  JsonDocument doc;
-  doc["enabled"] = ledHandler.isDNDEnabled();
-  doc["timeBasedEnabled"] = ledHandler.isDNDTimeBasedEnabled();
-  doc["startTime"] = String(ledHandler.getDNDStartHour()) + ":" + 
-                     (ledHandler.getDNDStartMinute() < 10 ? "0" : "") + String(ledHandler.getDNDStartMinute());
-  doc["endTime"] = String(ledHandler.getDNDEndHour()) + ":" + 
-                 (ledHandler.getDNDEndMinute() < 10 ? "0" : "") + String(ledHandler.getDNDEndMinute());
-  doc["active"] = ledHandler.isDNDActive();
-  
-  String response;
-  serializeJson(doc, response);
-  request->send(200, "application/json", response);
-}
-
-void onApiDNDEnable(AsyncWebServerRequest *request) {
-  auto& ledHandler = getLedHandler();
-  ledHandler.setDNDEnabled(true);
-  request->send(200);
-}
-
-void onApiDNDDisable(AsyncWebServerRequest *request) {
-  auto& ledHandler = getLedHandler();
-  ledHandler.setDNDEnabled(false);
-  request->send(200);
-}
-
-void onApiLightsGet(AsyncWebServerRequest *request)
-{
-  auto& ledHandler = getLedHandler();
-  auto& pixels = ledHandler.getPixels();
-  
-  JsonDocument doc;
-  JsonArray lights = doc.createNestedArray("lights");
-
-  for (uint i = 0; i < pixels.numPixels(); i++)
-  {
-    uint32_t pixColor = pixels.getPixelColor(pixels.numPixels() - i - 1);
-    JsonObject light = lights.createNestedObject();
-    light["r"] = (uint8_t)(pixColor >> 16);
-    light["g"] = (uint8_t)(pixColor >> 8);
-    light["b"] = (uint8_t)pixColor;
-  }
-
-  String output;
-  serializeJson(doc, output);
-  request->send(200, "application/json", output);
-}
-
-void onApiLightsPost(AsyncWebServerRequest *request, uint8_t *data, size_t len,
-                    size_t index, size_t total)
-{
-  auto& ledHandler = getLedHandler();
-  auto& pixels = ledHandler.getPixels();
-  
-  JsonDocument doc;
-  DeserializationError error = deserializeJson(doc, data);
-  if (error)
-  {
-    request->send(400);
-    return;
-  }
-
-  JsonArray lights = doc["lights"];
-  if (lights.size() != pixels.numPixels())
-  {
-    request->send(400);
-    return;
-  }
-
-  for (uint i = 0; i < pixels.numPixels(); i++)
-  {
-    JsonObject light = lights[i];
-    uint8_t red = light["r"];
-    uint8_t green = light["g"];
-    uint8_t blue = light["b"];
-
-    pixels.setPixelColor((pixels.numPixels() - i - 1),
-                        pixels.Color(red, green, blue));
-  }
-  pixels.show();
-
-  request->send(200);
-}
+#endif
--- a/src/lib/webserver.hpp
+++ b/src/lib/webserver.hpp
@ -67,10 +67,6 @@ void eventSourceTask(void *pvParameters);
 void onApiStopDataSources(AsyncWebServerRequest *request);
 void onApiRestartDataSources(AsyncWebServerRequest *request);

-void onApiDNDStatus(AsyncWebServerRequest *request);
-void onApiDNDEnable(AsyncWebServerRequest *request);
-void onApiDNDDisable(AsyncWebServerRequest *request);
-
 #ifdef HAS_FRONTLIGHT
 void onApiFrontlightOn(AsyncWebServerRequest *request);
 void onApiFrontlightFlash(AsyncWebServerRequest *request);
--- a/src/main.cpp
+++ b/src/main.cpp
@ -18,8 +18,6 @@
 #define WEBSERVER_H
 #include "ESPAsyncWebServer.h"
 #include "lib/config.hpp"
-#include "lib/led_handler.hpp"
-#include "lib/block_notify.hpp"

 uint wifiLostConnection;
 uint priceNotifyLostConnection = 0;
@ -50,8 +48,7 @@ void handleBlockNotifyDisconnection() {
    
    if ((getUptime() - blockNotifyLostConnection) > 300) { // 5 minutes timeout
        Serial.println(F("Block notification connection lost for 5 minutes, restarting handler..."));
-        auto& blockNotify = BlockNotify::getInstance();
-        blockNotify.restart();
+        restartBlockNotify();
        blockNotifyLostConnection = 0;
    }
 } 
@ -61,14 +58,13 @@ void handleFrontlight() {
  if (hasLightLevel() && preferences.getUInt("luxLightToggle", DEFAULT_LUX_LIGHT_TOGGLE) != 0) {
    uint lightLevel = getLightLevel();
    uint luxThreshold = preferences.getUInt("luxLightToggle", DEFAULT_LUX_LIGHT_TOGGLE);
-    auto& ledHandler = getLedHandler();
    
    if (lightLevel <= 1 && preferences.getBool("flOffWhenDark", DEFAULT_FL_OFF_WHEN_DARK)) {
-      if (ledHandler.frontlightIsOn()) ledHandler.frontlightFadeOutAll();
-    } else if (lightLevel < luxThreshold && !ledHandler.frontlightIsOn()) {
-      ledHandler.frontlightFadeInAll();
-    } else if (ledHandler.frontlightIsOn() && lightLevel > luxThreshold) {
-      ledHandler.frontlightFadeOutAll();
+      if (frontlightIsOn()) frontlightFadeOutAll();
+    } else if (lightLevel < luxThreshold && !frontlightIsOn()) {
+      frontlightFadeInAll();
+    } else if (frontlightIsOn() && lightLevel > luxThreshold) {
+      frontlightFadeOutAll();
    }
  }
 #endif
@ -94,18 +90,19 @@ void checkWiFiConnection() {

 void checkMissedBlocks() {
  Serial.println(F("Long time (45 min) since last block, checking if I missed anything..."));
-  auto& blockNotify = BlockNotify::getInstance();
-  int currentBlock = blockNotify.fetchLatestBlock();
+  int currentBlock = getBlockFetch();
  if (currentBlock != -1) {
-    if (currentBlock != blockNotify.getBlockHeight()) {
+    if (currentBlock != getBlockHeight()) {
      Serial.println(F("Detected stuck block height... restarting block handler."));
-      blockNotify.restart();
+      restartBlockNotify();
    }
-    blockNotify.setLastBlockUpdate(getUptime());
+    setLastBlockUpdate(getUptime());
  }
 }

+
 void monitorDataConnections() {
+ 
  // Price notification monitoring
  if (getPriceNotifyInit() && !preferences.getBool("fetchEurPrice", DEFAULT_FETCH_EUR_PRICE) && !isPriceNotifyConnected()) {
    handlePriceNotifyDisconnection();
@ -114,10 +111,9 @@ void monitorDataConnections() {
  }

  // Block notification monitoring
-  auto& blockNotify = BlockNotify::getInstance();
-  if (blockNotify.isInitialized() && !blockNotify.isConnected()) {
+  if (getBlockNotifyInit() && !isBlockNotifyConnected()) {
    handleBlockNotifyDisconnection();
-  } else if (blockNotifyLostConnection > 0 && blockNotify.isConnected()) {
+  } else if (blockNotifyLostConnection > 0 && isBlockNotifyConnected()) {
    blockNotifyLostConnection = 0;
  }

@ -129,7 +125,7 @@ void monitorDataConnections() {
  }

  // Check for missed blocks
-  if ((blockNotify.getLastBlockUpdate() - getUptime()) > 45 * 60) {
+  if ((getLastBlockUpdate() - getUptime()) > 45 * 60) {
    checkMissedBlocks();
  }
 }
@ -141,6 +137,7 @@ extern "C" void app_main() {

  bool thirdPartySource = getDataSource() == THIRD_PARTY_SOURCE;

+
  while (true) {
    if (eventSourceTaskHandle != NULL) {
      xTaskNotifyGive(eventSourceTaskHandle);
--- a/test/test_bitaxehandler/test_main.cpp
+++ b/test/test_bitaxehandler/test_main.cpp
@ -1,75 +0,0 @@
-#include <bitaxe_handler.hpp>
-#include <unity.h>
-
-template<size_t N>
-std::string joinArrayWithBrackets(const std::array<std::string, N>& arr, const std::string& separator = " ") {
-    std::ostringstream result;
-    for (size_t i = 0; i < N; ++i) {
-        if (i > 0) {
-            result << separator;
-        }
-        result << '[' << arr[i] << ']';
-    }
-    return result.str();
-}
-
-void setUp(void)
-{
-    // set stuff up here
-}
-
-void tearDown(void)
-{
-    // clean stuff up here
-}
-
-void test_BitaxeParseHashrate(void)
-{
-    std::array<std::string, NUM_SCREENS> output = parseBitaxeHashRate(656130000000);
-
-    std::string joined = joinArrayWithBrackets(output);
-
-
-    TEST_ASSERT_EQUAL_STRING_MESSAGE("mdi:bitaxe", output[0].c_str(), joined.c_str());
-
-    TEST_ASSERT_EQUAL_STRING_MESSAGE("6", output[NUM_SCREENS - 4].c_str(), joined.c_str());
-    TEST_ASSERT_EQUAL_STRING_MESSAGE("5", output[NUM_SCREENS - 3].c_str(), joined.c_str());
-    TEST_ASSERT_EQUAL_STRING_MESSAGE("6", output[NUM_SCREENS - 2].c_str(), joined.c_str());
-    TEST_ASSERT_EQUAL_STRING_MESSAGE("GH/S", output[NUM_SCREENS - 1].c_str(), joined.c_str());
-}
-
-void test_BitaxeParseBestDiff(void)
-{
-    std::array<std::string, NUM_SCREENS> output = parseBitaxeBestDiff(15800000000);
-
-    std::string joined = joinArrayWithBrackets(output);
-
-    TEST_ASSERT_EQUAL_STRING_MESSAGE("mdi:bitaxe", output[0].c_str(), joined.c_str());
-
-
-    TEST_ASSERT_EQUAL_STRING_MESSAGE("1", output[NUM_SCREENS - 5].c_str(), joined.c_str());
-    TEST_ASSERT_EQUAL_STRING_MESSAGE("5", output[NUM_SCREENS - 4].c_str(), joined.c_str());
-    TEST_ASSERT_EQUAL_STRING_MESSAGE(".", output[NUM_SCREENS - 3].c_str(), joined.c_str());
-    TEST_ASSERT_EQUAL_STRING_MESSAGE("8", output[NUM_SCREENS - 2].c_str(), joined.c_str());
-    TEST_ASSERT_EQUAL_STRING_MESSAGE("G", output[NUM_SCREENS - 1].c_str(), joined.c_str());
-}
-
-// not needed when using generate_test_runner.rb
-int runUnityTests(void)
-{
-    UNITY_BEGIN();
-    RUN_TEST(test_BitaxeParseHashrate);
-    RUN_TEST(test_BitaxeParseBestDiff);
-
-    return UNITY_END();
-}
-
-int main(void)
-{
-    return runUnityTests();
-}
-
-extern "C" void app_main()
-{
-    runUnityTests();
-}