Remove block 570 checkpoint - let nodes sync naturally to main chain

IBD stall fix: restore IsInitialBlockDownload() time check, add block 570 checkpoint, fix version handler IBD bypass
Promote NewIterator() override to public in both chain DB backends
2026-05-24 21:54:42 -07:00 · 2026-05-24 15:40:29 -07:00 · 2026-05-13 01:01:44 -07:00 · 2026-05-13 00:44:08 -07:00 · 2026-05-11 03:07:58 -07:00 · 2026-05-11 03:07:57 -07:00
415 changed files with 49929 additions and 162887 deletions
@@ -0,0 +1,49 @@
+# Triangles code style.
+# Conservative: do not reflow long lines, do not reorganize includes.
+# This config is enforced *only on changed lines* via `git clang-format` in CI,
+# so it shapes new/edited code without touching legacy files until they're touched.
+
+BasedOnStyle: LLVM
+Language: Cpp
+Standard: c++17
+
+IndentWidth: 4
+TabWidth: 4
+UseTab: Never
+ContinuationIndentWidth: 4
+AccessModifierOffset: -4
+
+ColumnLimit: 0          # Don't reflow long lines — too disruptive for legacy code.
+ReflowComments: false
+
+BreakBeforeBraces: Attach
+AllowShortFunctionsOnASingleLine: Inline
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+
+PointerAlignment: Left
+DerivePointerAlignment: false
+SpaceAfterCStyleCast: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+SpaceBeforeAssignmentOperators: true
+
+NamespaceIndentation: None
+FixNamespaceComments: true
+
+# Includes: don't shuffle — header order in this codebase is load-bearing
+# (e.g. main.cpp's mix of project + system headers carries platform meaning).
+SortIncludes: false
+IncludeBlocks: Preserve
+
+KeepEmptyLinesAtTheStartOfBlocks: false
+MaxEmptyLinesToKeep: 2
+
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignTrailingComments: true
+
+# Don't auto-add braces to single-statement bodies — too invasive.
+InsertBraces: false
@@ -0,0 +1,46 @@
+# Triangles clang-tidy config.
+#
+# Goal: catch real bugs in new/edited code without drowning in noise from
+# legacy patterns. Enforced *diff-only* in CI (changed lines on PRs).
+#
+# Conservative starter set. Graduate checks to WarningsAsErrors only after
+# the codebase is clean for that check.
+
+Checks: >
+  -*,
+  bugprone-*,
+  performance-*,
+  readability-misleading-indentation,
+  readability-redundant-control-flow,
+  readability-redundant-smartptr-get,
+  readability-redundant-string-cstr,
+  readability-redundant-string-init,
+  readability-string-compare,
+  modernize-use-nullptr,
+  modernize-use-override,
+  modernize-deprecated-headers,
+  cppcoreguidelines-init-variables,
+  cppcoreguidelines-pro-type-member-init,
+  -bugprone-easily-swappable-parameters,
+  -bugprone-implicit-widening-of-multiplication-result,
+  -bugprone-narrowing-conversions,
+  -bugprone-branch-clone,
+  -bugprone-signed-char-misuse,
+  -bugprone-reserved-identifier,
+  -bugprone-unchecked-optional-access,
+  -performance-no-int-to-ptr,
+  -performance-avoid-endl
+
+# Warn-only initially. Once a check is clean repo-wide we can promote it here.
+WarningsAsErrors: ''
+
+# Run on project sources; skip vendored/generated code.
+HeaderFilterRegex: '^.*src/(?!json/nlohmann_json|leveldb|lz4|tor/tor-src).*\.h$'
+
+FormatStyle: file
+
+CheckOptions:
+  - key: readability-identifier-naming.IgnoreMainLikeFunctions
+    value: '1'
+  - key: cppcoreguidelines-init-variables.IncludeStyle
+    value: 'google'
@@ -1,10 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"ls /mingw64/lib/libboost_system* 2>/dev/null\")"
-    ],
-    "additionalDirectories": [
-      "C:\\msys64\\mingw64\\bin"
-    ]
-  }
-}
@@ -1,79 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(git clone:*)",
-      "Bash(git init:*)",
-      "Bash(git remote add:*)",
-      "Bash(git fetch:*)",
-      "Bash(git checkout:*)",
-      "Bash(git config:*)",
-      "Bash(git -C \"E:\\\\repos\\\\triangles_old\" log --oneline --all)",
-      "Bash(git -C \"E:\\\\repos\\\\triangles_old\" branch -a)",
-      "Bash(git -C \"E:\\\\repos\\\\triangles_old\" log --oneline --all --graph)",
-      "Bash(git -C \"E:\\\\repos\\\\triangles_old\" show 7676e66 --stat)",
-      "Bash(python:*)",
-      "Bash(where:*)",
-      "Bash(powershell:*)",
-      "Bash(C:/msys64/usr/bin/bash.exe -lc \"pacman -Syu --noconfirm\")",
-      "Bash(C:/msys64/usr/bin/bash.exe -lc \"pacman -S --needed --noconfirm mingw-w64-x86_64-toolchain make\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"ls /mingw64/lib/libboost_system*.a 2>/dev/null; ls /mingw64/lib/cmake/boost_system* 2>/dev/null; ls /mingw64/lib/libboost*.a 2>/dev/null | head -10\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"cd /c/Qt/deps/openssl-1.0.2u && make -j4 2>&1 | tail -10\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"cd /e/repos/triangles && mingw32-make -j4 2>&1 | tail -40\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"cd /e/repos/triangles && mingw32-make -j1 2>&1 | grep ''error:'' | grep -v ''bignum'' | sort -u | head -30\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"cd /e/repos/triangles && mingw32-make -j4 2>&1 | grep ''error:'' | sort -u | head -30\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"grep ''MINIUPNPC_API_VERSION'' /mingw64/include/miniupnpc/miniupnpc.h\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"grep -A3 ''upnpDiscover\\('' /mingw64/include/miniupnpc/miniupnpc.h | head -10\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"grep -B1 -A5 ''UPNP_GetValidIGD\\('' /mingw64/include/miniupnpc/miniupnpc.h\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"cd /e/repos/triangles && qmake-qt5 triangles-qt.pro 2>&1 | tail -5 && mingw32-make -j4 2>&1 | grep ''error:'' | sort -u | head -30\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"cd /e/repos/triangles && mingw32-make clean 2>&1 | tail -5 && qmake triangles-qt.pro 2>&1 && mingw32-make -j4 2>&1 | grep ''error:'' | sort -u | head -40\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"export PATH=/mingw64/bin:$PATH && cd /e/repos/triangles && rm -f build/*.o build/*.cpp 2>/dev/null; qmake triangles-qt.pro && mingw32-make -j4 2>&1 | grep ''error:'' | sort -u | head -40\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"cd /e/repos/triangles && rm -f build/*.o build/*.cpp 2>/dev/null; /mingw64/bin/qmake triangles-qt.pro && mingw32-make -j4 2>&1 | grep ''error:'' | sort -u | head -40\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"which qmake 2>/dev/null || ls /mingw64/bin/qmake* 2>/dev/null || ls /mingw64/share/qt5/bin/qmake* 2>/dev/null || find /mingw64 -name ''qmake*'' -type f 2>/dev/null | head -5\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"cd /e/repos/triangles && rm -f build/*.o build/*.cpp 2>/dev/null; qmake-qt5 triangles-qt.pro && mingw32-make -j4 2>&1 | grep ''error:'' | sort -u | head -40\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"cd /e/repos/triangles && mingw32-make -j4 2>&1 | grep ''error:'' | sort -u | head -40\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"cd /e/repos/triangles && mingw32-make -j4 2>&1 | grep -E ''error:'' | sort -u | head -40\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"find /e/repos/triangles -name ''*.exe'' -type f 2>/dev/null; ls -la /e/repos/triangles/release/ 2>/dev/null; ls -la /e/repos/triangles/debug/ 2>/dev/null\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"cd /e/repos/triangles && mingw32-make -j4 2>&1 | tail -60\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"pacman -S --noconfirm mingw-w64-x86_64-qt5-tools 2>&1 | tail -10\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"which lrelease 2>/dev/null; which lrelease-qt5 2>/dev/null; ls /mingw64/bin/lrelease* 2>/dev/null\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"ln -sf /mingw64/bin/lrelease-qt5.exe /mingw64/bin/lrelease.exe 2>/dev/null; ls -la /mingw64/bin/lrelease.exe\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"cd /e/repos/triangles && mingw32-make -j4 2>&1 | tail -80\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"cd /e/repos/triangles && qmake-qt5 triangles-qt.pro && mingw32-make -j4 2>&1 | tail -30\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"find /mingw64/lib -name ''*boost_system*'' 2>/dev/null\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"find /mingw64/lib -name ''libboost_*'' -name ''*.a'' 2>/dev/null | head -20\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"cd /e/repos/triangles && rm -f build/net.o && mingw32-make -j4 2>&1 | tail -20\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"ls -la /e/repos/triangles/release/triangles-qt.exe\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"cd /e/repos/triangles/release && ldd triangles-qt.exe 2>/dev/null | grep mingw64\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"cd /e/repos/triangles/release && ./triangles-qt.exe &\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"identify /e/repos/triangles/src/qt/res/images/header_logo.png 2>/dev/null || file /e/repos/triangles/src/qt/res/images/header_logo.png\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"ls -la /e/repos/triangles/src/qt/res/images/ | grep -i header\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"cp ''/e/TRI/TRI logo w name new1 \\(300 x 63 px\\).png'' ''/e/repos/triangles/src/qt/res/images/header_logo.png'' && file ''/e/repos/triangles/src/qt/res/images/header_logo.png''\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"taskkill //IM triangles-qt.exe //F 2>/dev/null; echo done\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"cd /e/repos/triangles && qmake-qt5 triangles-qt.pro && mingw32-make -j4 2>&1 | tail -10\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"cd /e/repos/triangles/src/qt/locale && sed -i ''s|https://bittrex.com/Market/Index?MarketName=BTC-TRI|https://313.cash|g'' *.ts && sed -i ''s|TRI on Bittrex|TRI on Pinball|g'' *.ts && echo done\")",
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"cp ''/e/TRI/Copy of TRI logo w name new4 \\(300x63\\).png'' ''/e/repos/triangles/src/qt/res/images/header_logo.png'' && file ''/e/repos/triangles/src/qt/res/images/header_logo.png''\")",
-      "Bash(git add:*)",
-      "Bash(git push)",
-      "Bash(git remote set-url:*)",
-      "Bash(git -c http.sslVerify=false push)",
-      "Bash(git -c credential.helper= push)",
-      "Bash(ls:*)",
-      "Bash(cmd /c \"set PATH=C:\\\\msys64\\\\mingw64\\\\bin;C:\\\\msys64\\\\usr\\\\bin;%PATH% && where qmake && where mingw32-make && where g++\")",
-      "Bash(PATH=\"/c/msys64/mingw64/bin:/c/msys64/usr/bin:$PATH\")",
-      "Bash(qmake-qt5:*)",
-      "Bash(mingw32-make:*)",
-      "Bash(ldd:*)",
-      "Bash(objdump:*)",
-      "Bash(/c/msys64/mingw64/bin/objdump.exe:*)",
-      "Bash(tasklist:*)",
-      "Bash(cmd.exe /c \"start /b E:\\\\repos\\\\triangles\\\\release\\\\triangles-qt.exe -datadir=E:\\\\Coins\\\\TRI -reindex\")",
-      "Bash(gcc:*)",
-      "Bash(/c/msys64/mingw64/bin/gcc.exe:*)",
-      "Bash(cmd.exe:*)",
-      "Bash(PATH=\"/c/msys64/mingw64/bin:$PATH\" /e/repos/triangles/scan_chain_tip.exe:*)",
-      "Bash(PATH=\"/c/msys64/mingw64/bin:$PATH\" /c/msys64/mingw64/bin/qmake.exe:*)",
-      "Bash(PATH=\"/c/msys64/mingw64/bin:$PATH\" qmake-qt5:*)",
-      "Bash(PATH=\"/c/msys64/mingw64/bin:$PATH\" mingw32-make:*)"
-    ]
-  }
-}
@@ -0,0 +1,11 @@
+# Revisions listed here are skipped by `git blame` when --ignore-revs-file
+# is configured. GitHub honors this file automatically.
+#
+# Add the SHA of any large mechanical reformat / rename / mass-style commit
+# below, with a one-line comment.
+#
+# Example:
+#   abc1234567890abcdef  # repo-wide clang-format (no behavior change)
+#
+# To enable locally:
+#   git config blame.ignoreRevsFile .git-blame-ignore-revs
@@ -2,16 +2,89 @@ name: Build All Platforms

 on:
  push:
-    branches: [master]
+    branches: [master, cpp20-modernization]
    tags: ['v*']
  pull_request:
    branches: [master]
  workflow_dispatch:

-env:
-  VERSION: "5.1.8"
-
 jobs:
+  test-linux-unit:
+    runs-on: ubuntu-22.04
+    continue-on-error: true
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y build-essential cmake ninja-build \
+            libboost-all-dev libssl-dev libdb++-dev libleveldb-dev \
+            librocksdb-dev libevent-dev libminiupnpc-dev zlib1g-dev
+
+      - name: Configure
+        run: |
+          cmake -B build -G Ninja \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DBUILD_QT=OFF \
+            -DBUILD_DAEMON=ON \
+            -DBUILD_TESTS=ON \
+            -DUSE_UPNP=OFF
+
+      - name: Build
+        run: cmake --build build -j$(nproc)
+
+      - name: Run unit tests
+        run: cd build && ctest --output-on-failure || true
+
+  test-linux-sanitizers:
+    # ASan + UBSan build of the daemon + unit tests. Allowed to fail until
+    # findings are triaged — see .github/workflows/lint.yml comment block.
+    # Once the test suite is clean under sanitizers, drop continue-on-error.
+    runs-on: ubuntu-22.04
+    continue-on-error: true
+    env:
+      # ASan: leak detection off by default (BDB and OpenSSL produce noise on shutdown).
+      # Re-enable once we've quieted the legitimate suspects.
+      ASAN_OPTIONS: "detect_leaks=0:halt_on_error=1:abort_on_error=1:print_stacktrace=1:strict_string_checks=1:detect_stack_use_after_return=1"
+      # UBSan: print full stack traces on first error and exit non-zero.
+      UBSAN_OPTIONS: "halt_on_error=1:abort_on_error=1:print_stacktrace=1"
+      # Suppress UB categories that are pervasive in the Hash9 C cascade
+      # and BDB until they're fixed file-by-file.
+      SAN_FLAGS: "-fsanitize=address,undefined -fno-omit-frame-pointer -fno-sanitize-recover=undefined -fno-sanitize=alignment,signed-integer-overflow,vptr"
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y build-essential cmake ninja-build \
+            libboost-all-dev libssl-dev libdb++-dev libleveldb-dev \
+            librocksdb-dev libevent-dev libminiupnpc-dev zlib1g-dev
+
+      - name: Configure with sanitizers
+        run: |
+          cmake -B build-san -G Ninja \
+            -DCMAKE_BUILD_TYPE=Debug \
+            -DCMAKE_C_FLAGS="$SAN_FLAGS" \
+            -DCMAKE_CXX_FLAGS="$SAN_FLAGS" \
+            -DCMAKE_EXE_LINKER_FLAGS="$SAN_FLAGS" \
+            -DCMAKE_SHARED_LINKER_FLAGS="$SAN_FLAGS" \
+            -DBUILD_QT=OFF \
+            -DBUILD_DAEMON=ON \
+            -DBUILD_TESTS=ON \
+            -DUSE_UPNP=OFF
+
+      - name: Build
+        run: cmake --build build-san -j$(nproc)
+
+      - name: Run unit tests under sanitizers
+        run: cd build-san && ctest --output-on-failure
+
  build-windows-qt:
    runs-on: windows-latest
    defaults:
@@ -19,6 +92,8 @@ jobs:
        shell: msys2 {0}
    steps:
      - uses: actions/checkout@v4
+        with:
+          submodules: recursive

      - uses: msys2/setup-msys2@v2
        with:
@@ -26,6 +101,8 @@ jobs:
          update: true
          install: >-
            mingw-w64-x86_64-gcc
+            mingw-w64-x86_64-cmake
+            mingw-w64-x86_64-ninja
            mingw-w64-x86_64-qt5-base
            mingw-w64-x86_64-qt5-tools
            mingw-w64-x86_64-boost
@@ -33,49 +110,133 @@ jobs:
            mingw-w64-x86_64-db
            mingw-w64-x86_64-libevent
            mingw-w64-x86_64-miniupnpc
-            make
+            mingw-w64-x86_64-zlib
+            mingw-w64-x86_64-rocksdb

-      - name: Create Qt5 tool symlinks
+      - name: Set VERSION
        run: |
-          ln -sf /mingw64/bin/qmake-qt5.exe /mingw64/bin/qmake.exe 2>/dev/null || true
-          ln -sf /mingw64/bin/lrelease-qt5.exe /mingw64/bin/lrelease.exe 2>/dev/null || true
-          ln -sf /mingw64/bin/windeployqt-qt5.exe /mingw64/bin/windeployqt.exe 2>/dev/null || true
+          if [[ "${GITHUB_REF}" == refs/tags/v* ]]; then
+            echo "VERSION=${GITHUB_REF_NAME#v}" >> $GITHUB_ENV
+          else
+            MAJOR=$(grep 'CLIENT_VERSION_MAJOR' src/clientversion.h | awk '{print $3}')
+            MINOR=$(grep 'CLIENT_VERSION_MINOR' src/clientversion.h | awk '{print $3}')
+            REV=$(grep 'CLIENT_VERSION_REVISION' src/clientversion.h | awk '{print $3}')
+            echo "VERSION=${MAJOR}.${MINOR}.${REV}" >> $GITHUB_ENV
+          fi

-      - name: Clean stale build artifacts
-        run: rm -rf build/*.o build/*.h
-
-      - name: Build LevelDB
+      - name: Configure
        run: |
-          cd src/leveldb
-          make clean || true
-          CC=gcc CXX=g++ TARGET_OS=OS_WINDOWS_CROSSCOMPILE make OPT="-fno-keep-inline-dllexport -march=nocona -msahf -mtune=generic -Wa,-mbig-obj -O2" libleveldb.a libmemenv.a
-
-      - name: Run qmake
-        run: |
-          qmake triangles-qt.pro "RELEASE=1"
+          cmake -B build -G Ninja \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DBUILD_QT=ON \
+            -DBUILD_DAEMON=OFF \
+            -DBUILD_TESTS=OFF \
+            -DUSE_UPNP=ON \
+            -DUSE_QRCODE=OFF

      - name: Build
-        run: |
-          make -j$(nproc)
+        run: cmake --build build -j$(nproc)

      - name: Package
        run: |
          mkdir -p dist
-          cp release/triangles-qt.exe dist/
+          cp build/bin/triangles-qt.exe dist/
          windeployqt dist/triangles-qt.exe || true
-          # Copy runtime DLLs
+
+          # Copy ALL runtime DLLs the binary needs
+          # MinGW runtime
          for dll in libgcc_s_seh-1.dll libstdc++-6.dll libwinpthread-1.dll; do
            cp /mingw64/bin/$dll dist/ 2>/dev/null || true
          done
+          # Boost
+          for dll in /mingw64/bin/libboost_system*.dll /mingw64/bin/libboost_filesystem*.dll \
+                     /mingw64/bin/libboost_thread*.dll /mingw64/bin/libboost_program_options*.dll \
+                     /mingw64/bin/libboost_chrono*.dll; do
+            cp $dll dist/ 2>/dev/null || true
+          done
+          # OpenSSL
+          for dll in /mingw64/bin/libssl*.dll /mingw64/bin/libcrypto*.dll; do
+            cp $dll dist/ 2>/dev/null || true
+          done
+          # BerkeleyDB, libevent, miniupnpc, zlib
+          for dll in /mingw64/bin/libdb*.dll /mingw64/bin/libevent*.dll \
+                     /mingw64/bin/libminiupnpc*.dll /mingw64/bin/zlib1.dll; do
+            cp $dll dist/ 2>/dev/null || true
+          done

-      - name: Strip binary
-        run: strip --strip-all dist/triangles-qt.exe
+          # Catch anything we missed: scan ldd output for /mingw64 deps
+          ldd dist/triangles-qt.exe | grep '/mingw64' | awk '{print $3}' | while read dll; do
+            cp "$dll" dist/ 2>/dev/null || true
+          done

-      - name: Upload artifact
+          # Write qt.conf so the exe finds plugins relative to itself
+          printf '[Paths]\nPlugins = .\n' > dist/qt.conf
+
+          # Ensure Qt platform plugins are present (windeployqt sometimes misses them in MSYS2)
+          if [ ! -f dist/platforms/qwindows.dll ]; then
+            echo "WARNING: windeployqt did not copy platform plugins, copying manually..."
+            mkdir -p dist/platforms
+            cp /mingw64/share/qt5/plugins/platforms/qwindows.dll dist/platforms/ 2>/dev/null || \
+            cp /mingw64/lib/qt5/plugins/platforms/qwindows.dll dist/platforms/ 2>/dev/null || \
+            find /mingw64 -name 'qwindows.dll' -exec cp {} dist/platforms/ \; 2>/dev/null
+          fi
+
+          # Also copy styles and imageformats for good measure
+          for plugdir in styles imageformats; do
+            if [ ! -d "dist/$plugdir" ]; then
+              srcdir=$(find /mingw64 -type d -name "$plugdir" -path "*/plugins/*" 2>/dev/null | head -1)
+              if [ -n "$srcdir" ]; then
+                cp -r "$srcdir" dist/
+              fi
+            fi
+          done
+
+          strip --strip-all dist/triangles-qt.exe
+          echo "=== dist/ contents ==="
+          find dist/ -type f | head -50
+
+      - name: Download Tor
+        shell: powershell
+        run: |
+          $TOR_VERSION = "15.0.9"
+          $TOR_URL = "https://archive.torproject.org/tor-package-archive/torbrowser/${TOR_VERSION}/tor-expert-bundle-windows-x86_64-${TOR_VERSION}.tar.gz"
+          Invoke-WebRequest -Uri $TOR_URL -OutFile tor-bundle.tar.gz
+          New-Item -ItemType Directory -Path tor-extract -Force
+          tar -xzf tor-bundle.tar.gz -C tor-extract
+          New-Item -ItemType Directory -Path tor-files -Force
+          Copy-Item -Recurse tor-extract/tor/* tor-files/
+          if (Test-Path tor-extract/tor/pluggable_transports) {
+            Copy-Item -Recurse tor-extract/tor/pluggable_transports tor-files/pluggable_transports -Force
+          }
+          if (Test-Path tor-extract/data) {
+            Copy-Item -Recurse tor-extract/data tor-files/data
+          }
+          Write-Host "Bundled Tor runtime files:"
+          Get-ChildItem -Recurse tor-files | Select-Object FullName
+
+      - name: Install NSIS via MSYS2
+        run: pacman -S --noconfirm mingw-w64-x86_64-nsis
+
+      - name: Install NSIS inetc plugin
+        run: |
+          pacman -S --noconfirm unzip
+          NSIS_DIR="/mingw64/share/nsis"
+          cd /tmp
+          curl -L -o Inetc.zip "https://nsis.sourceforge.io/mediawiki/images/c/c9/Inetc.zip"
+          unzip -o Inetc.zip -d inetc_extract
+          # MSYS2 mingw64 NSIS is 64-bit, needs amd64-unicode plugin in Plugins/unicode/
+          mkdir -p "$NSIS_DIR/Plugins/unicode"
+          cp inetc_extract/Plugins/amd64-unicode/INetC.dll "$NSIS_DIR/Plugins/unicode/"
+          echo "Installed 64-bit INetC.dll to $NSIS_DIR/Plugins/unicode/"
+
+      - name: Build NSIS installer
+        run: makensis //DVERSION=$VERSION contrib/nsis/setup.nsi
+
+      - name: Upload installer
        uses: actions/upload-artifact@v4
        with:
-          name: windows-qt
-          path: dist/
+          name: windows-qt-setup
+          path: contrib/nsis/Cryptographic-Triangles-*-setup.exe

  build-windows-daemon:
    runs-on: windows-latest
@@ -84,6 +245,8 @@ jobs:
        shell: msys2 {0}
    steps:
      - uses: actions/checkout@v4
+        with:
+          submodules: recursive

      - uses: msys2/setup-msys2@v2
        with:
@@ -91,160 +254,409 @@ jobs:
          update: true
          install: >-
            mingw-w64-x86_64-gcc
+            mingw-w64-x86_64-cmake
+            mingw-w64-x86_64-ninja
            mingw-w64-x86_64-boost
            mingw-w64-x86_64-openssl
            mingw-w64-x86_64-db
            mingw-w64-x86_64-libevent
            mingw-w64-x86_64-miniupnpc
-            make
+            mingw-w64-x86_64-zlib
+            mingw-w64-x86_64-rocksdb

-      - name: Build LevelDB
+      - name: Configure
        run: |
-          cd src/leveldb
-          make clean || true
-          CC=gcc CXX=g++ TARGET_OS=OS_WINDOWS_CROSSCOMPILE make OPT="-fno-keep-inline-dllexport -march=nocona -msahf -mtune=generic -Wa,-mbig-obj -O2" libleveldb.a libmemenv.a
+          cmake -B build -G Ninja \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DBUILD_QT=OFF \
+            -DBUILD_DAEMON=ON \
+            -DBUILD_TESTS=OFF \
+            -DUSE_UPNP=ON

-      - name: Build daemon
+      - name: Build
        run: |
-          set -eo pipefail
-          cd src
-          mkdir -p obj
-          make -f makefile.mingw DEPSDIR=/mingw64 all -j$(nproc) 2>&1
-          strip --strip-all trianglesd.exe
-          cp trianglesd.exe ../trianglesd.exe
+          cmake --build build -j$(nproc)
+          strip --strip-all build/bin/trianglesd.exe
+
+      - name: Package daemon with DLLs
+        run: |
+          mkdir -p daemon-dist/tor
+          cp build/bin/trianglesd.exe daemon-dist/
+
+          # Copy all linked DLLs from MSYS2
+          ldd build/bin/trianglesd.exe | grep '/mingw64' | awk '{print $3}' | while read dll; do
+            cp "$dll" daemon-dist/ 2>/dev/null || true
+          done
+
+      - name: Bundle Tor for daemon
+        shell: powershell
+        run: |
+          $TOR_VERSION = "15.0.9"
+          Invoke-WebRequest -Uri "https://archive.torproject.org/tor-package-archive/torbrowser/${TOR_VERSION}/tor-expert-bundle-windows-x86_64-${TOR_VERSION}.tar.gz" -OutFile tor-bundle.tar.gz
+          New-Item -ItemType Directory -Path tor-extract -Force
+          tar -xzf tor-bundle.tar.gz -C tor-extract
+          Copy-Item -Recurse tor-extract/tor/* daemon-dist/tor/
+          if (Test-Path tor-extract/data) {
+            Copy-Item -Recurse tor-extract/data daemon-dist/tor/data
+          }

      - name: Upload artifact
        uses: actions/upload-artifact@v4
        with:
          name: windows-daemon
-          path: trianglesd.exe
+          path: daemon-dist/

  build-linux-qt:
    runs-on: ubuntu-22.04
    steps:
      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set VERSION
+        run: |
+          if [[ "${GITHUB_REF}" == refs/tags/v* ]]; then
+            echo "VERSION=${GITHUB_REF_NAME#v}" >> $GITHUB_ENV
+          else
+            MAJOR=$(grep 'CLIENT_VERSION_MAJOR' src/clientversion.h | awk '{print $3}')
+            MINOR=$(grep 'CLIENT_VERSION_MINOR' src/clientversion.h | awk '{print $3}')
+            REV=$(grep 'CLIENT_VERSION_REVISION' src/clientversion.h | awk '{print $3}')
+            echo "VERSION=${MAJOR}.${MINOR}.${REV}" >> $GITHUB_ENV
+          fi

      - name: Install dependencies
        run: |
          sudo apt-get update
-          sudo apt-get install -y build-essential qt5-qmake qtbase5-dev \
-            qttools5-dev-tools libboost-all-dev libssl-dev libdb++-dev \
-            libleveldb-dev libevent-dev libminiupnpc-dev
+          sudo apt-get install -y build-essential cmake ninja-build \
+            qtbase5-dev qttools5-dev-tools \
+            libboost-all-dev libssl-dev libdb++-dev \
+            libleveldb-dev librocksdb-dev libevent-dev libminiupnpc-dev zlib1g-dev

-      - name: Build LevelDB
+      - name: Configure
        run: |
-          cd src/leveldb
-          chmod +x build_detect_platform
-          make clean || true
-          make OPT="-O2" libleveldb.a libmemenv.a
-
-      - name: Clean stale build artifacts
-        run: rm -rf build/*.o
-
-      - name: Run qmake
-        run: qmake triangles-qt.pro "RELEASE=1"
+          cmake -B build -G Ninja \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DBUILD_QT=ON \
+            -DBUILD_DAEMON=OFF \
+            -DBUILD_TESTS=OFF \
+            -DUSE_UPNP=ON

      - name: Build
-        run: make -j$(nproc)
+        run: cmake --build build -j$(nproc)

      - name: Strip binary
-        run: strip --strip-all triangles-qt
+        run: strip --strip-all build/bin/triangles-qt

-      - name: Rename
-        run: mv triangles-qt Cryptographic-Triangles-v${VERSION}-linux-x64-qt
+      - name: Build .deb package (fully self-contained)
+        run: |
+          TOR_VERSION="15.0.9"
+          curl -sL "https://archive.torproject.org/tor-package-archive/torbrowser/${TOR_VERSION}/tor-expert-bundle-linux-x86_64-${TOR_VERSION}.tar.gz" -o tor-bundle.tar.gz
+          mkdir -p tor-extract && tar -xzf tor-bundle.tar.gz -C tor-extract

-      - name: Upload artifact
+          PKG="cryptographic-triangles_${VERSION}_amd64"
+          mkdir -p ${PKG}/DEBIAN
+          mkdir -p ${PKG}/usr/lib/cryptographic-triangles/lib
+          mkdir -p ${PKG}/usr/lib/cryptographic-triangles/tor
+          mkdir -p ${PKG}/usr/bin
+          mkdir -p ${PKG}/usr/share/applications
+          mkdir -p ${PKG}/usr/share/pixmaps
+
+          cp build/bin/triangles-qt ${PKG}/usr/lib/cryptographic-triangles/
+          cp tor-extract/tor/tor ${PKG}/usr/lib/cryptographic-triangles/tor/
+          chmod +x ${PKG}/usr/lib/cryptographic-triangles/tor/tor
+          [ -d tor-extract/data ] && cp -r tor-extract/data ${PKG}/usr/lib/cryptographic-triangles/tor/data
+
+          # Bundle ALL shared library dependencies (except glibc/kernel)
+          ldd build/bin/triangles-qt | grep '=> /' | awk '{print $3}' | while read lib; do
+            case "$lib" in
+              /lib/x86_64-linux-gnu/libc.so*|/lib/x86_64-linux-gnu/libm.so*|/lib/x86_64-linux-gnu/libpthread.so*|/lib/x86_64-linux-gnu/libdl.so*|/lib/x86_64-linux-gnu/librt.so*|/lib/x86_64-linux-gnu/ld-linux*|/lib64/ld-linux*)
+                ;; # Skip glibc core — always present
+              *)
+                cp -L "$lib" ${PKG}/usr/lib/cryptographic-triangles/lib/ 2>/dev/null || true
+                ;;
+            esac
+          done
+          echo "=== Bundled libs ==="
+          ls ${PKG}/usr/lib/cryptographic-triangles/lib/ | wc -l
+          ls ${PKG}/usr/lib/cryptographic-triangles/lib/
+
+          # Launcher with LD_LIBRARY_PATH
+          cat > ${PKG}/usr/bin/cryptographic-triangles << 'LAUNCHER'
+          #!/bin/bash
+          INSTALL_DIR=/usr/lib/cryptographic-triangles
+          export LD_LIBRARY_PATH="${INSTALL_DIR}/lib:${LD_LIBRARY_PATH}"
+          exec "${INSTALL_DIR}/triangles-qt" "$@"
+          LAUNCHER
+          sed -i 's/^          //' ${PKG}/usr/bin/cryptographic-triangles
+          chmod +x ${PKG}/usr/bin/cryptographic-triangles
+
+          cat > ${PKG}/usr/share/applications/cryptographic-triangles.desktop << 'DESKTOP'
+          [Desktop Entry]
+          Name=Cryptographic Triangles
+          Comment=Triangles Cryptocurrency Wallet
+          Exec=cryptographic-triangles
+          Terminal=false
+          Type=Application
+          Icon=cryptographic-triangles
+          Categories=Finance;Network;
+          DESKTOP
+          sed -i 's/^          //' ${PKG}/usr/share/applications/cryptographic-triangles.desktop
+
+          cp src/qt/res/icons/triangles.ico ${PKG}/usr/share/pixmaps/cryptographic-triangles.ico 2>/dev/null || true
+
+          cat > ${PKG}/DEBIAN/control << CTRL
+          Package: cryptographic-triangles
+          Version: ${VERSION}
+          Architecture: amd64
+          Maintainer: Cryptographic Triangles <dev@cryptographic-triangles.org>
+          Description: Cryptographic Triangles wallet with integrated Tor
+           Fully self-contained wallet with all libraries and Tor bundled.
+           No external dependencies required — runs on any x86_64 Linux.
+          Section: finance
+          Priority: optional
+          CTRL
+          sed -i 's/^          //' ${PKG}/DEBIAN/control
+
+          dpkg-deb --build ${PKG}
+
+      - name: Upload .deb
        uses: actions/upload-artifact@v4
        with:
-          name: linux-qt
-          path: Cryptographic-Triangles-v*-linux-x64-qt
+          name: linux-qt-deb
+          path: cryptographic-triangles_*_amd64.deb

  build-linux-daemon:
    runs-on: ubuntu-22.04
    steps:
      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set VERSION
+        run: |
+          if [[ "${GITHUB_REF}" == refs/tags/v* ]]; then
+            echo "VERSION=${GITHUB_REF_NAME#v}" >> $GITHUB_ENV
+          else
+            MAJOR=$(grep 'CLIENT_VERSION_MAJOR' src/clientversion.h | awk '{print $3}')
+            MINOR=$(grep 'CLIENT_VERSION_MINOR' src/clientversion.h | awk '{print $3}')
+            REV=$(grep 'CLIENT_VERSION_REVISION' src/clientversion.h | awk '{print $3}')
+            echo "VERSION=${MAJOR}.${MINOR}.${REV}" >> $GITHUB_ENV
+          fi

      - name: Install dependencies
        run: |
          sudo apt-get update
-          sudo apt-get install -y build-essential libboost-all-dev \
-            libssl-dev libdb++-dev libleveldb-dev libevent-dev libminiupnpc-dev
+          sudo apt-get install -y build-essential cmake ninja-build \
+            libboost-all-dev libssl-dev libdb++-dev libleveldb-dev \
+            librocksdb-dev libevent-dev libminiupnpc-dev zlib1g-dev

-      - name: Build LevelDB
+      - name: Configure
        run: |
-          cd src/leveldb
-          chmod +x build_detect_platform
-          make clean || true
-          make OPT="-O2" libleveldb.a libmemenv.a
+          cmake -B build -G Ninja \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DBUILD_QT=OFF \
+            -DBUILD_DAEMON=ON \
+            -DBUILD_TESTS=OFF \
+            -DUSE_UPNP=ON

-      - name: Build daemon
-        run: |
-          cd src
-          mkdir -p obj
-          make -f makefile.unix -j$(nproc)
+      - name: Build
+        run: cmake --build build -j$(nproc)

      - name: Strip binary
-        run: strip --strip-all src/trianglesd
+        run: strip --strip-all build/bin/trianglesd

-      - name: Rename
-        run: mv src/trianglesd Cryptographic-Triangles-v${VERSION}-linux-x64-daemon
+      - name: Build .deb package (fully self-contained)
+        run: |
+          TOR_VERSION="15.0.9"
+          curl -sL "https://archive.torproject.org/tor-package-archive/torbrowser/${TOR_VERSION}/tor-expert-bundle-linux-x86_64-${TOR_VERSION}.tar.gz" -o tor-bundle.tar.gz
+          mkdir -p tor-extract && tar -xzf tor-bundle.tar.gz -C tor-extract

-      - name: Upload artifact
+          PKG="cryptographic-triangles-daemon_${VERSION}_amd64"
+          mkdir -p ${PKG}/DEBIAN
+          mkdir -p ${PKG}/usr/lib/cryptographic-triangles/lib
+          mkdir -p ${PKG}/usr/lib/cryptographic-triangles/tor
+          mkdir -p ${PKG}/usr/bin
+          mkdir -p ${PKG}/etc/systemd/system
+
+          cp build/bin/trianglesd ${PKG}/usr/lib/cryptographic-triangles/
+          cp tor-extract/tor/tor ${PKG}/usr/lib/cryptographic-triangles/tor/
+          chmod +x ${PKG}/usr/lib/cryptographic-triangles/tor/tor
+          [ -d tor-extract/data ] && cp -r tor-extract/data ${PKG}/usr/lib/cryptographic-triangles/tor/data
+
+          # Bundle ALL shared library dependencies (except glibc/kernel)
+          ldd build/bin/trianglesd | grep '=> /' | awk '{print $3}' | while read lib; do
+            case "$lib" in
+              /lib/x86_64-linux-gnu/libc.so*|/lib/x86_64-linux-gnu/libm.so*|/lib/x86_64-linux-gnu/libpthread.so*|/lib/x86_64-linux-gnu/libdl.so*|/lib/x86_64-linux-gnu/librt.so*|/lib/x86_64-linux-gnu/ld-linux*|/lib64/ld-linux*)
+                ;; # Skip glibc core — always present
+              *)
+                cp -L "$lib" ${PKG}/usr/lib/cryptographic-triangles/lib/ 2>/dev/null || true
+                ;;
+            esac
+          done
+          echo "=== Bundled libs ==="
+          ls ${PKG}/usr/lib/cryptographic-triangles/lib/ | wc -l
+          ls ${PKG}/usr/lib/cryptographic-triangles/lib/
+
+          # Launcher with LD_LIBRARY_PATH
+          cat > ${PKG}/usr/bin/trianglesd << 'LAUNCHER'
+          #!/bin/bash
+          INSTALL_DIR=/usr/lib/cryptographic-triangles
+          export LD_LIBRARY_PATH="${INSTALL_DIR}/lib:${LD_LIBRARY_PATH}"
+          exec "${INSTALL_DIR}/trianglesd" "$@"
+          LAUNCHER
+          sed -i 's/^          //' ${PKG}/usr/bin/trianglesd
+          chmod +x ${PKG}/usr/bin/trianglesd
+
+          cat > ${PKG}/etc/systemd/system/trianglesd.service << 'SVC'
+          [Unit]
+          Description=Cryptographic Triangles Daemon
+          After=network-online.target
+          Wants=network-online.target
+
+          [Service]
+          Type=simple
+          Environment=LD_LIBRARY_PATH=/usr/lib/cryptographic-triangles/lib
+          ExecStart=/usr/lib/cryptographic-triangles/trianglesd
+          Restart=on-failure
+          RestartSec=10
+
+          [Install]
+          WantedBy=multi-user.target
+          SVC
+          sed -i 's/^          //' ${PKG}/etc/systemd/system/trianglesd.service
+
+          cat > ${PKG}/DEBIAN/control << CTRL
+          Package: cryptographic-triangles-daemon
+          Version: ${VERSION}
+          Architecture: amd64
+          Maintainer: Cryptographic Triangles <dev@cryptographic-triangles.org>
+          Description: Cryptographic Triangles daemon with integrated Tor
+           Fully self-contained headless node with all libraries, Tor, and systemd service.
+           No external dependencies required — runs on any x86_64 Linux.
+          Section: finance
+          Priority: optional
+          CTRL
+          sed -i 's/^          //' ${PKG}/DEBIAN/control
+
+          cat > ${PKG}/DEBIAN/postinst << 'POST'
+          #!/bin/bash
+          systemctl daemon-reload
+          echo ""
+          echo "Cryptographic Triangles daemon installed."
+          echo "  Start:     sudo systemctl start trianglesd"
+          echo "  On boot:   sudo systemctl enable trianglesd"
+          echo ""
+          POST
+          chmod +x ${PKG}/DEBIAN/postinst
+
+          dpkg-deb --build ${PKG}
+
+      - name: Upload .deb
        uses: actions/upload-artifact@v4
        with:
-          name: linux-daemon
-          path: Cryptographic-Triangles-v*-linux-x64-daemon
+          name: linux-daemon-deb
+          path: cryptographic-triangles-daemon_*_amd64.deb

  build-macos:
    runs-on: macos-15
    steps:
      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set VERSION
+        run: |
+          if [[ "${GITHUB_REF}" == refs/tags/v* ]]; then
+            echo "VERSION=${GITHUB_REF_NAME#v}" >> $GITHUB_ENV
+          else
+            MAJOR=$(grep 'CLIENT_VERSION_MAJOR' src/clientversion.h | awk '{print $3}')
+            MINOR=$(grep 'CLIENT_VERSION_MINOR' src/clientversion.h | awk '{print $3}')
+            REV=$(grep 'CLIENT_VERSION_REVISION' src/clientversion.h | awk '{print $3}')
+            echo "VERSION=${MAJOR}.${MINOR}.${REV}" >> $GITHUB_ENV
+          fi

      - name: Install dependencies
        run: |
-          brew install qt@5 openssl@3 boost berkeley-db@5 leveldb libevent miniupnpc
+          brew install cmake ninja qt@5 openssl@3 boost berkeley-db@5 leveldb rocksdb libevent miniupnpc

-      - name: Clean stale build artifacts
-        run: rm -rf build/*.o build/*.h
-
-      - name: Build LevelDB
-        run: |
-          cd src/leveldb
-          chmod +x build_detect_platform
-          make clean || true
-          CC=clang CXX=clang++ make OPT="-O2" libleveldb.a libmemenv.a
-
-      - name: Run qmake
+      - name: Configure
        run: |
          export PATH="/opt/homebrew/opt/qt@5/bin:$PATH"
-          qmake triangles-qt.pro -spec macx-clang \
-            "BOOST_INCLUDE_PATH=/opt/homebrew/opt/boost/include" \
-            "BOOST_LIB_PATH=/opt/homebrew/opt/boost/lib" \
-            "BDB_INCLUDE_PATH=/opt/homebrew/opt/berkeley-db@5/include" \
-            "BDB_LIB_PATH=/opt/homebrew/opt/berkeley-db@5/lib" \
-            "BDB_LIB_SUFFIX=" \
-            "OPENSSL_INCLUDE_PATH=/opt/homebrew/opt/openssl@3/include" \
-            "OPENSSL_LIB_PATH=/opt/homebrew/opt/openssl@3/lib" \
-            "MINIUPNPC_INCLUDE_PATH=/opt/homebrew/opt/miniupnpc/include" \
-            "MINIUPNPC_LIB_PATH=/opt/homebrew/opt/miniupnpc/lib" \
-            "EVENT_INCLUDE_PATH=/opt/homebrew/opt/libevent/include" \
-            "EVENT_LIB_PATH=/opt/homebrew/opt/libevent/lib" \
-            "RELEASE=1"
+          cmake -B build -G Ninja \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DBUILD_QT=ON \
+            -DBUILD_DAEMON=OFF \
+            -DBUILD_TESTS=OFF \
+            -DUSE_UPNP=ON \
+            -DBOOST_ROOT=/opt/homebrew/opt/boost \
+            -DBDB_INCLUDE_PATH=/opt/homebrew/opt/berkeley-db@5/include \
+            -DBDB_LIB_PATH=/opt/homebrew/opt/berkeley-db@5/lib \
+            -DOPENSSL_ROOT_DIR=/opt/homebrew/opt/openssl@3 \
+            -DEVENT_INCLUDE_PATH=/opt/homebrew/opt/libevent/include \
+            -DEVENT_LIB_PATH=/opt/homebrew/opt/libevent/lib \
+            -DMINIUPNPC_INCLUDE_PATH=/opt/homebrew/opt/miniupnpc/include \
+            -DMINIUPNPC_LIB_PATH=/opt/homebrew/opt/miniupnpc/lib \
+            -DQt5_DIR=/opt/homebrew/opt/qt@5/lib/cmake/Qt5

      - name: Build
-        run: |
-          export PATH="/opt/homebrew/opt/qt@5/bin:$PATH"
-          make -j$(sysctl -n hw.ncpu)
+        run: cmake --build build -j$(sysctl -n hw.ncpu)

      - name: Create .app bundle
        run: |
          export PATH="/opt/homebrew/opt/qt@5/bin:$PATH"
-          macdeployqt Triangles-Qt.app -verbose=1
+          macdeployqt build/bin/Triangles-Qt.app -verbose=1 || \
+          macdeployqt build/bin/triangles-qt.app -verbose=1 || true
+
+      - name: Bundle non-Qt dylibs into app
+        run: |
+          # Find the .app bundle
+          APP=$(find build/bin -name "*.app" -maxdepth 1 | head -1)
+          if [ -z "$APP" ]; then
+            echo "No .app bundle found, creating one manually..."
+            APP="build/bin/Triangles-Qt.app"
+            mkdir -p "$APP/Contents/MacOS" "$APP/Contents/Frameworks"
+            cp build/bin/triangles-qt "$APP/Contents/MacOS/Triangles-Qt"
+          fi
+          FRAMEWORKS="$APP/Contents/Frameworks"
+          BINARY=$(find "$APP/Contents/MacOS" -type f -perm +111 | head -1)
+
+          # Copy Homebrew dylibs that macdeployqt doesn't handle
+          for lib in boost_system boost_filesystem boost_thread boost_program_options boost_chrono; do
+            DYLIB=$(otool -L "$BINARY" | grep "$lib" | awk '{print $1}')
+            if [ -n "$DYLIB" ] && [ -f "$DYLIB" ]; then
+              cp "$DYLIB" "$FRAMEWORKS/"
+              BASENAME=$(basename "$DYLIB")
+              install_name_tool -change "$DYLIB" "@executable_path/../Frameworks/$BASENAME" "$BINARY"
+            fi
+          done
+          for lib in libssl libcrypto libevent libdb_cxx libminiupnpc libsodium; do
+            DYLIB=$(otool -L "$BINARY" | grep "$lib" | awk '{print $1}')
+            if [ -n "$DYLIB" ] && [ -f "$DYLIB" ]; then
+              cp "$DYLIB" "$FRAMEWORKS/"
+              BASENAME=$(basename "$DYLIB")
+              install_name_tool -change "$DYLIB" "@executable_path/../Frameworks/$BASENAME" "$BINARY"
+            fi
+          done
+
+          echo "=== Final dylib dependencies ==="
+          otool -L "$BINARY" | head -30
+
+      - name: Bundle Tor into app
+        run: |
+          TOR_VERSION="15.0.9"
+          curl -sL "https://archive.torproject.org/tor-package-archive/torbrowser/${TOR_VERSION}/tor-expert-bundle-macos-aarch64-${TOR_VERSION}.tar.gz" -o tor-bundle.tar.gz
+          mkdir -p tor-extract && tar -xzf tor-bundle.tar.gz -C tor-extract
+          APP=$(find build/bin -name "*.app" -maxdepth 1 | head -1)
+          mkdir -p "$APP/Contents/MacOS/tor"
+          cp tor-extract/tor/tor "$APP/Contents/MacOS/tor/"
+          chmod +x "$APP/Contents/MacOS/tor/tor"
+          [ -d tor-extract/data ] && cp -r tor-extract/data "$APP/Contents/MacOS/tor/data"

      - name: Create DMG
        run: |
+          APP=$(find build/bin -name "*.app" -maxdepth 1 | head -1)
          mkdir -p dmg_contents
-          cp -R Triangles-Qt.app dmg_contents/
+          cp -R "$APP" dmg_contents/
          ln -s /Applications dmg_contents/Applications
          hdiutil create -volname "Cryptographic Triangles" \
            -srcfolder dmg_contents \
@@ -264,6 +676,9 @@ jobs:
    permissions:
      contents: write
    steps:
+      - name: Set VERSION from tag
+        run: echo "VERSION=${GITHUB_REF_NAME#v}" >> $GITHUB_ENV
+
      - name: Download all artifacts
        uses: actions/download-artifact@v4
        with:
@@ -272,14 +687,15 @@ jobs:
      - name: Prepare release assets
        run: |
          mkdir -p release
-          # Windows
-          cd artifacts/windows-qt && zip -r ../../release/Cryptographic-Triangles-${VERSION}-win-x64.zip . && cd ../..
-          cp artifacts/windows-qt/triangles-qt.exe release/Cryptographic-Triangles-${VERSION}-win-x64-qt.exe
-          cp artifacts/windows-daemon/trianglesd.exe release/Cryptographic-Triangles-${VERSION}-win-x64-daemon.exe
-          # Linux
-          cp artifacts/linux-qt/Cryptographic-Triangles-* release/
-          cp artifacts/linux-daemon/Cryptographic-Triangles-* release/
-          # macOS
+          # Windows Qt installer (setup.exe — includes Tor, Start Menu shortcuts, uninstaller)
+          cp artifacts/windows-qt-setup/*.exe release/
+          # Windows daemon (zip with DLLs + Tor)
+          cd artifacts/windows-daemon && zip -r "../../release/Cryptographic-Triangles-${VERSION}-win-x64-daemon.zip" . && cd ../..
+          # Linux Qt .deb (dpkg -i to install — includes Tor, desktop entry, icon)
+          cp artifacts/linux-qt-deb/*.deb release/
+          # Linux daemon .deb (dpkg -i to install — includes Tor, systemd service)
+          cp artifacts/linux-daemon-deb/*.deb release/
+          # macOS DMG (drag to Applications — Tor inside .app bundle)
          cp artifacts/macos-arm64-dmg/*.dmg release/
          ls -la release/

@@ -288,3 +704,19 @@ jobs:
        with:
          files: release/*
          generate_release_notes: true
+
+  trigger-tripi:
+    name: Trigger TRI-PI ARM64 Build
+    if: startsWith(github.ref, 'refs/tags/v')
+    needs: release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Dispatch tri-pi ARM64 build
+        run: |
+          curl -f -X POST \
+            -H "Accept: application/vnd.github+json" \
+            -H "Authorization: Bearer ${{ secrets.TRIPI_BUILD_TOKEN }}" \
+            -H "X-GitHub-Api-Version: 2022-11-28" \
+            https://api.github.com/repos/SamiAhmed7777/tri-pi/dispatches \
+            -d '{"event_type":"new-release","client_payload":{"version":"${{ github.ref_name }}","source_repo":"SamiAhmed7777/triangles_v5"}}'
+          echo "Triggered tri-pi repository_dispatch for ${{ github.ref_name }}"
@@ -0,0 +1,100 @@
+name: Lint
+
+on:
+  pull_request:
+    branches: [master]
+  workflow_dispatch:
+
+# Diff-only enforcement: clang-format and clang-tidy run only on lines changed
+# in the PR. Existing files keep their current style until they're edited.
+# See .clang-format and .clang-tidy for the rule sets.
+
+jobs:
+  clang-format-diff:
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          # Need merge-base with target branch to compute the diff.
+          fetch-depth: 0
+
+      - name: Install clang-format
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y clang-format-15
+          sudo ln -sf /usr/bin/clang-format-15 /usr/local/bin/clang-format
+
+      - name: Check format on changed lines
+        run: |
+          BASE_SHA=$(git merge-base origin/${{ github.base_ref }} HEAD)
+          echo "Comparing against merge-base: $BASE_SHA"
+
+          # git-clang-format prints a diff if any changed line violates style.
+          # --diff exits non-zero when reformatting would change something.
+          OUTPUT=$(git clang-format --diff "$BASE_SHA" -- '*.cpp' '*.h' '*.hpp' '*.cc' || true)
+
+          if [ -z "$OUTPUT" ] || [ "$OUTPUT" = "no modified files to format" ] || [ "$OUTPUT" = "clang-format did not modify any files" ]; then
+            echo "clang-format: clean"
+            exit 0
+          fi
+
+          echo "::error::clang-format wants to change the following on lines you touched."
+          echo "Run \`git clang-format $BASE_SHA\` locally and commit the result."
+          echo "$OUTPUT"
+          exit 1
+
+  clang-tidy-diff:
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Install dependencies + clang-tidy
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y build-essential cmake ninja-build clang-tidy-15 \
+            libboost-all-dev libssl-dev libdb++-dev libleveldb-dev \
+            librocksdb-dev libevent-dev libminiupnpc-dev zlib1g-dev
+          sudo ln -sf /usr/bin/clang-tidy-15 /usr/local/bin/clang-tidy
+
+      - name: Configure (export compile_commands.json)
+        run: |
+          cmake -B build -G Ninja \
+            -DCMAKE_BUILD_TYPE=Debug \
+            -DCMAKE_EXPORT_COMPILE_COMMANDS=ON \
+            -DBUILD_QT=OFF \
+            -DBUILD_DAEMON=ON \
+            -DBUILD_TESTS=ON \
+            -DUSE_UPNP=OFF
+
+      - name: Generate build artifacts that headers depend on
+        # build.h, qt UI headers, etc. — clang-tidy needs them to parse sources.
+        run: cmake --build build --target generate_build_info
+
+      - name: Run clang-tidy on changed lines
+        run: |
+          BASE_SHA=$(git merge-base origin/${{ github.base_ref }} HEAD)
+          echo "Comparing against merge-base: $BASE_SHA"
+
+          # clang-tidy-diff.py ships with clang-tidy; runs tidy only on changed lines.
+          DIFF_SCRIPT=$(dpkg -L clang-tidy-15 | grep clang-tidy-diff.py | head -1)
+          if [ -z "$DIFF_SCRIPT" ]; then
+            DIFF_SCRIPT=/usr/share/clang/clang-tidy-diff.py
+          fi
+          echo "Using: $DIFF_SCRIPT"
+
+          # -p1 strips the leading "a/"/"b/" from git diff paths.
+          # -path=build points clang-tidy at compile_commands.json.
+          # -iregex restricts to project sources (not vendored).
+          git diff -U0 "$BASE_SHA" -- 'src/*.cpp' 'src/*.h' \
+            ':(exclude)src/json/nlohmann_json.hpp' \
+            ':(exclude)src/leveldb/*' \
+            ':(exclude)src/lz4/*' \
+            ':(exclude)src/tor/tor-src/*' \
+            | python3 "$DIFF_SCRIPT" -p1 -path build \
+                -iregex '.*\.(cpp|cc|h|hpp)$' \
+                -j$(nproc) || EXIT=$?
+
+          # Warn-only initially. Flip this to `exit ${EXIT:-0}` once we're clean.
+          exit 0
@@ -1,3 +1,6 @@
+# Per-user Claude Code settings (machine-specific paths/permissions)
+.claude/
+
 # Build artifacts
 *.o
 *.exe
@@ -5,12 +8,22 @@
 *.so
 *.dylib
 *.a
+/dist/
 build/
+build2/
+build_*/
 release/
 debug/
+build_err*.txt
+*build_err.txt
+/Makefile
 Makefile.Debug
 Makefile.Release
 .qmake.stash
+object_script.triangles-qt.Debug
+object_script.triangles-qt.Release
+/*.zip
+/*.tar.gz

 # Qt
 moc_*.cpp
@@ -18,6 +31,7 @@ ui_*.h
 qrc_*.cpp
 *.pro.user
 *.pro.user.*
+*.qm

 # Blockchain data
 *.dat
@@ -35,6 +49,7 @@ blocks/
 # IDE
 .vscode/
 .idea/
+.claude/
 *.swp
 *.swo
 *~
@@ -45,6 +60,7 @@ blocks/
 .*.json
 temp/
 tmp/
+testnet-sync/

 # Private/Local
 triangles.conf
@@ -52,3 +68,6 @@ triangles.conf
 *.key
 *.cert
 *.gpg
+*.o
+src/trianglesd
+src/obj/
@@ -0,0 +1,6 @@
+[submodule "src/tor/tor-src"]
+	path = src/tor/tor-src
+	url = https://gitlab.torproject.org/tpo/core/tor.git
+[submodule "src/secp256k1"]
+	path = src/secp256k1
+	url = https://github.com/bitcoin-core/secp256k1
@@ -0,0 +1,199 @@
+cmake_minimum_required(VERSION 3.16)
+
+# Silence CMP0167 warning (FindBoost removed in CMake 3.30+, use BoostConfig)
+if(POLICY CMP0167)
+    cmake_policy(SET CMP0167 NEW)
+endif()
+
+project(Triangles
+    VERSION 6.0.0
+    DESCRIPTION "Cryptographic Triangles Wallet"
+    LANGUAGES C CXX
+)
+
+# ── C++ Standard ──
+# C++20 required: RocksDB headers in MSYS2/Homebrew (8.x+) use `using enum`
+# and defaulted operator== on user-defined types, both C++20-only.
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_C_STANDARD 11)
+
+# ── Build acceleration ──
+# ccache: auto-detect and use if available
+find_program(CCACHE_PROGRAM ccache)
+if(CCACHE_PROGRAM)
+    set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
+    set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
+    message(STATUS "ccache found: ${CCACHE_PROGRAM}")
+else()
+    message(STATUS "ccache not found — install it for faster rebuilds")
+endif()
+
+# Unity (jumbo) build: batch source files to reduce header parsing overhead
+option(ENABLE_UNITY_BUILD "Enable CMake unity (jumbo) builds" OFF)
+if(ENABLE_UNITY_BUILD)
+    set(CMAKE_UNITY_BUILD ON)
+    set(CMAKE_UNITY_BUILD_BATCH_SIZE 8)
+endif()
+
+# ── Output directories ──
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib")
+
+# ── Custom module path ──
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
+
+# ── User-facing options ──
+option(BUILD_QT           "Build triangles-qt (Qt5 GUI wallet)"              ON)
+option(BUILD_DAEMON       "Build trianglesd (headless daemon)"               ON)
+option(BUILD_TESTS        "Build test_triangles (Boost.Test unit tests)"     ON)
+option(USE_UPNP           "Enable UPnP support via miniupnpc"               ON)
+option(USE_IPV6           "Enable IPv6 support"                              ON)
+option(USE_QRCODE         "Enable QR code generation via libqrencode"        OFF)
+option(USE_DBUS           "Enable D-Bus notifications (Linux only)"          ON)
+option(USE_ZMQ            "Enable ZMQ publisher support"                     OFF)
+option(USE_TOR_EMBEDDED   "Enable embedded Tor library linking"              OFF)
+option(USE_O3             "Use -O3 optimization instead of -O2"              OFF)
+option(ENABLE_PIE         "Build position-independent executables"           OFF)
+option(ENABLE_STATIC      "Prefer static linking (Linux release builds)"     OFF)
+
+# Cache variables for custom dependency paths
+set(BDB_INCLUDE_PATH "" CACHE PATH "Path to Berkeley DB headers")
+set(BDB_LIB_PATH     "" CACHE PATH "Path to Berkeley DB libraries")
+set(EVENT_INCLUDE_PATH "" CACHE PATH "Path to libevent headers")
+set(EVENT_LIB_PATH     "" CACHE PATH "Path to libevent libraries")
+set(MINIUPNPC_INCLUDE_PATH "" CACHE PATH "Path to miniupnpc headers")
+set(MINIUPNPC_LIB_PATH     "" CACHE PATH "Path to miniupnpc libraries")
+set(TOR_SOURCE_ROOT   "" CACHE PATH "Path to Tor source tree (for USE_TOR_EMBEDDED)")
+
+# ── Compiler/linker flags ──
+include(AddCompilerFlags)
+
+# ── Find required dependencies ──
+find_package(OpenSSL REQUIRED)
+find_package(Boost 1.71 REQUIRED COMPONENTS
+    program_options thread chrono
+)
+if(BUILD_TESTS)
+    find_package(Boost REQUIRED COMPONENTS unit_test_framework)
+endif()
+find_package(BerkeleyDB REQUIRED)
+find_package(Libevent REQUIRED)
+find_package(ZLIB REQUIRED)
+find_package(Threads REQUIRED)
+
+# ── Find optional dependencies ──
+if(USE_UPNP)
+    find_package(Miniupnpc REQUIRED)
+endif()
+
+if(USE_QRCODE)
+    find_package(QRencode REQUIRED)
+endif()
+
+if(USE_ZMQ)
+    find_package(PkgConfig REQUIRED)
+    pkg_check_modules(ZMQ REQUIRED IMPORTED_TARGET libzmq)
+endif()
+
+# RocksDB is now a hard dependency: backs both the chain database and the
+# secure-messaging store (smessage). Probe in order:
+#   1. CMake config package (MSYS2, Homebrew, vcpkg, recent Linux)
+#   2. pkg-config (some Linux distros, no .cmake files)
+#   3. Manual find_path/find_library (Ubuntu 22.04's librocksdb-dev ships
+#      neither a CMake config nor a .pc file)
+# In all paths, a target named RocksDB::rocksdb is exposed for consumers.
+find_package(RocksDB CONFIG QUIET)
+if(NOT RocksDB_FOUND)
+    find_package(PkgConfig QUIET)
+    if(PkgConfig_FOUND)
+        pkg_check_modules(RocksDB IMPORTED_TARGET QUIET rocksdb)
+    endif()
+endif()
+if(NOT TARGET RocksDB::rocksdb AND NOT TARGET PkgConfig::RocksDB)
+    find_path(ROCKSDB_INCLUDE_DIR
+        NAMES rocksdb/db.h
+        PATHS /usr/include /usr/local/include
+    )
+    find_library(ROCKSDB_LIBRARY
+        NAMES rocksdb
+        PATHS /usr/lib /usr/lib/x86_64-linux-gnu /usr/local/lib
+    )
+    if(NOT ROCKSDB_INCLUDE_DIR OR NOT ROCKSDB_LIBRARY)
+        message(FATAL_ERROR
+            "RocksDB not found. Install librocksdb-dev (Ubuntu/Debian), "
+            "rocksdb (Homebrew), or mingw-w64-x86_64-rocksdb (MSYS2).")
+    endif()
+    add_library(RocksDB::rocksdb UNKNOWN IMPORTED)
+    set_target_properties(RocksDB::rocksdb PROPERTIES
+        IMPORTED_LOCATION "${ROCKSDB_LIBRARY}"
+        INTERFACE_INCLUDE_DIRECTORIES "${ROCKSDB_INCLUDE_DIR}"
+    )
+    message(STATUS "Found RocksDB (manual probe): ${ROCKSDB_LIBRARY}")
+endif()
+
+# libsecp256k1 — vendored as a git submodule under src/secp256k1. Provides
+# ECDSA signing/verification, pubkey recovery (via the recovery module), and
+# ECDH for secure messaging. Configure the submodule's build for our needs:
+# only ECDH + recovery, none of the test/benchmark/extra-module bloat, and
+# don't install (we link statically against the in-tree target).
+if(NOT EXISTS "${CMAKE_SOURCE_DIR}/src/secp256k1/CMakeLists.txt")
+    message(FATAL_ERROR
+        "src/secp256k1 is empty. Run: git submodule update --init --recursive")
+endif()
+set(SECP256K1_DISABLE_SHARED            ON  CACHE INTERNAL "")
+set(SECP256K1_INSTALL                   OFF CACHE INTERNAL "")
+set(SECP256K1_BUILD_BENCHMARK           OFF CACHE INTERNAL "")
+set(SECP256K1_BUILD_TESTS               OFF CACHE INTERNAL "")
+set(SECP256K1_BUILD_EXHAUSTIVE_TESTS    OFF CACHE INTERNAL "")
+set(SECP256K1_BUILD_CTIME_TESTS         OFF CACHE INTERNAL "")
+set(SECP256K1_BUILD_EXAMPLES            OFF CACHE INTERNAL "")
+set(SECP256K1_ENABLE_MODULE_ECDH        ON  CACHE INTERNAL "")
+set(SECP256K1_ENABLE_MODULE_RECOVERY    ON  CACHE INTERNAL "")
+set(SECP256K1_ENABLE_MODULE_EXTRAKEYS   OFF CACHE INTERNAL "")
+set(SECP256K1_ENABLE_MODULE_SCHNORRSIG  OFF CACHE INTERNAL "")
+set(SECP256K1_ENABLE_MODULE_MUSIG       OFF CACHE INTERNAL "")
+set(SECP256K1_ENABLE_MODULE_ELLSWIFT    OFF CACHE INTERNAL "")
+add_subdirectory(src/secp256k1 EXCLUDE_FROM_ALL)
+
+if(BUILD_QT)
+    find_package(Qt5 5.9 REQUIRED COMPONENTS Core Gui Widgets)
+    find_package(Qt5 COMPONENTS LinguistTools QUIET)
+    if(USE_DBUS AND UNIX AND NOT APPLE)
+        find_package(Qt5 COMPONENTS DBus QUIET)
+        if(NOT Qt5DBus_FOUND)
+            message(STATUS "Qt5 DBus not found -- disabling D-Bus notifications")
+            set(USE_DBUS OFF CACHE BOOL "" FORCE)
+        endif()
+    else()
+        set(USE_DBUS OFF CACHE BOOL "" FORCE)
+    endif()
+endif()
+
+# ── Build bundled LevelDB ──
+include(BuildLevelDB)
+
+# ── Generate build.h from git describe ──
+include(GenerateBuildInfo)
+
+# ── Descend into source tree ──
+add_subdirectory(src)
+
+# ── Configuration summary ──
+message(STATUS "")
+message(STATUS "Triangles ${PROJECT_VERSION} build configuration:")
+message(STATUS "  Build Qt GUI:       ${BUILD_QT}")
+message(STATUS "  Build daemon:       ${BUILD_DAEMON}")
+message(STATUS "  Build tests:        ${BUILD_TESTS}")
+message(STATUS "  UPnP:               ${USE_UPNP}")
+message(STATUS "  IPv6:               ${USE_IPV6}")
+message(STATUS "  QR code:            ${USE_QRCODE}")
+message(STATUS "  D-Bus:              ${USE_DBUS}")
+message(STATUS "  ZMQ:                ${USE_ZMQ}")
+message(STATUS "  Embedded Tor:       ${USE_TOR_EMBEDDED}")
+message(STATUS "  Static linking:     ${ENABLE_STATIC}")
+message(STATUS "  ccache:             ${CCACHE_PROGRAM}")
+message(STATUS "  Unity build:        ${ENABLE_UNITY_BUILD}")
+message(STATUS "  Precompiled header: ON")
+message(STATUS "")
@@ -0,0 +1,398 @@
+# Triangles Bootstrap Server Setup - DNS2
+
+**For:** Krystie (@Krystie7777bot)
+**Server:** DNS2 (194.233.88.206) - Ubuntu
+**Date:** March 2026
+
+---
+
+## What This Server Does
+
+Your server is the **bootstrap server** for the Triangles network. When someone opens a fresh Triangles wallet:
+
+1. The wallet connects to `bootstrap.cryptographic-triangles.org` on **port 80**
+2. If that fails, it falls back to your IP directly: `194.233.88.206` on **port 80**
+3. It downloads `/filelist.txt` to see which blockchain files are available
+4. It downloads each file listed (mainly `blk0001.dat`, the entire blockchain)
+5. The user is now synced and ready to go
+
+Your IP is hardcoded in the wallet. If your server is down, new users can't bootstrap.
+
+Your server also runs the Triangles daemon so it doubles as a seed node on **port 24112**.
+
+---
+
+## Step 1: Install nginx
+
+```bash
+sudo apt update
+sudo apt install -y nginx curl
+```
+
+---
+
+## Step 2: Download the Daemon
+
+No building required. Download the pre-built Linux binary from GitHub:
+
+```bash
+cd /tmp
+curl -L -o trianglesd https://github.com/SamiAhmed7777/triangles_v5/releases/download/v5.3.7/Cryptographic-Triangles-v5.3.7-linux-x64-daemon
+chmod +x trianglesd
+sudo mv trianglesd /usr/local/bin/
+```
+
+Verify it works:
+
+```bash
+trianglesd --version
+```
+
+---
+
+## Step 3: Configure the Daemon
+
+```bash
+mkdir -p ~/.triangles
+
+RPC_PASS=$(openssl rand -hex 32)
+
+cat > ~/.triangles/triangles.conf << EOF
+port=24112
+listen=1
+maxconnections=125
+rpcport=19112
+rpcuser=trianglesrpc
+rpcpassword=$RPC_PASS
+rpcallowip=127.0.0.1
+server=1
+externalip=194.233.88.206
+addnode=74.208.167.19
+txindex=1
+daemon=1
+EOF
+```
+
+---
+
+## Step 4: Get the Blockchain Data
+
+OpenClaw will send you `blk0001.dat` (or a tarball containing it). Put it in `~/.triangles/`:
+
+```bash
+cd ~/.triangles
+# If you received a tarball:
+tar xzf /path/to/blockchain-data.tar.gz
+# Or if you received blk0001.dat directly:
+cp /path/to/blk0001.dat ~/.triangles/
+```
+
+After this step you should have:
+
+```
+~/.triangles/blk0001.dat
+~/.triangles/triangles.conf
+```
+
+Do NOT copy someone else's `wallet.dat` unless you intend to use that wallet.
+
+---
+
+## Step 5: Open Firewall Ports
+
+You need **two** ports open:
+
+```bash
+sudo ufw allow 80/tcp comment "Bootstrap HTTP server"
+sudo ufw allow 24112/tcp comment "Triangles P2P"
+sudo ufw enable
+sudo ufw status
+```
+
+Verify both show ALLOW:
+
+```
+80/tcp                     ALLOW       Anywhere        # Bootstrap HTTP server
+24112/tcp                  ALLOW       Anywhere        # Triangles P2P
+```
+
+Do NOT open 19112 (RPC).
+
+---
+
+## Step 6: Test the Daemon
+
+```bash
+trianglesd
+```
+
+Wait 10 seconds, then:
+
+```bash
+trianglesd getinfo
+```
+
+Look for:
+- `"blocks"` around 2,186,940 or higher
+- `"connections"` should become 1+ within a couple minutes
+
+If it works, stop it:
+
+```bash
+trianglesd stop
+```
+
+---
+
+## Step 7: Set Up the Daemon as a systemd Service
+
+```bash
+sudo tee /etc/systemd/system/trianglesd.service << 'EOF'
+[Unit]
+Description=Triangles Daemon
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=forking
+ExecStart=/usr/local/bin/trianglesd -daemon -datadir=/root/.triangles
+ExecStop=/usr/local/bin/trianglesd -datadir=/root/.triangles stop
+Restart=on-failure
+RestartSec=30
+TimeoutStopSec=120
+LimitNOFILE=65536
+
+[Install]
+WantedBy=multi-user.target
+EOF
+
+sudo systemctl daemon-reload
+sudo systemctl enable trianglesd
+sudo systemctl start trianglesd
+```
+
+If you're running as a non-root user, change `/root/.triangles` to `/home/youruser/.triangles`.
+
+Verify:
+
+```bash
+sudo systemctl status trianglesd
+trianglesd getinfo
+```
+
+---
+
+## Step 8: Set Up the Bootstrap File Server
+
+This is the main event.
+
+### 8a. Create the bootstrap directory and tarball
+
+```bash
+sudo mkdir -p /var/www/triangles-bootstrap
+
+# Create the compressed tarball from the blockchain data
+# Only blk0001.dat is needed - the wallet builds its own block index after download
+cd ~/.triangles
+tar czf /tmp/bootstrap.tar.gz blk0001.dat
+sudo mv /tmp/bootstrap.tar.gz /var/www/triangles-bootstrap/
+
+# Also create the legacy fallback files (for older wallet versions)
+sudo cp ~/.triangles/blk0001.dat /var/www/triangles-bootstrap/
+sudo tee /var/www/triangles-bootstrap/filelist.txt << 'EOF'
+blk0001.dat
+EOF
+
+sudo chown -R www-data:www-data /var/www/triangles-bootstrap
+```
+
+The wallet tries to download `bootstrap.tar.gz` first (compressed, faster). If that's missing, it falls back to downloading `blk0001.dat` directly using `filelist.txt`. After download, the wallet automatically imports the blocks and builds its own index.
+
+### 8b. Configure nginx
+
+```bash
+sudo rm -f /etc/nginx/sites-enabled/default
+
+sudo tee /etc/nginx/sites-available/triangles-bootstrap << 'EOF'
+server {
+    listen 80;
+    server_name bootstrap.cryptographic-triangles.org 194.233.88.206;
+
+    root /var/www/triangles-bootstrap;
+
+    location / {
+        try_files $uri =404;
+    }
+
+    send_timeout 600s;
+    keepalive_timeout 600s;
+}
+EOF
+
+sudo ln -sf /etc/nginx/sites-available/triangles-bootstrap /etc/nginx/sites-enabled/
+sudo nginx -t
+```
+
+That should print `syntax is ok` and `test is successful`. Then:
+
+```bash
+sudo systemctl enable nginx
+sudo systemctl restart nginx
+```
+
+### 8c. Verify it works
+
+```bash
+# Should print "blk0001.dat"
+curl http://localhost/filelist.txt
+
+# Should show HTTP 200 and a Content-Length
+curl -I http://localhost/blk0001.dat
+```
+
+### 8d. Test from outside
+
+Ask OpenClaw to test from another machine:
+
+```bash
+curl -I http://194.233.88.206/bootstrap.tar.gz
+curl http://194.233.88.206/filelist.txt
+```
+
+If both return HTTP 200, the bootstrap server is live.
+
+---
+
+## Step 9: Keeping Bootstrap Data Fresh
+
+Periodically rebuild the tarball from the latest blockchain data:
+
+```bash
+sudo systemctl stop trianglesd
+cd ~/.triangles
+tar czf /tmp/bootstrap.tar.gz blk0001.dat
+sudo mv /tmp/bootstrap.tar.gz /var/www/triangles-bootstrap/
+sudo cp ~/.triangles/blk0001.dat /var/www/triangles-bootstrap/
+sudo chown -R www-data:www-data /var/www/triangles-bootstrap
+sudo systemctl start trianglesd
+```
+
+Or set up a weekly cron job:
+
+```bash
+sudo tee /etc/cron.d/triangles-bootstrap-update << 'EOF'
+0 4 * * 0 root systemctl stop trianglesd && cd /root/.triangles && tar czf /tmp/bootstrap.tar.gz blk0001.dat && mv /tmp/bootstrap.tar.gz /var/www/triangles-bootstrap/ && cp /root/.triangles/blk0001.dat /var/www/triangles-bootstrap/ && chown -R www-data:www-data /var/www/triangles-bootstrap && systemctl start trianglesd
+EOF
+```
+
+---
+
+## Step 10: Tor Hidden Service (Optional)
+
+```bash
+sudo apt install -y tor
+```
+
+Add to `/etc/tor/torrc`:
+
+```
+HiddenServiceDir /var/lib/tor/triangles/
+HiddenServiceVersion 3
+HiddenServicePort 24112 127.0.0.1:24112
+```
+
+Then:
+
+```bash
+sudo systemctl restart tor
+sudo cat /var/lib/tor/triangles/hostname
+```
+
+Send the `.onion` address to OpenClaw, add `externalip=YOUR_ONION_ADDRESS.onion` to `triangles.conf`, and restart the daemon.
+
+---
+
+## Troubleshooting
+
+### Bootstrap server isn't working
+
+```bash
+sudo systemctl status nginx
+sudo ss -tlnp | grep :80
+ls -lh /var/www/triangles-bootstrap/
+curl http://localhost/filelist.txt
+sudo tail -30 /var/log/nginx/error.log
+```
+
+### Daemon has 0 connections
+
+```bash
+sudo ss -tlnp | grep 24112
+sudo ufw status
+trianglesd addnode 74.208.167.19 add
+```
+
+### Daemon won't start
+
+```bash
+tail -100 ~/.triangles/debug.log
+ps aux | grep trianglesd
+ls ~/.triangles/.lock
+```
+
+### "Error loading block database"
+
+```bash
+rm -rf ~/.triangles/txleveldb/
+sudo systemctl restart trianglesd
+```
+
+---
+
+## Quick Reference
+
+| What | Where / Value |
+|------|---------------|
+| **Bootstrap files** | `/var/www/triangles-bootstrap/` |
+| **bootstrap.tar.gz** | `/var/www/triangles-bootstrap/bootstrap.tar.gz` |
+| **filelist.txt** | `/var/www/triangles-bootstrap/filelist.txt` (legacy fallback) |
+| **blk0001.dat (web)** | `/var/www/triangles-bootstrap/blk0001.dat` (legacy fallback) |
+| **nginx config** | `/etc/nginx/sites-available/triangles-bootstrap` |
+| **nginx logs** | `/var/log/nginx/error.log` |
+| Daemon binary | `/usr/local/bin/trianglesd` |
+| Data directory | `~/.triangles/` |
+| Config file | `~/.triangles/triangles.conf` |
+| Debug log | `~/.triangles/debug.log` |
+| P2P port | **24112** (must be open) |
+| HTTP port | **80** (must be open) |
+| RPC port | 19112 (localhost only) |
+| Restart daemon | `sudo systemctl restart trianglesd` |
+| Restart nginx | `sudo systemctl restart nginx` |
+| Other seed node | 74.208.167.19 (DNS3-Sami) |
+| Contact | OpenClaw on Telegram |
+
+---
+
+## You're Done
+
+Once you've completed all the steps, your server is:
+
+1. **A seed node** — other wallets discover and connect to you on port 24112
+2. **A bootstrap server** — new wallets download the blockchain from you on port 80
+
+Send OpenClaw your `.onion` address (if you set up Tor) so it can be added to the wallet's onion seed list.
+
+To confirm everything is running:
+
+```bash
+# Daemon healthy?
+trianglesd getinfo
+
+# nginx serving files?
+curl -I http://localhost/bootstrap.tar.gz
+
+# Ports open externally?
+sudo ss -tlnp | grep -E ':(80|24112)\b'
+```
+
+If all three check out, you're live on the Triangles network.
@@ -2,7 +2,7 @@ FROM ubuntu:22.04

 LABEL maintainer="Cryptographic Triangles Team"
 LABEL description="Cryptographic Triangles (TRI) headless daemon"
-LABEL version="5.1.5"
+LABEL version="5.7.6"

 RUN apt-get update && apt-get install -y --no-install-recommends \
    ca-certificates \
@@ -19,8 +19,9 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
    tor \
    && rm -rf /var/lib/apt/lists/*

+ARG VERSION=5.7.6
 RUN curl -L -o /usr/local/bin/trianglesd \
-    https://github.com/SamiAhmed7777/triangles_v5/releases/download/v5.1.5/trianglesd-linux \
+    https://github.com/SamiAhmed7777/triangles_v5/releases/download/v${VERSION}/Cryptographic-Triangles-v${VERSION}-linux-x64-daemon \
    && chmod +x /usr/local/bin/trianglesd

 RUN useradd -m -s /bin/bash triangles
@@ -1,284 +0,0 @@
-#############################################################################
-# Makefile for building: triangles-qt
-# Generated by qmake (3.1) (Qt 5.15.18)
-# Project:  triangles-qt.pro
-# Template: app
-# Command: C:/msys64/mingw64/bin/qmake-qt5.exe -o Makefile triangles-qt.pro
-#############################################################################
-
-MAKEFILE      = Makefile
-
-EQ            = =
-
-first: release
-install: release-install
-uninstall: release-uninstall
-QMAKE         = C:/msys64/mingw64/bin/qmake-qt5.exe
-DEL_FILE      = rm -f
-CHK_DIR_EXISTS= test -d
-MKDIR         = mkdir -p
-COPY          = cp -f
-COPY_FILE     = cp -f
-COPY_DIR      = cp -f -R
-INSTALL_FILE  = cp -f
-INSTALL_PROGRAM = cp -f
-INSTALL_DIR   = cp -f -R
-QINSTALL      = C:/msys64/mingw64/bin/qmake-qt5.exe -install qinstall
-QINSTALL_PROGRAM = C:/msys64/mingw64/bin/qmake-qt5.exe -install qinstall -exe
-DEL_FILE      = rm -f
-SYMLINK       = $(QMAKE) -install ln -f -s
-DEL_DIR       = rmdir
-MOVE          = mv -f
-IDC           = idc
-IDL           = widl
-ZIP           = 
-DEF_FILE      = 
-RES_FILE      = build/triangles-qt_res.o
-SED           = sed
-MOVE          = mv -f
-SUBTARGETS    =  \
-		release \
-		debug
-
-
-release: FORCE
-	$(MAKE) -f $(MAKEFILE).Release
-release-make_first: FORCE
-	$(MAKE) -f $(MAKEFILE).Release 
-release-all: FORCE
-	$(MAKE) -f $(MAKEFILE).Release all
-release-clean: FORCE
-	$(MAKE) -f $(MAKEFILE).Release clean
-release-distclean: FORCE
-	$(MAKE) -f $(MAKEFILE).Release distclean
-release-install: FORCE
-	$(MAKE) -f $(MAKEFILE).Release install
-release-uninstall: FORCE
-	$(MAKE) -f $(MAKEFILE).Release uninstall
-debug: FORCE
-	$(MAKE) -f $(MAKEFILE).Debug
-debug-make_first: FORCE
-	$(MAKE) -f $(MAKEFILE).Debug 
-debug-all: FORCE
-	$(MAKE) -f $(MAKEFILE).Debug all
-debug-clean: FORCE
-	$(MAKE) -f $(MAKEFILE).Debug clean
-debug-distclean: FORCE
-	$(MAKE) -f $(MAKEFILE).Debug distclean
-debug-install: FORCE
-	$(MAKE) -f $(MAKEFILE).Debug install
-debug-uninstall: FORCE
-	$(MAKE) -f $(MAKEFILE).Debug uninstall
-
-Makefile: triangles-qt.pro C:/msys64/mingw64/share/qt5/mkspecs/win32-g++/qmake.conf C:/msys64/mingw64/share/qt5/mkspecs/features/spec_pre.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/qdevice.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/device_config.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/common/sanitize.conf \
-		C:/msys64/mingw64/share/qt5/mkspecs/common/gcc-base.conf \
-		C:/msys64/mingw64/share/qt5/mkspecs/common/g++-base.conf \
-		C:/msys64/mingw64/share/qt5/mkspecs/common/angle.conf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/win32/windows_vulkan_sdk.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/common/windows-vulkan.conf \
-		C:/msys64/mingw64/share/qt5/mkspecs/common/g++-win32.conf \
-		C:/msys64/mingw64/share/qt5/mkspecs/common/windows-desktop.conf \
-		C:/msys64/mingw64/share/qt5/mkspecs/qconfig.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_accessibility_support_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_bootstrap_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_concurrent.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_concurrent_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_core.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_core_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_dbus.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_dbus_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_designer.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_designer_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_designercomponents_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_devicediscovery_support_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_edid_support_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_eventdispatcher_support_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_fb_support_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_fontdatabase_support_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_gui.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_gui_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_help.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_help_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_network.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_network_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_opengl.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_opengl_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_openglextensions.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_openglextensions_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_platformcompositor_support_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_printsupport.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_printsupport_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_sql.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_sql_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_testlib.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_testlib_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_theme_support_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_uiplugin.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_uitools.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_uitools_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_vulkan_support_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_widgets.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_widgets_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_windowsuiautomation_support_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_xml.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_xml_private.pri \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/qt_functions.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/qt_config.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/win32-g++/qmake.conf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/spec_post.prf \
-		.qmake.stash \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/exclusive_builds.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/toolchain.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/default_pre.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/win32/default_pre.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/resolve_config.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/exclusive_builds_post.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/default_post.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/precompile_header.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/warn_on.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/qt.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/resources_functions.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/resources.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/moc.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/win32/opengl.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/uic.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/qmake_use.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/file_copies.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/win32/windows.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/testcase_targets.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/exceptions.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/yacc.prf \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/lex.prf \
-		triangles-qt.pro \
-		C:/msys64/mingw64/lib/qtmain.prl \
-		C:/msys64/mingw64/share/qt5/mkspecs/features/build_pass.prf \
-		src/qt/triangles.qrc
-	$(QMAKE) -o Makefile triangles-qt.pro
-C:/msys64/mingw64/share/qt5/mkspecs/features/spec_pre.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/qdevice.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/features/device_config.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/common/sanitize.conf:
-C:/msys64/mingw64/share/qt5/mkspecs/common/gcc-base.conf:
-C:/msys64/mingw64/share/qt5/mkspecs/common/g++-base.conf:
-C:/msys64/mingw64/share/qt5/mkspecs/common/angle.conf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/win32/windows_vulkan_sdk.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/common/windows-vulkan.conf:
-C:/msys64/mingw64/share/qt5/mkspecs/common/g++-win32.conf:
-C:/msys64/mingw64/share/qt5/mkspecs/common/windows-desktop.conf:
-C:/msys64/mingw64/share/qt5/mkspecs/qconfig.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_accessibility_support_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_bootstrap_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_concurrent.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_concurrent_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_core.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_core_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_dbus.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_dbus_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_designer.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_designer_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_designercomponents_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_devicediscovery_support_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_edid_support_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_eventdispatcher_support_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_fb_support_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_fontdatabase_support_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_gui.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_gui_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_help.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_help_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_network.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_network_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_opengl.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_opengl_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_openglextensions.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_openglextensions_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_platformcompositor_support_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_printsupport.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_printsupport_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_sql.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_sql_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_testlib.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_testlib_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_theme_support_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_uiplugin.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_uitools.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_uitools_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_vulkan_support_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_widgets.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_widgets_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_windowsuiautomation_support_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_xml.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/modules/qt_lib_xml_private.pri:
-C:/msys64/mingw64/share/qt5/mkspecs/features/qt_functions.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/qt_config.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/win32-g++/qmake.conf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/spec_post.prf:
-.qmake.stash:
-C:/msys64/mingw64/share/qt5/mkspecs/features/exclusive_builds.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/toolchain.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/default_pre.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/win32/default_pre.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/resolve_config.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/exclusive_builds_post.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/default_post.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/precompile_header.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/warn_on.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/qt.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/resources_functions.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/resources.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/moc.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/win32/opengl.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/uic.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/qmake_use.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/file_copies.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/win32/windows.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/testcase_targets.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/exceptions.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/yacc.prf:
-C:/msys64/mingw64/share/qt5/mkspecs/features/lex.prf:
-triangles-qt.pro:
-C:/msys64/mingw64/lib/qtmain.prl:
-C:/msys64/mingw64/share/qt5/mkspecs/features/build_pass.prf:
-src/qt/triangles.qrc:
-qmake: FORCE
-	@$(QMAKE) -o Makefile triangles-qt.pro
-
-qmake_all: FORCE
-
-make_first: release-make_first debug-make_first  FORCE
-all: release-all debug-all  FORCE
-clean: release-clean debug-clean  FORCE
-	-$(DEL_FILE) E:/repos/triangles/src/leveldb/libleveldb.a;
-	-$(DEL_FILE) cd
-	-$(DEL_FILE) E:/repos/triangles/src/leveldb
-	-$(DEL_FILE) ;
-	-$(DEL_FILE) clean
-distclean: release-distclean debug-distclean  FORCE
-	-$(DEL_FILE) Makefile
-	-$(DEL_FILE) .qmake.stash
-
-E:/repos/triangles/src/leveldb/libleveldb.a: FORCE
-	cd E:/repos/triangles/src/leveldb && CC=gcc CXX=g++ TARGET_OS=OS_WINDOWS_CROSSCOMPILE $(MAKE) OPT="-fno-keep-inline-dllexport -march=nocona -msahf -mtune=generic -Wa,-mbig-obj -O2" libleveldb.a libmemenv.a && ranlib E:/repos/triangles/src/leveldb/libleveldb.a && ranlib E:/repos/triangles/src/leveldb/libmemenv.a
-
-release-mocclean:
-	$(MAKE) -f $(MAKEFILE).Release mocclean
-debug-mocclean:
-	$(MAKE) -f $(MAKEFILE).Debug mocclean
-mocclean: release-mocclean debug-mocclean
-
-release-mocables:
-	$(MAKE) -f $(MAKEFILE).Release mocables
-debug-mocables:
-	$(MAKE) -f $(MAKEFILE).Debug mocables
-mocables: release-mocables debug-mocables
-
-check: first
-
-benchmark: first
-FORCE:
-
-$(MAKEFILE).Release: Makefile
-$(MAKEFILE).Debug: Makefile
@@ -1,4 +1,4 @@
-# Cryptographic Triangles (TRI) - v5.1.5
+# Cryptographic Triangles (TRI)

 Triangles is a privacy-focused cryptocurrency featuring Proof-of-Stake consensus, Tor v3 onion routing, and built-in encrypted messaging. Originally launched in July 2014, the chain was revived in March 2026 after being frozen since December 2022.

@@ -16,7 +16,7 @@ Triangles is a privacy-focused cryptocurrency featuring Proof-of-Stake consensus
 |----------|-------|
 | Algorithm | Hash9 (PoW blocks 0-9000), PoS from block 9001 |
 | Block Time | ~120 seconds |
-| Max Supply | 222,222 TRI |
+| Max Supply | 2,222,222 TRI |
 | PoS Reward | 33% annual, coin-age based |
 | P2P Port | 24112 |
 | RPC Port | 19112 |
@@ -24,43 +24,60 @@ Triangles is a privacy-focused cryptocurrency featuring Proof-of-Stake consensus

 ## Network Status

-The Triangles network is live with seed nodes operating on both clearnet and Tor:
-
-**Clearnet Seeds:**
- `194.233.88.206:24112`
- `74.208.167.19:24112`
+The Triangles network operates exclusively over Tor for privacy:

 **Tor v3 Seeds:**
- `gxvrhv3qitnc6kobrhsrse46bmcfitnybapor3or3oczzuxn6hfzxyid.onion:24112`
- `futmtrvh6j34t7s6yjdxfia6iwuyfzwh4k5eqfof5kfhoqk3xmi3qoqd.onion:24112`
+- `jbpfhe7zw3qm67wy3j2ayysp3mnrjobopthnko3b3sgahqtecblwqmid.onion:24112`
+- `uddaxjbo3lh2zskg7w6gwln4ty5cel7q4c5jbx7fdtv6zf2j47gdlyad.onion:24112`
+- `el5sirhhleecuctpeeprelzubpqmoqivvra3rzlwbjttinxa4fq3wnid.onion:24112`
+- `sj5dhybnlp3v4y5niyc5unrnd6s43lyx5ibup7rolyosjbi2u2hsbvyd.onion:24112`
+- `i3kr5meha7se4ns3wss3h7v46m6uksfzv4wrohdqxpj6n35wyo2bvlid.onion:24112`

-**DNS Seeds:**
- `seed1.cryptographic-triangles.org`
- `seed2.cryptographic-triangles.org`
+**HTTP Seed List:**
+- `seeds.cryptographic-triangles.org/seeds.txt` - Dynamically updated list of active onion peers

 ## Building from Source

+Triangles uses CMake. All platforms follow the same build pattern.
+
+### Dependencies
+
+| Dependency | Minimum Version |
+|------------|----------------|
+| CMake | 3.16+ |
+| C++ compiler | C++17 support |
+| OpenSSL | 3.x |
+| Boost | 1.90+ |
+| Berkeley DB | 5.3 (with C++ bindings) |
+| libevent | 2.x |
+| LevelDB | bundled |
+
 ### Linux (Ubuntu 24.04 / Debian 12+)

 Install dependencies:
 ```bash
-sudo apt-get install -y build-essential libboost-all-dev libssl-dev \
-    libdb5.3++-dev libevent-dev zlib1g-dev libminiupnpc-dev
+sudo apt-get install -y build-essential cmake ninja-build \
+    libboost-all-dev libssl-dev libdb5.3++-dev libevent-dev \
+    zlib1g-dev libminiupnpc-dev
 ```

-Build the daemon:
+For the Qt wallet, also install:
 ```bash
-cd src/leveldb && make libleveldb.a libmemenv.a && cd ..
-make -j$(nproc) -f makefile.unix USE_UPNP=0
-strip trianglesd
+sudo apt-get install -y qtbase5-dev qt5-qmake libqrencode-dev
+```
+
+Build:
+```bash
+cmake -B build -G Ninja -DBUILD_QT=ON
+cmake --build build
 ```

 ### Linux (AlmaLinux 9 / RHEL 9)

 Install dependencies:
 ```bash
-sudo dnf install -y gcc-c++ make boost-devel openssl-devel libevent-devel \
-    zlib-devel miniupnpc-devel
+sudo dnf install -y gcc-c++ cmake ninja-build boost-devel openssl-devel \
+    libevent-devel zlib-devel miniupnpc-devel
 ```

 BDB 5.3 C++ bindings must be built from source on RHEL-based systems (the `libdb-devel` package does not include C++ headers). Download BDB 5.3.28 from Oracle and build with `--enable-cxx`.
@@ -71,17 +88,27 @@ Then build as above.

 Open an MSYS2 MinGW64 shell and install:
 ```bash
-pacman -S mingw-w64-x86_64-boost mingw-w64-x86_64-openssl \
+pacman -S mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja \
+    mingw-w64-x86_64-boost mingw-w64-x86_64-openssl \
    mingw-w64-x86_64-db mingw-w64-x86_64-miniupnpc \
-    mingw-w64-x86_64-qt5-base mingw-w64-x86_64-qrencode
+    mingw-w64-x86_64-qt5-base mingw-w64-x86_64-qrencode \
+    mingw-w64-x86_64-libevent
 ```

-Build the Qt wallet:
+Build:
 ```bash
-qmake triangles-qt.pro
-make -j$(nproc)
+cmake -B build -G Ninja -DBUILD_QT=ON
+cmake --build build
 ```

+### Build Options
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `BUILD_QT` | ON | Build the Qt GUI wallet |
+| `BUILD_DAEMON` | ON | Build the headless daemon |
+| `BUILD_TESTS` | OFF | Build unit tests |
+
 ## Running

 ### First Run
@@ -98,15 +125,13 @@ txindex=1
 listen=1
 server=1
 daemon=1
-addnode=194.233.88.206
-addnode=74.208.167.19
-externalip=<your-public-ip>
+proxy=127.0.0.1:9050
 EOF

 trianglesd
 ```

-The node will connect to seed nodes and sync the blockchain automatically.
+The node will connect to seed nodes over Tor and sync the blockchain automatically.

 ### Existing Wallet Holders

@@ -150,7 +175,7 @@ Messages are encrypted end-to-end using AES and distributed through the peer net

 ### Tor Support

-To connect through Tor, install the Tor daemon and add to your config:
+Triangles is designed as a Tor-only network. Install the Tor daemon and configure your proxy:
 ```
 # triangles.conf
 proxy=127.0.0.1:9050
@@ -194,7 +219,7 @@ Then set `externalip=<your-onion-address>` in `triangles.conf`.
 - **Block 9001+** - Proof-of-Stake only
 - **Block 17,651** - V5 hard fork (removed Tor v2, disabled checkpoint master key)
 - **December 8, 2022** - Chain frozen (all nodes offline)
- **March 11, 2026** - Chain revived with v5.0.0.0, staking resumed
+- **March 11, 2026** - Chain revived, staking resumed

 ## Project Structure

@@ -0,0 +1,284 @@
+# Triangles Tor-Native Architecture
+
+**Date:** 2026-03-26  
+**Status:** ✅ IMPLEMENTED & WORKING
+
+---
+
+## What This Is
+
+Triangles is now a **Tor-native proof-of-stake network** where:
+
+- **Every node = Tor hidden service** (.onion address)
+- **All P2P traffic = routed through Tor** (mandatory SOCKS5)
+- **Zero clearnet connections** (IPv4/IPv6 disabled)
+- **Network-layer anonymity = enforced by design**
+
+This is not "Tor support" or "Tor optional" — this is a network that **cannot exist outside Tor**.
+
+---
+
+## Architecture Enforcements
+
+### 1. Mandatory Tor Routing (`init.cpp`)
+
+```cpp
+// Force all network types through Tor SOCKS proxy
+SetProxy(NET_IPV4, torProxyAddr, 5);
+SetProxy(NET_IPV6, torProxyAddr, 5);
+SetProxy(NET_TOR, torProxyAddr, 5);
+SetNameProxy(torProxyAddr, 5);
+
+// Disable clearnet reachability
+SetReachable(NET_IPV4, false);
+SetReachable(NET_IPV6, false);
+SetReachable(NET_TOR, true);
+```
+
+**Result:** No traffic can leave except through Tor.
+
+---
+
+### 2. .onion-Only Peer Filter (`net.cpp`)
+
+```cpp
+// Reject all non-.onion addresses at connection time
+std::string addrStr = pszDest ? std::string(pszDest) : addrConnect.ToStringIP();
+if (addrStr.find(".onion") == std::string::npos) {
+    printf("ConnectNode(): REJECTED non-onion address: %s\n", addrStr.c_str());
+    return NULL;
+}
+```
+
+**Result:** Peers with IP addresses are refused immediately.
+
+---
+
+### 3. Onion-Only DNS Seeds (`net.cpp`)
+
+```cpp
+static const char* strDNSSeed[] = {
+    "7nu7ibx7cnbjy2dohuc2rhzjowruuoq6tyaeuhivepg5ougxrye656yd.onion",
+    "byo5cmef72jtrotvo4lbadlqsciijcws2v5g7c6ligh4pcazolouvvqd.onion",
+};
+```
+
+**Result:** Bootstrap uses .onion seeds only (no DNS, no clearnet fallback).
+
+---
+
+### 4. UPnP Disabled (`init.cpp`)
+
+```cpp
+#ifdef USE_UPNP
+fUseUPnP = false;
+#endif
+```
+
+**Result:** No port forwarding attempts (not needed for hidden services).
+
+---
+
+### 5. Embedded Tor Requirement (`init.cpp`)
+
+```cpp
+if (torStarted) {
+    printf("TOR-NATIVE MODE: All network traffic forced through Tor\n");
+} else {
+    return InitError(_("Tor failed to start. Triangles requires Tor to operate."));
+}
+```
+
+**Result:** If Tor doesn't start, the daemon refuses to run.
+
+---
+
+## What This Achieves
+
+### Privacy Guarantees
+
+| Attack Vector | Protection |
+|---------------|------------|
+| IP address exposure | ✅ Impossible - all traffic through Tor |
+| ISP/network monitoring | ✅ Tor circuits + encryption |
+| Node location tracking | ✅ Hidden service identity only |
+| Clearnet metadata leaks | ✅ Clearnet completely disabled |
+| Peer correlation | ✅ .onion addresses unlinkable to IPs |
+
+---
+
+### Network Properties
+
+- **Identity = .onion address** (56-character Ed25519 v3)
+- **No DNS required** (onion resolution via Tor)
+- **No port forwarding** (hidden services are inbound-accessible)
+- **Global connectivity** (Tor handles NAT traversal)
+- **Censorship resistance** (Tor bridges available)
+
+---
+
+## Testing Verification
+
+### Expected Behavior
+
+1. **Startup:**
+   ```
+   Embedded Tor starting (SOCKS 19099, HS port 24111)...
+   TOR-NATIVE MODE: All network traffic forced through Tor
+     Clearnet disabled - .onion addresses only
+   Tor hidden service: [56-char-onion].onion
+   ```
+
+2. **Connection attempts:**
+   ```
+   SOCKS5 connecting [onion-address].onion
+   trying connection [onion-address].onion:24111
+   ```
+
+3. **No clearnet peers:**
+   ```
+   # This should NOT appear:
+   trying connection 192.168.x.x  ❌
+   trying connection 8.8.8.8      ❌
+   ```
+
+### Test Command
+
+```bash
+./trianglesd -testnet -datadir=/tmp/test
+
+# Check log:
+tail -f /tmp/test/testnet/debug.log | grep -E "TOR-NATIVE|SOCKS5|onion"
+```
+
+---
+
+## Positioning Statement
+
+**Before:**
+> Triangles is a cryptocurrency with Tor support
+
+**After:**
+> **Triangles is a Tor-native proof-of-stake network where all nodes operate as hidden services and all communication is routed through the Tor network, eliminating IP-level identity exposure.**
+
+---
+
+## Implementation Commits
+
+1. `85fe0d0` - Add Tor 0.4.9 as submodule
+2. `de1d4ec` - Fix makefile link order for libtor
+3. `36ade21` - Document embedded Tor success
+4. `fe5a4cb` - **Enforce Tor-native architecture**
+
+---
+
+## Trade-offs
+
+### Pros ✅
+- **Network-layer anonymity** (not optional)
+- **Censorship resistance** (Tor bridges)
+- **No port forwarding** needed
+- **Global connectivity** (NAT traversal via Tor)
+- **Real privacy differentiation** (not marketing)
+
+### Cons ⚠️
+- **Latency** (~300-500ms circuit build time)
+- **Bootstrap dependency** (requires Tor network to be accessible)
+- **Bandwidth** (Tor circuits add overhead)
+- **Seed node requirement** (must run .onion seeds)
+
+---
+
+## Future Work
+
+### Phase 2: Tor Control Port Integration
+
+Currently: Tor runs embedded but without control port management.
+
+**Next:**
+- Connect to Tor control port (127.0.0.1:9051)
+- Use `ADD_ONION` to create hidden service programmatically
+- Persist onion identity across restarts
+- Advertise .onion to network
+
+### Phase 3: End-to-End Encrypted Messaging
+
+Tor provides hop-by-hop encryption. For secure messaging:
+
+- Add E2EE layer on top of Tor
+- Use wallet keys for identity
+- Implement forward secrecy (Double Ratchet)
+
+### Phase 4: Seed Node Infrastructure
+
+- Deploy at least 3 stable .onion seed nodes
+- Consider using `HiddenServiceNonAnonymousMode` for seeds (faster, acceptable for public seeds)
+- Monitor seed health
+
+---
+
+## Security Considerations
+
+### What Tor Provides
+
+- **Circuit-level encryption** (3 hops)
+- **IP address hiding** (exit node sees destination, not origin)
+- **Hidden service anonymity** (rendezvous point protocol)
+
+### What Tor Does NOT Provide
+
+- **End-to-end encryption** (add separately for messaging)
+- **Traffic analysis immunity** (sophisticated adversaries can correlate)
+- **Perfect forward secrecy** (depends on implementation)
+
+### Threat Model
+
+**Protected against:**
+- ISP surveillance
+- Network-level attackers
+- Peer location tracking
+- Passive metadata collection
+
+**NOT protected against:**
+- Global passive adversary (NSA-level)
+- Timing correlation attacks (requires significant resources)
+- Application-level leaks (use Tor Browser principles)
+
+---
+
+## Comparison to Other Projects
+
+| Project | Tor Integration | Enforcement |
+|---------|----------------|-------------|
+| **Triangles** | Embedded, mandatory | ✅ Enforced |
+| Bitcoin | Optional (via `-onlynet=onion`) | ❌ Optional |
+| Monero | Optional (via `--proxy`) | ❌ Optional |
+| Zcash | Optional | ❌ Optional |
+| Verge (XVG) | Embedded | ⚠️ Mixed mode |
+
+**Key difference:** Triangles cannot operate without Tor. The network architecture requires it.
+
+---
+
+## Documentation Updates Needed
+
+1. **README.md** - Update project description
+2. **Build docs** - Add Tor dependency requirements
+3. **FAQ** - Explain why Tor is mandatory
+4. **Whitepaper** - Document privacy architecture
+
+---
+
+## Conclusion
+
+Triangles is no longer "a coin with Tor support" — it's a **Tor-native network**.
+
+This architectural decision makes privacy a fundamental property, not a feature. Clearnet connectivity isn't just discouraged — it's **architecturally impossible**.
+
+For users who value network-layer anonymity, Triangles is now the only cryptocurrency where every single node is guaranteed to be a Tor hidden service.
+
+---
+
+**Implementation:** Complete ✅  
+**Testing:** Verified ✅  
+**Ready for:** Mainnet deployment
@@ -0,0 +1,281 @@
+# Triangles (TRI) RPC Command Reference
+
+This document describes every RPC command available in the Triangles daemon (`trianglesd`) and Qt wallet. Connect via JSON-RPC on port **19112** (default). All commands can also be run from the Qt wallet's debug console.
+
+Triangles is a Tor-only PoS cryptocurrency. PoW ended at block 9000; from block 9001 onward the chain is pure Proof-of-Stake with 33% annual interest (coin-age based). Block time is 2 minutes. Max supply is 2,222,222 TRI.
+
+---
+
+## Server Control
+
+| Command | Parameters | Description |
+|---------|-----------|-------------|
+| `help` | `[command]` | List all commands, or get detailed help for a specific command. |
+| `stop` | | Shut down the daemon. |
+
+---
+
+## Blockchain
+
+| Command | Parameters | Description |
+|---------|-----------|-------------|
+| `getbestblockhash` | | Returns the hash of the tip of the best chain. |
+| `getblockcount` | | Returns the current block height. |
+| `getblockhash` | `<index>` | Returns the block hash at the given height. |
+| `getblock` | `<hash> [txinfo]` | Returns block details for the given hash. Set `txinfo=true` for full transaction data. |
+| `getblockbynumber` | `<number> [txinfo]` | Same as `getblock` but accepts a height instead of a hash. |
+| `getblockheader` | `<hash> [verbose=true]` | Returns block header data. If verbose is false, returns hex-encoded header. |
+| `getblockchaininfo` | | Returns chain state info: chain name, block height, best hash, difficulty, etc. |
+| `getdifficulty` | | Returns current PoW and PoS difficulty values. |
+| `gettxoutsetinfo` | | Returns statistics about the UTXO set (total txouts, size, etc.). |
+| `getrawmempool` | | Returns all transaction IDs currently in the mempool. |
+| `getcheckpoint` | | Returns info about the current synchronized checkpoint. |
+| `getchaintips` | | Returns info about all known chain tips (forks). |
+| `invalidateblock` | `<hash>` | Permanently marks a block as invalid and rewinds the chain past it. |
+| `reconsiderblock` | `<hash>` | Removes the invalid mark from a previously invalidated block. |
+| `recalculatesupply` | | Recalculates money supply by summing all UTXOs. Updates the stored value at the chain tip and persists to disk. Returns old/new supply and difference. |
+| `settxfee` | `<amount>` | Sets the transaction fee per kB. Amount is rounded to nearest 0.01. |
+| `estimatefee` | `<nblocks>` | Estimates the fee per kB needed for confirmation within `nblocks` blocks. |
+
+---
+
+## Address Index
+
+These commands query the address index. The daemon must be running with `-addressindex=1`.
+
+| Command | Parameters | Description |
+|---------|-----------|-------------|
+| `getaddressbalance` | `{"addresses":["addr",...]}` | Returns confirmed balance for the given address(es). |
+| `getaddressutxos` | `{"addresses":["addr",...]}` | Returns all unspent outputs for the given address(es). |
+| `getaddresstxids` | `{"addresses":["addr",...], "start":n, "end":n}` | Returns transaction IDs for the given address(es), optionally filtered by block range. |
+
+---
+
+## Mining & Staking
+
+| Command | Parameters | Description |
+|---------|-----------|-------------|
+| `getmininginfo` | | Returns mining-related info: height, difficulty, network hashrate, etc. |
+| `getstakinginfo` | | Returns staking-related info: whether staking is active, weight, expected time to stake, etc. |
+| `getsubsidy` | `[nTarget]` | Returns the PoW subsidy value for the given target height (historical reference only since PoW ended at block 9000). |
+
+---
+
+## Network
+
+| Command | Parameters | Description |
+|---------|-----------|-------------|
+| `getconnectioncount` | | Returns the number of peer connections. |
+| `getpeerinfo` | | Returns detailed info about each connected peer (address, version, ping time, etc.). |
+| `getnetworkinfo` | | Returns P2P network state: version, protocol, peer mix, connections, relay fee, etc. |
+| `getseedlist` | | Returns the list of configured seed nodes. |
+| `addnode` | `<node> <add\|remove\|onetry>` | Add or remove a node from the manual peer list, or try connecting once. For Tor nodes use the `.onion` address. |
+| `disconnectnode` | `<node>` | Immediately disconnects from the specified peer. |
+| `sendalert` | `<message> <privatekey> <minver> <maxver> <priority> <id> [cancelupto]` | Broadcasts a network alert (requires the alert master private key). |
+
+---
+
+## Wallet — General
+
+| Command | Parameters | Description |
+|---------|-----------|-------------|
+| `getinfo` | | Returns general info: version, balance, stake, block height, connections, etc. |
+| `getwalletinfo` | | Returns wallet-specific info: balance, unconfirmed, immature, txcount, keypoolsize, etc. |
+| `getbalance` | `[account] [minconf=1]` | Returns total available balance (optionally for a specific account). |
+| `checkwallet` | | Checks wallet database for consistency errors. |
+| `repairwallet` | | Attempts to repair the wallet database. |
+| `resendtx` | | Re-broadcasts all unconfirmed wallet transactions. |
+
+---
+
+## Wallet — Addresses & Accounts
+
+| Command | Parameters | Description |
+|---------|-----------|-------------|
+| `getnewaddress` | `[account]` | Generates a new receiving address (optionally assigned to an account). |
+| `getnewpubkey` | `[account]` | Returns a new public key for the wallet. |
+| `getaccountaddress` | `<account>` | Returns the current receiving address for the given account. |
+| `setaccount` | `<address> <account>` | Assigns an address to the given account label. |
+| `getaccount` | `<address>` | Returns the account label for the given address. |
+| `getaddressesbyaccount` | `<account>` | Returns all addresses assigned to the given account. |
+| `listaddressgroupings` | | Returns addresses grouped by common ownership (based on transaction history). |
+| `validateaddress` | `<address>` | Validates a Triangles address and returns info (ismine, account, pubkey, etc.). |
+| `validatepubkey` | `<pubkey>` | Validates a Triangles public key. |
+| `listaccounts` | `[minconf=1]` | Returns all account names and their balances. |
+
+---
+
+## Wallet — Sending
+
+| Command | Parameters | Description |
+|---------|-----------|-------------|
+| `sendtoaddress` | `<address> <amount> [comment] [comment-to]` | Sends TRI to an address. Returns the transaction ID. |
+| `sendfrom` | `<fromaccount> <address> <amount> [minconf=1] [comment] [comment-to]` | Sends TRI from a specific account. |
+| `sendmany` | `<fromaccount> {"addr":amount,...} [minconf=1] [comment]` | Sends TRI to multiple addresses in a single transaction. |
+| `move` | `<fromaccount> <toaccount> <amount> [minconf=1] [comment]` | Moves funds between accounts (internal bookkeeping only, no on-chain tx). |
+
+---
+
+## Wallet — Transaction History
+
+| Command | Parameters | Description |
+|---------|-----------|-------------|
+| `listtransactions` | `[account] [count=10] [from=0]` | Returns the most recent transactions (optionally filtered by account). |
+| `listsinceblock` | `[blockhash] [target-confirmations]` | Returns all transactions since the given block. |
+| `gettransaction` | `<txid>` | Returns detailed info about a wallet transaction. |
+| `getreceivedbyaddress` | `<address> [minconf=1]` | Returns total amount received by an address. |
+| `getreceivedbyaccount` | `<account> [minconf=1]` | Returns total amount received by an account. |
+| `listreceivedbyaddress` | `[minconf=1] [includeempty=false]` | Returns amounts received for each address. |
+| `listreceivedbyaccount` | `[minconf=1] [includeempty=false]` | Returns amounts received for each account. |
+
+---
+
+## Wallet — Staking Control
+
+| Command | Parameters | Description |
+|---------|-----------|-------------|
+| `reservebalance` | `[reserve] [amount]` | Show or set a reserve balance that will not be used for staking. `reserve` is true/false, `amount` is the TRI to reserve. |
+
+---
+
+## Wallet — Security
+
+| Command | Parameters | Description |
+|---------|-----------|-------------|
+| `encryptwallet` | `<passphrase>` | Encrypts the wallet with the given passphrase. **This shuts down the daemon.** The wallet must be re-started and unlocked afterward. |
+| `walletpassphrase` | `<passphrase> <timeout> [stakingonly]` | Unlocks the wallet for `timeout` seconds. Set `stakingonly=true` to allow staking but prevent sending. |
+| `walletpassphrasechange` | `<oldpassphrase> <newpassphrase>` | Changes the wallet encryption passphrase. |
+| `walletlock` | | Immediately locks the wallet (removes decryption key from memory). |
+| `keypoolrefill` | `[new-size]` | Tops up the pre-generated key pool. |
+| `makekeypair` | `[prefix]` | Generates a new public/private keypair (not added to wallet). |
+
+---
+
+## Wallet — Backup & Import
+
+| Command | Parameters | Description |
+|---------|-----------|-------------|
+| `backupwallet` | `<destination>` | Copies `wallet.dat` to the given file path. |
+| `dumpwallet` | `<filename>` | Exports all wallet private keys to a plaintext file. |
+| `dumpprivkey` | `<address>` | Returns the private key (WIF format) for the given address. |
+| `importwallet` | `<filename>` | Imports keys from a wallet dump file. |
+| `importprivkey` | `<privkey> [label]` | Imports a single private key (WIF format) with optional label. |
+
+---
+
+## Wallet — Multisig
+
+| Command | Parameters | Description |
+|---------|-----------|-------------|
+| `addmultisigaddress` | `<nrequired> ["key",...] [account]` | Creates an M-of-N multisig address. `nrequired` is the number of signatures needed. |
+| `addredeemscript` | `<redeemScript> [account]` | Adds a P2SH redeem script to the wallet. |
+
+---
+
+## Wallet — Message Signing
+
+| Command | Parameters | Description |
+|---------|-----------|-------------|
+| `signmessage` | `<address> <message>` | Signs a message with the private key of the given address. |
+| `verifymessage` | `<address> <signature> <message>` | Verifies a signed message. Returns true/false. |
+
+---
+
+## Raw Transactions
+
+| Command | Parameters | Description |
+|---------|-----------|-------------|
+| `listunspent` | `[minconf=1] [maxconf=9999999] ["addr",...]` | Returns unspent transaction outputs, optionally filtered by address and confirmation count. |
+| `createrawtransaction` | `[{"txid":"id","vout":n},...] {"addr":amount,...}` | Creates an unsigned raw transaction from the given inputs and outputs. |
+| `decoderawtransaction` | `<hex>` | Decodes a raw transaction hex string into a JSON object. |
+| `decodescript` | `<hex>` | Decodes a hex-encoded script into human-readable form. |
+| `signrawtransaction` | `<hex> [prevtxs] [privkeys] [sighashtype="ALL"]` | Signs a raw transaction. Can provide previous tx outputs and private keys for offline signing. |
+| `sendrawtransaction` | `<hex>` | Broadcasts a signed raw transaction to the network. Returns the txid. |
+| `getrawtransaction` | `<txid> [verbose=0]` | Returns raw transaction data. Set verbose=1 for decoded JSON output. |
+
+---
+
+## Secure Messaging (SMSG)
+
+Triangles has a built-in encrypted peer-to-peer messaging system. Messages are stored in a DHT-like bucket system and relayed through the network.
+
+| Command | Parameters | Description |
+|---------|-----------|-------------|
+| `smsgenable` | | Enables the secure messaging system. |
+| `smsgdisable` | | Disables the secure messaging system. |
+| `smsgoptions` | `[list\|set <optname> <value>]` | View or change secure messaging options. |
+| `smsglocalkeys` | `[whitelist\|all\|wallet\|recv +/- <addr>\|anon +/- <addr>]` | Manage which local keys participate in secure messaging. |
+| `smsgaddkey` | `<address> <pubkey>` | Adds someone's public key so you can send them encrypted messages. |
+| `smsggetpubkey` | `<address>` | Retrieves the public key for an address (needed to send messages to it). |
+| `smsgsend` | `<fromAddr> <toAddr> <message>` | Sends an encrypted message from one of your addresses to a recipient. |
+| `smsgsendanon` | `<toAddr> <message>` | Sends an anonymous encrypted message (no sender address attached). |
+| `smsginbox` | `[all\|unread\|clear]` | View received secure messages. Default shows unread. |
+| `smsgoutbox` | `[all\|clear]` | View sent secure messages. |
+| `smsgscanchain` | | Scans the blockchain for secure message public keys. |
+| `smsgscanbuckets` | | Scans stored message buckets for messages addressed to your keys. |
+| `smsgbuckets` | `[stats\|dump]` | View secure message bucket statistics or dump contents. |
+| `smsgbroadcast` | `<fromAddr> <message>` | Broadcasts a message to all SMSG participants (not encrypted to a single recipient). |
+
+---
+
+## Quick Reference — Common Tasks
+
+**Check node status:**
+```
+getinfo
+getblockcount
+getconnectioncount
+getstakinginfo
+```
+
+**Check balance and transactions:**
+```
+getbalance
+listtransactions
+```
+
+**Send coins:**
+```
+walletpassphrase "yourpassphrase" 60
+sendtoaddress "TRIaddress" 100
+walletlock
+```
+
+**Unlock for staking only:**
+```
+walletpassphrase "yourpassphrase" 999999999 true
+```
+
+**Add a peer manually (Tor .onion):**
+```
+addnode "abcdef1234567890.onion" "add"
+```
+
+**Export/import a private key:**
+```
+dumpprivkey "TRIaddress"
+importprivkey "5KPrivKeyHere" "mylabel"
+```
+
+**Fix incorrect money supply display:**
+```
+recalculatesupply
+```
+
+**Full reindex (rebuild block index from raw data):**
+```
+trianglesd -reindex
+```
+
+---
+
+## Connection Info
+
+| Setting | Value |
+|---------|-------|
+| Default RPC port | 19112 |
+| Default P2P port | 24112 |
+| Config file (Windows) | `%APPDATA%\triangles\triangles.conf` |
+| Config file (Linux) | `~/.triangles/triangles.conf` |
+| Protocol version | 70205 |
+| Network | Tor-only |
@@ -0,0 +1,73 @@
+# cmake/AddCompilerFlags.cmake
+# Shared compiler and linker flag configuration for all Triangles targets.
+
+# ── Common warning flags ──
+add_compile_options(
+    -Wall -Wextra -Wno-ignored-qualifiers
+    -Wformat -Wformat-security -Wno-unused-parameter
+)
+
+# ── Common defines ──
+add_compile_definitions(
+    BOOST_SPIRIT_THREADSAFE
+    BOOST_THREAD_USE_LIB
+    BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
+    BOOST_BIND_GLOBAL_PLACEHOLDERS
+    __NO_SYSTEM_INCLUDES
+)
+
+# ── Hardening (non-Windows) ──
+if(NOT WIN32)
+    # Ubuntu bug #691722 workaround: reset before re-enabling
+    add_compile_options(-fno-stack-protector)
+    add_compile_options(-fstack-protector-all -Wstack-protector)
+    add_compile_definitions(_FORTIFY_SOURCE=2)
+    # -z relro/now is ELF-only (Linux); macOS linker doesn't support it
+    if(NOT APPLE)
+        add_link_options(-Wl,-z,relro -Wl,-z,now)
+    endif()
+endif()
+
+# ── PIE (position-independent executables) ──
+if(ENABLE_PIE AND NOT WIN32)
+    add_compile_options(-fPIE)
+    add_link_options(-pie)
+endif()
+
+# ── Optimization override ──
+if(USE_O3)
+    string(REPLACE "-O2" "-O3" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
+    string(REPLACE "-O2" "-O3" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
+    string(REPLACE "-O2" "-O3" CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}")
+    string(REPLACE "-O2" "-O3" CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
+endif()
+
+# ── 32-bit SSE2 ──
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "i[3-6]86")
+    add_compile_options(-msse2)
+endif()
+
+# ── Platform: Windows (MSYS2 MinGW64) ──
+if(WIN32)
+    add_compile_options(-Wa,-mbig-obj)
+    add_compile_options(-Wno-deprecated-declarations -Wno-reserved-user-defined-literal)
+    add_link_options(-static -static-libgcc -static-libstdc++)
+    add_compile_definitions(WIN32 _MT)
+endif()
+
+# ── Platform: macOS ──
+if(APPLE)
+    set(CMAKE_OSX_DEPLOYMENT_TARGET "11.0" CACHE STRING "Minimum macOS version")
+    add_compile_options(-Wno-reserved-user-defined-literal -Wno-deprecated-declarations)
+    add_compile_definitions(MAC_OSX MSG_NOSIGNAL=0)
+endif()
+
+# ── Platform: Linux ──
+if(UNIX AND NOT APPLE)
+    add_compile_definitions(LINUX)
+endif()
+
+# ── Static linking (Linux release builds) ──
+if(ENABLE_STATIC AND UNIX AND NOT APPLE)
+    add_link_options(-static)
+endif()
@@ -0,0 +1,28 @@
+# cmake/BuildLevelDB.cmake
+# Builds the bundled LevelDB via its native CMake sub-build.
+# Exposes leveldb_lib, leveldb_memenv, leveldb_bundled, and build_leveldb.
+
+set(LEVELDB_SOURCE_DIR "${CMAKE_SOURCE_DIR}/src/leveldb")
+set(LEVELDB_BINARY_DIR "${CMAKE_BINARY_DIR}/leveldb")
+
+if(NOT TARGET leveldb_lib)
+    add_subdirectory("${LEVELDB_SOURCE_DIR}" "${LEVELDB_BINARY_DIR}")
+endif()
+
+# Pin bundled LevelDB to C++17. It only needs C++11 (declared via its own
+# target_compile_features) but inherits CMAKE_CXX_STANDARD=20 from the
+# top-level project, where some of its atomic-enum syntax
+# (std::memory_order::memory_order_relaxed) becomes a hard error.
+foreach(_leveldb_target leveldb_lib leveldb_memenv)
+    if(TARGET ${_leveldb_target})
+        set_target_properties(${_leveldb_target} PROPERTIES
+            CXX_STANDARD 17
+            CXX_STANDARD_REQUIRED ON
+            CXX_EXTENSIONS OFF
+        )
+    endif()
+endforeach()
+
+if(NOT TARGET build_leveldb)
+    add_custom_target(build_leveldb DEPENDS leveldb_lib leveldb_memenv)
+endif()
@@ -0,0 +1,51 @@
+# cmake/FindBerkeleyDB.cmake
+# Finds Berkeley DB C++ headers and library.
+#
+# User can set BDB_INCLUDE_PATH and BDB_LIB_PATH to guide search.
+#
+# Creates imported target: BerkeleyDB::BerkeleyDB
+# Sets: BerkeleyDB_FOUND, BerkeleyDB_INCLUDE_DIR, BerkeleyDB_LIBRARY
+
+find_path(BerkeleyDB_INCLUDE_DIR
+    NAMES db_cxx.h
+    HINTS
+        ${BDB_INCLUDE_PATH}
+        ENV BDB_INCLUDE_PATH
+    PATHS
+        /opt/homebrew/opt/berkeley-db@5/include
+        /opt/homebrew/opt/berkeley-db/include
+        /usr/include/db5
+        /usr/local/include/db5
+        /usr/include
+        /usr/local/include
+        C:/msys64/mingw64/include
+)
+
+find_library(BerkeleyDB_LIBRARY
+    NAMES db_cxx db_cxx-5 db_cxx-5.3 db_cxx-4.8
+    HINTS
+        ${BDB_LIB_PATH}
+        ENV BDB_LIB_PATH
+    PATHS
+        /opt/homebrew/opt/berkeley-db@5/lib
+        /opt/homebrew/opt/berkeley-db/lib
+        /usr/lib/x86_64-linux-gnu
+        /usr/lib
+        /usr/local/lib
+        C:/msys64/mingw64/lib
+)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(BerkeleyDB
+    REQUIRED_VARS BerkeleyDB_LIBRARY BerkeleyDB_INCLUDE_DIR
+)
+
+if(BerkeleyDB_FOUND AND NOT TARGET BerkeleyDB::BerkeleyDB)
+    add_library(BerkeleyDB::BerkeleyDB UNKNOWN IMPORTED)
+    set_target_properties(BerkeleyDB::BerkeleyDB PROPERTIES
+        IMPORTED_LOCATION "${BerkeleyDB_LIBRARY}"
+        INTERFACE_INCLUDE_DIRECTORIES "${BerkeleyDB_INCLUDE_DIR}"
+    )
+endif()
+
+mark_as_advanced(BerkeleyDB_INCLUDE_DIR BerkeleyDB_LIBRARY)
@@ -0,0 +1,46 @@
+# cmake/FindLibevent.cmake
+# Finds libevent headers and library.
+#
+# User can set EVENT_INCLUDE_PATH and EVENT_LIB_PATH.
+#
+# Creates imported target: Libevent::Libevent
+
+find_path(Libevent_INCLUDE_DIR
+    NAMES event2/event.h
+    HINTS
+        ${EVENT_INCLUDE_PATH}
+        ENV EVENT_INCLUDE_PATH
+    PATHS
+        /opt/homebrew/include
+        /usr/include
+        /usr/local/include
+        C:/msys64/mingw64/include
+)
+
+find_library(Libevent_LIBRARY
+    NAMES event libevent
+    HINTS
+        ${EVENT_LIB_PATH}
+        ENV EVENT_LIB_PATH
+    PATHS
+        /opt/homebrew/lib
+        /usr/lib/x86_64-linux-gnu
+        /usr/lib
+        /usr/local/lib
+        C:/msys64/mingw64/lib
+)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Libevent
+    REQUIRED_VARS Libevent_LIBRARY Libevent_INCLUDE_DIR
+)
+
+if(Libevent_FOUND AND NOT TARGET Libevent::Libevent)
+    add_library(Libevent::Libevent UNKNOWN IMPORTED)
+    set_target_properties(Libevent::Libevent PROPERTIES
+        IMPORTED_LOCATION "${Libevent_LIBRARY}"
+        INTERFACE_INCLUDE_DIRECTORIES "${Libevent_INCLUDE_DIR}"
+    )
+endif()
+
+mark_as_advanced(Libevent_INCLUDE_DIR Libevent_LIBRARY)
@@ -0,0 +1,46 @@
+# cmake/FindMiniupnpc.cmake
+# Finds miniupnpc headers and library.
+#
+# User can set MINIUPNPC_INCLUDE_PATH and MINIUPNPC_LIB_PATH.
+#
+# Creates imported target: Miniupnpc::Miniupnpc
+
+find_path(Miniupnpc_INCLUDE_DIR
+    NAMES miniupnpc/miniupnpc.h
+    HINTS
+        ${MINIUPNPC_INCLUDE_PATH}
+        ENV MINIUPNPC_INCLUDE_PATH
+    PATHS
+        /opt/homebrew/include
+        /usr/include
+        /usr/local/include
+        C:/msys64/mingw64/include
+)
+
+find_library(Miniupnpc_LIBRARY
+    NAMES miniupnpc
+    HINTS
+        ${MINIUPNPC_LIB_PATH}
+        ENV MINIUPNPC_LIB_PATH
+    PATHS
+        /opt/homebrew/lib
+        /usr/lib/x86_64-linux-gnu
+        /usr/lib
+        /usr/local/lib
+        C:/msys64/mingw64/lib
+)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Miniupnpc
+    REQUIRED_VARS Miniupnpc_LIBRARY Miniupnpc_INCLUDE_DIR
+)
+
+if(Miniupnpc_FOUND AND NOT TARGET Miniupnpc::Miniupnpc)
+    add_library(Miniupnpc::Miniupnpc UNKNOWN IMPORTED)
+    set_target_properties(Miniupnpc::Miniupnpc PROPERTIES
+        IMPORTED_LOCATION "${Miniupnpc_LIBRARY}"
+        INTERFACE_INCLUDE_DIRECTORIES "${Miniupnpc_INCLUDE_DIR}"
+    )
+endif()
+
+mark_as_advanced(Miniupnpc_INCLUDE_DIR Miniupnpc_LIBRARY)
@@ -0,0 +1,38 @@
+# cmake/FindQRencode.cmake
+# Finds libqrencode headers and library.
+#
+# Creates imported target: QRencode::QRencode
+
+find_path(QRencode_INCLUDE_DIR
+    NAMES qrencode.h
+    PATHS
+        /opt/homebrew/include
+        /usr/include
+        /usr/local/include
+        C:/msys64/mingw64/include
+)
+
+find_library(QRencode_LIBRARY
+    NAMES qrencode
+    PATHS
+        /opt/homebrew/lib
+        /usr/lib/x86_64-linux-gnu
+        /usr/lib
+        /usr/local/lib
+        C:/msys64/mingw64/lib
+)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(QRencode
+    REQUIRED_VARS QRencode_LIBRARY QRencode_INCLUDE_DIR
+)
+
+if(QRencode_FOUND AND NOT TARGET QRencode::QRencode)
+    add_library(QRencode::QRencode UNKNOWN IMPORTED)
+    set_target_properties(QRencode::QRencode PROPERTIES
+        IMPORTED_LOCATION "${QRencode_LIBRARY}"
+        INTERFACE_INCLUDE_DIRECTORIES "${QRencode_INCLUDE_DIR}"
+    )
+endif()
+
+mark_as_advanced(QRencode_INCLUDE_DIR QRencode_LIBRARY)
@@ -0,0 +1,19 @@
+# cmake/GenerateBuildInfo.cmake
+# Sets up a custom target that generates build.h from git describe,
+# equivalent to share/genbuild.sh.
+
+set(BUILD_HEADER_DIR "${CMAKE_BINARY_DIR}/generated")
+set(BUILD_HEADER     "${BUILD_HEADER_DIR}/build.h")
+file(MAKE_DIRECTORY  "${BUILD_HEADER_DIR}")
+
+# Custom command runs on every build to regenerate build.h if git state changed
+add_custom_target(generate_build_info ALL
+    COMMAND ${CMAKE_COMMAND}
+        -DSOURCE_DIR=${CMAKE_SOURCE_DIR}
+        -DOUTPUT_FILE=${BUILD_HEADER}
+        -P "${CMAKE_SOURCE_DIR}/cmake/GenerateBuildInfoScript.cmake"
+    WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
+    COMMENT "Generating build.h from git describe..."
+    BYPRODUCTS "${BUILD_HEADER}"
+    VERBATIM
+)
@@ -0,0 +1,96 @@
+# cmake/GenerateBuildInfoScript.cmake
+# Called at build time by the custom target in GenerateBuildInfo.cmake.
+# Reads the version from clientversion.h (single source of truth) and
+# appends git commit info for non-release builds.
+
+# Read existing build.h first line if it exists
+set(OLD_LINE "")
+if(EXISTS "${OUTPUT_FILE}")
+    file(STRINGS "${OUTPUT_FILE}" _lines LIMIT_COUNT 1)
+    if(_lines)
+        list(GET _lines 0 OLD_LINE)
+    endif()
+endif()
+
+# ── Read version from clientversion.h ──
+file(STRINGS "${SOURCE_DIR}/src/clientversion.h" _ver_lines)
+foreach(_line ${_ver_lines})
+    if(_line MATCHES "^#define CLIENT_VERSION_MAJOR +([0-9]+)")
+        set(VER_MAJOR "${CMAKE_MATCH_1}")
+    elseif(_line MATCHES "^#define CLIENT_VERSION_MINOR +([0-9]+)")
+        set(VER_MINOR "${CMAKE_MATCH_1}")
+    elseif(_line MATCHES "^#define CLIENT_VERSION_REVISION +([0-9]+)")
+        set(VER_REVISION "${CMAKE_MATCH_1}")
+    elseif(_line MATCHES "^#define CLIENT_VERSION_BUILD +([0-9]+)")
+        set(VER_BUILD "${CMAKE_MATCH_1}")
+    endif()
+endforeach()
+
+set(BASE_VERSION "v${VER_MAJOR}.${VER_MINOR}.${VER_REVISION}.${VER_BUILD}")
+
+# ── Get git commit info (suffix only, not the version number) ──
+set(GIT_SUFFIX "")
+
+# Get short commit hash
+execute_process(
+    COMMAND git rev-parse --short HEAD
+    WORKING_DIRECTORY "${SOURCE_DIR}"
+    OUTPUT_VARIABLE GIT_HASH
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    ERROR_QUIET
+    RESULT_VARIABLE _result
+)
+
+if(_result EQUAL 0 AND GIT_HASH)
+    # Check if working directory is dirty
+    execute_process(
+        COMMAND git diff-index --quiet HEAD --
+        WORKING_DIRECTORY "${SOURCE_DIR}"
+        RESULT_VARIABLE _dirty
+    )
+
+    # Check if HEAD is exactly on a tag matching our version
+    execute_process(
+        COMMAND git describe --tags --exact-match HEAD
+        WORKING_DIRECTORY "${SOURCE_DIR}"
+        OUTPUT_VARIABLE GIT_TAG
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        ERROR_QUIET
+        RESULT_VARIABLE _tag_result
+    )
+
+    set(_on_release_tag FALSE)
+    if(_tag_result EQUAL 0 AND GIT_TAG STREQUAL "${BASE_VERSION}")
+        set(_on_release_tag TRUE)
+    endif()
+
+    # Only add git suffix for non-release builds (not on exact version tag, or dirty)
+    if(NOT _on_release_tag OR NOT _dirty EQUAL 0)
+        set(GIT_SUFFIX "-g${GIT_HASH}")
+        if(NOT _dirty EQUAL 0)
+            set(GIT_SUFFIX "${GIT_SUFFIX}-dirty")
+        endif()
+    endif()
+endif()
+
+set(FULL_VERSION "${BASE_VERSION}${GIT_SUFFIX}")
+
+# Get commit timestamp
+execute_process(
+    COMMAND git log -n 1 --format=%ci
+    WORKING_DIRECTORY "${SOURCE_DIR}"
+    OUTPUT_VARIABLE GIT_TIME
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    ERROR_QUIET
+)
+
+# Build new content
+set(NEW_LINE "#define BUILD_DESC \"${FULL_VERSION}\"")
+
+# Only write if changed
+if(NOT "${OLD_LINE}" STREQUAL "${NEW_LINE}")
+    file(WRITE "${OUTPUT_FILE}"
+        "${NEW_LINE}\n"
+        "#define BUILD_DATE \"${GIT_TIME}\"\n"
+    )
+endif()
@@ -0,0 +1,84 @@
+# Chain DB benchmark harness
+
+Measures `FastImportBlockFile()` speed under each chain-DB backend
+(LevelDB vs RocksDB) using a user-supplied `blk0001.dat` block stream.
+
+## Prerequisites
+
+- A `trianglesd` binary (RocksDB is now a hard build dep, both backends are
+  always available):
+  ```
+  cmake -B build -G Ninja \
+      -DCMAKE_BUILD_TYPE=Release \
+      -DBUILD_QT=OFF \
+      -DBUILD_DAEMON=ON
+  cmake --build build
+  ```
+- An `blk0001.dat` file (old-style block stream). If you have a synced
+  node, copy `~/.triangles/blk0001.dat` (Linux) or `%APPDATA%\triangles\blk0001.dat` (Windows).
+- Free disk space: ~3× the size of `blk0001.dat` per backend run
+  (raw blocks + chain DB index + working space).
+
+## Usage
+
+```bash
+contrib/bench/bench-chaindb.sh \
+  --binary=$(pwd)/build/bin/trianglesd \
+  --bootstrap=/path/to/blk0001.dat
+```
+
+Runs each backend in turn, appends a CSV row to `./bench-results.csv`,
+and prints a summary to stdout. Default `--dbcache=2048` (MB).
+
+### Options
+
+| Flag | Default | Notes |
+| --- | --- | --- |
+| `--binary=PATH` | (required) | Path to `trianglesd` |
+| `--bootstrap=PATH` | (required) | Path to `blk0001.dat` |
+| `--backends=LIST` | `leveldb,rocksdb` | Comma-separated subset |
+| `--workdir=DIR` | `/tmp/triangles-bench-XXXXXX` | Per-backend datadirs go here |
+| `--dbcache=MB` | `2048` | Chain DB cache size |
+| `--results-csv=FILE` | `./bench-results.csv` | Appended to |
+| `--keep-datadirs` | off | Preserve datadirs after run for inspection |
+| `--rpc-port=BASE` | `19112` | Each backend uses `BASE+offset` |
+
+## What it measures
+
+| Column | Source |
+| --- | --- |
+| `wall_ms` | The daemon's own log line: `FastImportBlockFile: indexed N blocks in Mms` |
+| `peak_rss_kb` | `ps -o rss=` sampled once per second |
+| `datadir_bytes` | `du -sb` of the working datadir (includes `blk0001.dat`) |
+| `blocks_indexed` | Parsed from the same log line |
+
+## What it does not measure
+
+- Network IBD (peer fetch, header sync) — this is pure DB ingest.
+- UTXO snapshot load — `LoadSnapshot` is currently rocksdb-guarded
+  (see `src/utxosnapshot.cpp`); will be unblocked when LevelDB is retired.
+- Reorg cost — separate test, not yet implemented.
+- Disk I/O bytes (read/written) — could be added with `iostat` integration.
+
+## Interpreting results
+
+A meaningful comparison requires both rows to have run on the same machine
+with the same `blk0001.dat`. The `host` column makes mixing runs across
+machines visible in the CSV.
+
+Backend-relevant size comparisons should subtract `bootstrap_size_bytes`
+from `datadir_bytes` to isolate the chain DB tree.
+
+## One-liners
+
+```bash
+# LevelDB only
+./bench-chaindb.sh --binary=... --bootstrap=... --backends=leveldb
+
+# Compare 2GB vs 4GB cache on RocksDB
+./bench-chaindb.sh --binary=... --bootstrap=... --backends=rocksdb --dbcache=2048
+./bench-chaindb.sh --binary=... --bootstrap=... --backends=rocksdb --dbcache=4096
+
+# Keep the datadirs for poking around afterwards
+./bench-chaindb.sh --binary=... --bootstrap=... --keep-datadirs
+```
@@ -0,0 +1,217 @@
+#!/usr/bin/env bash
+# Benchmark FastImportBlockFile() speed across chain-DB backends.
+#
+# Reads a user-supplied blk0001.dat (old-style block stream) and times the
+# full block-index rebuild under each backend. Output: a CSV row per backend
+# with wall time, peak RSS, and resulting datadir size on disk.
+#
+# Usage:
+#   ./bench-chaindb.sh \
+#     --binary=/path/to/trianglesd \
+#     --bootstrap=/path/to/blk0001.dat \
+#     [--backends=leveldb,rocksdb]       default: both
+#     [--workdir=/tmp/triangles-bench]   parent dir for per-backend datadirs
+#     [--dbcache=2048]                   in MB
+#     [--results-csv=./bench-results.csv]
+#     [--keep-datadirs]                  preserve datadirs after run
+#     [--rpc-port=BASE]                  default 19112; each run uses BASE+offset
+#
+# Notes:
+#   - RocksDB is a hard build dep, so any current trianglesd has both backends.
+#   - This script does not assume Tor is configured. It launches with -nolisten
+#     and -connect=0 to keep the run network-isolated.
+#   - Wall time comes from the daemon's own perf log line:
+#         "FastImportBlockFile: indexed N blocks in Mms"
+#   - Peak RSS is sampled via `ps -o rss=` once a second.
+
+set -euo pipefail
+
+# ── Defaults ────────────────────────────────────────────────────────────────
+BINARY=""
+BOOTSTRAP=""
+BACKENDS="leveldb,rocksdb"
+WORKDIR=""
+DBCACHE=2048
+RESULTS_CSV="./bench-results.csv"
+KEEP=0
+RPC_BASE=19112
+
+# ── Arg parsing ─────────────────────────────────────────────────────────────
+for arg in "$@"; do
+    case "$arg" in
+        --binary=*)         BINARY="${arg#*=}" ;;
+        --bootstrap=*)      BOOTSTRAP="${arg#*=}" ;;
+        --backends=*)       BACKENDS="${arg#*=}" ;;
+        --workdir=*)        WORKDIR="${arg#*=}" ;;
+        --dbcache=*)        DBCACHE="${arg#*=}" ;;
+        --results-csv=*)    RESULTS_CSV="${arg#*=}" ;;
+        --keep-datadirs)    KEEP=1 ;;
+        --rpc-port=*)       RPC_BASE="${arg#*=}" ;;
+        -h|--help)
+            sed -n '2,28p' "$0" | sed 's/^# \?//'
+            exit 0 ;;
+        *)
+            echo "Unknown argument: $arg" >&2
+            exit 2 ;;
+    esac
+done
+
+[ -n "$BINARY" ]    || { echo "--binary is required" >&2; exit 2; }
+[ -n "$BOOTSTRAP" ] || { echo "--bootstrap is required" >&2; exit 2; }
+[ -x "$BINARY" ]    || { echo "Binary not executable: $BINARY" >&2; exit 2; }
+[ -f "$BOOTSTRAP" ] || { echo "Bootstrap file not found: $BOOTSTRAP" >&2; exit 2; }
+
+if [ -z "$WORKDIR" ]; then
+    WORKDIR="$(mktemp -d -t triangles-bench-XXXXXX)"
+fi
+mkdir -p "$WORKDIR"
+echo "Workdir: $WORKDIR"
+
+# ── CSV header (only if file is new) ───────────────────────────────────────
+if [ ! -f "$RESULTS_CSV" ]; then
+    echo "timestamp,backend,bootstrap_size_bytes,dbcache_mb,blocks_indexed,wall_ms,peak_rss_kb,datadir_bytes,binary,host" > "$RESULTS_CSV"
+fi
+
+bootstrap_size="$(stat -c%s "$BOOTSTRAP" 2>/dev/null || stat -f%z "$BOOTSTRAP")"
+host="$(hostname)"
+ts_run="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+
+# ── Per-backend run ─────────────────────────────────────────────────────────
+run_backend() {
+    local backend="$1"
+    local idx="$2"
+    local datadir="$WORKDIR/$backend"
+    local rpc_port=$((RPC_BASE + idx))
+    local rss_log="$WORKDIR/$backend.rss.log"
+
+    echo
+    echo "════════════════════════════════════════════════════════════════════"
+    echo "  Backend: $backend  (datadir: $datadir, rpcport: $rpc_port)"
+    echo "════════════════════════════════════════════════════════════════════"
+
+    # Fresh datadir, copy bootstrap into place. FastImportBlockFile() picks
+    # this up automatically when the block index is empty.
+    rm -rf "$datadir"
+    mkdir -p "$datadir"
+    cp "$BOOTSTRAP" "$datadir/blk0001.dat"
+
+    # Minimal config — disable network so we measure only the import path.
+    cat > "$datadir/triangles.conf" <<EOF
+chaindb=$backend
+dbcache=$DBCACHE
+nolisten=1
+connect=0
+rpcuser=bench
+rpcpassword=bench
+rpcport=$rpc_port
+debug=1
+printtoconsole=0
+EOF
+
+    # Launch in background. -daemon would daemonize but we want to track the
+    # process tree; run in foreground and background it ourselves so we keep
+    # the PID for RSS sampling and clean shutdown.
+    local pid
+    "$BINARY" -datadir="$datadir" -conf="triangles.conf" >"$datadir/stdout.log" 2>&1 &
+    pid=$!
+    echo "Launched $backend (pid $pid)"
+
+    # RSS sampler: log peak every second to a file.
+    (
+        while kill -0 "$pid" 2>/dev/null; do
+            ps -o rss= -p "$pid" 2>/dev/null | tr -d ' ' >> "$rss_log" || true
+            sleep 1
+        done
+    ) &
+    local sampler_pid=$!
+
+    # Watch for "FastImportBlockFile: indexed N blocks in Mms" in the daemon's
+    # debug.log, which is the deterministic completion signal.
+    local debug_log="$datadir/debug.log"
+    local wait_start
+    wait_start="$(date +%s)"
+    local timeout_s=86400  # 24 hours hard cap
+    local indexed_line=""
+    while :; do
+        if [ -f "$debug_log" ]; then
+            indexed_line="$(grep -E "FastImportBlockFile: indexed [0-9]+ blocks in [0-9]+ms" "$debug_log" | tail -1 || true)"
+            if [ -n "$indexed_line" ]; then
+                break
+            fi
+        fi
+        if ! kill -0 "$pid" 2>/dev/null; then
+            echo "Daemon exited before completion line appeared. Check $datadir/stdout.log" >&2
+            kill "$sampler_pid" 2>/dev/null || true
+            return 1
+        fi
+        local elapsed=$(( $(date +%s) - wait_start ))
+        if [ "$elapsed" -gt "$timeout_s" ]; then
+            echo "Timeout after ${timeout_s}s without completion line" >&2
+            kill "$pid" 2>/dev/null || true
+            kill "$sampler_pid" 2>/dev/null || true
+            return 1
+        fi
+        sleep 5
+    done
+
+    echo "Completion: $indexed_line"
+
+    # Parse blocks_indexed and wall_ms from the line.
+    local blocks_indexed wall_ms
+    blocks_indexed="$(echo "$indexed_line" | sed -E 's/.*indexed ([0-9]+) blocks.*/\1/')"
+    wall_ms="$(echo "$indexed_line" | sed -E 's/.*in ([0-9]+)ms.*/\1/')"
+
+    # Stop daemon cleanly via RPC, fall back to SIGTERM.
+    "$BINARY" -datadir="$datadir" -conf="triangles.conf" stop >/dev/null 2>&1 || \
+        kill -TERM "$pid" 2>/dev/null || true
+
+    # Wait up to 60s for clean exit.
+    local stop_wait=0
+    while kill -0 "$pid" 2>/dev/null && [ "$stop_wait" -lt 60 ]; do
+        sleep 1
+        stop_wait=$((stop_wait + 1))
+    done
+    kill -KILL "$pid" 2>/dev/null || true
+    wait "$sampler_pid" 2>/dev/null || true
+
+    # Peak RSS: max of the sampler's recorded values.
+    local peak_rss_kb=0
+    if [ -f "$rss_log" ] && [ -s "$rss_log" ]; then
+        peak_rss_kb="$(sort -nr "$rss_log" | head -1)"
+    fi
+
+    # Datadir size — separate the chain DB from blk0001.dat (which is ~constant
+    # across backends). We report the total datadir size; the consumer can
+    # subtract bootstrap_size_bytes if they want chain-DB-only.
+    local datadir_bytes
+    datadir_bytes="$(du -sb "$datadir" 2>/dev/null | awk '{print $1}' || du -sk "$datadir" | awk '{print $1*1024}')"
+
+    # Append CSV row.
+    echo "$ts_run,$backend,$bootstrap_size,$DBCACHE,$blocks_indexed,$wall_ms,$peak_rss_kb,$datadir_bytes,$BINARY,$host" >> "$RESULTS_CSV"
+
+    # Stdout summary.
+    printf "  blocks indexed: %s\n" "$blocks_indexed"
+    printf "  wall time:      %s ms (%.1f min)\n" "$wall_ms" "$(awk "BEGIN{print $wall_ms/60000}")"
+    printf "  peak RSS:       %s KB (%.1f GB)\n" "$peak_rss_kb" "$(awk "BEGIN{print $peak_rss_kb/1024/1024}")"
+    printf "  datadir size:   %s bytes (%.1f GB)\n" "$datadir_bytes" "$(awk "BEGIN{print $datadir_bytes/1024/1024/1024}")"
+
+    # Cleanup unless --keep-datadirs.
+    if [ "$KEEP" -eq 0 ]; then
+        rm -rf "$datadir"
+    fi
+}
+
+# ── Main loop ──────────────────────────────────────────────────────────────
+idx=0
+IFS=',' read -r -a backends_arr <<< "$BACKENDS"
+for backend in "${backends_arr[@]}"; do
+    case "$backend" in
+        leveldb|rocksdb) ;;
+        *) echo "Unknown backend: $backend" >&2; exit 2 ;;
+    esac
+    run_backend "$backend" "$idx"
+    idx=$((idx + 1))
+done
+
+echo
+echo "Done. Results appended to $RESULTS_CSV"
@@ -0,0 +1,148 @@
+; Cryptographic Triangles NSIS Installer
+; Produces a single setup.exe with wallet + Tor bundled
+; Uses per-user install (no UAC elevation) so network drives stay visible
+
+!include "MUI2.nsh"
+!include "FileFunc.nsh"
+
+!ifndef VERSION
+  !define VERSION "0.0.0"
+!endif
+
+!define APPNAME "Cryptographic Triangles"
+!define COMPANYNAME "Cryptographic Triangles"
+!define EXENAME "triangles-qt.exe"
+
+Name "${APPNAME} v${VERSION}"
+OutFile "Cryptographic-Triangles-${VERSION}-win-x64-setup.exe"
+InstallDir "$LOCALAPPDATA\${APPNAME}"
+InstallDirRegKey HKCU "Software\${APPNAME}" "InstallDir"
+RequestExecutionLevel user
+
+; UI — icons and bitmaps are relative to THIS .nsi file
+!define MUI_ICON "..\..\src\qt\res\icons\triangles.ico"
+!define MUI_UNICON "..\..\src\qt\res\icons\triangles.ico"
+!define MUI_HEADERIMAGE
+!define MUI_HEADERIMAGE_BITMAP "..\..\share\pixmaps\nsis-header.bmp"
+!define MUI_WELCOMEFINISHPAGE_BITMAP "..\..\share\pixmaps\nsis-wizard.bmp"
+!define MUI_ABORTWARNING
+!define MUI_FINISHPAGE_RUN "$INSTDIR\${EXENAME}"
+!define MUI_FINISHPAGE_RUN_TEXT "Launch ${APPNAME}"
+
+!insertmacro MUI_PAGE_WELCOME
+!insertmacro MUI_PAGE_DIRECTORY
+
+; Bootstrap page
+Page custom BootstrapPage
+
+!insertmacro MUI_PAGE_INSTFILES
+!insertmacro MUI_PAGE_FINISH
+
+!insertmacro MUI_UNPAGE_CONFIRM
+!insertmacro MUI_UNPAGE_INSTFILES
+
+!insertmacro MUI_LANGUAGE "English"
+
+; Bootstrap selection variable
+Var BootstrapChoice
+
+; Bootstrap page function
+Function BootstrapPage
+  !insertmacro MUI_HEADER_TEXT "Blockchain Sync" "Choose how to synchronize the blockchain"
+  
+  nsDialogs::Create 1018
+  Pop $0
+  
+  ${NSD_CreateLabel} 0 10u 100% 20u "The Triangles blockchain requires ~1GB of data. Choose sync method:"
+  Pop $0
+  
+  ${NSD_CreateRadioButton} 10u 40u 100% 12u "Download bootstrap (~1.3GB) — Recommended (fast)"
+  Pop $1
+  ${NSD_Check} $1
+  
+  ${NSD_CreateRadioButton} 10u 60u 100% 12u "Sync from network — Slow (may take days)"
+  Pop $2
+  
+  ${NSD_CreateLabel} 10u 80u 100% 30u "Bootstrap will download a recent blockchain snapshot, saving hours or days of sync time. Network bandwidth required: ~1.3GB."
+  Pop $0
+  
+  nsDialogs::Show
+  
+  ${NSD_GetState} $1 $BootstrapChoice
+FunctionEnd
+
+Section "Install"
+  SetOutPath "$INSTDIR"
+
+  ; Wallet + Qt DLLs (prepared by the Package step into dist/)
+  File /r "..\..\dist\*.*"
+
+  ; Tor binary + data (prepared by Download Tor step into tor-files/)
+  SetOutPath "$INSTDIR\tor"
+  File /r "..\..\tor-files\*.*"
+
+  ; Create data directory
+  CreateDirectory "$APPDATA\Triangles"
+
+  ; Download blockchain bootstrap if selected
+  ${If} $BootstrapChoice == ${BST_CHECKED}
+    DetailPrint "Downloading blockchain bootstrap..."
+    inetc::get /CAPTION "Downloading Blockchain" /CANCELTEXT "Skip" \
+      "http://bootstrap.cryptographic-triangles.org/tri-blockchain.tar.gz" \
+      "$TEMP\tri-blockchain.tar.gz" /END
+    Pop $0
+    ${If} $0 == "OK"
+      DetailPrint "Extracting blockchain..."
+      nsExec::ExecToLog '"$INSTDIR\7z.exe" x "$TEMP\tri-blockchain.tar.gz" -o"$TEMP" -y'
+      nsExec::ExecToLog '"$INSTDIR\7z.exe" x "$TEMP\tri-blockchain.tar" -o"$APPDATA\Triangles" -y'
+      Delete "$TEMP\tri-blockchain.tar.gz"
+      Delete "$TEMP\tri-blockchain.tar"
+      DetailPrint "Blockchain bootstrap installed!"
+    ${Else}
+      DetailPrint "Bootstrap download failed or skipped — will sync from network"
+    ${EndIf}
+  ${EndIf}
+
+  ; Uninstaller
+  WriteUninstaller "$INSTDIR\uninstall.exe"
+
+  ; Start menu
+  CreateDirectory "$SMPROGRAMS\${APPNAME}"
+  CreateShortcut "$SMPROGRAMS\${APPNAME}\${APPNAME}.lnk" "$INSTDIR\${EXENAME}" "" "$INSTDIR\${EXENAME}" 0
+  CreateShortcut "$SMPROGRAMS\${APPNAME}\Uninstall.lnk" "$INSTDIR\uninstall.exe"
+
+  ; Desktop shortcut
+  CreateShortcut "$DESKTOP\${APPNAME}.lnk" "$INSTDIR\${EXENAME}" "" "$INSTDIR\${EXENAME}" 0
+
+  ; Add/Remove Programs (per-user)
+  WriteRegStr HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\${APPNAME}" "DisplayName" "${APPNAME}"
+  WriteRegStr HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\${APPNAME}" "UninstallString" '"$INSTDIR\uninstall.exe"'
+  WriteRegStr HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\${APPNAME}" "DisplayIcon" "$INSTDIR\${EXENAME}"
+  WriteRegStr HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\${APPNAME}" "Publisher" "${COMPANYNAME}"
+  WriteRegStr HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\${APPNAME}" "DisplayVersion" "${VERSION}"
+  WriteRegDWORD HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\${APPNAME}" "NoModify" 1
+  WriteRegDWORD HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\${APPNAME}" "NoRepair" 1
+  WriteRegStr HKCU "Software\${APPNAME}" "InstallDir" "$INSTDIR"
+
+  ${GetSize} "$INSTDIR" "/S=0K" $0 $1 $2
+  IntFmt $0 "0x%08X" $0
+  WriteRegDWORD HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\${APPNAME}" "EstimatedSize" "$0"
+SectionEnd
+
+Section "Uninstall"
+  ; Stop running processes
+  nsExec::ExecToLog 'taskkill /F /IM triangles-qt.exe'
+  nsExec::ExecToLog 'taskkill /F /IM trianglesd.exe'
+  nsExec::ExecToLog 'taskkill /F /IM tor.exe'
+
+  ; Remove installation
+  RMDir /r "$INSTDIR"
+
+  ; Remove shortcuts
+  RMDir /r "$SMPROGRAMS\${APPNAME}"
+  Delete "$DESKTOP\${APPNAME}.lnk"
+
+  ; Remove registry
+  DeleteRegKey HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\${APPNAME}"
+  DeleteRegKey HKCU "Software\${APPNAME}"
+SectionEnd
@@ -0,0 +1,147 @@
+# Triangles Dynamic Seed Node - Setup Guide
+
+## Overview
+
+Triangles v5.5.0+ uses a dynamic HTTP seed list instead of hardcoded addresses.
+A collector script runs on a VPS alongside a Triangles node, periodically
+querying the node for known .onion peers and publishing them to a static file.
+New wallets fetch this file on startup to bootstrap peer discovery.
+
+Once any wallet syncs and obtains its own .onion address, other nodes learn
+about it via P2P address exchange. The collector picks it up automatically
+on its next run. No manual intervention is needed after initial setup.
+
+## Requirements
+
+- Linux VPS
+- Triangles daemon (`trianglesd`) running with Tor enabled
+- A web server (Caddy, nginx, Apache, etc.)
+- DNS control for the domain serving the seed list
+- `jq` and `curl` (`apt install jq curl`)
+
+## Step 1: DNS
+
+Create an A record for the seed list hostname pointing to the VPS IP address.
+
+The default hostname the wallet fetches is `seeds.cryptographic-triangles.org`.
+This can be overridden per-node with the `-seedurl` flag.
+
+## Step 2: Web Server
+
+Create a directory for the seed file:
+
+```bash
+sudo mkdir -p /var/www/seeds
+sudo chown $USER:$USER /var/www/seeds
+```
+
+Configure the web server to serve that directory on the seed list hostname.
+
+**Caddy example** (add to Caddyfile):
+
+```
+seeds.cryptographic-triangles.org {
+    root * /var/www/seeds
+    file_server
+}
+```
+
+**nginx example** (add server block):
+
+```
+server {
+    listen 80;
+    server_name seeds.cryptographic-triangles.org;
+    root /var/www/seeds;
+}
+```
+
+Reload the web server after making changes.
+
+## Step 3: Install the Collector Script
+
+```bash
+sudo cp contrib/seeds/collect-seeds.sh /usr/local/bin/collect-seeds.sh
+sudo chmod +x /usr/local/bin/collect-seeds.sh
+```
+
+## Step 4: Configure and Test
+
+The script communicates with `trianglesd` via JSON-RPC. It reads credentials
+from environment variables. Check `triangles.conf` for `rpcuser` and `rpcpassword`.
+
+Run it manually to verify:
+
+```bash
+export RPC_USER="your_rpc_username"
+export RPC_PASSWORD="your_rpc_password"
+export RPC_PORT="19112"
+export OUTPUT_FILE="/var/www/seeds/seeds.txt"
+
+/usr/local/bin/collect-seeds.sh
+```
+
+Expected output: `Updated /var/www/seeds/seeds.txt with N seeds`
+
+The resulting file should contain one `.onion:port` entry per line:
+
+```
+# Triangles seed nodes - auto-generated 2026-04-01T12:00:00Z
+exampleaddress1234567890abcdefghijklmnopqrstuvwxyz234567.onion:24112
+anotheraddress1234567890abcdefghijklmnopqrstuvwxyz23456.onion:24112
+```
+
+## Step 5: Cron Job
+
+Schedule the collector to run every 5 minutes:
+
+```bash
+crontab -e
+```
+
+Add:
+
+```
+*/5 * * * * RPC_USER="your_rpc_username" RPC_PASSWORD="your_rpc_password" OUTPUT_FILE="/var/www/seeds/seeds.txt" /usr/local/bin/collect-seeds.sh >> /var/log/triangles-seeds.log 2>&1
+```
+
+## Step 6: Verify End-to-End
+
+From any machine:
+
+```bash
+curl http://seeds.cryptographic-triangles.org/seeds.txt
+```
+
+The response should list .onion addresses.
+
+## Troubleshooting
+
+**"no onion seeds found"**
+The node has not yet learned any .onion peer addresses. Ensure Tor is enabled
+and the node has at least one connected peer. Check with `trianglesd getpeerinfo`.
+
+**"RPC call failed"**
+Verify `trianglesd` is running and RPC credentials are correct:
+```bash
+curl -s --user "user:pass" --data-binary \
+  '{"jsonrpc":"1.0","method":"getinfo","params":[]}' \
+  http://127.0.0.1:19112/
+```
+
+**seeds.txt not updating**
+Check the cron log: `tail /var/log/triangles-seeds.log`
+
+## How It Works
+
+1. The collector calls the `getseedlist` RPC, which returns all known .onion
+   addresses from the node's address manager
+2. Results are written to a static text file served by the web server
+3. On startup, Triangles wallets fetch this file and add the addresses to
+   their peer database
+4. As wallets connect and exchange addresses via P2P, new .onion addresses
+   propagate across the network
+5. The collector discovers newly-propagated addresses on its next run
+
+This creates a fully automatic cycle where every online wallet with a Tor
+hidden service becomes a discoverable seed node.
@@ -0,0 +1,49 @@
+#!/bin/bash
+# Triangles Dynamic Seed Collector
+# Run via cron on a VPS that runs a Triangles node.
+# Queries the local node's getseedlist RPC for known .onion peers
+# and writes them to a static file served by a web server.
+#
+# Example cron (every 5 minutes):
+#   */5 * * * * /path/to/collect-seeds.sh
+#
+# The web server (Caddy, nginx, etc.) serves the output file at:
+#   http://seeds.cryptographic-triangles.org/seeds.txt
+
+# Configuration
+RPC_USER="${RPC_USER:-trianglesrpc}"
+RPC_PASSWORD="${RPC_PASSWORD:-}"
+RPC_PORT="${RPC_PORT:-19112}"
+OUTPUT_FILE="${OUTPUT_FILE:-/var/www/seeds/seeds.txt}"
+
+if [ -z "$RPC_PASSWORD" ]; then
+    echo "Error: RPC_PASSWORD not set" >&2
+    exit 1
+fi
+
+# Query the node for known onion seeds
+RESPONSE=$(curl -s --user "${RPC_USER}:${RPC_PASSWORD}" \
+    --data-binary '{"jsonrpc":"1.0","id":"seedcollect","method":"getseedlist","params":[]}' \
+    -H 'content-type: text/plain;' \
+    "http://127.0.0.1:${RPC_PORT}/" 2>/dev/null)
+
+if [ $? -ne 0 ] || [ -z "$RESPONSE" ]; then
+    echo "Error: RPC call failed" >&2
+    exit 1
+fi
+
+# Extract addresses and write to temp file, then atomically move
+TMPFILE=$(mktemp)
+
+echo "# Triangles seed nodes - auto-generated $(date -u +%Y-%m-%dT%H:%M:%SZ)" > "$TMPFILE"
+echo "$RESPONSE" | jq -r '.result[] | .address + ":" + (.port|tostring)' >> "$TMPFILE" 2>/dev/null
+
+SEED_COUNT=$(grep -c '.onion' "$TMPFILE" 2>/dev/null || echo 0)
+
+if [ "$SEED_COUNT" -gt 0 ]; then
+    mv "$TMPFILE" "$OUTPUT_FILE"
+    echo "Updated ${OUTPUT_FILE} with ${SEED_COUNT} seeds"
+else
+    rm -f "$TMPFILE"
+    echo "Warning: no onion seeds found, keeping previous file" >&2
+fi
@@ -0,0 +1,26 @@
+# systemd drop-in for trianglesd: enable unlimited core dumps so that
+# crashes can be diagnosed post-mortem with `coredumpctl gdb`.
+#
+# Installation:
+#   sudo mkdir -p /etc/systemd/system/trianglesd.service.d
+#   sudo cp contrib/systemd/coredump.conf /etc/systemd/system/trianglesd.service.d/
+#   sudo systemctl daemon-reload
+#   sudo systemctl restart trianglesd
+#
+# Verify it took effect:
+#   systemctl show trianglesd | grep -E 'LimitCORE|LimitNOFILE'
+#
+# When the next crash happens, retrieve the stack trace with:
+#   coredumpctl list trianglesd
+#   coredumpctl gdb   # most recent core; then run `bt full` at the (gdb) prompt
+#
+# See contrib/debug/CRASHDUMPS.md for the full playbook.
+
+[Service]
+# Allow the kernel to write a full core dump on SIGSEGV/SIGABRT/SIGBUS/SIGFPE.
+LimitCORE=infinity
+
+# systemd-coredump compresses and stores cores under /var/lib/systemd/coredump/.
+# Make sure the package is installed:
+#   apt install systemd-coredump         # Debian/Ubuntu
+#   dnf install systemd-coredump         # Fedora/RHEL
@@ -0,0 +1,59 @@
+# Embedded Tor Rebase Notes
+
+This repository currently contains a legacy Tor source snapshot under
+`src/tor/`, but the wallet target does not build most of that tree.
+
+## Current state
+
+- The vendored Tor headers report `0.2.5.1-alpha-dev` in:
+  - `src/tor/orconfig_linux.h`
+  - `src/tor/orconfig_apple.h`
+  - `src/tor/orconfig_win32.h`
+- The Qt wallet target currently builds only these Tor-related sources:
+  - `src/tor_embed_hooks.cpp`
+  - `src/tor/onion_v3.cpp`
+  - `src/tor/tor_process.cpp`
+- This means the large legacy `src/tor/` tree is mostly dormant from the
+  wallet build's perspective.
+
+## Rebase target
+
+- Target upstream Tor line: `0.4.9.x`
+- Imported source tree: `src/tor/tor-src`
+- Imported branch: `release-0.4.9`
+- Imported commit: `1442ca4`
+
+## Why this matters
+
+Attempting to "upgrade embedded Tor" by rebasing the entire old source tree in
+place is unnecessarily expensive if the wallet is only relying on:
+
+- process management for a bundled Tor executable
+- Tor v3 onion address/key handling
+- a few local embedding hooks
+
+The migration should preserve the embedded product experience while reducing
+coupling to legacy upstream Tor internals.
+
+## Strategy
+
+1. Keep the product-level embedding model.
+   - The wallet can still ship with Tor and launch it automatically.
+2. Separate Triangles-owned glue from vendored Tor code.
+   - `src/tor_embed_hooks.*` now holds local process/bootstrap helpers that
+     previously lived under `src/tor/anonymize.*`.
+3. Treat `src/tor/onion_v3.cpp` and `src/tor/tor_process.cpp` as the active
+   compatibility boundary.
+4. Re-vendor a newer upstream Tor snapshot only after deciding whether the
+   product truly needs upstream Tor source in-tree or only a bundled Tor
+   runtime plus the wallet's own v3/onion management code.
+
+## Immediate next tasks
+
+1. Audit whether any live build target still includes legacy `src/tor/*.c`
+   sources beyond the current wallet target.
+2. Decide whether `onion_v3.cpp` should remain wallet-owned code or be reduced
+   further in favor of runtime Tor control/provisioning.
+3. Add build metadata recording the intended upstream Tor version and source.
+4. If full upstream vendoring is still required, import a fresh `0.4.8.19`
+   tree side-by-side instead of trying to patch the legacy `0.2.5.1` tree.
@@ -3,7 +3,7 @@
 # Run on a Linux x64 system with appimagetool installed
 set -e

-VERSION="5.1.5"
+VERSION="5.7.6"
 APPDIR="Triangles-x86_64.AppDir"
 RELEASE_URL="https://github.com/SamiAhmed7777/triangles_v5/releases/download/v${VERSION}"

@@ -17,7 +17,7 @@ mkdir -p "$APPDIR/usr/share/icons/hicolor/256x256/apps"

 # Download binary
 echo "Downloading triangles-qt..."
-curl -L -o "$APPDIR/usr/bin/triangles-qt" "${RELEASE_URL}/triangles-qt-linux"
+curl -L -o "$APPDIR/usr/bin/triangles-qt" "${RELEASE_URL}/Cryptographic-Triangles-v${VERSION}-linux-x64-qt"
 chmod +x "$APPDIR/usr/bin/triangles-qt"

 # Create desktop entry
@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<component type="desktop-application">
+  <id>org.cryptographic_triangles.TrianglesQt</id>
+  <metadata_license>MIT</metadata_license>
+  <project_license>MIT</project_license>
+  <name>Cryptographic Triangles</name>
+  <summary>TRI cryptocurrency wallet with staking and encrypted messaging</summary>
+
+  <description>
+    <p>
+      Cryptographic Triangles is a privacy-focused cryptocurrency wallet featuring
+      Proof-of-Stake consensus, Tor v3 onion routing, and built-in encrypted messaging.
+    </p>
+    <p>Features:</p>
+    <ul>
+      <li>Proof-of-Stake with 33% annual staking rewards</li>
+      <li>Hash9 algorithm (13-step hash cascade)</li>
+      <li>Encrypted peer-to-peer messaging (SmsgMessage)</li>
+      <li>Tor v3 integration for anonymous transactions</li>
+      <li>Full node with built-in block explorer</li>
+    </ul>
+  </description>
+
+  <launchable type="desktop-id">org.cryptographic_triangles.TrianglesQt.desktop</launchable>
+
+  <icon type="stock">org.cryptographic_triangles.TrianglesQt</icon>
+
+  <categories>
+    <category>Finance</category>
+    <category>Network</category>
+    <category>P2P</category>
+  </categories>
+
+  <url type="homepage">https://cryptographic-triangles.org</url>
+  <url type="bugtracker">https://github.com/SamiAhmed7777/triangles_v5/issues</url>
+  <url type="vcs-browser">https://github.com/SamiAhmed7777/triangles_v5</url>
+
+  <provides>
+    <binary>triangles-qt</binary>
+    <binary>trianglesd</binary>
+  </provides>
+
+  <releases>
+    <release version="5.3.7" date="2026-03-24">
+      <description>
+        <p>Version 5.3.7 release.</p>
+      </description>
+    </release>
+    <release version="5.3.6" date="2026-03-23">
+      <description>
+        <p>IBD sync optimizations, Linux build fixes, and modern compiler support.</p>
+      </description>
+    </release>
+    <release version="5.2.0" date="2025-01-01">
+      <description>
+        <p>Tor v3 embedded support, OpenSSL 3.x compatibility, and Boost 1.90+ support.</p>
+      </description>
+    </release>
+  </releases>
+
+  <content_rating type="oars-1.1" />
+
+  <supports>
+    <control>pointing</control>
+    <control>keyboard</control>
+  </supports>
+</component>
@@ -1,6 +1,6 @@
 # Maintainer: Cryptographic Triangles Team
 pkgname=triangles-qt-bin
-pkgver=5.1.5
+pkgver=5.5.6
 pkgrel=1
 pkgdesc="Cryptographic Triangles (TRI) cryptocurrency wallet - Qt GUI"
 arch=('x86_64')
@@ -11,13 +11,13 @@ optdepends=('tor: anonymous networking support')
 provides=('triangles-qt' 'trianglesd')
 conflicts=('triangles-qt' 'trianglesd')
 source=(
-    "triangles-qt-${pkgver}::https://github.com/SamiAhmed7777/triangles_v5/releases/download/v${pkgver}/triangles-qt-linux"
-    "trianglesd-${pkgver}::https://github.com/SamiAhmed7777/triangles_v5/releases/download/v${pkgver}/trianglesd-linux"
+    "triangles-qt-${pkgver}::https://github.com/SamiAhmed7777/triangles_v5/releases/download/v${pkgver}/Cryptographic-Triangles-v${pkgver}-linux-x64-qt"
+    "trianglesd-${pkgver}::https://github.com/SamiAhmed7777/triangles_v5/releases/download/v${pkgver}/Cryptographic-Triangles-v${pkgver}-linux-x64-daemon"
    "triangles-qt.desktop"
 )
 sha256sums=(
-    '19eaadfdf18b899ce8434fe714e690e2db0546597e36037de37a29854fc23aeb'
-    '6f5c19d34a2e1f6cdadee095d9e11b25d18b41a0d1602a163ffca7ec80b3da37'
+    'ed220eb8d0b403f62cdac28988541fd1a27864491e233216f9c00a4c2537b4a3'
+    '4d2ab25d61127d6aff3e6f3069556d04f4b823f8849e97629c12871ad4779517'
    'SKIP'
 )

@@ -3,8 +3,8 @@ $ErrorActionPreference = 'Stop'
 $packageArgs = @{
    packageName    = 'triangles'
    unzipLocation  = "$(Split-Path -Parent $MyInvocation.MyCommand.Definition)"
-    url64bit       = 'https://github.com/SamiAhmed7777/triangles_v5/releases/download/v5.1.5/Triangles-v5.1.5-win-x64.zip'
-    checksum64     = '777e475f366164b342e917111bcf3155ec39e0ab4bd97b2ac295885ad30a93c6'
+    url64bit       = 'https://github.com/SamiAhmed7777/triangles_v5/releases/download/v5.3.7/Cryptographic-Triangles-5.3.7-win-x64.zip'
+    checksum64     = '6f002a669a7e92aaf3d8dd7b1ae80f06a086c99a15ca05cf107665009ffc06b7'
    checksumType64 = 'sha256'
 }

@@ -2,7 +2,7 @@
 <package xmlns="http://schemas.microsoft.com/packaging/2015/06/nuspec.xsd">
  <metadata>
    <id>triangles</id>
-    <version>5.1.5</version>
+    <version>5.5.6</version>
    <title>Cryptographic Triangles</title>
    <authors>Cryptographic Triangles Team</authors>
    <owners>SamiAhmed7777</owners>
@@ -25,6 +25,6 @@ featuring the unique Hash9 algorithm (13-step hash cascade).
 - Encrypted peer-to-peer messaging
 - Tor v3 integration for anonymous transactions
    </description>
-    <releaseNotes>https://github.com/SamiAhmed7777/triangles_v5/releases/tag/v5.1.5</releaseNotes>
+    <releaseNotes>https://github.com/SamiAhmed7777/triangles_v5/releases/tag/v5.3.7</releaseNotes>
  </metadata>
 </package>
@@ -1,5 +1,5 @@
 Package: triangles
-Version: 5.1.5-1
+Version: 5.5.6-1
 Section: net
 Priority: optional
 Architecture: amd64
@@ -0,0 +1,18 @@
+#!/bin/bash
+# Post-installation script for Triangles .deb package
+
+set -e
+
+echo "════════════════════════════════════════════════════════"
+echo "  Triangles Installation Complete"
+echo "════════════════════════════════════════════════════════"
+echo ""
+echo "Optional: Download blockchain bootstrap to skip days of sync"
+echo ""
+echo "  sudo triangles-bootstrap-install"
+echo ""
+echo "This will download ~1.3GB and extract to ~/.triangles/"
+echo "════════════════════════════════════════════════════════"
+echo ""
+
+exit 0
@@ -3,7 +3,7 @@
 # Run from the packaging/debian directory
 set -e

-VERSION="5.1.5"
+VERSION="5.7.6"
 PKGDIR="triangles_${VERSION}-1_amd64"
 RELEASE_URL="https://github.com/SamiAhmed7777/triangles_v5/releases/download/v${VERSION}"

@@ -13,17 +13,24 @@ echo "Building .deb package for Triangles v${VERSION}..."
 rm -rf "$PKGDIR"
 mkdir -p "$PKGDIR/DEBIAN"
 mkdir -p "$PKGDIR/usr/bin"
+mkdir -p "$PKGDIR/usr/local/bin"
 mkdir -p "$PKGDIR/usr/share/applications"

-# Copy control file
+# Copy control and postinst
 cp DEBIAN/control "$PKGDIR/DEBIAN/"
+cp DEBIAN/postinst "$PKGDIR/DEBIAN/"
+chmod 755 "$PKGDIR/DEBIAN/postinst"

 # Download binaries
 echo "Downloading binaries..."
-curl -L -o "$PKGDIR/usr/bin/triangles-qt" "${RELEASE_URL}/triangles-qt-linux"
-curl -L -o "$PKGDIR/usr/bin/trianglesd" "${RELEASE_URL}/trianglesd-linux"
+curl -L -o "$PKGDIR/usr/bin/triangles-qt" "${RELEASE_URL}/Cryptographic-Triangles-v${VERSION}-linux-x64-qt"
+curl -L -o "$PKGDIR/usr/bin/trianglesd" "${RELEASE_URL}/Cryptographic-Triangles-v${VERSION}-linux-x64-daemon"
 chmod 755 "$PKGDIR/usr/bin/triangles-qt" "$PKGDIR/usr/bin/trianglesd"

+# Copy bootstrap installer
+cp usr/local/bin/triangles-bootstrap-install "$PKGDIR/usr/local/bin/"
+chmod 755 "$PKGDIR/usr/local/bin/triangles-bootstrap-install"
+
 # Create desktop entry
 cat > "$PKGDIR/usr/share/applications/triangles-qt.desktop" << 'DESKTOP'
 [Desktop Entry]
@@ -0,0 +1,87 @@
+#!/bin/bash
+# Triangles Blockchain Bootstrap Installer
+# Downloads and extracts blockchain snapshot to save sync time
+
+set -e
+
+echo "╔═══════════════════════════════════════╗"
+echo "║  Triangles Blockchain Bootstrap      ║"
+echo "╚═══════════════════════════════════════╝"
+echo ""
+
+# Determine data directory
+if [ -n "$1" ]; then
+    DATA_DIR="$1"
+elif [ -d "$HOME/.triangles" ]; then
+    DATA_DIR="$HOME/.triangles"
+else
+    DATA_DIR="$HOME/.triangles"
+    mkdir -p "$DATA_DIR"
+fi
+
+echo "Data directory: $DATA_DIR"
+echo ""
+
+# Check if triangles is running
+if pgrep -x trianglesd > /dev/null || pgrep -x triangles-qt > /dev/null; then
+    echo "⚠️  Triangles is currently running!"
+    echo "   Please stop it first:"
+    echo "   trianglesd stop  (or close triangles-qt)"
+    echo ""
+    exit 1
+fi
+
+# Check existing blockchain
+if [ -f "$DATA_DIR/blk0001.dat" ]; then
+    SIZE=$(du -sh "$DATA_DIR/blk0001.dat" | cut -f1)
+    echo "⚠️  Existing blockchain found ($SIZE)"
+    echo ""
+    read -p "   Overwrite? This will replace your current blockchain [y/N]: " CONFIRM
+    if [[ ! "$CONFIRM" =~ ^[Yy]$ ]]; then
+        echo "Cancelled."
+        exit 0
+    fi
+    echo ""
+fi
+
+# Download bootstrap
+BOOTSTRAP_URL="http://bootstrap.cryptographic-triangles.org/tri-blockchain.tar.gz"
+TMP_FILE="/tmp/tri-blockchain-$$.tar.gz"
+
+echo "⬇️  Downloading blockchain bootstrap (~1.3GB)..."
+echo "   This may take several minutes..."
+echo ""
+
+if ! curl -# -L --fail --connect-timeout 30 --max-time 1800 -o "$TMP_FILE" "$BOOTSTRAP_URL"; then
+    echo "❌ Download failed!"
+    echo "   URL: $BOOTSTRAP_URL"
+    rm -f "$TMP_FILE"
+    exit 1
+fi
+
+echo ""
+echo "✓ Downloaded!"
+echo ""
+
+# Extract
+echo "📦 Extracting blockchain..."
+if ! tar xzf "$TMP_FILE" -C "$DATA_DIR/"; then
+    echo "❌ Extraction failed!"
+    rm -f "$TMP_FILE"
+    exit 1
+fi
+
+rm -f "$TMP_FILE"
+
+echo "✓ Blockchain installed!"
+echo ""
+echo "╔═══════════════════════════════════════╗"
+echo "║         Bootstrap Complete!           ║"
+echo "╚═══════════════════════════════════════╝"
+echo ""
+echo "You can now start Triangles:"
+echo "  trianglesd -daemon"
+echo "  (or launch triangles-qt)"
+echo ""
+echo "The node will sync the remaining ~8,000 blocks from the network."
+echo ""
@@ -0,0 +1,40 @@
+FROM ubuntu:22.04
+
+LABEL maintainer="Cryptographic Triangles Team"
+LABEL description="Cryptographic Triangles (TRI) headless daemon"
+LABEL version="5.7.6"
+
+ARG VERSION=5.7.6
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    curl \
+    ca-certificates \
+    libssl3 \
+    libevent-2.1-7 \
+    libboost-system1.74.0 \
+    libboost-filesystem1.74.0 \
+    libboost-program-options1.74.0 \
+    libboost-thread1.74.0 \
+    libboost-chrono1.74.0 \
+    libdb5.3++ \
+    libminiupnpc17 \
+    tor \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN curl -L -o /usr/local/bin/trianglesd \
+    "https://github.com/SamiAhmed7777/triangles_v5/releases/download/v${VERSION}/Cryptographic-Triangles-v${VERSION}-linux-x64-daemon" \
+    && chmod +x /usr/local/bin/trianglesd
+
+RUN useradd -m -s /bin/bash triangles
+
+USER triangles
+WORKDIR /home/triangles
+
+RUN mkdir -p /home/triangles/.triangles
+
+VOLUME /home/triangles/.triangles
+
+EXPOSE 24112 19112
+
+ENTRYPOINT ["trianglesd"]
+CMD ["-daemon=0", "-printtoconsole"]
@@ -0,0 +1,17 @@
+version: "3.8"
+
+services:
+  trianglesd:
+    build: .
+    image: cryptographic-triangles/trianglesd:5.7.6
+    container_name: trianglesd
+    restart: unless-stopped
+    ports:
+      - "24112:24112"
+      - "19112:19112"
+    volumes:
+      - triangles-data:/home/triangles/.triangles
+    command: ["-daemon=0", "-printtoconsole", "-rpcallowip=172.16.0.0/12"]
+
+volumes:
+  triangles-data:
@@ -0,0 +1,3 @@
+{
+  "only-arches": ["x86_64"]
+}
@@ -19,13 +19,35 @@ modules:
    build-commands:
      - install -Dm755 triangles-qt-linux /app/bin/triangles-qt
      - install -Dm644 triangles-qt.desktop /app/share/applications/org.cryptographic_triangles.TrianglesQt.desktop
+      - install -Dm644 triangles.svg /app/share/icons/hicolor/scalable/apps/org.cryptographic_triangles.TrianglesQt.svg
+      - install -Dm644 triangles-128.png /app/share/icons/hicolor/128x128/apps/org.cryptographic_triangles.TrianglesQt.png
+      - install -Dm644 triangles-256.png /app/share/icons/hicolor/256x256/apps/org.cryptographic_triangles.TrianglesQt.png
+      - install -Dm644 org.cryptographic_triangles.TrianglesQt.metainfo.xml /app/share/metainfo/org.cryptographic_triangles.TrianglesQt.metainfo.xml
    sources:
      - type: file
-        url: https://github.com/SamiAhmed7777/triangles_v5/releases/download/v5.1.5/triangles-qt-linux
-        sha256: 19eaadfdf18b899ce8434fe714e690e2db0546597e36037de37a29854fc23aeb
+        url: https://github.com/SamiAhmed7777/triangles_v5/releases/download/v5.7.6/Cryptographic-Triangles-v5.7.6-linux-x64-qt
+        sha256: ed220eb8d0b403f62cdac28988541fd1a27864491e233216f9c00a4c2537b4a3
        dest-filename: triangles-qt-linux
      - type: file
-        path: triangles-qt.desktop
+        url: https://raw.githubusercontent.com/SamiAhmed7777/triangles_v5/master/packaging/flatpak/triangles-qt.desktop
+        sha256: f56c4be5870fed6d3f0fb74398241ea909bd3b6f3305fe06ef5f58fba25602ca
+        dest-filename: triangles-qt.desktop
+      - type: file
+        url: https://raw.githubusercontent.com/SamiAhmed7777/triangles_v5/master/src/qt/res/src/triangles.svg
+        sha256: c08d0731e209b1941606709d7236526c4334ee52d1cbda2173cad417d6169486
+        dest-filename: triangles.svg
+      - type: file
+        url: https://raw.githubusercontent.com/SamiAhmed7777/triangles_v5/master/src/qt/res/icons/triangles-128.png
+        sha256: 3a9030b2141ba822059e1d32c29f004c5ed9a4d3c8fc1fba6188201cfdf4ccf5
+        dest-filename: triangles-128.png
+      - type: file
+        url: https://raw.githubusercontent.com/SamiAhmed7777/triangles_v5/master/src/qt/res/icons/triangles.png
+        sha256: eebe5b1890c4cf43b8ae3160f81bac93a2a10cd221c99815de9fcd850f225f4e
+        dest-filename: triangles-256.png
+      - type: file
+        url: https://raw.githubusercontent.com/SamiAhmed7777/triangles_v5/master/packaging/appstream/org.cryptographic_triangles.TrianglesQt.metainfo.xml
+        sha256: dd5ecf9f4916cf0ef3d7ceec763dbbbcf7c4bf806be1e404a96dcfc9423c9fad
+        dest-filename: org.cryptographic_triangles.TrianglesQt.metainfo.xml

  - name: trianglesd
    buildsystem: simple
@@ -33,6 +55,6 @@ modules:
      - install -Dm755 trianglesd-linux /app/bin/trianglesd
    sources:
      - type: file
-        url: https://github.com/SamiAhmed7777/triangles_v5/releases/download/v5.1.5/trianglesd-linux
-        sha256: 6f5c19d34a2e1f6cdadee095d9e11b25d18b41a0d1602a163ffca7ec80b3da37
+        url: https://github.com/SamiAhmed7777/triangles_v5/releases/download/v5.7.6/Cryptographic-Triangles-v5.7.6-linux-x64-daemon
+        sha256: 4d2ab25d61127d6aff3e6f3069556d04f4b823f8849e97629c12871ad4779517
        dest-filename: trianglesd-linux
@@ -2,21 +2,16 @@ class Triangles < Formula
  desc "Cryptographic Triangles (TRI) cryptocurrency wallet and daemon"
  homepage "https://cryptographic-triangles.org"
  license "MIT"
-  version "5.1.5"
+  version "5.5.6"

  on_macos do
-    if Hardware::CPU.intel?
-      url "https://github.com/SamiAhmed7777/triangles_v5/releases/download/v5.1.5/Cryptographic-Triangles-v5.1.5-macos-x64.dmg"
-      sha256 "PLACEHOLDER_X64_HASH"
-    else
-      url "https://github.com/SamiAhmed7777/triangles_v5/releases/download/v5.1.5/Cryptographic-Triangles-v5.1.5-macos-arm64.dmg"
-      sha256 "PLACEHOLDER_ARM64_HASH"
-    end
+    url "https://github.com/SamiAhmed7777/triangles_v5/releases/download/v5.3.7/Cryptographic-Triangles-v5.3.7-macos-arm64.dmg"
+    sha256 "3a58e795d898656b455fd639c0ea826a4457d390a64d00ace9a1257598d053be"
  end

  on_linux do
-    url "https://github.com/SamiAhmed7777/triangles_v5/releases/download/v5.1.5/trianglesd-linux"
-    sha256 "6f5c19d34a2e1f6cdadee095d9e11b25d18b41a0d1602a163ffca7ec80b3da37"
+    url "https://github.com/SamiAhmed7777/triangles_v5/releases/download/v5.3.7/Cryptographic-Triangles-v5.3.7-linux-x64-daemon"
+    sha256 "4d2ab25d61127d6aff3e6f3069556d04f4b823f8849e97629c12871ad4779517"
  end

  depends_on "openssl@3"
@@ -26,7 +21,7 @@ class Triangles < Formula
      prefix.install "Triangles-Qt.app"
      bin.write_exec_script prefix/"Triangles-Qt.app/Contents/MacOS/Triangles-Qt"
    else
-      bin.install "trianglesd-linux" => "trianglesd"
+      bin.install "Cryptographic-Triangles-v5.3.7-linux-x64-daemon" => "trianglesd"
    end
  end

@@ -14,7 +14,7 @@
 }:

 let
-  version = "5.1.5";
+  version = "5.5.6";

  desktopItem = makeDesktopItem {
    name = "triangles-qt";
@@ -34,13 +34,13 @@ stdenv.mkDerivation {

  srcs = [
    (fetchurl {
-      url = "https://github.com/SamiAhmed7777/triangles_v5/releases/download/v${version}/triangles-qt-linux";
-      sha256 = "19eaadfdf18b899ce8434fe714e690e2db0546597e36037de37a29854fc23aeb";
+      url = "https://github.com/SamiAhmed7777/triangles_v5/releases/download/v${version}/Cryptographic-Triangles-v${version}-linux-x64-qt";
+      sha256 = "ed220eb8d0b403f62cdac28988541fd1a27864491e233216f9c00a4c2537b4a3";
      name = "triangles-qt-linux";
    })
    (fetchurl {
-      url = "https://github.com/SamiAhmed7777/triangles_v5/releases/download/v${version}/trianglesd-linux";
-      sha256 = "6f5c19d34a2e1f6cdadee095d9e11b25d18b41a0d1602a163ffca7ec80b3da37";
+      url = "https://github.com/SamiAhmed7777/triangles_v5/releases/download/v${version}/Cryptographic-Triangles-v${version}-linux-x64-daemon";
+      sha256 = "4d2ab25d61127d6aff3e6f3069556d04f4b823f8849e97629c12871ad4779517";
      name = "trianglesd-linux";
    })
  ];
@@ -4,7 +4,7 @@
 # Install build tools: sudo dnf install rpm-build rpmdevtools
 set -e

-VERSION="5.1.5"
+VERSION="5.7.6"
 RELEASE_URL="https://github.com/SamiAhmed7777/triangles_v5/releases/download/v${VERSION}"

 echo "Building RPM for Triangles v${VERSION}..."
@@ -14,8 +14,8 @@ rpmdev-setuptree

 # Download sources into SOURCES
 echo "Downloading binaries..."
-curl -L -o ~/rpmbuild/SOURCES/triangles-qt-linux "${RELEASE_URL}/triangles-qt-linux"
-curl -L -o ~/rpmbuild/SOURCES/trianglesd-linux "${RELEASE_URL}/trianglesd-linux"
+curl -L -o ~/rpmbuild/SOURCES/Cryptographic-Triangles-v${VERSION}-linux-x64-qt "${RELEASE_URL}/Cryptographic-Triangles-v${VERSION}-linux-x64-qt"
+curl -L -o ~/rpmbuild/SOURCES/Cryptographic-Triangles-v${VERSION}-linux-x64-daemon "${RELEASE_URL}/Cryptographic-Triangles-v${VERSION}-linux-x64-daemon"
 cp triangles-qt.desktop ~/rpmbuild/SOURCES/

 # Copy spec file
@@ -1,11 +1,11 @@
 Name:           triangles
-Version:        5.1.5
+Version:        5.7.6
 Release:        1%{?dist}
 Summary:        Cryptographic Triangles (TRI) cryptocurrency wallet
 License:        MIT
 URL:            https://cryptographic-triangles.org
-Source0:        https://github.com/SamiAhmed7777/triangles_v5/releases/download/v%{version}/triangles-qt-linux
-Source1:        https://github.com/SamiAhmed7777/triangles_v5/releases/download/v%{version}/trianglesd-linux
+Source0:        https://github.com/SamiAhmed7777/triangles_v5/releases/download/v%{version}/Cryptographic-Triangles-v%{version}-linux-x64-qt
+Source1:        https://github.com/SamiAhmed7777/triangles_v5/releases/download/v%{version}/Cryptographic-Triangles-v%{version}-linux-x64-daemon
 Source2:        triangles-qt.desktop

 BuildArch:      x86_64
@@ -0,0 +1,29 @@
+{
+    "version": "5.7.6",
+    "description": "Cryptographic Triangles (TRI) cryptocurrency wallet with PoS staking and encrypted messaging",
+    "homepage": "https://cryptographic-triangles.org",
+    "license": "MIT",
+    "architecture": {
+        "64bit": {
+            "url": "https://github.com/SamiAhmed7777/triangles_v5/releases/download/v5.7.6/Cryptographic-Triangles-5.7.6-win-x64.zip",
+            "hash": "6f002a669a7e92aaf3d8dd7b1ae80f06a086c99a15ca05cf107665009ffc06b7"
+        }
+    },
+    "bin": [
+        "triangles-qt.exe",
+        "trianglesd.exe"
+    ],
+    "shortcuts": [
+        ["triangles-qt.exe", "Cryptographic Triangles"]
+    ],
+    "checkver": {
+        "github": "https://github.com/SamiAhmed7777/triangles_v5"
+    },
+    "autoupdate": {
+        "architecture": {
+            "64bit": {
+                "url": "https://github.com/SamiAhmed7777/triangles_v5/releases/download/v$version/Cryptographic-Triangles-$version-win-x64.zip"
+            }
+        }
+    }
+}
@@ -1,5 +1,5 @@
 PackageIdentifier: CryptographicTriangles.TrianglesQt
-PackageVersion: 5.1.5
+PackageVersion: 5.7.6
 PackageLocale: en-US
 Publisher: Cryptographic Triangles
 PublisherUrl: https://cryptographic-triangles.org
@@ -27,7 +27,7 @@ Installers:
      - RelativeFilePath: triangles-qt.exe
        PortableCommandAlias: triangles-qt
    ArchiveBinariesDependOnPath: true
-    InstallerUrl: https://github.com/SamiAhmed7777/triangles_v5/releases/download/v5.1.5/Triangles-v5.1.5-win-x64.zip
-    InstallerSha256: 777e475f366164b342e917111bcf3155ec39e0ab4bd97b2ac295885ad30a93c6
+    InstallerUrl: https://github.com/SamiAhmed7777/triangles_v5/releases/download/v5.7.6/Cryptographic-Triangles-5.7.6-win-x64.zip
+    InstallerSha256: 6F002A669A7E92AAF3D8DD7B1AE80F06A086C99A15CA05CF107665009FFC06B7
 ManifestType: singleton
 ManifestVersion: 1.6.0
@@ -0,0 +1,29 @@
+# Version Bump Script
+
+Updates the version number across all files in the repo from a single command.
+
+## Usage
+
+**Set a specific version:**
+```bash
+bash scripts/bump-version.sh 5.7.0
+```
+
+**Or edit `src/clientversion.h` first, then sync everything else:**
+```bash
+bash scripts/bump-version.sh
+```
+
+## What it updates
+
+- `src/clientversion.h` (source of truth)
+- `src/version.h`
+- `triangles-qt.pro`
+- `Dockerfile`
+- All packaging manifests (Docker, Snap, Scoop, WinGet, RPM, Flatpak, Debian, AppImage)
+
+## What still needs manual review after running
+
+- `packaging/appstream/...metainfo.xml` — add a new `<release>` entry
+- `README.md` — update header version if desired
+- Any documentation with download URLs
@@ -0,0 +1,149 @@
+#!/bin/bash
+# bump-version.sh - Sync all version references from src/clientversion.h
+#
+# Usage:
+#   ./scripts/bump-version.sh              # Read version from clientversion.h, update everything
+#   ./scripts/bump-version.sh 5.7.0        # Set version to 5.7.0 in clientversion.h AND everywhere else
+#
+# The single source of truth is src/clientversion.h
+
+set -e
+
+REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+CLIENTVERSION="$REPO_ROOT/src/clientversion.h"
+
+if [ ! -f "$CLIENTVERSION" ]; then
+    echo "ERROR: Cannot find $CLIENTVERSION"
+    exit 1
+fi
+
+# If a version argument is provided, update clientversion.h first
+if [ -n "$1" ]; then
+    IFS='.' read -r MAJOR MINOR REV <<< "$1"
+    REV="${REV:-0}"
+    BUILD=0
+    sed -i "s/#define CLIENT_VERSION_MAJOR.*/#define CLIENT_VERSION_MAJOR       $MAJOR/" "$CLIENTVERSION"
+    sed -i "s/#define CLIENT_VERSION_MINOR.*/#define CLIENT_VERSION_MINOR       $MINOR/" "$CLIENTVERSION"
+    sed -i "s/#define CLIENT_VERSION_REVISION.*/#define CLIENT_VERSION_REVISION    $REV/" "$CLIENTVERSION"
+    sed -i "s/#define CLIENT_VERSION_BUILD.*/#define CLIENT_VERSION_BUILD       $BUILD/" "$CLIENTVERSION"
+    echo "Updated clientversion.h to $MAJOR.$MINOR.$REV.$BUILD"
+fi
+
+# Read version from clientversion.h (the source of truth)
+MAJOR=$(grep '#define CLIENT_VERSION_MAJOR' "$CLIENTVERSION" | awk '{print $3}')
+MINOR=$(grep '#define CLIENT_VERSION_MINOR' "$CLIENTVERSION" | awk '{print $3}')
+REV=$(grep '#define CLIENT_VERSION_REVISION' "$CLIENTVERSION" | awk '{print $3}')
+BUILD=$(grep '#define CLIENT_VERSION_BUILD' "$CLIENTVERSION" | awk '{print $3}')
+
+VERSION="$MAJOR.$MINOR.$REV"
+VERSION_FULL="$MAJOR.$MINOR.$REV.$BUILD"
+
+echo "Syncing all files to version $VERSION (full: $VERSION_FULL)"
+echo "==========================================================="
+
+update_file() {
+    local file="$1"
+    local pattern="$2"
+    local replacement="$3"
+    if [ -f "$file" ]; then
+        sed -i "$pattern" "$file"
+        echo "  Updated: $file"
+    fi
+}
+
+# --- Source files ---
+
+# src/version.h - DISPLAY_VERSION macros
+update_file "$REPO_ROOT/src/version.h" \
+    "s/#define DISPLAY_VERSION_MAJOR.*/#define DISPLAY_VERSION_MAJOR       $MAJOR/" ""
+update_file "$REPO_ROOT/src/version.h" \
+    "s/#define DISPLAY_VERSION_MINOR.*/#define DISPLAY_VERSION_MINOR       $MINOR/" ""
+update_file "$REPO_ROOT/src/version.h" \
+    "s/#define DISPLAY_VERSION_REVISION.*/#define DISPLAY_VERSION_REVISION    $REV/" ""
+update_file "$REPO_ROOT/src/version.h" \
+    "s/#define DISPLAY_VERSION_BUILD.*/#define DISPLAY_VERSION_BUILD       $BUILD/" ""
+
+# triangles-qt.pro
+update_file "$REPO_ROOT/triangles-qt.pro" \
+    "s/^VERSION = .*/VERSION = $VERSION_FULL/" ""
+
+# --- Docker ---
+
+update_file "$REPO_ROOT/Dockerfile" \
+    "s/LABEL version=\"[^\"]*\"/LABEL version=\"$VERSION\"/" ""
+
+update_file "$REPO_ROOT/packaging/docker/Dockerfile" \
+    "s/LABEL version=\"[^\"]*\"/LABEL version=\"$VERSION\"/" ""
+update_file "$REPO_ROOT/packaging/docker/Dockerfile" \
+    "s/ARG VERSION=.*/ARG VERSION=$VERSION/" ""
+
+update_file "$REPO_ROOT/packaging/docker/docker-compose.yml" \
+    "s|cryptographic-triangles/trianglesd:[0-9.]*|cryptographic-triangles/trianglesd:$VERSION|" ""
+
+# --- Snap ---
+
+update_file "$REPO_ROOT/snap/snapcraft.yaml" \
+    "s/^version: '[^']*'/version: '$VERSION'/" ""
+# Update download URLs in snapcraft.yaml
+if [ -f "$REPO_ROOT/snap/snapcraft.yaml" ]; then
+    sed -i "s|/download/v[0-9.]*\/|/download/v$VERSION/|g" "$REPO_ROOT/snap/snapcraft.yaml"
+    sed -i "s/Cryptographic-Triangles-v[0-9.]*-linux/Cryptographic-Triangles-v$VERSION-linux/g" "$REPO_ROOT/snap/snapcraft.yaml"
+fi
+
+# --- Scoop ---
+
+if [ -f "$REPO_ROOT/packaging/scoop/triangles.json" ]; then
+    sed -i "s/\"version\": \"[^\"]*\"/\"version\": \"$VERSION\"/" "$REPO_ROOT/packaging/scoop/triangles.json"
+    sed -i "s|/download/v[0-9.]*/|/download/v$VERSION/|g" "$REPO_ROOT/packaging/scoop/triangles.json"
+    sed -i "s/Cryptographic-Triangles-[0-9.]*-win/Cryptographic-Triangles-$VERSION-win/g" "$REPO_ROOT/packaging/scoop/triangles.json"
+    echo "  Updated: packaging/scoop/triangles.json"
+fi
+
+# --- WinGet ---
+
+if [ -f "$REPO_ROOT/packaging/winget/CryptographicTriangles.TrianglesQt.yaml" ]; then
+    sed -i "s/PackageVersion: .*/PackageVersion: $VERSION/" "$REPO_ROOT/packaging/winget/CryptographicTriangles.TrianglesQt.yaml"
+    sed -i "s|/download/v[0-9.]*/|/download/v$VERSION/|g" "$REPO_ROOT/packaging/winget/CryptographicTriangles.TrianglesQt.yaml"
+    sed -i "s/Cryptographic-Triangles-[0-9.]*-win/Cryptographic-Triangles-$VERSION-win/g" "$REPO_ROOT/packaging/winget/CryptographicTriangles.TrianglesQt.yaml"
+    echo "  Updated: packaging/winget/CryptographicTriangles.TrianglesQt.yaml"
+fi
+
+# --- RPM ---
+
+update_file "$REPO_ROOT/packaging/rpm/triangles.spec" \
+    "s/^Version:        .*/Version:        $VERSION/" ""
+
+if [ -f "$REPO_ROOT/packaging/rpm/build-rpm.sh" ]; then
+    sed -i "s/^VERSION=\"[^\"]*\"/VERSION=\"$VERSION\"/" "$REPO_ROOT/packaging/rpm/build-rpm.sh"
+    echo "  Updated: packaging/rpm/build-rpm.sh"
+fi
+
+# --- Flatpak ---
+
+if [ -f "$REPO_ROOT/packaging/flatpak/org.cryptographic_triangles.TrianglesQt.yml" ]; then
+    sed -i "s|/download/v[0-9.]*/|/download/v$VERSION/|g" "$REPO_ROOT/packaging/flatpak/org.cryptographic_triangles.TrianglesQt.yml"
+    sed -i "s/Cryptographic-Triangles-v[0-9.]*-linux/Cryptographic-Triangles-v$VERSION-linux/g" "$REPO_ROOT/packaging/flatpak/org.cryptographic_triangles.TrianglesQt.yml"
+    echo "  Updated: packaging/flatpak/org.cryptographic_triangles.TrianglesQt.yml"
+fi
+
+# --- Debian ---
+
+if [ -f "$REPO_ROOT/packaging/debian/build-deb.sh" ]; then
+    sed -i "s/^VERSION=\"[^\"]*\"/VERSION=\"$VERSION\"/" "$REPO_ROOT/packaging/debian/build-deb.sh"
+    echo "  Updated: packaging/debian/build-deb.sh"
+fi
+
+# --- AppImage ---
+
+if [ -f "$REPO_ROOT/packaging/appimage/build-appimage.sh" ]; then
+    sed -i "s/^VERSION=\"[^\"]*\"/VERSION=\"$VERSION\"/" "$REPO_ROOT/packaging/appimage/build-appimage.sh"
+    echo "  Updated: packaging/appimage/build-appimage.sh"
+fi
+
+echo ""
+echo "Done! All files synced to v$VERSION"
+echo ""
+echo "Files NOT auto-updated (require manual review):"
+echo "  - packaging/appstream/...metainfo.xml  (add new <release> entry)"
+echo "  - README.md                            (update header version)"
+echo "  - Documentation .md files              (update download URLs if needed)"
@@ -15,8 +15,13 @@ if [ -e "$(which git)" ]; then
    # clean 'dirty' status of touched files that haven't been modified
    git diff >/dev/null 2>/dev/null 

-    # get a string like "v0.6.0-66-g59887e8-dirty"
-    DESC="$(git describe --dirty 2>/dev/null)"
+    # Try exact tag match first (when building from a release tag)
+    DESC="$(git describe --tags --exact-match 2>/dev/null)"
+    
+    # If no exact match, fall back to git describe with commit distance
+    if [ -z "$DESC" ]; then
+        DESC="$(git describe --tags --dirty 2>/dev/null)"
+    fi

    # get a string like "2012-04-10 16:27:19 +0200"
    TIME="$(git log -n 1 --format="%ci")"
@@ -1,6 +1,6 @@
 name: triangles
 base: core22
-version: '5.1.5'
+version: '5.7.6'
 summary: Cryptographic Triangles (TRI) cryptocurrency wallet
 description: |
  Privacy-focused cryptocurrency featuring Proof-of-Stake consensus,
@@ -51,10 +51,10 @@ apps:
 parts:
  triangles:
    plugin: dump
-    source: https://github.com/SamiAhmed7777/triangles_v5/releases/download/v5.1.5/triangles-qt-linux
+    source: https://github.com/SamiAhmed7777/triangles_v5/releases/download/v5.7.6/Cryptographic-Triangles-v5.7.6-linux-x64-qt
    source-type: file
    organize:
-      triangles-qt-linux: bin/triangles-qt
+      Cryptographic-Triangles-v5.7.6-linux-x64-qt: bin/triangles-qt
    stage-packages:
      - libqt5widgets5
      - libqt5gui5
@@ -73,13 +73,19 @@ parts:

  trianglesd:
    plugin: dump
-    source: https://github.com/SamiAhmed7777/triangles_v5/releases/download/v5.1.5/trianglesd-linux
+    source: https://github.com/SamiAhmed7777/triangles_v5/releases/download/v5.7.6/Cryptographic-Triangles-v5.7.6-linux-x64-daemon
    source-type: file
    organize:
-      trianglesd-linux: bin/trianglesd
+      Cryptographic-Triangles-v5.7.6-linux-x64-daemon: bin/trianglesd

  desktop-entry:
    plugin: dump
    source: snap/gui
    organize:
      triangles-qt.desktop: share/applications/triangles-qt.desktop
+
+  appstream:
+    plugin: dump
+    source: packaging/appstream
+    organize:
+      org.cryptographic_triangles.TrianglesQt.metainfo.xml: share/metainfo/org.cryptographic_triangles.TrianglesQt.metainfo.xml
@@ -0,0 +1,475 @@
+# src/CMakeLists.txt
+# Defines all build targets: libraries and executables.
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 1. Hash9 cryptographic primitives (pure C)
+# ═══════════════════════════════════════════════════════════════════════════════
+add_library(hash9_crypto STATIC
+    blake.c
+    groestl.c
+    jh.c
+    keccak.c
+    skein.c
+    aes_helper.c
+    bmw.c
+    cubehash.c
+    echo.c
+    fugue.c
+    hamsi.c
+    hamsi_helper.c
+    luffa.c
+    shavite.c
+    simd.c
+)
+target_include_directories(hash9_crypto PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}")
+set_target_properties(hash9_crypto PROPERTIES LINKER_LANGUAGE C)
+# Hash9 C files have colliding static symbols (IV512, DECL_STATE, etc.) — skip unity
+set_target_properties(hash9_crypto PROPERTIES UNITY_BUILD OFF)
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 2. JSON library (header-only nlohmann/json via json_compat.h shim)
+# ═══════════════════════════════════════════════════════════════════════════════
+add_library(json_compat INTERFACE)
+target_include_directories(json_compat INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/json")
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 3. Common core library (shared between daemon, Qt, and tests)
+#
+#    EXCLUDES init.cpp, wallet.cpp (QT_GUI-conditional), noui.cpp (target-specific)
+# ═══════════════════════════════════════════════════════════════════════════════
+set(CORE_SOURCES
+    addrman.cpp
+    bootstrap.cpp
+    checkpoints.cpp
+    crypter.cpp
+    crypto_ecdh.cpp
+    crypto_ecdsa.cpp
+    db.cpp
+    key.cpp
+    keystore.cpp
+    main.cpp
+    miner.cpp
+    net.cpp
+    net_bootstrap.cpp
+    netbase.cpp
+    protocol.cpp
+    script.cpp
+    sync.cpp
+    util.cpp
+    version.cpp
+    walletdb.cpp
+    kernel.cpp
+    pbkdf2.cpp
+    scrypt.cpp
+    smessage.cpp
+    syncmanager.cpp
+    chaindb_migrate.cpp
+    tor_embed_hooks.cpp
+    rest.cpp
+    trianglesrpc.cpp
+    rpcdump.cpp
+    rpcnet.cpp
+    rpcmining.cpp
+    rpcwallet.cpp
+    rpcblockchain.cpp
+    rpcrawtransaction.cpp
+    rpcsmessage.cpp
+    zmqpublishnotifier.cpp
+    txdb-base.cpp
+    txdb-factory.cpp
+    txdb-leveldb.cpp
+    utxosnapshot.cpp
+    snapshotnet.cpp
+    lz4/lz4.c
+    tor/onion_v3.cpp
+    tor/tor_process.cpp
+    tor/tor_embedded.cpp
+)
+
+# Scrypt assembly — platform-specific
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64|amd64")
+    enable_language(ASM)
+    list(APPEND CORE_SOURCES scrypt-x86_64.S)
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "i[3-6]86|x86")
+    enable_language(ASM)
+    list(APPEND CORE_SOURCES scrypt-x86.S)
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64|ARM64")
+    enable_language(ASM)
+    list(APPEND CORE_SOURCES scrypt-arm.S)
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "arm|ARM")
+    enable_language(ASM)
+    list(APPEND CORE_SOURCES scrypt-arm.S)
+endif()
+
+# RocksDB chain database backend (always built; see top-level CMakeLists.txt
+# for the rationale — RocksDB also backs the smessage store).
+list(APPEND CORE_SOURCES txdb-rocksdb.cpp)
+
+add_library(triangles_common OBJECT ${CORE_SOURCES})
+
+target_include_directories(triangles_common PUBLIC
+    "${CMAKE_CURRENT_SOURCE_DIR}"
+    "${CMAKE_CURRENT_SOURCE_DIR}/json"
+    "${CMAKE_CURRENT_SOURCE_DIR}/tor"
+    "${CMAKE_BINARY_DIR}/generated"       # for build.h
+)
+
+target_compile_definitions(triangles_common PUBLIC HAVE_BUILD_INFO)
+
+target_link_libraries(triangles_common PUBLIC
+    hash9_crypto
+    json_compat
+    leveldb_bundled
+    OpenSSL::SSL
+    OpenSSL::Crypto
+    Boost::program_options
+    Boost::thread
+    Boost::chrono
+    BerkeleyDB::BerkeleyDB
+    Libevent::Libevent
+    ZLIB::ZLIB
+    Threads::Threads
+)
+
+# Optional: UPnP
+if(USE_UPNP)
+    target_compile_definitions(triangles_common PUBLIC USE_UPNP=1 STATICLIB MINIUPNP_STATICLIB)
+    target_link_libraries(triangles_common PUBLIC Miniupnpc::Miniupnpc)
+    if(WIN32)
+        target_link_libraries(triangles_common PUBLIC iphlpapi)
+    endif()
+endif()
+
+# Optional: IPv6
+if(USE_IPV6)
+    target_compile_definitions(triangles_common PUBLIC USE_IPV6=1)
+endif()
+
+# Optional: ZMQ
+if(USE_ZMQ)
+    target_compile_definitions(triangles_common PUBLIC ENABLE_ZMQ)
+    target_link_libraries(triangles_common PUBLIC PkgConfig::ZMQ)
+endif()
+
+# libsecp256k1 (mandatory) — ECDH / ECDSA replacement for OpenSSL EC.
+# Provided by add_subdirectory(src/secp256k1) in the top-level CMakeLists.
+target_link_libraries(triangles_common PUBLIC secp256k1)
+
+# RocksDB (mandatory)
+if(TARGET RocksDB::rocksdb)
+    target_link_libraries(triangles_common PUBLIC RocksDB::rocksdb)
+elseif(TARGET PkgConfig::RocksDB)
+    target_link_libraries(triangles_common PUBLIC PkgConfig::RocksDB)
+endif()
+
+# Optional: Embedded Tor
+if(USE_TOR_EMBEDDED)
+    if(TOR_SOURCE_ROOT STREQUAL "")
+        set(TOR_SOURCE_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/tor/tor-src")
+    endif()
+    target_compile_definitions(triangles_common PUBLIC ENABLE_TOR_EMBEDDED)
+    target_include_directories(triangles_common PUBLIC "${TOR_SOURCE_ROOT}/src/feature/api")
+    target_link_directories(triangles_common PUBLIC "${TOR_SOURCE_ROOT}")
+    # libtor.a has circular deps with libevent/openssl/zlib
+    # OpenSSL and zlib already linked via imported targets above, so only add
+    # libevent and compression libs that libtor needs but aren't yet linked.
+    # --start-group / --end-group resolves circular references between libtor
+    # and its dependencies.
+    # Use --allow-multiple-definition because libtor.a may pull in static
+    # OpenSSL objects that duplicate the DLL import lib already linked above.
+    target_link_libraries(triangles_common PUBLIC
+        -Wl,--allow-multiple-definition
+        -Wl,--start-group
+        -ltor
+        -levent -levent_core -levent_extra -levent_openssl
+        -lssl -lcrypto -lz -llzma -lzstd
+        -Wl,--end-group
+    )
+    if(WIN32)
+        target_link_libraries(triangles_common PUBLIC iphlpapi shlwapi crypt32)
+    endif()
+endif()
+
+# Platform-specific libraries
+if(WIN32)
+    target_link_libraries(triangles_common PUBLIC
+        ws2_32 shlwapi mswsock ole32 oleaut32 uuid gdi32 crypt32)
+elseif(APPLE)
+    target_link_libraries(triangles_common PUBLIC
+        "-framework Foundation"
+        "-framework ApplicationServices"
+        "-framework AppKit")
+else()
+    # Linux
+    target_link_libraries(triangles_common PUBLIC rt dl)
+endif()
+
+add_dependencies(triangles_common generate_build_info build_leveldb)
+
+# ── Precompiled header (heavy STL + Boost + OpenSSL includes, C++ only) ──
+target_precompile_headers(triangles_common PRIVATE
+    "$<$<COMPILE_LANGUAGE:CXX>:<string$<ANGLE-R>>"
+    "$<$<COMPILE_LANGUAGE:CXX>:<vector$<ANGLE-R>>"
+    "$<$<COMPILE_LANGUAGE:CXX>:<map$<ANGLE-R>>"
+    "$<$<COMPILE_LANGUAGE:CXX>:<deque$<ANGLE-R>>"
+    "$<$<COMPILE_LANGUAGE:CXX>:<algorithm$<ANGLE-R>>"
+    "$<$<COMPILE_LANGUAGE:CXX>:<sstream$<ANGLE-R>>"
+    "$<$<COMPILE_LANGUAGE:CXX>:<stdexcept$<ANGLE-R>>"
+    "$<$<COMPILE_LANGUAGE:CXX>:<cstdint$<ANGLE-R>>"
+    "$<$<COMPILE_LANGUAGE:CXX>:<cstring$<ANGLE-R>>"
+    "$<$<COMPILE_LANGUAGE:CXX>:<memory$<ANGLE-R>>"
+    "$<$<COMPILE_LANGUAGE:CXX>:<functional$<ANGLE-R>>"
+    "$<$<COMPILE_LANGUAGE:CXX>:<filesystem$<ANGLE-R>>"
+    "$<$<COMPILE_LANGUAGE:CXX>:<fstream$<ANGLE-R>>"
+    "$<$<COMPILE_LANGUAGE:CXX>:<thread$<ANGLE-R>>"
+    "$<$<COMPILE_LANGUAGE:CXX>:<mutex$<ANGLE-R>>"
+    "$<$<COMPILE_LANGUAGE:CXX>:<condition_variable$<ANGLE-R>>"
+    "$<$<COMPILE_LANGUAGE:CXX>:<boost/algorithm/string.hpp$<ANGLE-R>>"
+    "$<$<COMPILE_LANGUAGE:CXX>:<openssl/sha.h$<ANGLE-R>>"
+    "$<$<COMPILE_LANGUAGE:CXX>:<openssl/crypto.h$<ANGLE-R>>"
+    "$<$<COMPILE_LANGUAGE:CXX>:<openssl/rand.h$<ANGLE-R>>"
+    "$<$<COMPILE_LANGUAGE:CXX>:<openssl/evp.h$<ANGLE-R>>"
+)
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 4. Headless daemon (trianglesd)
+# ═══════════════════════════════════════════════════════════════════════════════
+if(BUILD_DAEMON)
+    add_executable(trianglesd
+        noui.cpp
+        init.cpp
+        wallet.cpp
+    )
+    # No QT_GUI define — daemon gets the #if !defined(QT_GUI) code paths
+    target_link_libraries(trianglesd PRIVATE triangles_common)
+    target_precompile_headers(trianglesd REUSE_FROM triangles_common)
+
+    if(WIN32)
+        set_target_properties(trianglesd PROPERTIES SUFFIX ".exe")
+    endif()
+endif()
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 5. Qt5 GUI wallet (triangles-qt)
+# ═══════════════════════════════════════════════════════════════════════════════
+if(BUILD_QT)
+    set(CMAKE_AUTOMOC ON)
+    set(CMAKE_AUTOUIC ON)
+    set(CMAKE_AUTORCC ON)
+
+    set(CMAKE_AUTOUIC_SEARCH_PATHS
+        "${CMAKE_CURRENT_SOURCE_DIR}/qt/forms"
+        "${CMAKE_CURRENT_SOURCE_DIR}/qt/plugins/mrichtexteditor"
+    )
+
+    # ui_interface.h is a hand-written header (Bitcoin convention), NOT a Qt
+    # Designer file. Disable AutoUic globally and run UIC manually for real .ui files.
+    set(CMAKE_AUTOUIC OFF)
+
+    # Collect all .ui files and run UIC on them explicitly
+    file(GLOB_RECURSE UI_FILES
+        "${CMAKE_CURRENT_SOURCE_DIR}/qt/forms/*.ui"
+        "${CMAKE_CURRENT_SOURCE_DIR}/qt/plugins/mrichtexteditor/*.ui"
+    )
+    qt5_wrap_ui(UI_HEADERS ${UI_FILES})
+
+    set(QT_SOURCES
+        qt/triangles.cpp
+        qt/trianglesgui.cpp
+        qt/transactiontablemodel.cpp
+        qt/addresstablemodel.cpp
+        qt/optionsdialog.cpp
+        qt/sendcoinsdialog.cpp
+        qt/coincontroldialog.cpp
+        qt/coincontroltreewidget.cpp
+        qt/addressbookpage.cpp
+        qt/aboutdialog.cpp
+        qt/introdialog.cpp
+        qt/editaddressdialog.cpp
+        qt/trianglesaddressvalidator.cpp
+        qt/clientmodel.cpp
+        qt/guiutil.cpp
+        qt/transactionrecord.cpp
+        qt/optionsmodel.cpp
+        qt/monitoreddatamapper.cpp
+        qt/transactiondesc.cpp
+        qt/transactiondescdialog.cpp
+        qt/trianglesstrings.cpp
+        qt/trianglesamountfield.cpp
+        qt/transactionfilterproxy.cpp
+        qt/transactionview.cpp
+        qt/walletmodel.cpp
+        qt/overviewpage.cpp
+        qt/csvmodelwriter.cpp
+        qt/sendcoinsentry.cpp
+        qt/qvalidatedlineedit.cpp
+        qt/trianglesunits.cpp
+        qt/qvaluecombobox.cpp
+        qt/askpassphrasedialog.cpp
+        qt/notificator.cpp
+        qt/qtipcserver.cpp
+        qt/rpcconsole.cpp
+        qt/messagepage.cpp
+        qt/dialog_move_handler.cpp
+        qt/signmessagepage.cpp
+        qt/verifymessagepage.cpp
+        qt/messagemodel.cpp
+        qt/sendmessagesdialog.cpp
+        qt/sendmessagesentry.cpp
+        qt/qvalidatedtextedit.cpp
+        qt/plugins/mrichtexteditor/mrichtextedit.cpp
+    )
+
+    set(QT_RESOURCES qt/triangles.qrc)
+
+    set(QT_FORMS
+        qt/forms/coincontroldialog.ui
+        qt/forms/sendcoinsdialog.ui
+        qt/forms/addressbookpage.ui
+        qt/forms/aboutdialog.ui
+        qt/forms/editaddressdialog.ui
+        qt/forms/transactiondescdialog.ui
+        qt/forms/overviewpage.ui
+        qt/forms/sendcoinsentry.ui
+        qt/forms/askpassphrasedialog.ui
+        qt/forms/rpcconsole.ui
+        qt/forms/optionsdialog.ui
+        qt/forms/messagepage.ui
+        qt/forms/sendmessagesentry.ui
+        qt/forms/sendmessagesdialog.ui
+        qt/plugins/mrichtexteditor/mrichtextedit.ui
+        qt/forms/mainwindow.ui
+        qt/forms/signmessagepage.ui
+        qt/forms/verifymessagepage.ui
+        qt/forms/transactionspage.ui
+    )
+
+    # Optional QR code dialog
+    if(USE_QRCODE)
+        list(APPEND QT_SOURCES qt/qrcodedialog.cpp)
+        list(APPEND QT_FORMS qt/forms/qrcodedialog.ui)
+    endif()
+
+    # macOS Objective-C++ sources
+    if(APPLE)
+        list(APPEND QT_SOURCES
+            qt/macdockiconhandler.mm
+            qt/macnotificationhandler.mm
+        )
+    endif()
+
+    add_executable(triangles-qt WIN32 MACOSX_BUNDLE
+        ${QT_SOURCES}
+        ${QT_RESOURCES}
+        ${QT_FORMS}
+        ${UI_HEADERS}
+        # Per-target: compiled with QT_GUI define
+        init.cpp
+        wallet.cpp
+        noui.cpp
+    )
+
+    target_compile_definitions(triangles-qt PRIVATE
+        QT_GUI
+        QT_DISABLE_DEPRECATED_BEFORE=0
+    )
+
+    target_include_directories(triangles-qt PRIVATE
+        "${CMAKE_CURRENT_SOURCE_DIR}/qt"
+        "${CMAKE_CURRENT_SOURCE_DIR}/qt/plugins/mrichtexteditor"
+        "${CMAKE_CURRENT_BINARY_DIR}"
+    )
+
+    target_link_libraries(triangles-qt PRIVATE
+        triangles_common
+        Qt5::Core
+        Qt5::Gui
+        Qt5::Widgets
+    )
+
+    # Optional: D-Bus notifications (Linux)
+    if(USE_DBUS)
+        target_compile_definitions(triangles-qt PRIVATE USE_DBUS)
+        target_link_libraries(triangles-qt PRIVATE Qt5::DBus)
+    endif()
+
+    # Optional: QR code
+    if(USE_QRCODE)
+        target_compile_definitions(triangles-qt PRIVATE USE_QRCODE)
+        target_link_libraries(triangles-qt PRIVATE QRencode::QRencode)
+    endif()
+
+    # Windows resource file (.rc with version info and icon)
+    if(WIN32)
+        target_sources(triangles-qt PRIVATE qt/res/triangles-qt.rc)
+        # Ensure RC compiler can find clientversion.h
+        if(MINGW)
+            set_source_files_properties(qt/res/triangles-qt.rc PROPERTIES
+                COMPILE_FLAGS "-I${CMAKE_CURRENT_SOURCE_DIR}"
+            )
+        endif()
+    endif()
+
+    # macOS bundle settings
+    if(APPLE)
+        set_target_properties(triangles-qt PROPERTIES
+            OUTPUT_NAME "Triangles-Qt"
+            MACOSX_BUNDLE_ICON_FILE triangles.icns
+            MACOSX_BUNDLE_BUNDLE_NAME "Triangles-Qt"
+            MACOSX_BUNDLE_BUNDLE_VERSION "${PROJECT_VERSION}"
+            MACOSX_BUNDLE_SHORT_VERSION_STRING "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}"
+        )
+        set_source_files_properties(
+            "${CMAKE_CURRENT_SOURCE_DIR}/qt/res/icons/triangles.icns"
+            PROPERTIES MACOSX_PACKAGE_LOCATION "Resources"
+        )
+        target_sources(triangles-qt PRIVATE qt/res/icons/triangles.icns)
+    endif()
+
+    # Translations (optional — requires LinguistTools)
+    if(TARGET Qt5::lrelease)
+        file(GLOB TS_FILES "${CMAKE_CURRENT_SOURCE_DIR}/qt/locale/triangles_*.ts")
+        if(TS_FILES)
+            set_source_files_properties(${TS_FILES} PROPERTIES
+                OUTPUT_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/qt/locale"
+            )
+            qt5_add_translation(QM_FILES ${TS_FILES})
+            target_sources(triangles-qt PRIVATE ${QM_FILES})
+        endif()
+    endif()
+endif()
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 6. Unit tests (test_triangles)
+# ═══════════════════════════════════════════════════════════════════════════════
+if(BUILD_TESTS)
+    enable_testing()
+
+    file(GLOB TEST_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/test/*.cpp")
+    # Exclude miner_tests.cpp (never ported from Bitcoin)
+    list(FILTER TEST_SOURCES EXCLUDE REGEX "miner_tests\\.cpp$")
+
+    add_executable(test_triangles
+        ${TEST_SOURCES}
+        # Per-target: wallet without QT_GUI, noui for noui_connect()
+        wallet.cpp
+        noui.cpp
+    )
+    # No init.cpp — test_triangles.cpp provides its own StartShutdown() stub
+
+    target_compile_definitions(test_triangles PRIVATE
+        "TEST_DATA_DIR=\"${CMAKE_CURRENT_SOURCE_DIR}/test/data\""
+    )
+
+    target_include_directories(test_triangles PRIVATE
+        "${CMAKE_CURRENT_SOURCE_DIR}"
+        "${CMAKE_CURRENT_SOURCE_DIR}/test"
+    )
+
+    target_link_libraries(test_triangles PRIVATE
+        triangles_common
+        Boost::unit_test_framework
+    )
+
+    add_test(NAME triangles_unit_tests COMMAND test_triangles --log_level=test_suite)
+endif()
@@ -4,6 +4,8 @@

 #include "addrman.h"

+#include <cmath>
+
 using namespace std;

 int CAddrInfo::GetTriedBucket(const std::vector<unsigned char> &nKey) const
@@ -79,15 +81,14 @@ double CAddrInfo::GetChance(int64_t nNow) const

 CAddrInfo* CAddrMan::Find(const CNetAddr& addr, int *pnId)
 {
-    std::map<CNetAddr, int>::iterator it = mapAddr.find(addr);
+    auto it = mapAddr.find(addr);
    if (it == mapAddr.end())
-        return NULL;
+        return nullptr;
    if (pnId)
-        *pnId = (*it).second;
-    std::map<int, CAddrInfo>::iterator it2 = mapInfo.find((*it).second);
-    if (it2 != mapInfo.end())
-        return &(*it2).second;
-    return NULL;
+        *pnId = it->second;
+    if (auto it2 = mapInfo.find(it->second); it2 != mapInfo.end())
+        return &it2->second;
+    return nullptr;
 }

 CAddrInfo* CAddrMan::Create(const CAddress &addr, const CNetAddr &addrSource, int *pnId)
@@ -175,13 +176,13 @@ int CAddrMan::ShrinkNew(int nUBucket)
    int n[4] = {GetRandInt(vNew.size()), GetRandInt(vNew.size()), GetRandInt(vNew.size()), GetRandInt(vNew.size())};
    int nI = 0;
    int nOldest = -1;
-    for (std::set<int>::iterator it = vNew.begin(); it != vNew.end(); it++)
+    for (const auto& elem : vNew)
    {
        if (nI == n[0] || nI == n[1] || nI == n[2] || nI == n[3])
        {
-            assert(nOldest == -1 || mapInfo.count(*it) == 1);
-            if (nOldest == -1 || mapInfo[*it].nTime < mapInfo[nOldest].nTime)
-                nOldest = *it;
+            assert(nOldest == -1 || mapInfo.count(elem) == 1);
+            if (nOldest == -1 || mapInfo[elem].nTime < mapInfo[nOldest].nTime)
+                nOldest = elem;
        }
        nI++;
    }
@@ -438,10 +439,8 @@ int CAddrMan::Check_()

    if (vRandom.size() != nTried + nNew) return -7;

-    for (std::map<int, CAddrInfo>::iterator it = mapInfo.begin(); it != mapInfo.end(); it++)
+    for (auto& [n, info] : mapInfo)
    {
-        int n = (*it).first;
-        CAddrInfo &info = (*it).second;
        if (info.fInTried)
        {

@@ -465,10 +464,10 @@ int CAddrMan::Check_()
    for (int n=0; n<vvTried.size(); n++)
    {
        std::vector<int> &vTried = vvTried[n];
-        for (std::vector<int>::iterator it = vTried.begin(); it != vTried.end(); it++)
+        for (const auto& elem : vTried)
        {
-            if (!setTried.count(*it)) return -11;
-            setTried.erase(*it);
+            if (!setTried.count(elem)) return -11;
+            setTried.erase(elem);
        }
    }

@@ -1,277 +0,0 @@
-//
-// Alert system
-//
-
-#include <algorithm>
-#include <boost/algorithm/string/classification.hpp>
-#include <boost/algorithm/string/replace.hpp>
-#include <boost/foreach.hpp>
-#include <map>
-
-#include "alert.h"
-#include "key.h"
-#include "net.h"
-#include "sync.h"
-#include "ui_interface.h"
-
-using namespace std;
-
-map<uint256, CAlert> mapAlerts;
-CCriticalSection cs_mapAlerts;
-
-// Alert keys disabled for decentralization - v5 hard fork
-static const char* pszMainKey = "";
-
-// TestNet alerts pubKey
-static const char* pszTestKey = "";
-
-void CUnsignedAlert::SetNull()
-{
-    nVersion = 1;
-    nRelayUntil = 0;
-    nExpiration = 0;
-    nID = 0;
-    nCancel = 0;
-    setCancel.clear();
-    nMinVer = 0;
-    nMaxVer = 0;
-    setSubVer.clear();
-    nPriority = 0;
-
-    strComment.clear();
-    strStatusBar.clear();
-    strReserved.clear();
-}
-
-std::string CUnsignedAlert::ToString() const
-{
-    std::string strSetCancel;
-    BOOST_FOREACH(int n, setCancel)
-        strSetCancel += strprintf("%d ", n);
-    std::string strSetSubVer;
-    BOOST_FOREACH(std::string str, setSubVer)
-        strSetSubVer += "\"" + str + "\" ";
-    return strprintf(
-        "CAlert(\n"
-        "    nVersion     = %d\n"
-        "    nRelayUntil  = %"PRId64"\n"
-        "    nExpiration  = %"PRId64"\n"
-        "    nID          = %d\n"
-        "    nCancel      = %d\n"
-        "    setCancel    = %s\n"
-        "    nMinVer      = %d\n"
-        "    nMaxVer      = %d\n"
-        "    setSubVer    = %s\n"
-        "    nPriority    = %d\n"
-        "    strComment   = \"%s\"\n"
-        "    strStatusBar = \"%s\"\n"
-        ")\n",
-        nVersion,
-        nRelayUntil,
-        nExpiration,
-        nID,
-        nCancel,
-        strSetCancel.c_str(),
-        nMinVer,
-        nMaxVer,
-        strSetSubVer.c_str(),
-        nPriority,
-        strComment.c_str(),
-        strStatusBar.c_str());
-}
-
-void CUnsignedAlert::print() const
-{
-    printf("%s", ToString().c_str());
-}
-
-void CAlert::SetNull()
-{
-    CUnsignedAlert::SetNull();
-    vchMsg.clear();
-    vchSig.clear();
-}
-
-bool CAlert::IsNull() const
-{
-    return (nExpiration == 0);
-}
-
-uint256 CAlert::GetHash() const
-{
-    return Hash(this->vchMsg.begin(), this->vchMsg.end());
-}
-
-bool CAlert::IsInEffect() const
-{
-    return (GetAdjustedTime() < nExpiration);
-}
-
-bool CAlert::Cancels(const CAlert& alert) const
-{
-    if (!IsInEffect())
-        return false; // this was a no-op before 31403
-    return (alert.nID <= nCancel || setCancel.count(alert.nID));
-}
-
-bool CAlert::AppliesTo(int nVersion, std::string strSubVerIn) const
-{
-    // TODO: rework for client-version-embedded-in-strSubVer ?
-    return (IsInEffect() &&
-            nMinVer <= nVersion && nVersion <= nMaxVer &&
-            (setSubVer.empty() || setSubVer.count(strSubVerIn)));
-}
-
-bool CAlert::AppliesToMe() const
-{
-    return AppliesTo(PROTOCOL_VERSION, FormatSubVersion(CLIENT_NAME, CLIENT_VERSION, std::vector<std::string>()));
-}
-
-bool CAlert::RelayTo(CNode* pnode) const
-{
-    if (!IsInEffect())
-        return false;
-    // returns true if wasn't already contained in the set
-    if (pnode->setKnown.insert(GetHash()).second)
-    {
-        if (AppliesTo(pnode->nVersion, pnode->strSubVer) ||
-            AppliesToMe() ||
-            GetAdjustedTime() < nRelayUntil)
-        {
-            pnode->PushMessage("alert", *this);
-            return true;
-        }
-    }
-    return false;
-}
-
-bool CAlert::CheckSignature() const
-{
-    // Alert key system disabled for decentralization - v5 hard fork
-    const char* pszKey = fTestNet ? pszTestKey : pszMainKey;
-    if (pszKey[0] == '\0')
-        return false; // No alerts accepted without a valid key
-
-    CKey key;
-    if (!key.SetPubKey(ParseHex(pszKey)))
-        return error("CAlert::CheckSignature() : SetPubKey failed");
-    if (!key.Verify(Hash(vchMsg.begin(), vchMsg.end()), vchSig))
-        return error("CAlert::CheckSignature() : verify signature failed");
-
-    // Now unserialize the data
-    CDataStream sMsg(vchMsg, SER_NETWORK, PROTOCOL_VERSION);
-    sMsg >> *(CUnsignedAlert*)this;
-    return true;
-}
-
-CAlert CAlert::getAlertByHash(const uint256 &hash)
-{
-    CAlert retval;
-    {
-        LOCK(cs_mapAlerts);
-        map<uint256, CAlert>::iterator mi = mapAlerts.find(hash);
-        if(mi != mapAlerts.end())
-            retval = mi->second;
-    }
-    return retval;
-}
-
-bool CAlert::ProcessAlert(bool fThread)
-{
-    if (!CheckSignature())
-        return false;
-    if (!IsInEffect())
-        return false;
-
-    // alert.nID=max is reserved for if the alert key is
-    // compromised. It must have a pre-defined message,
-    // must never expire, must apply to all versions,
-    // and must cancel all previous
-    // alerts or it will be ignored (so an attacker can't
-    // send an "everything is OK, don't panic" version that
-    // cannot be overridden):
-    int maxInt = std::numeric_limits<int>::max();
-    if (nID == maxInt)
-    {
-        if (!(
-                nExpiration == maxInt &&
-                nCancel == (maxInt-1) &&
-                nMinVer == 0 &&
-                nMaxVer == maxInt &&
-                setSubVer.empty() &&
-                nPriority == maxInt &&
-                strStatusBar == "URGENT: Alert key compromised, upgrade required"
-                ))
-            return false;
-    }
-
-    {
-        LOCK(cs_mapAlerts);
-        // Cancel previous alerts
-        for (map<uint256, CAlert>::iterator mi = mapAlerts.begin(); mi != mapAlerts.end();)
-        {
-            const CAlert& alert = (*mi).second;
-            if (Cancels(alert))
-            {
-                printf("cancelling alert %d\n", alert.nID);
-                uiInterface.NotifyAlertChanged((*mi).first, CT_DELETED);
-                mapAlerts.erase(mi++);
-            }
-            else if (!alert.IsInEffect())
-            {
-                printf("expiring alert %d\n", alert.nID);
-                uiInterface.NotifyAlertChanged((*mi).first, CT_DELETED);
-                mapAlerts.erase(mi++);
-            }
-            else
-                mi++;
-        }
-
-        // Check if this alert has been cancelled
-        BOOST_FOREACH(PAIRTYPE(const uint256, CAlert)& item, mapAlerts)
-        {
-            const CAlert& alert = item.second;
-            if (alert.Cancels(*this))
-            {
-                printf("alert already cancelled by %d\n", alert.nID);
-                return false;
-            }
-        }
-
-        // Add to mapAlerts
-        mapAlerts.insert(make_pair(GetHash(), *this));
-        // Notify UI and -alertnotify if it applies to me
-        if(AppliesToMe())
-        {
-            uiInterface.NotifyAlertChanged(GetHash(), CT_NEW);
-            std::string strCmd = GetArg("-alertnotify", "");
-            if (!strCmd.empty())
-            {
-                // Alert text should be plain ascii coming from a trusted source, but to
-                // be safe we first strip anything not in safeChars, then add single quotes around
-                // the whole string before passing it to the shell:
-                std::string singleQuote("'");
-                // safeChars chosen to allow simple messages/URLs/email addresses, but avoid anything
-                // even possibly remotely dangerous like & or >
-                std::string safeChars("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890 .,;_/:?@");
-                std::string safeStatus;
-                for (std::string::size_type i = 0; i < strStatusBar.size(); i++)
-                {
-                    if (safeChars.find(strStatusBar[i]) != std::string::npos)
-                        safeStatus.push_back(strStatusBar[i]);
-                }
-                safeStatus = singleQuote+safeStatus+singleQuote;
-                boost::replace_all(strCmd, "%s", safeStatus);
-
-                if (fThread)
-                    boost::thread t(runCommand, strCmd); // thread runs free
-                else
-                    runCommand(strCmd);
-            }
-        }
-    }
-
-    printf("accepted alert %d, AppliesToMe()=%d\n", nID, AppliesToMe());
-    return true;
-}
-
@@ -1,104 +0,0 @@
-// Copyright (c) 2010 Satoshi Nakamoto
-// Copyright (c) 2009-2012 The Bitcoin developers
-// Distributed under the MIT/X11 software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#ifndef _TRIANGLESALERT_H_
-#define _TRIANGLESALERT_H_ 1
-
-#include <set>
-#include <string>
-
-#include "uint256.h"
-#include "util.h"
-
-class CNode;
-
-/** Alerts are for notifying old versions if they become too obsolete and
- * need to upgrade.  The message is displayed in the status bar.
- * Alert messages are broadcast as a vector of signed data.  Unserializing may
- * not read the entire buffer if the alert is for a newer version, but older
- * versions can still relay the original data.
- */
-class CUnsignedAlert
-{
-public:
-    int nVersion;
-    int64_t nRelayUntil;      // when newer nodes stop relaying to newer nodes
-    int64_t nExpiration;
-    int nID;
-    int nCancel;
-    std::set<int> setCancel;
-    int nMinVer;            // lowest version inclusive
-    int nMaxVer;            // highest version inclusive
-    std::set<std::string> setSubVer;  // empty matches all
-    int nPriority;
-
-    // Actions
-    std::string strComment;
-    std::string strStatusBar;
-    std::string strReserved;
-
-    IMPLEMENT_SERIALIZE
-    (
-        READWRITE(this->nVersion);
-        nVersion = this->nVersion;
-        READWRITE(nRelayUntil);
-        READWRITE(nExpiration);
-        READWRITE(nID);
-        READWRITE(nCancel);
-        READWRITE(setCancel);
-        READWRITE(nMinVer);
-        READWRITE(nMaxVer);
-        READWRITE(setSubVer);
-        READWRITE(nPriority);
-
-        READWRITE(strComment);
-        READWRITE(strStatusBar);
-        READWRITE(strReserved);
-    )
-
-    void SetNull();
-
-    std::string ToString() const;
-    void print() const;
-};
-
-/** An alert is a combination of a serialized CUnsignedAlert and a signature. */
-class CAlert : public CUnsignedAlert
-{
-public:
-    std::vector<unsigned char> vchMsg;
-    std::vector<unsigned char> vchSig;
-
-    CAlert()
-    {
-        SetNull();
-    }
-
-    IMPLEMENT_SERIALIZE
-    (
-        READWRITE(vchMsg);
-        READWRITE(vchSig);
-    )
-
-    void SetNull();
-    bool IsNull() const;
-    uint256 GetHash() const;
-    bool IsInEffect() const;
-    bool Cancels(const CAlert& alert) const;
-    bool AppliesTo(int nVersion, std::string strSubVerIn) const;
-    bool AppliesToMe() const;
-    bool RelayTo(CNode* pnode) const;
-    bool CheckSignature() const;
-    bool ProcessAlert(bool fThread = true);
-
-    /*
-     * Get copy of (active) alert object by hash. Returns a null alert if it is not found.
-     */
-    static CAlert getAlertByHash(const uint256 &hash);
-};
-
-#endif
-
-
@@ -7,7 +7,7 @@

 #include <string.h>
 #include <string>
-#include <boost/thread/mutex.hpp>
+#include <mutex>
 #include <map>

 #ifdef WIN32
@@ -55,7 +55,7 @@ public:
    // For all pages in affected range, increase lock count
    void LockRange(void *p, size_t size)
    {
-        boost::mutex::scoped_lock lock(mutex);
+        std::lock_guard<std::mutex> lock(mutex);
        if(!size) return;
        const size_t base_addr = reinterpret_cast<size_t>(p);
        const size_t start_page = base_addr & page_mask;
@@ -66,7 +66,7 @@ public:
            if(it == histogram.end()) // Newly locked page
            {
                locker.Lock(reinterpret_cast<void*>(page), page_size);
-                histogram.insert(std::make_pair(page, 1));
+                histogram.insert({page, 1});
            }
            else // Page was already locked; increase counter
            {
@@ -78,7 +78,7 @@ public:
    // For all pages in affected range, decrease lock count
    void UnlockRange(void *p, size_t size)
    {
-        boost::mutex::scoped_lock lock(mutex);
+        std::lock_guard<std::mutex> lock(mutex);
        if(!size) return;
        const size_t base_addr = reinterpret_cast<size_t>(p);
        const size_t start_page = base_addr & page_mask;
@@ -101,13 +101,13 @@ public:
    // Get number of locked pages for diagnostics
    int GetLockedPageCount()
    {
-        boost::mutex::scoped_lock lock(mutex);
+        std::lock_guard<std::mutex> lock(mutex);
        return histogram.size();
    }

 private:
    Locker locker;
-    boost::mutex mutex;
+    std::mutex mutex;
    size_t page_size, page_mask;
    // map of page base address to lock count
    typedef std::map<size_t,int> Histogram;
@@ -182,35 +182,36 @@ private:
 template<typename T>
 struct secure_allocator : public std::allocator<T>
 {
-    // MSVC8 default copy constructor is broken
+    // C++20 removed pointer/reference/etc. member typedefs from std::allocator
+    // and removed the 2-arg allocate(n, hint). Define what we still need
+    // directly instead of pulling from base.
    typedef std::allocator<T> base;
-    typedef typename base::size_type size_type;
-    typedef typename base::difference_type  difference_type;
-    typedef typename base::pointer pointer;
-    typedef typename base::const_pointer const_pointer;
-    typedef typename base::reference reference;
-    typedef typename base::const_reference const_reference;
-    typedef typename base::value_type value_type;
-    secure_allocator() throw() {}
-    secure_allocator(const secure_allocator& a) throw() : base(a) {}
+    typedef T              value_type;
+    typedef T*             pointer;
+    typedef const T*       const_pointer;
+    typedef T&             reference;
+    typedef const T&       const_reference;
+    typedef std::size_t    size_type;
+    typedef std::ptrdiff_t difference_type;
+    secure_allocator() noexcept {}
+    secure_allocator(const secure_allocator& a) noexcept : base(a) {}
    template <typename U>
-    secure_allocator(const secure_allocator<U>& a) throw() : base(a) {}
-    ~secure_allocator() throw() {}
+    secure_allocator(const secure_allocator<U>& a) noexcept : base(a) {}
+    ~secure_allocator() noexcept {}
    template<typename _Other> struct rebind
    { typedef secure_allocator<_Other> other; };

-    T* allocate(std::size_t n, const void *hint = 0)
+    T* allocate(std::size_t n)
    {
-        T *p;
-        p = std::allocator<T>::allocate(n, hint);
-        if (p != NULL)
+        T* p = std::allocator<T>::allocate(n);
+        if (p != nullptr)
            LockedPageManager::instance.LockRange(p, sizeof(T) * n);
        return p;
    }

    void deallocate(T* p, std::size_t n)
    {
-        if (p != NULL)
+        if (p != nullptr)
        {
            memset(p, 0, sizeof(T) * n);
            LockedPageManager::instance.UnlockRange(p, sizeof(T) * n);
@@ -226,32 +227,38 @@ struct secure_allocator : public std::allocator<T>
 template<typename T>
 struct zero_after_free_allocator : public std::allocator<T>
 {
-    // MSVC8 default copy constructor is broken
+    // C++20 removed pointer/reference/etc. member typedefs from std::allocator.
+    // Define what we still need directly instead of pulling from base.
    typedef std::allocator<T> base;
-    typedef typename base::size_type size_type;
-    typedef typename base::difference_type  difference_type;
-    typedef typename base::pointer pointer;
-    typedef typename base::const_pointer const_pointer;
-    typedef typename base::reference reference;
-    typedef typename base::const_reference const_reference;
-    typedef typename base::value_type value_type;
-    zero_after_free_allocator() throw() {}
-    zero_after_free_allocator(const zero_after_free_allocator& a) throw() : base(a) {}
+    typedef T              value_type;
+    typedef T*             pointer;
+    typedef const T*       const_pointer;
+    typedef T&             reference;
+    typedef const T&       const_reference;
+    typedef std::size_t    size_type;
+    typedef std::ptrdiff_t difference_type;
+    zero_after_free_allocator() noexcept {}
+    zero_after_free_allocator(const zero_after_free_allocator& a) noexcept : base(a) {}
    template <typename U>
-    zero_after_free_allocator(const zero_after_free_allocator<U>& a) throw() : base(a) {}
-    ~zero_after_free_allocator() throw() {}
+    zero_after_free_allocator(const zero_after_free_allocator<U>& a) noexcept : base(a) {}
+    ~zero_after_free_allocator() noexcept {}
    template<typename _Other> struct rebind
    { typedef zero_after_free_allocator<_Other> other; };

    void deallocate(T* p, std::size_t n)
    {
-        if (p != NULL)
+        if (p != nullptr)
            memset(p, 0, sizeof(T) * n);
        std::allocator<T>::deallocate(p, n);
    }
 };

 // This is exactly like std::string, but with a custom allocator.
-typedef std::basic_string<char, std::char_traits<char>, secure_allocator<char> > SecureString;
+using SecureString = std::basic_string<char, std::char_traits<char>, secure_allocator<char>>;
+
+static inline SecureString MakeSecureString(const std::string& value)
+{
+    return SecureString(value.begin(), value.end());
+}

 #endif
@@ -260,7 +260,7 @@ public:
 * The data vector contains RIPEMD160(SHA256(cscript)), where cscript is the serialized redemption script.
 */
 class CTrianglesAddress;
-class CTrianglesAddressVisitor : public boost::static_visitor<bool>
+class CTrianglesAddressVisitor
 {
 private:
    CTrianglesAddress *addr;
@@ -294,7 +294,7 @@ public:

    bool Set(const CTxDestination &dest)
    {
-        return boost::apply_visitor(CTrianglesAddressVisitor(this), dest);
+        return std::visit(CTrianglesAddressVisitor(this), dest);
    }

    bool IsValid() const
@@ -11,7 +11,9 @@
 #include "version.h"

 #include <openssl/bn.h>
+#include <openssl/opensslv.h>

+#include <algorithm>
 #include <stdexcept>
 #include <vector>

@@ -36,20 +38,20 @@ public:
    CAutoBN_CTX()
    {
        pctx = BN_CTX_new();
-        if (pctx == NULL)
+        if (pctx == nullptr)
            throw bignum_error("CAutoBN_CTX : BN_CTX_new() returned NULL");
    }

    ~CAutoBN_CTX()
    {
-        if (pctx != NULL)
+        if (pctx != nullptr)
            BN_CTX_free(pctx);
    }

    operator BN_CTX*() { return pctx; }
    BN_CTX& operator*() { return *pctx; }
    BN_CTX** operator&() { return &pctx; }
-    bool operator!() { return (pctx == NULL); }
+    bool operator!() { return (pctx == nullptr); }
 };


@@ -63,14 +65,14 @@ public:
    CBigNum()
    {
        pbn = BN_new();
-        if (pbn == NULL)
+        if (pbn == nullptr)
            throw bignum_error("CBigNum::CBigNum() : BN_new() returned NULL");
    }

    CBigNum(const CBigNum& b)
    {
        pbn = BN_new();
-        if (pbn == NULL)
+        if (pbn == nullptr)
            throw bignum_error("CBigNum::CBigNum(const CBigNum&) : BN_new() returned NULL");
        if (!BN_copy(pbn, b.pbn))
        {
@@ -88,7 +90,7 @@ public:

    ~CBigNum()
    {
-        if (pbn != NULL)
+        if (pbn != nullptr)
            BN_clear_free(pbn);
    }

@@ -219,7 +221,7 @@ public:

    uint64_t getuint64()
    {
-        unsigned int nSize = BN_bn2mpi(pbn, NULL);
+        unsigned int nSize = BN_bn2mpi(pbn, nullptr);
        if (nSize < 4)
            return 0;
        std::vector<unsigned char> vch(nSize);
@@ -289,7 +291,7 @@ public:

    uint256 getuint256() const
    {
-        unsigned int nSize = BN_bn2mpi(pbn, NULL);
+        unsigned int nSize = BN_bn2mpi(pbn, nullptr);
        if (nSize < 4)
            return 0;
        std::vector<unsigned char> vch(nSize);
@@ -320,7 +322,7 @@ public:

    std::vector<unsigned char> getvch() const
    {
-        unsigned int nSize = BN_bn2mpi(pbn, NULL);
+        unsigned int nSize = BN_bn2mpi(pbn, nullptr);
        if (nSize <= 4)
            return std::vector<unsigned char>();
        std::vector<unsigned char> vch(nSize);
@@ -344,7 +346,7 @@ public:

    unsigned int GetCompact() const
    {
-        unsigned int nSize = BN_bn2mpi(pbn, NULL);
+        unsigned int nSize = BN_bn2mpi(pbn, nullptr);
        std::vector<unsigned char> vch(nSize);
        nSize -= 4;
        BN_bn2mpi(pbn, &vch[0]);
@@ -373,7 +375,7 @@ public:
            psz++;

        // hex string to bignum
-        static const signed char phexdigit[256] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0, 0,0xa,0xb,0xc,0xd,0xe,0xf,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0xa,0xb,0xc,0xd,0xe,0xf,0,0,0,0,0,0,0,0,0 };
+        static constexpr signed char phexdigit[256] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0, 0,0xa,0xb,0xc,0xd,0xe,0xf,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0xa,0xb,0xc,0xd,0xe,0xf,0,0,0,0,0,0,0,0,0 };
        *this = 0;
        while (isxdigit(*psz))
        {
@@ -514,7 +516,7 @@ public:
     */
    static CBigNum generatePrime(const unsigned int numBits, bool safe = false) {
        CBigNum ret;
-        if(!BN_generate_prime_ex(ret.pbn, numBits, (safe == true), NULL, NULL, NULL))
+        if(!BN_generate_prime_ex(ret.pbn, numBits, (safe == true), nullptr, nullptr, nullptr))
            throw bignum_error("CBigNum::generatePrime*= :BN_generate_prime_ex");
        return ret;
    }
@@ -540,7 +542,14 @@ public:
    */
    bool isPrime(const int checks=BN_prime_checks) const {
        CAutoBN_CTX pctx;
-        int ret = BN_is_prime_ex(pbn, checks, pctx, NULL);
+#if OPENSSL_VERSION_NUMBER >= 0x30000000L
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+        int ret = BN_is_prime_ex(pbn, checks, pctx, nullptr);
+#if OPENSSL_VERSION_NUMBER >= 0x30000000L
+#pragma GCC diagnostic pop
+#endif
        if(ret < 0){
            throw bignum_error("CBigNum::isPrime :BN_is_prime_ex");
        }
@@ -705,7 +714,7 @@ inline const CBigNum operator/(const CBigNum& a, const CBigNum& b)
 {
    CAutoBN_CTX pctx;
    CBigNum r;
-    if (!BN_div(r.pbn, NULL, a.pbn, b.pbn, pctx))
+    if (!BN_div(r.pbn, nullptr, a.pbn, b.pbn, pctx))
        throw bignum_error("CBigNum::operator/ : BN_div failed");
    return r;
 }
@@ -0,0 +1,808 @@
+// Copyright (c) 2024 Triangles developers
+// Distributed under the MIT/X11 software license
+
+#include "bootstrap.h"
+#include "utxosnapshot.h"
+#include "txdb.h"
+
+#include <filesystem>
+#include <fstream>
+
+#include <zlib.h>
+
+#include "version.h"
+#include "uint256.h"
+#include "netbase.h"
+#include "net.h"
+
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+
+#include <fstream>
+#include <sstream>
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+
+#ifdef WIN32
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#else
+#include <sys/socket.h>
+#include <netdb.h>
+#include <unistd.h>
+#endif
+
+// Forward declarations to avoid pulling in heavy consensus headers
+extern bool fTestNet;
+namespace Checkpoints { bool IsKnownCheckpoint(int nHeight, const uint256& hash); }
+
+namespace fs = std::filesystem;
+
+namespace Bootstrap {
+
+bool NeedsBootstrap(const fs::path& dataDir)
+{
+    return !fs::exists(dataDir / "blk0001.dat");
+}
+
+// Direct TCP connection bypassing Tor SOCKS proxy.
+// Used for bootstrap downloads where the server is on clearnet.
+static SOCKET ConnectDirectTCP(const std::string& host, int port, std::string& strError)
+{
+    struct addrinfo hints, *result, *rp;
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = SOCK_STREAM;
+
+    std::string portStr = std::to_string(port);
+    int rc = getaddrinfo(host.c_str(), portStr.c_str(), &hints, &result);
+    if (rc != 0) {
+        strError = "DNS resolution failed for " + host;
+        return INVALID_SOCKET;
+    }
+
+    SOCKET hSocket = INVALID_SOCKET;
+    for (rp = result; rp != nullptr; rp = rp->ai_next) {
+        hSocket = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
+        if (hSocket == INVALID_SOCKET)
+            continue;
+
+        if (connect(hSocket, rp->ai_addr, (int)rp->ai_addrlen) == 0)
+            break; // success
+
+        closesocket(hSocket);
+        hSocket = INVALID_SOCKET;
+    }
+    freeaddrinfo(result);
+
+    if (hSocket == INVALID_SOCKET)
+        strError = "Cannot connect to " + host + ":" + portStr;
+
+    return hSocket;
+}
+
+// RAII wrapper for an HTTP(S) connection (socket + optional TLS)
+struct HttpConn {
+    SOCKET sock;
+    SSL_CTX* ctx;
+    SSL* ssl;
+
+    HttpConn() : sock(INVALID_SOCKET), ctx(nullptr), ssl(nullptr) {}
+    ~HttpConn() { Close(); }
+
+    void Close() {
+        if (ssl)  { SSL_shutdown(ssl); SSL_free(ssl); ssl = nullptr; }
+        if (ctx)  { SSL_CTX_free(ctx); ctx = nullptr; }
+        if (sock != INVALID_SOCKET) { closesocket(sock); sock = INVALID_SOCKET; }
+    }
+
+    bool Send(const char* data, size_t len) {
+        while (len > 0) {
+            int n = ssl ? SSL_write(ssl, data, (int)std::min(len, (size_t)65536))
+                        : send(sock, data, (int)std::min(len, (size_t)65536), MSG_NOSIGNAL);
+            if (n <= 0) return false;
+            data += n;
+            len -= n;
+        }
+        return true;
+    }
+
+    int Recv(char* buf, int len) {
+        return ssl ? SSL_read(ssl, buf, len) : recv(sock, buf, len, 0);
+    }
+
+    // Read until delimiter found. Returns data including delimiter.
+    bool RecvUntil(std::string& out, const std::string& delim) {
+        out.clear();
+        char c;
+        while (true) {
+            int n = Recv(&c, 1);
+            if (n <= 0) return false;
+            out += c;
+            if (out.size() >= delim.size() &&
+                out.compare(out.size() - delim.size(), delim.size(), delim) == 0)
+                return true;
+            if (out.size() > 64 * 1024) return false; // header too large
+        }
+    }
+
+    // Establish TLS on an already-connected socket
+    bool StartTLS(const std::string& hostname, std::string& strError) {
+        ctx = SSL_CTX_new(TLS_client_method());
+        if (!ctx) {
+            strError = "Failed to create SSL context";
+            return false;
+        }
+        // Skip cert verification — we verify data integrity via checkpoint hashes
+        SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, nullptr);
+
+        ssl = SSL_new(ctx);
+        if (!ssl) {
+            strError = "Failed to create SSL object";
+            return false;
+        }
+        SSL_set_fd(ssl, (int)sock);
+        SSL_set_tlsext_host_name(ssl, hostname.c_str()); // SNI
+
+        if (SSL_connect(ssl) != 1) {
+            unsigned long err = ERR_get_error();
+            char errBuf[256];
+            ERR_error_string_n(err, errBuf, sizeof(errBuf));
+            strError = "TLS handshake failed with " + hostname + ": " + errBuf;
+            return false;
+        }
+        return true;
+    }
+};
+
+// Parse host, port, and path from an absolute URL.
+// Sets useSSL, host, port, path. Returns false for unsupported schemes.
+static bool ParseAbsoluteUrl(const std::string& url,
+                              bool& useSSL, std::string& host,
+                              int& port, std::string& path)
+{
+    if (url.compare(0, 8, "https://") == 0) {
+        useSSL = true;
+        std::string rest = url.substr(8);
+        size_t pathStart = rest.find('/');
+        if (pathStart != std::string::npos) {
+            host = rest.substr(0, pathStart);
+            path = rest.substr(pathStart);
+        } else {
+            host = rest;
+            path = "/";
+        }
+        size_t colonPos = host.find(':');
+        if (colonPos != std::string::npos) {
+            port = std::atoi(host.c_str() + colonPos + 1);
+            host = host.substr(0, colonPos);
+        } else {
+            port = 443;
+        }
+        return true;
+    } else if (url.compare(0, 7, "http://") == 0) {
+        useSSL = false;
+        std::string rest = url.substr(7);
+        size_t pathStart = rest.find('/');
+        if (pathStart != std::string::npos) {
+            host = rest.substr(0, pathStart);
+            path = rest.substr(pathStart);
+        } else {
+            host = rest;
+            path = "/";
+        }
+        size_t colonPos = host.find(':');
+        if (colonPos != std::string::npos) {
+            port = std::atoi(host.c_str() + colonPos + 1);
+            host = host.substr(0, colonPos);
+        } else {
+            port = 80;
+        }
+        return true;
+    }
+    return false;
+}
+
+bool DownloadFile(const std::string& host, const std::string& urlPath,
+                  const fs::path& destPath,
+                  ProgressCallback progressFn,
+                  std::string& strError,
+                  bool noProxy,
+                  int portOverride)
+{
+    try {
+        std::string currentHost = host;
+        std::string currentPath = urlPath;
+        int currentPort = (portOverride > 0) ? portOverride : PORT;
+        bool useSSL = false;
+        std::string headerData;
+        int redirectCount = 0;
+        const int MAX_REDIRECTS = 5;
+
+        HttpConn conn;
+
+        // Connection + redirect loop
+        while (true) {
+            conn.Close(); // clean slate for each attempt
+
+            if (noProxy) {
+                conn.sock = ConnectDirectTCP(currentHost, currentPort, strError);
+                if (conn.sock == INVALID_SOCKET)
+                    return false;
+            } else {
+                CService addr;
+                if (!ConnectSocketByName(addr, conn.sock, currentHost.c_str(), currentPort, 30)) {
+                    strError = "Cannot connect to " + currentHost + " (check Tor proxy)";
+                    return false;
+                }
+            }
+
+            // Establish TLS when needed
+            if (useSSL) {
+                if (!conn.StartTLS(currentHost, strError))
+                    return false;
+                printf("Bootstrap: TLS established with %s:%d\n",
+                       currentHost.c_str(), currentPort);
+            }
+
+            // Send HTTP GET request
+            std::string request =
+                "GET " + currentPath + " HTTP/1.1\r\n"
+                "Host: " + currentHost + "\r\n"
+                "Connection: close\r\n"
+                "User-Agent: Triangles\r\n"
+                "\r\n";
+
+            if (!conn.Send(request.data(), request.size())) {
+                strError = "Failed to send request to " + currentHost;
+                return false;
+            }
+
+            // Read response headers
+            if (!conn.RecvUntil(headerData, "\r\n\r\n")) {
+                strError = "Failed to read HTTP headers from " + currentHost;
+                return false;
+            }
+
+            // Parse status code from "HTTP/1.x NNN ..."
+            unsigned int status_code = 0;
+            size_t sp = headerData.find(' ');
+            if (sp != std::string::npos)
+                status_code = atoi(headerData.c_str() + sp + 1);
+
+            // Handle HTTP redirects
+            if (status_code == 301 || status_code == 302 ||
+                status_code == 307 || status_code == 308) {
+
+                if (++redirectCount > MAX_REDIRECTS) {
+                    strError = "Too many redirects for " + urlPath;
+                    return false;
+                }
+
+                // Find Location header (case-insensitive)
+                std::string lowerHdr = headerData;
+                std::transform(lowerHdr.begin(), lowerHdr.end(),
+                               lowerHdr.begin(), ::tolower);
+                size_t locPos = lowerHdr.find("\nlocation:");
+                if (locPos == std::string::npos) {
+                    strError = "Redirect " + std::to_string(status_code) + " without Location header";
+                    return false;
+                }
+
+                size_t valStart = locPos + 10; // skip "\nlocation:"
+                while (valStart < headerData.size() && headerData[valStart] == ' ')
+                    valStart++;
+                size_t lineEnd = headerData.find("\r\n", valStart);
+                std::string location;
+                if (lineEnd != std::string::npos)
+                    location = headerData.substr(valStart, lineEnd - valStart);
+                else
+                    location = headerData.substr(valStart);
+                location = TrimString(location);
+
+                // Parse redirect URL — supports http://, https://, and relative paths
+                if (location.compare(0, 7, "http://") == 0 ||
+                    location.compare(0, 8, "https://") == 0) {
+                    if (!ParseAbsoluteUrl(location, useSSL, currentHost,
+                                          currentPort, currentPath)) {
+                        strError = "Unsupported redirect location: " + location;
+                        return false;
+                    }
+                } else if (!location.empty() && location[0] == '/') {
+                    currentPath = location;
+                } else {
+                    strError = "Unsupported redirect location: " + location;
+                    return false;
+                }
+
+                printf("Bootstrap: redirect %d -> %s%s%s (port %d)\n",
+                       status_code, useSSL ? "https://" : "http://",
+                       currentHost.c_str(), currentPath.c_str(), currentPort);
+                continue;
+            }
+
+            if (status_code != 200) {
+                strError = "HTTP error " + std::to_string(status_code) + " for " + currentPath;
+                return false;
+            }
+
+            break; // Got 200, proceed to download
+        }
+
+        // Parse Content-Length
+        int64_t content_length = 0;
+        std::string lowerHeaders = headerData;
+        std::transform(lowerHeaders.begin(), lowerHeaders.end(),
+                       lowerHeaders.begin(), ::tolower);
+        size_t clPos = lowerHeaders.find("content-length:");
+        if (clPos != std::string::npos) {
+            size_t valStart = clPos + 15;
+            size_t lineEnd = lowerHeaders.find("\r\n", valStart);
+            if (lineEnd != std::string::npos)
+                content_length = std::stoll(headerData.substr(valStart, lineEnd - valStart));
+        }
+
+        // Open output file
+        FILE* file = fopen(destPath.string().c_str(), "wb");
+        if (!file) {
+            strError = "Cannot create file: " + destPath.string();
+            return false;
+        }
+
+        // Read body in chunks
+        int64_t bytes_written = 0;
+        int64_t last_progress = 0;
+        char chunk[65536];
+
+        while (true) {
+            int n = conn.Recv(chunk, sizeof(chunk));
+            if (n < 0) {
+                fclose(file);
+                fs::remove(destPath);
+                strError = "Network error during download";
+                return false;
+            }
+            if (n == 0) break; // EOF
+
+            fwrite(chunk, 1, n, file);
+            bytes_written += n;
+
+            if (progressFn && (bytes_written - last_progress >= 262144)) {
+                last_progress = bytes_written;
+                progressFn(bytes_written, content_length);
+            }
+        }
+
+        fclose(file);
+        // conn destructor handles socket + SSL cleanup
+
+        // Verify download size if Content-Length was provided
+        if (content_length > 0 && bytes_written != content_length) {
+            fs::remove(destPath);
+            strError = "Incomplete download: got " + std::to_string(bytes_written)
+                     + " of " + std::to_string(content_length) + " bytes";
+            return false;
+        }
+
+        return true;
+
+    } catch (std::exception& e) {
+        strError = std::string("Download failed: ") + e.what();
+        return false;
+    }
+}
+
+bool FetchFileList(const std::string& host,
+                   std::vector<std::string>& files,
+                   std::string& strError,
+                   bool noProxy)
+{
+    // Download filelist.txt to a temp file
+    fs::path tmpPath = fs::temp_directory_path() / "triangles_bootstrap_filelist.txt";
+
+    std::string urlPath = std::string(BASE_PATH) + "filelist.txt";
+    if (!DownloadFile(host, urlPath, tmpPath, nullptr, strError, noProxy))
+        return false;
+
+    // Read lines
+    std::ifstream in(tmpPath.string().c_str());
+    if (!in.is_open()) {
+        strError = "Cannot read downloaded file list";
+        return false;
+    }
+
+    files.clear();
+    std::string line;
+    while (std::getline(in, line)) {
+        line = TrimString(line);
+        if (!line.empty() && line[0] != '#')
+            files.push_back(line);
+    }
+    in.close();
+    fs::remove(tmpPath);
+
+    if (files.empty()) {
+        strError = "File list is empty";
+        return false;
+    }
+
+    return true;
+}
+
+// --- tar.gz bootstrap support ---
+
+namespace {
+
+// Parse a tar octal field (ASCII octal, null/space terminated)
+static int64_t ParseTarOctal(const char* field, size_t len)
+{
+    int64_t result = 0;
+    for (size_t i = 0; i < len && field[i] != '\0' && field[i] != ' '; i++) {
+        if (field[i] < '0' || field[i] > '7') continue;
+        result = (result << 3) | (field[i] - '0');
+    }
+    return result;
+}
+
+// Extract a tar.gz file to a destination directory
+static bool ExtractTarGz(const fs::path& tarGzPath,
+                          const fs::path& destDir,
+                          std::string& strError)
+{
+    gzFile gz = gzopen(tarGzPath.string().c_str(), "rb");
+    if (!gz) {
+        strError = "Cannot open " + tarGzPath.string();
+        return false;
+    }
+
+    gzbuffer(gz, 262144); // 256 KB buffer for performance
+
+    char header[512];
+
+    while (true) {
+        int bytesRead = gzread(gz, header, 512);
+        if (bytesRead == 0) break; // EOF
+        if (bytesRead != 512) {
+            strError = "Truncated tar header";
+            gzclose(gz);
+            return false;
+        }
+
+        // End-of-archive marker (zero block)
+        bool allZero = true;
+        for (int i = 0; i < 512; i++) {
+            if (header[i] != 0) { allZero = false; break; }
+        }
+        if (allZero) break;
+
+        // Parse filename: name (offset 0, 100 bytes) + optional prefix (offset 345, 155 bytes)
+        char name[101] = {0};
+        char prefix[156] = {0};
+        memcpy(name, header, 100);
+        memcpy(prefix, header + 345, 155);
+
+        std::string fullName;
+        if (prefix[0] != '\0')
+            fullName = std::string(prefix) + "/" + std::string(name);
+        else
+            fullName = std::string(name);
+
+        // Security: reject absolute paths and path traversal
+        if (fullName.empty() || fullName[0] == '/' || fullName.find("..") != std::string::npos) {
+            strError = "Unsafe path in tar archive: " + fullName;
+            gzclose(gz);
+            return false;
+        }
+
+        char typeflag = header[156];
+        int64_t fileSize = ParseTarOctal(header + 124, 12);
+
+        if (typeflag == '5' || (!fullName.empty() && fullName.back() == '/')) {
+            // Directory entry
+            fs::create_directories(destDir / fullName);
+        } else if (typeflag == '0' || typeflag == '\0') {
+            // Regular file
+            fs::path filePath = destDir / fullName;
+            fs::create_directories(filePath.parent_path());
+
+            FILE* outFile = fopen(filePath.string().c_str(), "wb");
+            if (!outFile) {
+                strError = "Cannot create file: " + filePath.string();
+                gzclose(gz);
+                return false;
+            }
+
+            int64_t remaining = fileSize;
+            char buf[65536];
+            while (remaining > 0) {
+                int toRead = (remaining > (int64_t)sizeof(buf)) ? (int)sizeof(buf) : (int)remaining;
+                int n = gzread(gz, buf, toRead);
+                if (n <= 0) {
+                    fclose(outFile);
+                    strError = "Truncated tar data for: " + fullName;
+                    gzclose(gz);
+                    return false;
+                }
+                fwrite(buf, 1, n, outFile);
+                remaining -= n;
+            }
+            fclose(outFile);
+
+            // Skip padding to next 512-byte boundary
+            int64_t pad = (512 - (fileSize % 512)) % 512;
+            if (pad > 0) {
+                char padBuf[512];
+                if (gzread(gz, padBuf, (unsigned)pad) != (int)pad) {
+                    strError = "Truncated tar padding for: " + fullName;
+                    gzclose(gz);
+                    return false;
+                }
+            }
+        } else {
+            // Unknown entry type - skip its data
+            int64_t totalSkip = fileSize + ((512 - (fileSize % 512)) % 512);
+            char skipBuf[512];
+            while (totalSkip > 0) {
+                int toRead = (totalSkip > 512) ? 512 : (int)totalSkip;
+                if (gzread(gz, skipBuf, toRead) != toRead) break;
+                totalSkip -= toRead;
+            }
+        }
+    }
+
+    gzclose(gz);
+    return true;
+}
+
+} // anonymous namespace
+
+bool ParseManifest(const fs::path& manifestPath,
+                   SnapshotManifest& manifest,
+                   std::string& strError)
+{
+    std::ifstream in(manifestPath.string().c_str());
+    if (!in.is_open()) {
+        strError = "Cannot open " + manifestPath.string();
+        return false;
+    }
+
+    manifest.format = 0;
+    manifest.network.clear();
+    manifest.height = -1;
+    manifest.hash.clear();
+    manifest.dbversion = 0;
+
+    std::string line;
+    while (std::getline(in, line)) {
+        line = TrimString(line);
+        if (line.empty() || line[0] == '#')
+            continue;
+
+        size_t eq = line.find('=');
+        if (eq == std::string::npos)
+            continue;
+
+        std::string key = line.substr(0, eq);
+        std::string val = line.substr(eq + 1);
+        key = TrimString(key);
+        val = TrimString(val);
+
+        if (key == "format")
+            manifest.format = std::atoi(val.c_str());
+        else if (key == "network")
+            manifest.network = val;
+        else if (key == "height")
+            manifest.height = std::atoi(val.c_str());
+        else if (key == "hash")
+            manifest.hash = val;
+        else if (key == "dbversion")
+            manifest.dbversion = std::atoi(val.c_str());
+    }
+    in.close();
+
+    if (manifest.format == 0) {
+        strError = "Manifest missing 'format' field";
+        return false;
+    }
+    if (manifest.network.empty()) {
+        strError = "Manifest missing 'network' field";
+        return false;
+    }
+    if (manifest.height < 0) {
+        strError = "Manifest missing or invalid 'height' field";
+        return false;
+    }
+    if (manifest.hash.empty()) {
+        strError = "Manifest missing 'hash' field";
+        return false;
+    }
+    if (manifest.dbversion == 0) {
+        strError = "Manifest missing 'dbversion' field";
+        return false;
+    }
+
+    return true;
+}
+
+bool VerifyManifest(const SnapshotManifest& manifest,
+                    std::string& strError)
+{
+    if (manifest.format != 1) {
+        strError = "Unsupported manifest format: " + std::to_string(manifest.format);
+        return false;
+    }
+
+    std::string expectedNetwork = fTestNet ? "test" : "main";
+    if (manifest.network != expectedNetwork) {
+        strError = "Network mismatch: manifest says '" + manifest.network
+                 + "', expected '" + expectedNetwork + "'";
+        return false;
+    }
+
+    if (manifest.dbversion != DATABASE_VERSION) {
+        strError = "DB version mismatch: manifest says "
+                 + std::to_string(manifest.dbversion)
+                 + ", binary expects " + std::to_string(DATABASE_VERSION);
+        return false;
+    }
+
+    uint256 manifestHash(manifest.hash);
+    if (manifestHash == 0) {
+        strError = "Invalid hash in manifest: " + manifest.hash;
+        return false;
+    }
+
+    if (!Checkpoints::IsKnownCheckpoint(manifest.height, manifestHash)) {
+        strError = "Height " + std::to_string(manifest.height)
+                 + " / hash " + manifest.hash
+                 + " is not a known checkpoint";
+        return false;
+    }
+
+    return true;
+}
+
+bool DownloadBootstrap(const std::string& host,
+                       const fs::path& dataDir,
+                       ProgressCallback progressFn,
+                       std::string& strError)
+{
+    bool gotBlockFile = false;
+
+    // Try downloading bootstrap.tar.gz first
+    // Bootstrap server is on clearnet — bypass Tor proxy for DNS + HTTP
+    const bool noProxy = true;
+    fs::path tmpTarGz = dataDir / "bootstrap.tar.gz.tmp";
+    std::string tarUrl = std::string(BASE_PATH) + "triangles-bootstrap.tar.gz";
+
+    printf("DownloadBootstrap(): attempting tar.gz download from %s%s\n", host.c_str(), tarUrl.c_str());
+    bool tarDownloaded = DownloadFile(host, tarUrl, tmpTarGz, progressFn, strError, noProxy);
+    printf("DownloadBootstrap(): tarDownloaded=%d result=%s\n", tarDownloaded, strError.c_str());
+
+    if (tarDownloaded) {
+        bool extractOk = ExtractTarGz(tmpTarGz, dataDir, strError);
+        fs::remove(tmpTarGz);
+
+        if (extractOk && fs::exists(dataDir / "blk0001.dat"))
+            gotBlockFile = true;
+        // If extraction failed, fall through to legacy path
+    }
+
+    if (!gotBlockFile) {
+        // Fallback: try filelist.txt + individual file downloads
+        std::string fallbackError;
+        std::vector<std::string> files;
+        if (!FetchFileList(host, files, fallbackError, noProxy)) {
+            if (!tarDownloaded)
+                strError = strError + " (fallback also failed: " + fallbackError + ")";
+            else
+                strError = "Extraction failed: " + strError + " (fallback also failed: " + fallbackError + ")";
+            return false;
+        }
+
+        for (size_t i = 0; i < files.size(); i++) {
+            fs::path destPath = dataDir / files[i];
+            fs::create_directories(destPath.parent_path());
+
+            std::string urlPath = std::string(BASE_PATH) + files[i];
+            if (!DownloadFile(host, urlPath, destPath, progressFn, strError, noProxy))
+                return false;
+        }
+
+        gotBlockFile = fs::exists(dataDir / "blk0001.dat");
+    }
+
+    if (!gotBlockFile) {
+        strError = "No blk0001.dat after download";
+        return false;
+    }
+
+    // Check if the archive included a trusted pre-built index for the active
+    // backend with a valid snapshot.manifest. If verified, keep it to skip the
+    // multi-hour FastImportBlockFile() rebuild.
+    fs::path chainDbPath = GetChainDataDir();
+    fs::path database  = dataDir / "database";
+    fs::path manifestPath = dataDir / "snapshot.manifest";
+
+    bool keepIndex = false;
+
+    if (fs::exists(manifestPath) && fs::exists(chainDbPath)) {
+        SnapshotManifest manifest;
+        std::string manifestError;
+
+        if (ParseManifest(manifestPath, manifest, manifestError)) {
+            printf("Bootstrap: snapshot.manifest found (format=%d, network=%s, "
+                   "height=%d, dbversion=%d)\n",
+                   manifest.format, manifest.network.c_str(),
+                   manifest.height, manifest.dbversion);
+
+            if (VerifyManifest(manifest, manifestError)) {
+                printf("Bootstrap: manifest verified - keeping pre-built index "
+                       "(height %d, checkpoint match)\n", manifest.height);
+                keepIndex = true;
+            } else {
+                printf("Bootstrap: manifest verification failed: %s\n",
+                       manifestError.c_str());
+            }
+        } else {
+            printf("Bootstrap: cannot parse snapshot.manifest: %s\n",
+                   manifestError.c_str());
+        }
+    }
+
+    if (!keepIndex) {
+        // No valid manifest or verification failed - delete the index.
+        // FastImportBlockFile() will rebuild from blk0001.dat on next startup.
+        printf("Bootstrap: removing extracted %s/ (will rebuild index from blk0001.dat)\n",
+               GetChainDataDir().filename().string().c_str());
+        if (fs::exists(chainDbPath))
+            fs::remove_all(chainDbPath);
+    }
+
+    // Always remove BDB database/ dir (wallet environment from another machine)
+    if (fs::exists(database))
+        fs::remove_all(database);
+
+    // Clean up manifest file (not needed after verification)
+    if (fs::exists(manifestPath))
+        fs::remove(manifestPath);
+
+    return true;
+}
+
+bool DownloadUtxoSnapshot(const std::string& host,
+                          const fs::path& dataDir,
+                          ProgressCallback progressFn,
+                          std::string& strError)
+{
+    const bool noProxy = true;
+    const char* snapshotFilename = "utxo-snapshot.bin";
+
+    // Download utxo-snapshot.bin to a temp file
+    fs::path tmpPath = dataDir / "utxo-snapshot.bin.tmp";
+    std::string urlPath = std::string(BASE_PATH) + snapshotFilename;
+
+    printf("Bootstrap: downloading UTXO snapshot from %s%s...\n", host.c_str(), urlPath.c_str());
+
+    if (!DownloadFile(host, urlPath, tmpPath, progressFn, strError, noProxy)) {
+        fs::remove(tmpPath);
+        return false;
+    }
+
+    printf("Bootstrap: UTXO snapshot downloaded, loading into database...\n");
+
+    // Load the snapshot into a fresh active chain DB
+    if (!UtxoSnapshot::LoadSnapshot(tmpPath, dataDir, strError)) {
+        fs::remove(tmpPath);
+        return false;
+    }
+
+    // Clean up the temp file
+    fs::remove(tmpPath);
+
+    printf("Bootstrap: UTXO snapshot loaded successfully.\n");
+    return true;
+}
+
+} // namespace Bootstrap
@@ -0,0 +1,77 @@
+// Copyright (c) 2024 Triangles developers
+// Distributed under the MIT/X11 software license
+
+#ifndef TRIANGLES_BOOTSTRAP_H
+#define TRIANGLES_BOOTSTRAP_H
+
+#include <string>
+#include <vector>
+#include <functional>
+#include <filesystem>
+
+namespace Bootstrap {
+
+    // Bootstrap server configuration
+    static const char* DEFAULT_HOST = "bootstrap.cryptographic-triangles.org";
+    static const char* BASE_PATH = "/";
+    static const int PORT = 80;
+
+    // Progress callback: (bytesDownloaded, totalBytes)
+    typedef std::function<void(int64_t, int64_t)> ProgressCallback;
+
+    // Check if data dir already has blockchain data
+    bool NeedsBootstrap(const std::filesystem::path& dataDir);
+
+    // Download a single file via HTTP GET, write to destPath.
+    // If noProxy is true, bypass Tor SOCKS proxy and connect directly
+    // (used for clearnet bootstrap downloads).
+    // If portOverride is set (>0), uses that port instead of the default PORT.
+    bool DownloadFile(const std::string& host, const std::string& urlPath,
+                      const std::filesystem::path& destPath,
+                      ProgressCallback progressFn,
+                      std::string& strError,
+                      bool noProxy = false,
+                      int portOverride = -1);
+
+    // Fetch the file manifest (list of relative paths to download)
+    bool FetchFileList(const std::string& host,
+                       std::vector<std::string>& files,
+                       std::string& strError,
+                       bool noProxy = false);
+
+    // Download bootstrap.tar.gz and extract to dataDir.
+    // Falls back to filelist.txt + individual file download if tar.gz unavailable.
+    bool DownloadBootstrap(const std::string& host,
+                           const std::filesystem::path& dataDir,
+                           ProgressCallback progressFn,
+                           std::string& strError);
+
+    // Snapshot manifest (parsed from snapshot.manifest in bootstrap archive)
+    struct SnapshotManifest {
+        int format;            // format version, must be 1
+        std::string network;   // "main" or "test"
+        int height;            // block height of the snapshot tip
+        std::string hash;      // block hash at that height (hex, no 0x prefix)
+        int dbversion;         // DATABASE_VERSION the txleveldb was built with
+    };
+
+    // Parse a snapshot.manifest file into a SnapshotManifest struct.
+    bool ParseManifest(const std::filesystem::path& manifestPath,
+                       SnapshotManifest& manifest,
+                       std::string& strError);
+
+    // Verify a parsed manifest against compiled-in checkpoints and config.
+    bool VerifyManifest(const SnapshotManifest& manifest,
+                        std::string& strError);
+
+    // Download a UTXO snapshot and load it into a fresh txleveldb.
+    // This is much faster than downloading the full bootstrap archive.
+    // Returns true if snapshot was downloaded and loaded successfully.
+    bool DownloadUtxoSnapshot(const std::string& host,
+                              const std::filesystem::path& dataDir,
+                              ProgressCallback progressFn,
+                              std::string& strError);
+
+} // namespace Bootstrap
+
+#endif // TRIANGLES_BOOTSTRAP_H
@@ -0,0 +1,198 @@
+// Copyright (c) 2026 The Triangles developers.
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "chaindb_migrate.h"
+
+#include "txdb-leveldb.h"
+#include "txdb-rocksdb.h"
+#include "util.h"
+
+#include <filesystem>
+#include <fstream>
+#include <memory>
+
+namespace fs = std::filesystem;
+
+namespace {
+
+struct ChainDbStats
+{
+    int64_t nRecords = 0;
+    int64_t nUtxos = 0;
+    int64_t nUtxoValue = 0;
+    uint256 hashBestChain = 0;
+    int nDbFormat = 0;
+};
+
+bool CollectStats(CTxDBBase& db, ChainDbStats& stats, std::string& strError)
+{
+    stats = ChainDbStats();
+
+    auto it = db.NewIterator();
+    for (it->Seek(std::string()); it->Valid(); it->Next())
+        stats.nRecords++;
+
+    int nUtxos = 0;
+    stats.nUtxoValue = db.SumUtxoValues(nUtxos);
+    stats.nUtxos = nUtxos;
+    db.ReadHashBestChain(stats.hashBestChain);
+    db.ReadDbFormat(stats.nDbFormat);
+
+    if (stats.nRecords <= 0) {
+        strError = "source chain database contains no records";
+        return false;
+    }
+    return true;
+}
+
+bool StatsMatch(const ChainDbStats& src, const ChainDbStats& dst, std::string& strError)
+{
+    if (src.nRecords != dst.nRecords) {
+        strError = strprintf("record count mismatch after migration: source=%lld rocksdb=%lld",
+                             (long long)src.nRecords, (long long)dst.nRecords);
+        return false;
+    }
+    if (src.nUtxos != dst.nUtxos || src.nUtxoValue != dst.nUtxoValue) {
+        strError = strprintf("UTXO mismatch after migration: source=(%lld,%lld) rocksdb=(%lld,%lld)",
+                             (long long)src.nUtxos, (long long)src.nUtxoValue,
+                             (long long)dst.nUtxos, (long long)dst.nUtxoValue);
+        return false;
+    }
+    if (src.hashBestChain != dst.hashBestChain) {
+        strError = strprintf("best-chain hash mismatch after migration: source=%s rocksdb=%s",
+                             src.hashBestChain.ToString().c_str(),
+                             dst.hashBestChain.ToString().c_str());
+        return false;
+    }
+    if (src.nDbFormat != dst.nDbFormat) {
+        strError = strprintf("dbformat mismatch after migration: source=%d rocksdb=%d",
+                             src.nDbFormat, dst.nDbFormat);
+        return false;
+    }
+    return true;
+}
+
+} // namespace
+
+bool MaybeMigrateLevelDbToRocksDb(bool fForce, std::string& strError)
+{
+    strError.clear();
+
+    const fs::path dataDir = GetDataDir();
+    const fs::path levelPath = dataDir / "txleveldb";
+    const fs::path rocksPath = dataDir / "rocksdb";
+    const fs::path markerPath = rocksPath / "MIGRATION_INCOMPLETE";
+
+    if (!fs::exists(levelPath))
+        return true;
+
+    if (fs::exists(rocksPath)) {
+        if (fs::exists(markerPath)) {
+            printf("ChainDB migration: removing incomplete previous RocksDB migration\n");
+            fs::remove_all(rocksPath);
+        }
+        else if (!fForce)
+            return true;
+        else {
+            printf("ChainDB migration: removing existing RocksDB directory due to -migratechaindbforce\n");
+            fs::remove_all(rocksPath);
+        }
+    }
+
+    printf("ChainDB migration: copying LevelDB chain state to RocksDB...\n");
+    printf("ChainDB migration: source=%s destination=%s\n",
+           levelPath.string().c_str(), rocksPath.string().c_str());
+
+    try {
+        fs::create_directories(rocksPath);
+        {
+            std::ofstream marker(markerPath);
+            marker << "RocksDB migration in progress. Safe to delete this directory and retry.\n";
+        }
+
+        CTxDB source("r");
+        CRocksTxDB destination("c+");
+
+        ChainDbStats srcStats;
+        if (!CollectStats(source, srcStats, strError)) {
+            source.Close();
+            destination.Close();
+            return false;
+        }
+
+        if (!destination.TxnBegin()) {
+            strError = "failed to begin RocksDB migration batch";
+            source.Close();
+            destination.Close();
+            return false;
+        }
+
+        int64_t nCopied = 0;
+        auto it = source.NewIterator();
+        for (it->Seek(std::string()); it->Valid(); it->Next())
+        {
+            if (!destination.WriteRawRecordForMigration(it->KeyStr(), it->ValueStr())) {
+                destination.TxnAbort();
+                strError = "failed to write migrated record to RocksDB";
+                source.Close();
+                destination.Close();
+                return false;
+            }
+
+            if (++nCopied % 100000 == 0)
+            {
+                if (!destination.TxnCommit()) {
+                    strError = "failed to commit RocksDB migration batch";
+                    source.Close();
+                    destination.Close();
+                    return false;
+                }
+                printf("ChainDB migration: copied %lld / %lld records\n",
+                       (long long)nCopied, (long long)srcStats.nRecords);
+                if (!destination.TxnBegin()) {
+                    strError = "failed to begin RocksDB migration batch";
+                    source.Close();
+                    destination.Close();
+                    return false;
+                }
+            }
+        }
+
+        if (!destination.TxnCommit()) {
+            strError = "failed to commit final RocksDB migration batch";
+            source.Close();
+            destination.Close();
+            return false;
+        }
+
+        ChainDbStats dstStats;
+        if (!CollectStats(destination, dstStats, strError)) {
+            source.Close();
+            destination.Close();
+            return false;
+        }
+        if (!StatsMatch(srcStats, dstStats, strError)) {
+            source.Close();
+            destination.Close();
+            return false;
+        }
+
+        printf("ChainDB migration: verified %lld records, %lld UTXOs, best=%s\n",
+               (long long)dstStats.nRecords,
+               (long long)dstStats.nUtxos,
+               dstStats.hashBestChain.ToString().substr(0,20).c_str());
+
+        source.Close();
+        destination.Close();
+        fs::remove(markerPath);
+    }
+    catch (std::exception& e) {
+        strError = e.what();
+        return false;
+    }
+
+    printf("ChainDB migration: complete. Legacy LevelDB was left untouched at %s\n",
+           levelPath.string().c_str());
+    return true;
+}
@@ -0,0 +1,14 @@
+// Copyright (c) 2026 The Triangles developers.
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+#ifndef TRIANGLES_CHAINDB_MIGRATE_H
+#define TRIANGLES_CHAINDB_MIGRATE_H
+
+#include <string>
+
+// Migrate legacy LevelDB chain state from <datadir>/txleveldb to RocksDB in
+// <datadir>/rocksdb. The source is never modified. Returns true when migration
+// succeeds or when there is nothing to migrate.
+bool MaybeMigrateLevelDbToRocksDb(bool fForce, std::string& strError);
+
+#endif // TRIANGLES_CHAINDB_MIGRATE_H
@@ -2,9 +2,6 @@
 // Distributed under the MIT/X11 software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.

-#include <boost/assign/list_of.hpp> // for 'map_list_of()'
-#include <boost/foreach.hpp>
-
 #include "checkpoints.h"

 #include "txdb.h"
@@ -22,39 +19,49 @@ namespace Checkpoints
    //    timestamp before)
    // + Contains no strange transactions
    //
-    static MapCheckpoints mapCheckpoints =
-        boost::assign::map_list_of
-    (     0, hashGenesisBlockOfficial )
-    (  2000, uint256("0x0000000000b5f20078bf46ebdf1500813bb6b2cb482065aa93b89e073b2c6467"))
-    (  2101, uint256("0xd4ea1ac45b63c8162a7fc8033cec441db8d532ba988202849d7831e32fe2d059"))
-    (  2847, uint256("0xb5015e2835f13fd3bb6135cff9b31ac33310c9b77d694bdb592b8680d98d018e"))
-    (  3589, uint256("0xb12a2ca3db4e288cada98aa2139768532bd4474c49dd7b8158031032dac08d51"))
-    (  3935, uint256("0xe16290c9757d1368b8d7c35de07d4f8f70c2c9f9c785b667df0c3bff85086ca6"))
-    (  5703, uint256("0x587db07bb2172ad7db72c5fabc2518262a1b27f503f99417510b2c6fafa6557b"))
-    (  9000, uint256("0x00000000019ef6b2f5e7c324c7d083ee94502305aabc7e9cd73a7fb2a57bb8db"))
-    (  9001, uint256("0x6d5c6c5f201cc9e59659ee0da30d1430dc6bf3b12a8ff4c3864ab8d6286b0007"))
-    (  9002, uint256("0xa1e20fb1d44688b763690cf74d6aefe859e4cc32981f9e3f2b2ae9702bbcf249"))
-    ( 10881, uint256("0x4b6554c45e1e6764a6f3c309c47baf53c9edd81f624e52b072518cd15da237e6"))
-	  ( 17650, uint256("0x224940e1f986a202209b8e762728d1452ab45870c308abf84905674acf326a47"))
-    (2186940, uint256("0xbd952e8d4a612e336d840ad924a7e09395e36bcd9d929b302e47e60b5c3098c0"))
-            ;
+    static MapCheckpoints mapCheckpoints = {
+        {     0, hashGenesisBlockOfficial },
+        {  2000, uint256("0x0000000000b5f20078bf46ebdf1500813bb6b2cb482065aa93b89e073b2c6467")},
+        {  2101, uint256("0xd4ea1ac45b63c8162a7fc8033cec441db8d532ba988202849d7831e32fe2d059")},
+        {  2847, uint256("0xb5015e2835f13fd3bb6135cff9b31ac33310c9b77d694bdb592b8680d98d018e")},
+        {  3589, uint256("0xb12a2ca3db4e288cada98aa2139768532bd4474c49dd7b8158031032dac08d51")},
+        {  3935, uint256("0xe16290c9757d1368b8d7c35de4f8f70c2c9f9c785b667df0c3bff85086ca6")},
+        {  5703, uint256("0x587db07bb2172ad7db72c5fabc2518262a1b27f503f99417510b2c6fafa6557b")},
+        {  9000, uint256("0x00000000019ef6b2f5e7c324c7d083ee94502305aabc7e9cd73a7fb2a57bb8db")},
+        {  9001, uint256("0x6d5c6c5f201cc9e59659ee0da30d1430dc6bf3b12a8ff4c3864ab8d6286b0007")},
+        {  9002, uint256("0xa1e20fb1d44688b763690cf74d6aefe859e4cc32981f9e3f2b2ae9702bbcf249")},
+        { 10881, uint256("0x4b6554c45e1e6764a6f3c309c47baf53c9edd81f624e52b072518cd15da237e6")},
+        { 17650, uint256("0x224940e1f986a202209b8e762728d1452ab45870c308abf84905674acf326a47")},
+    };

-    static MapCheckpoints mapCheckpointsTestnet =
-        boost::assign::map_list_of
-    (     0, hashGenesisBlockTestNet )
-    (  2000, uint256("0x0000000000b5f20078bf46ebdf1500813bb6b2cb482065aa93b89e073b2c6467"))
-    (  2101, uint256("0xd4ea1ac45b63c8162a7fc8033cec441db8d532ba988202849d7831e32fe2d059"))
-    (  2847, uint256("0xb5015e2835f13fd3bb6135cff9b31ac33310c9b77d694bdb592b8680d98d018e"))
-    (  3589, uint256("0xb12a2ca3db4e288cada98aa2139768532bd4474c49dd7b8158031032dac08d51"))
-    (  3935, uint256("0xe16290c9757d1368b8d7c35de07d4f8f70c2c9f9c785b667df0c3bff85086ca6"))
-    (  5703, uint256("0x587db07bb2172ad7db72c5fabc2518262a1b27f503f99417510b2c6fafa6557b"))
-    (  9000, uint256("0x00000000019ef6b2f5e7c324c7d083ee94502305aabc7e9cd73a7fb2a57bb8db"))
-    (  9001, uint256("0x6d5c6c5f201cc9e59659ee0da30d1430dc6bf3b12a8ff4c3864ab8d6286b0007"))
-    (  9002, uint256("0xa1e20fb1d44688b763690cf74d6aefe859e4cc32981f9e3f2b2ae9702bbcf249"))
-    ( 10881, uint256("0x4b6554c45e1e6764a6f3c309c47baf53c9edd81f624e52b072518cd15da237e6"))
-	  ( 17650, uint256("0x224940e1f986a202209b8e762728d1452ab45870c308abf84905674acf326a47"))
-    (2186940, uint256("0xbd952e8d4a612e336d840ad924a7e09395e36bcd9d929b302e47e60b5c3098c0"))
-            ;
+    // Published UTXO snapshot file SHA256, keyed by snapshot height.
+    // Each entry binds height -> SHA256 of the canonical snapshot file produced by
+    // UtxoSnapshot::DumpSnapshot at that height. Used by SnapshotNet to verify
+    // P2P-delivered snapshots without trusting any peer.
+    //
+    // Maintainers: after producing a snapshot, sha256 the file and add an entry
+    // here. The corresponding (height, blockhash) must already exist in
+    // mapCheckpoints / mapCheckpointsTestnet.
+    static std::map<int, uint256> mapSnapshotHashes = {
+    };
+
+    static std::map<int, uint256> mapSnapshotHashesTestnet = {
+    };
+
+    static MapCheckpoints mapCheckpointsTestnet = {
+        {     0, hashGenesisBlockTestNet },
+        {  2000, uint256("0x0000000000b5f20078bf46ebdf1500813bb6b2cb482065aa93b89e073b2c6467")},
+        {  2101, uint256("0xd4ea1ac45b63c8162a7fc8033cec441db8d532ba988202849d7831e32fe2d059")},
+        {  2847, uint256("0xb5015e2835f13fd3bb6135cff9b31ac33310c9b77d694bdb592b8680d98d018e")},
+        {  3589, uint256("0xb12a2ca3db4e288cada98aa2139768532bd4474c49dd7b8158031032dac08d51")},
+        {  3935, uint256("0xe16290c9757d1368b8d7c35de4f8f70c2c9f9c785b667df0c3bff85086ca6")},
+        {  5703, uint256("0x587db07bb2172ad7db72c5fabc2518262a1b27f503f99417510b2c6fafa6557b")},
+        {  9000, uint256("0x00000000019ef6b2f5e7c324c7d083ee94502305aabc7e9cd73a7fb2a57bb8db")},
+        {  9001, uint256("0x6d5c6c5f201cc9e59659ee0da30d1430dc6bf3b12a8ff4c3864ab8d6286b0007")},
+        {  9002, uint256("0xa1e20fb1d44688b763690cf74d6aefe859e4cc32981f9e3f2b2ae9702bbcf249")},
+        { 10881, uint256("0x4b6554c45e1e6764a6f3c309c47baf53c9edd81f624e52b072518cd15da237e6")},
+        { 17650, uint256("0x224940e1f986a202209b8e762728d1452ab45870c308abf84905674acf326a47")},
+    };

    bool CheckHardened(int nHeight, const uint256& hash)
    {
@@ -65,6 +72,14 @@ namespace Checkpoints
        return hash == i->second;
    }

+    bool IsKnownCheckpoint(int nHeight, const uint256& hash)
+    {
+        MapCheckpoints& checkpoints = (fTestNet ? mapCheckpointsTestnet : mapCheckpoints);
+        MapCheckpoints::const_iterator i = checkpoints.find(nHeight);
+        if (i == checkpoints.end()) return false;
+        return hash == i->second;
+    }
+
    int GetTotalBlocksEstimate()
    {
        MapCheckpoints& checkpoints = (fTestNet ? mapCheckpointsTestnet : mapCheckpoints);
@@ -72,23 +87,39 @@ namespace Checkpoints
        return checkpoints.rbegin()->first;
    }

+    int GetBestSnapshotHeight()
+    {
+        std::map<int, uint256>& snaps = (fTestNet ? mapSnapshotHashesTestnet : mapSnapshotHashes);
+        if (snaps.empty()) return 0;
+        return snaps.rbegin()->first;
+    }
+
+    bool GetSnapshotHash(int nHeight, uint256& fileHashOut)
+    {
+        std::map<int, uint256>& snaps = (fTestNet ? mapSnapshotHashesTestnet : mapSnapshotHashes);
+        auto it = snaps.find(nHeight);
+        if (it == snaps.end()) return false;
+        fileHashOut = it->second;
+        return true;
+    }
+
    CBlockIndex* GetLastCheckpoint(const std::map<uint256, CBlockIndex*>& mapBlockIndex)
    {
        MapCheckpoints& checkpoints = (fTestNet ? mapCheckpointsTestnet : mapCheckpoints);

-        BOOST_REVERSE_FOREACH(const MapCheckpoints::value_type& i, checkpoints)
+        for (auto it = checkpoints.rbegin(); it != checkpoints.rend(); ++it)
        {
-            const uint256& hash = i.second;
+            const uint256& hash = it->second;
            std::map<uint256, CBlockIndex*>::const_iterator t = mapBlockIndex.find(hash);
            if (t != mapBlockIndex.end())
                return t->second;
        }
-        return NULL;
+        return nullptr;
    }

    // triangles: synchronized checkpoint (centrally broadcasted)
-    uint256 hashSyncCheckpoint = uint256("0xbd952e8d4a612e336d840ad924a7e09395e36bcd9d929b302e47e60b5c3098c0");
-    uint256 hashPendingCheckpoint = uint256("0xbd952e8d4a612e336d840ad924a7e09395e36bcd9d929b302e47e60b5c3098c0");
+    uint256 hashSyncCheckpoint = uint256("0x7e7a6e4dd5fe895106fca912dfbacaeaf2a89e76c6a588df8ff96e0e18b96021");
+    uint256 hashPendingCheckpoint = uint256("0x7e7a6e4dd5fe895106fca912dfbacaeaf2a89e76c6a588df8ff96e0e18b96021");
    CSyncCheckpoint checkpointMessage;
    CSyncCheckpoint checkpointMessagePending;
    uint256 hashInvalidCheckpoint = 0;
@@ -102,7 +133,7 @@ namespace Checkpoints
            error("GetSyncCheckpoint: block index missing for current sync-checkpoint %s", hashSyncCheckpoint.ToString().c_str());
        else
            return mapBlockIndex[hashSyncCheckpoint];
-        return NULL;
+        return nullptr;
    }

    // triangles: only descendant of current sync-checkpoint is allowed
@@ -150,7 +181,7 @@ namespace Checkpoints

    bool WriteSyncCheckpoint(const uint256& hashCheckpoint)
    {
-        CTxDB txdb;
+        auto txdb_holder = MakeChainDB(); CTxDBBase& txdb = *txdb_holder;
        txdb.TxnBegin();
        if (!txdb.WriteSyncCheckpoint(hashCheckpoint))
        {
@@ -176,7 +207,7 @@ namespace Checkpoints
                return false;
            }

-            CTxDB txdb;
+            auto txdb_holder = MakeChainDB(); CTxDBBase& txdb = *txdb_holder;
            CBlockIndex* pindexCheckpoint = mapBlockIndex[hashPendingCheckpoint];
            if (!pindexCheckpoint->IsInMainChain())
            {
@@ -199,7 +230,7 @@ namespace Checkpoints
            // relay the checkpoint
            if (!checkpointMessage.IsNull())
            {
-                BOOST_FOREACH(CNode* pnode, vNodes)
+                for (CNode* pnode : vNodes)
                    checkpointMessage.RelayTo(pnode);
            }
            return true;
@@ -218,30 +249,10 @@ namespace Checkpoints
    }

    // Check against synchronized checkpoint
+    // Disabled: master key removed in V5, no new sync checkpoints possible.
+    // Always returns true to prevent stale DB-persisted checkpoints from blocking IBD.
    bool CheckSync(const uint256& hashBlock, const CBlockIndex* pindexPrev)
    {
-        if (fTestNet) return true; // Testnet has no checkpoints
-        int nHeight = pindexPrev->nHeight + 1;
-
-        LOCK(cs_hashSyncCheckpoint);
-        // sync-checkpoint should always be accepted block
-        assert(mapBlockIndex.count(hashSyncCheckpoint));
-        const CBlockIndex* pindexSync = mapBlockIndex[hashSyncCheckpoint];
-
-        if (nHeight > pindexSync->nHeight)
-        {
-            // trace back to same height as sync-checkpoint
-            const CBlockIndex* pindex = pindexPrev;
-            while (pindex->nHeight > pindexSync->nHeight)
-                if (!(pindex = pindex->pprev))
-                    return error("CheckSync: pprev null - block index structure failure");
-            if (pindex->nHeight < pindexSync->nHeight || pindex->GetBlockHash() != hashSyncCheckpoint)
-                return false; // only descendant of sync-checkpoint can pass check
-        }
-        if (nHeight == pindexSync->nHeight && hashBlock != hashSyncCheckpoint)
-            return false; // same height with sync-checkpoint
-        if (nHeight < pindexSync->nHeight && !mapBlockIndex.count(hashBlock))
-            return false; // lower height than sync-checkpoint
        return true;
    }

@@ -252,8 +263,8 @@ namespace Checkpoints
            return false;
        if (hashBlock == hashPendingCheckpoint)
            return true;
-        if (mapOrphanBlocks.count(hashPendingCheckpoint) 
-            && hashBlock == WantedByOrphan(mapOrphanBlocks[hashPendingCheckpoint]))
+        if (mapOrphanBlocks.count(hashPendingCheckpoint)
+            && hashBlock == WantedByOrphan(mapOrphanBlocks[hashPendingCheckpoint].get()))
            return true;
        return false;
    }
@@ -267,7 +278,7 @@ namespace Checkpoints
        {
            // checkpoint block accepted but not yet in main chain
            printf("ResetSyncCheckpoint: SetBestChain to hardened checkpoint %s\n", hash.ToString().c_str());
-            CTxDB txdb;
+            auto txdb_holder = MakeChainDB(); CTxDBBase& txdb = *txdb_holder;
            CBlock block;
            if (!block.ReadFromDisk(mapBlockIndex[hash]))
                return error("ResetSyncCheckpoint: ReadFromDisk failed for hardened checkpoint %s", hash.ToString().c_str());
@@ -284,9 +295,9 @@ namespace Checkpoints
            printf("ResetSyncCheckpoint: pending for sync-checkpoint %s\n", hashPendingCheckpoint.ToString().c_str());
        }

-        BOOST_REVERSE_FOREACH(const MapCheckpoints::value_type& i, mapCheckpoints)
+        for (auto it = mapCheckpoints.rbegin(); it != mapCheckpoints.rend(); ++it)
        {
-            const uint256& hash = i.second;
+            const uint256& hash = it->second;
            if (mapBlockIndex.count(hash) && mapBlockIndex[hash]->IsInMainChain())
            {
                if (!WriteSyncCheckpoint(hash))
@@ -342,7 +353,7 @@ namespace Checkpoints
        if (!key.Sign(Hash(checkpoint.vchMsg.begin(), checkpoint.vchMsg.end()), checkpoint.vchSig))
            return error("SendSyncCheckpoint: Unable to sign checkpoint, check private key?");

-        if(!checkpoint.ProcessSyncCheckpoint(NULL))
+        if(!checkpoint.ProcessSyncCheckpoint(nullptr))
        {
            printf("WARNING: SendSyncCheckpoint: Failed to process checkpoint.\n");
            return false;
@@ -351,7 +362,7 @@ namespace Checkpoints
        // Relay checkpoint
        {
            LOCK(cs_vNodes);
-            BOOST_FOREACH(CNode* pnode, vNodes)
+            for (CNode* pnode : vNodes)
                checkpoint.RelayTo(pnode);
        }
        return true;
@@ -361,8 +372,8 @@ namespace Checkpoints
    bool IsMatureSyncCheckpoint()
    {
        LOCK(cs_hashSyncCheckpoint);
-        // sync-checkpoint should always be accepted block
-        assert(mapBlockIndex.count(hashSyncCheckpoint));
+        if (!mapBlockIndex.count(hashSyncCheckpoint))
+            return true; // no valid sync checkpoint, treat as mature
        const CBlockIndex* pindexSync = mapBlockIndex[hashSyncCheckpoint];
        return (nBestHeight >= pindexSync->nHeight + nCoinbaseMaturity ||
                pindexSync->GetBlockTime() + nStakeMinAge < GetAdjustedTime());
@@ -403,7 +414,7 @@ bool CSyncCheckpoint::ProcessSyncCheckpoint(CNode* pfrom)
            pfrom->PushGetBlocks(pindexBest, hashCheckpoint);
            // ask directly as well in case rejected earlier by duplicate
            // proof-of-stake because getblocks may not get it this time
-            pfrom->AskFor(CInv(MSG_BLOCK, mapOrphanBlocks.count(hashCheckpoint)? WantedByOrphan(mapOrphanBlocks[hashCheckpoint]) : hashCheckpoint));
+            pfrom->AskFor(CInv(MSG_BLOCK, mapOrphanBlocks.count(hashCheckpoint)? WantedByOrphan(mapOrphanBlocks[hashCheckpoint].get()) : hashCheckpoint));
        }
        return false;
    }
@@ -411,7 +422,7 @@ bool CSyncCheckpoint::ProcessSyncCheckpoint(CNode* pfrom)
    if (!Checkpoints::ValidateSyncCheckpoint(hashCheckpoint))
        return false;

-    CTxDB txdb;
+    auto txdb_holder = MakeChainDB(); CTxDBBase& txdb = *txdb_holder;
    CBlockIndex* pindexCheckpoint = mapBlockIndex[hashCheckpoint];
    if (!pindexCheckpoint->IsInMainChain())
    {
@@ -39,9 +39,17 @@ namespace Checkpoints
    // Returns true if block passes checkpoint checks
    bool CheckHardened(int nHeight, const uint256& hash);

+    // Returns true only if (nHeight, hash) is an exact entry in mapCheckpoints
+    bool IsKnownCheckpoint(int nHeight, const uint256& hash);
+
    // Return conservative estimate of total number of blocks, 0 if unknown
    int GetTotalBlocksEstimate();

+    // Return the highest checkpoint height that has a published UTXO snapshot
+    // hash, along with the snapshot's file SHA256. Returns 0 height if none.
+    int GetBestSnapshotHeight();
+    bool GetSnapshotHash(int nHeight, uint256& fileHashOut);
+
    // Returns last CBlockIndex* in mapBlockIndex that is a checkpoint
    CBlockIndex* GetLastCheckpoint(const std::map<uint256, CBlockIndex*>& mapBlockIndex);

@@ -0,0 +1,181 @@
+// Copyright (c) 2012-2013 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef TRIANGLES_CHECKQUEUE_H
+#define TRIANGLES_CHECKQUEUE_H
+
+#include <algorithm>
+#include <deque>
+#include <vector>
+
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+
+template<typename T>
+class CCheckQueue
+{
+private:
+    std::mutex mutex;
+    std::condition_variable condWorker;
+    std::condition_variable condMaster;
+
+    std::deque<T> queue;
+    unsigned int nIdle;
+    unsigned int nTotal;
+    bool fAllOk;
+    unsigned int nTodo;
+    bool fQuit;
+
+    unsigned int nBatchSize;
+
+    bool Loop(bool fMaster)
+    {
+        std::unique_lock<std::mutex> lock(mutex);
+        if (!fMaster)
+            nTotal++;
+        nIdle++;
+
+        bool fOk = true;
+
+        for (;;)
+        {
+            while (queue.empty())
+            {
+                if (fQuit)
+                {
+                    nIdle--;
+                    if (!fMaster)
+                        nTotal--;
+                    return false;
+                }
+                if (fMaster && nTodo == 0)
+                {
+                    bool fRet = fAllOk;
+                    nIdle--;
+                    return fRet;
+                }
+                if (fMaster)
+                    condMaster.wait(lock);
+                else
+                    condWorker.wait(lock);
+            }
+
+            unsigned int nNow = std::max(1U, std::min((unsigned int)queue.size() / (nTotal + 1), nBatchSize));
+            std::vector<T> vChecks(nNow);
+            for (unsigned int i = 0; i < nNow; i++)
+            {
+                vChecks[i].swap(queue.front());
+                queue.pop_front();
+            }
+            nIdle--;
+            lock.unlock();
+
+            for (auto& check : vChecks)
+            {
+                if (fOk)
+                    fOk = check();
+            }
+            vChecks.clear();
+
+            lock.lock();
+            nIdle++;
+            nTodo -= nNow;
+            if (!fOk)
+                fAllOk = false;
+
+            if (nTodo == 0)
+                condMaster.notify_one();
+        }
+    }
+
+public:
+    CCheckQueue(unsigned int nBatchSizeIn = 128)
+        : nIdle(0), nTotal(0), fAllOk(true), nTodo(0), fQuit(false),
+          nBatchSize(nBatchSizeIn) {}
+
+    void Thread()
+    {
+        Loop(false);
+    }
+
+    void StartBatch()
+    {
+        std::unique_lock<std::mutex> lock(mutex);
+        fAllOk = true;
+        nTodo = 0;
+    }
+
+    void Add(std::vector<T>& vChecks)
+    {
+        if (vChecks.empty())
+            return;
+
+        std::unique_lock<std::mutex> lock(mutex);
+        for (typename std::vector<T>::iterator it = vChecks.begin(); it != vChecks.end(); ++it)
+        {
+            queue.push_back(T());
+            queue.back().swap(*it);
+        }
+        nTodo += vChecks.size();
+        if (vChecks.size() == 1)
+            condWorker.notify_one();
+        else
+            condWorker.notify_all();
+    }
+
+    bool Wait()
+    {
+        return Loop(true);
+    }
+
+    void Quit()
+    {
+        std::unique_lock<std::mutex> lock(mutex);
+        fQuit = true;
+        condWorker.notify_all();
+        condMaster.notify_all();
+    }
+};
+
+template<typename T>
+class CCheckQueueControl
+{
+private:
+    CCheckQueue<T>* pqueue;
+    bool fDone;
+
+    CCheckQueueControl(const CCheckQueueControl&);
+    CCheckQueueControl& operator=(const CCheckQueueControl&);
+
+public:
+    CCheckQueueControl(CCheckQueue<T>* pqueueIn)
+        : pqueue(pqueueIn), fDone(false)
+    {
+        if (pqueue)
+            pqueue->StartBatch();
+    }
+
+    bool Wait()
+    {
+        if (!pqueue || fDone)
+            return true;
+        fDone = true;
+        return pqueue->Wait();
+    }
+
+    void Add(std::vector<T>& vChecks)
+    {
+        if (pqueue)
+            pqueue->Add(vChecks);
+    }
+
+    ~CCheckQueueControl()
+    {
+        if (!fDone)
+            Wait();
+    }
+};
+
+#endif // TRIANGLES_CHECKQUEUE_H
@@ -7,8 +7,8 @@

 // These need to be macros, as version.cpp's and triangles-qt.rc's voodoo requires it
 #define CLIENT_VERSION_MAJOR       5
-#define CLIENT_VERSION_MINOR       1
-#define CLIENT_VERSION_REVISION    8
+#define CLIENT_VERSION_MINOR       9
+#define CLIENT_VERSION_REVISION    9
 #define CLIENT_VERSION_BUILD       0

 // Converts the parameter X to a string after macro replacement on X has been performed.
@@ -75,7 +75,7 @@ bool CCrypter::Encrypt(const CKeyingMaterial& vchPlaintext, std::vector<unsigned

    bool fOk = true;

-    if (fOk) fOk = EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, chKey, chIV);
+    if (fOk) fOk = EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), nullptr, chKey, chIV);
    if (fOk) fOk = EVP_EncryptUpdate(ctx, &vchCiphertext[0], &nCLen, &vchPlaintext[0], nLen);
    if (fOk) fOk = EVP_EncryptFinal_ex(ctx, (&vchCiphertext[0])+nCLen, &nFLen);
    EVP_CIPHER_CTX_free(ctx);
@@ -102,7 +102,7 @@ bool CCrypter::Decrypt(const std::vector<unsigned char>& vchCiphertext, CKeyingM

    bool fOk = true;

-    if (fOk) fOk = EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, chKey, chIV);
+    if (fOk) fOk = EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), nullptr, chKey, chIV);
    if (fOk) fOk = EVP_DecryptUpdate(ctx, &vchPlaintext[0], &nPLen, &vchCiphertext[0], nLen);
    if (fOk) fOk = EVP_DecryptFinal_ex(ctx, (&vchPlaintext[0])+nPLen, &nFLen);
    EVP_CIPHER_CTX_free(ctx);
@@ -8,6 +8,8 @@
 #include "key.h"
 #include "serialize.h"

+#include <openssl/crypto.h> /* for OPENSSL_cleanse */
+
 const unsigned int WALLET_CRYPTO_KEY_SIZE = 32;
 const unsigned int WALLET_CRYPTO_SALT_SIZE = 8;

@@ -78,7 +80,7 @@ public:

 };

-typedef std::vector<unsigned char, secure_allocator<unsigned char> > CKeyingMaterial;
+using CKeyingMaterial = std::vector<unsigned char, secure_allocator<unsigned char>>;

 /** Encryption/decryption context with key information */
 class CCrypter
@@ -0,0 +1,56 @@
+// Copyright (c) 2026 The Triangles developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "crypto_ecdh.h"
+
+#include <cstring>
+#include <mutex>
+
+#include <secp256k1.h>
+#include <secp256k1_ecdh.h>
+
+namespace {
+
+// One process-wide context is sufficient for ECDH — no signing or verification
+// flags needed. Created lazily on first use; libsecp256k1 contexts are
+// thread-safe for read-only operations like ECDH.
+secp256k1_context* GetECDHContext()
+{
+    static std::once_flag once;
+    static secp256k1_context* ctx = nullptr;
+    std::call_once(once, []() {
+        ctx = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
+    });
+    return ctx;
+}
+
+// Hash function callback that returns the raw X coordinate of the shared
+// point. Mirrors OpenSSL's ECDH_compute_key behaviour when the KDF is nullptr.
+int hash_xonly(unsigned char* output,
+               const unsigned char* x32,
+               const unsigned char* /*y32*/,
+               void* /*data*/)
+{
+    std::memcpy(output, x32, 32);
+    return 1;
+}
+
+} // namespace
+
+bool ECDH_xonly_secp256k1(unsigned char out32[32],
+                          const unsigned char privkey32[32],
+                          const unsigned char* pubkey,
+                          std::size_t pubkey_len)
+{
+    if (pubkey_len != 33 && pubkey_len != 65) return false;
+
+    secp256k1_context* ctx = GetECDHContext();
+    if (!ctx) return false;
+
+    secp256k1_pubkey pk;
+    if (!secp256k1_ec_pubkey_parse(ctx, &pk, pubkey, pubkey_len))
+        return false;
+
+    return secp256k1_ecdh(ctx, out32, &pk, privkey32, hash_xonly, nullptr) == 1;
+}
@@ -0,0 +1,31 @@
+// Copyright (c) 2026 The Triangles developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+#ifndef TRIANGLES_CRYPTO_ECDH_H
+#define TRIANGLES_CRYPTO_ECDH_H
+
+#include <cstddef>
+
+/**
+ * Compute the shared secret X coordinate via secp256k1 ECDH.
+ *
+ * Output matches OpenSSL's ECDH_compute_key(buf, 32, peer_pub, our_priv, NULL)
+ * — i.e. the raw X coordinate of the shared point, with no KDF applied. This
+ * preserves bit-for-bit compatibility with smessage's existing key derivation
+ * (which feeds the X coordinate into SHA-512 itself), so historical encrypted
+ * messages remain decryptable after the migration off OpenSSL EC.
+ *
+ * @param out32       32-byte buffer for the shared X coordinate.
+ * @param privkey32   32-byte secret scalar (big-endian).
+ * @param pubkey      Peer public key, serialized as either 33 bytes (compressed)
+ *                    or 65 bytes (uncompressed).
+ * @param pubkey_len  33 or 65; any other length fails immediately.
+ * @return true on success, false if the public key is malformed or the
+ *         private key is invalid (zero / >= curve order).
+ */
+bool ECDH_xonly_secp256k1(unsigned char out32[32],
+                          const unsigned char privkey32[32],
+                          const unsigned char* pubkey,
+                          std::size_t pubkey_len);
+
+#endif // TRIANGLES_CRYPTO_ECDH_H
@@ -0,0 +1,389 @@
+// Copyright (c) 2026 The Triangles developers
+// Copyright (c) 2015 Pieter Wuille (lax DER parser, MIT licence)
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "crypto_ecdsa.h"
+
+#include <cstring>
+#include <mutex>
+
+#include <secp256k1.h>
+#include <secp256k1_recovery.h>
+
+namespace {
+
+// Combined VERIFY + SIGN context. libsecp256k1 contexts are thread-safe for
+// signing and verification once created. In libsecp256k1 >= 0.2 these flags
+// are accepted but increasingly no-ops; passing both keeps us compatible with
+// older versions still in distro packages.
+secp256k1_context* GetEcdsaContext()
+{
+    static std::once_flag once;
+    static secp256k1_context* ctx = nullptr;
+    std::call_once(once, []() {
+        ctx = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY | SECP256K1_CONTEXT_SIGN);
+    });
+    return ctx;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Lax DER parser, vendored from Bitcoin Core (contrib/lax_der_parsing.c).
+//
+// libsecp256k1's strict parser rejects DER encodings that OpenSSL has
+// historically accepted: non-minimal length bytes, extra leading zeros on R/S,
+// negative integers, etc. Many such signatures already exist on chain. This
+// parser tolerates them, normalises (R, S) into a 64-byte compact buffer, and
+// hands that to libsecp256k1's compact-signature parser. Anything that still
+// fails to fit (e.g. R or S exceeding 32 bytes after stripping leading zeros)
+// is treated as zero so the verify call returns a clean failure rather than
+// crashing.
+// ─────────────────────────────────────────────────────────────────────────────
+int ecdsa_signature_parse_der_lax(const secp256k1_context* ctx,
+                                  secp256k1_ecdsa_signature* sig,
+                                  const unsigned char* input,
+                                  std::size_t inputlen)
+{
+    std::size_t rpos, rlen, spos, slen;
+    std::size_t pos = 0;
+    std::size_t lenbyte;
+    unsigned char tmpsig[64] = {0};
+    int overflow = 0;
+
+    // Initialise sig with a parseable but invalid signature so the caller
+    // always gets a defined value back even on early-exit paths.
+    secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
+
+    // SEQUENCE tag.
+    if (pos == inputlen || input[pos] != 0x30) return 0;
+    pos++;
+
+    // SEQUENCE length (skipped — we trust the inner element lengths).
+    if (pos == inputlen) return 0;
+    lenbyte = input[pos++];
+    if (lenbyte & 0x80) {
+        lenbyte -= 0x80;
+        if (lenbyte > inputlen - pos) return 0;
+        pos += lenbyte;
+    }
+
+    // R: INTEGER tag.
+    if (pos == inputlen || input[pos] != 0x02) return 0;
+    pos++;
+
+    // R: length.
+    if (pos == inputlen) return 0;
+    lenbyte = input[pos++];
+    if (lenbyte & 0x80) {
+        lenbyte -= 0x80;
+        if (lenbyte > inputlen - pos) return 0;
+        while (lenbyte > 0 && input[pos] == 0) { pos++; lenbyte--; }
+        if (lenbyte >= sizeof(std::size_t)) return 0;
+        rlen = 0;
+        while (lenbyte > 0) { rlen = (rlen << 8) + input[pos]; pos++; lenbyte--; }
+    } else {
+        rlen = lenbyte;
+    }
+    if (rlen > inputlen - pos) return 0;
+    rpos = pos;
+    pos += rlen;
+
+    // S: INTEGER tag.
+    if (pos == inputlen || input[pos] != 0x02) return 0;
+    pos++;
+
+    // S: length.
+    if (pos == inputlen) return 0;
+    lenbyte = input[pos++];
+    if (lenbyte & 0x80) {
+        lenbyte -= 0x80;
+        if (lenbyte > inputlen - pos) return 0;
+        while (lenbyte > 0 && input[pos] == 0) { pos++; lenbyte--; }
+        if (lenbyte >= sizeof(std::size_t)) return 0;
+        slen = 0;
+        while (lenbyte > 0) { slen = (slen << 8) + input[pos]; pos++; lenbyte--; }
+    } else {
+        slen = lenbyte;
+    }
+    if (slen > inputlen - pos) return 0;
+    spos = pos;
+
+    // Strip leading zeros from R and place right-aligned in tmpsig[0..32).
+    while (rlen > 0 && input[rpos] == 0) { rlen--; rpos++; }
+    if (rlen > 32) {
+        overflow = 1;
+    } else {
+        std::memcpy(tmpsig + 32 - rlen, input + rpos, rlen);
+    }
+
+    // Strip leading zeros from S and place right-aligned in tmpsig[32..64).
+    while (slen > 0 && input[spos] == 0) { slen--; spos++; }
+    if (slen > 32) {
+        overflow = 1;
+    } else {
+        std::memcpy(tmpsig + 64 - slen, input + spos, slen);
+    }
+
+    if (!overflow) {
+        overflow = !secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
+    }
+    if (overflow) {
+        std::memset(tmpsig, 0, 64);
+        secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
+    }
+    return 1;
+}
+
+} // namespace
+
+bool ECDSA_verify_secp256k1(const unsigned char hash32[32],
+                            const unsigned char* sig, std::size_t sig_len,
+                            const unsigned char* pubkey, std::size_t pubkey_len)
+{
+    if (sig_len == 0)                           return false;
+    if (pubkey_len != 33 && pubkey_len != 65)   return false;
+
+    secp256k1_context* ctx = GetEcdsaContext();
+    if (!ctx) return false;
+
+    secp256k1_pubkey pk;
+    if (!secp256k1_ec_pubkey_parse(ctx, &pk, pubkey, pubkey_len))
+        return false;
+
+    secp256k1_ecdsa_signature parsed_sig;
+    if (!ecdsa_signature_parse_der_lax(ctx, &parsed_sig, sig, sig_len))
+        return false;
+
+    return secp256k1_ecdsa_verify(ctx, &parsed_sig, hash32, &pk) == 1;
+}
+
+bool ECDSA_sign_secp256k1(unsigned char* out, std::size_t* out_len,
+                          const unsigned char hash32[32],
+                          const unsigned char privkey32[32])
+{
+    if (!out || !out_len) return false;
+    secp256k1_context* ctx = GetEcdsaContext();
+    if (!ctx) return false;
+
+    secp256k1_ecdsa_signature sig;
+    if (!secp256k1_ecdsa_sign(ctx, &sig, hash32, privkey32, nullptr, nullptr))
+        return false;
+
+    return secp256k1_ecdsa_signature_serialize_der(ctx, out, out_len, &sig) == 1;
+}
+
+bool ECDSA_sign_compact_secp256k1(unsigned char out65[65],
+                                  const unsigned char hash32[32],
+                                  const unsigned char privkey32[32],
+                                  bool fCompressed)
+{
+    secp256k1_context* ctx = GetEcdsaContext();
+    if (!ctx) return false;
+
+    secp256k1_ecdsa_recoverable_signature recsig;
+    if (!secp256k1_ecdsa_sign_recoverable(ctx, &recsig, hash32, privkey32, nullptr, nullptr))
+        return false;
+
+    int recid = -1;
+    if (!secp256k1_ecdsa_recoverable_signature_serialize_compact(ctx, &out65[1], &recid, &recsig))
+        return false;
+    if (recid < 0 || recid > 3) return false;
+
+    out65[0] = static_cast<unsigned char>(27 + recid + (fCompressed ? 4 : 0));
+    return true;
+}
+
+bool ECDSA_recover_compact_secp256k1(unsigned char* pubkey_out,
+                                     std::size_t* pubkey_len_out,
+                                     const unsigned char hash32[32],
+                                     const unsigned char sig65[65])
+{
+    if (!pubkey_out || !pubkey_len_out) return false;
+
+    int header = sig65[0];
+    if (header < 27 || header >= 35) return false;
+    bool fCompressed = (header >= 31);
+    int recid = (header - 27) & 0x3;
+
+    secp256k1_context* ctx = GetEcdsaContext();
+    if (!ctx) return false;
+
+    secp256k1_ecdsa_recoverable_signature recsig;
+    if (!secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &recsig, &sig65[1], recid))
+        return false;
+
+    secp256k1_pubkey pk;
+    if (!secp256k1_ecdsa_recover(ctx, &pk, &recsig, hash32))
+        return false;
+
+    std::size_t out_len = fCompressed ? 33 : 65;
+    if (!secp256k1_ec_pubkey_serialize(ctx, pubkey_out, &out_len, &pk,
+                                        fCompressed ? SECP256K1_EC_COMPRESSED
+                                                    : SECP256K1_EC_UNCOMPRESSED))
+        return false;
+
+    *pubkey_len_out = out_len;
+    return true;
+}
+
+bool ECDSA_seckey_verify_secp256k1(const unsigned char privkey32[32])
+{
+    secp256k1_context* ctx = GetEcdsaContext();
+    if (!ctx) return false;
+    return secp256k1_ec_seckey_verify(ctx, privkey32) == 1;
+}
+
+bool ECDSA_pubkey_verify_secp256k1(const unsigned char* pubkey, std::size_t pubkey_len)
+{
+    if (pubkey_len != 33 && pubkey_len != 65) return false;
+    secp256k1_context* ctx = GetEcdsaContext();
+    if (!ctx) return false;
+    secp256k1_pubkey pk;
+    return secp256k1_ec_pubkey_parse(ctx, &pk, pubkey, pubkey_len) == 1;
+}
+
+bool ECDSA_pubkey_from_privkey_secp256k1(unsigned char* out, std::size_t* out_len_out,
+                                         const unsigned char privkey32[32],
+                                         bool fCompressed)
+{
+    if (!out || !out_len_out) return false;
+    secp256k1_context* ctx = GetEcdsaContext();
+    if (!ctx) return false;
+
+    secp256k1_pubkey pk;
+    if (!secp256k1_ec_pubkey_create(ctx, &pk, privkey32))
+        return false;
+
+    std::size_t len = fCompressed ? 33 : 65;
+    if (!secp256k1_ec_pubkey_serialize(ctx, out, &len, &pk,
+                                        fCompressed ? SECP256K1_EC_COMPRESSED
+                                                    : SECP256K1_EC_UNCOMPRESSED))
+        return false;
+    *out_len_out = len;
+    return true;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// SEC1 / RFC-5915 DER codec for secp256k1 ECPrivateKey
+//
+// Vendored from Bitcoin Core (src/key.cpp), MIT-licensed. The decoder is lax
+// about details (matches OpenSSL's d2i_ECPrivateKey lenience); the encoder
+// writes the exact byte layout that OpenSSL's i2d_ECPrivateKey produces for
+// this curve so wallet.dat records remain interchangeable across versions.
+//
+//   Compressed pubkey:   214 bytes
+//   Uncompressed pubkey: 279 bytes
+//
+// The static templates below carry every byte except the 32-byte private
+// scalar and the public key bytes, which are spliced into the precomputed
+// offsets at encode time.
+// ─────────────────────────────────────────────────────────────────────────────
+
+namespace {
+
+const unsigned char der_template_compressed[214] = {
+    0x30,0x81,0xD3,0x02,0x01,0x01,0x04,0x20,
+    /* private key (32 bytes) at offset 8 */
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0xA0,0x81,0x85,0x30,0x81,0x82,0x02,0x01,0x01,0x30,0x2C,0x06,0x07,0x2A,0x86,0x48,
+    0xCE,0x3D,0x01,0x01,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0xFF,0xFF,0xFC,0x2F,0x30,0x06,0x04,0x01,0x00,
+    0x04,0x01,0x07,0x04,0x21,0x02,0x79,0xBE,0x66,0x7E,0xF9,0xDC,0xBB,0xAC,0x55,0xA0,
+    0x62,0x95,0xCE,0x87,0x0B,0x07,0x02,0x9B,0xFC,0xDB,0x2D,0xCE,0x28,0xD9,0x59,0xF2,
+    0x81,0x5B,0x16,0xF8,0x17,0x98,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,
+    0x3B,0xBF,0xD2,0x5E,0x8C,0xD0,0x36,0x41,0x41,0x02,0x01,0x01,0xA1,0x24,0x03,0x22,
+    0x00,
+    /* compressed pubkey (33 bytes) at offset 181 */
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+};
+
+const unsigned char der_template_uncompressed[279] = {
+    0x30,0x82,0x01,0x13,0x02,0x01,0x01,0x04,0x20,
+    /* private key (32 bytes) at offset 9 */
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0xA0,0x81,0xA5,0x30,0x81,0xA2,0x02,0x01,0x01,0x30,0x2C,0x06,0x07,0x2A,0x86,0x48,
+    0xCE,0x3D,0x01,0x01,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0xFF,0xFF,0xFC,0x2F,0x30,0x06,0x04,0x01,0x00,
+    0x04,0x01,0x07,0x04,0x41,0x04,0x79,0xBE,0x66,0x7E,0xF9,0xDC,0xBB,0xAC,0x55,0xA0,
+    0x62,0x95,0xCE,0x87,0x0B,0x07,0x02,0x9B,0xFC,0xDB,0x2D,0xCE,0x28,0xD9,0x59,0xF2,
+    0x81,0x5B,0x16,0xF8,0x17,0x98,0x48,0x3A,0xDA,0x77,0x26,0xA3,0xC4,0x65,0x5D,0xA4,
+    0xFB,0xFC,0x0E,0x11,0x08,0xA8,0xFD,0x17,0xB4,0x48,0xA6,0x85,0x54,0x19,0x9C,0x47,
+    0xD0,0x8F,0xFB,0x10,0xD4,0xB8,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,
+    0x3B,0xBF,0xD2,0x5E,0x8C,0xD0,0x36,0x41,0x41,0x02,0x01,0x01,0xA1,0x44,0x03,0x42,
+    0x00,
+    /* uncompressed pubkey (65 bytes) at offset 214 */
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0
+};
+
+} // namespace
+
+bool ECDSA_privkey_export_der_secp256k1(unsigned char* out, std::size_t* out_len_out,
+                                        const unsigned char privkey32[32],
+                                        bool fCompressed)
+{
+    if (!out || !out_len_out) return false;
+
+    secp256k1_context* ctx = GetEcdsaContext();
+    if (!ctx) return false;
+
+    secp256k1_pubkey pk;
+    if (!secp256k1_ec_pubkey_create(ctx, &pk, privkey32))
+        return false;
+
+    if (fCompressed) {
+        std::memcpy(out, der_template_compressed, sizeof(der_template_compressed));
+        std::memcpy(out + 8, privkey32, 32);
+        std::size_t pub_len = 33;
+        if (!secp256k1_ec_pubkey_serialize(ctx, out + 181, &pub_len, &pk, SECP256K1_EC_COMPRESSED))
+            return false;
+        *out_len_out = sizeof(der_template_compressed);
+    } else {
+        std::memcpy(out, der_template_uncompressed, sizeof(der_template_uncompressed));
+        std::memcpy(out + 9, privkey32, 32);
+        std::size_t pub_len = 65;
+        if (!secp256k1_ec_pubkey_serialize(ctx, out + 214, &pub_len, &pk, SECP256K1_EC_UNCOMPRESSED))
+            return false;
+        *out_len_out = sizeof(der_template_uncompressed);
+    }
+    return true;
+}
+
+bool ECDSA_privkey_import_der_secp256k1(unsigned char privkey32_out[32],
+                                        const unsigned char* der, std::size_t der_len)
+{
+    // Lax SEC1/RFC-5915 ECPrivateKey parser. We only need to find the OCTET
+    // STRING containing the private key scalar; everything else (curve params,
+    // optional public key) is informational. Mirrors Bitcoin Core's
+    // ec_privkey_import_der.
+    const unsigned char* end = der + der_len;
+    if (end < der + 1 || *(der++) != 0x30) return false;
+
+    // Outer SEQUENCE length — variable length encoding.
+    if (der >= end) return false;
+    int lenb = *(der++);
+    if (lenb < 0x80) {
+        // short form, ignore
+    } else {
+        int n = lenb & 0x7F;
+        if (n == 0 || n > 2) return false;
+        if (der + n > end) return false;
+        der += n;
+    }
+
+    // Version INTEGER (1).
+    if (der + 3 > end || der[0] != 0x02 || der[1] != 0x01 || der[2] != 0x01) return false;
+    der += 3;
+
+    // privateKey OCTET STRING (length 32).
+    if (der + 2 > end || der[0] != 0x04 || der[1] != 0x20) return false;
+    der += 2;
+    if (der + 32 > end) return false;
+    std::memcpy(privkey32_out, der, 32);
+
+    // Validate the result against the curve order; reject zero / >= n.
+    return ECDSA_seckey_verify_secp256k1(privkey32_out);
+}
@@ -0,0 +1,121 @@
+// Copyright (c) 2026 The Triangles developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+#ifndef TRIANGLES_CRYPTO_ECDSA_H
+#define TRIANGLES_CRYPTO_ECDSA_H
+
+#include <cstddef>
+
+/**
+ * Verify a DER-encoded secp256k1 ECDSA signature using libsecp256k1.
+ *
+ * Drop-in replacement for OpenSSL's
+ *   ECDSA_verify(0, hash, 32, sig, sig_len, pkey)
+ * with one important caveat baked in: the DER input is parsed *laxly*
+ * (Bitcoin Core's `lax_der_parsing` algorithm), so historical non-canonical
+ * encodings already on chain — extra padding, leading zeros, length-byte
+ * quirks that OpenSSL's permissive ASN.1 reader once accepted — continue
+ * to verify. Strict-DER-only parsing here would silently fork the chain.
+ *
+ * High-S signatures are accepted (libsecp256k1's verify behaviour by default).
+ * No malleability check is applied; that is policy and lives elsewhere.
+ *
+ * @param hash32      32-byte message hash to verify against.
+ * @param sig         DER-encoded signature bytes.
+ * @param sig_len     Length of `sig`.
+ * @param pubkey      Serialized public key (33 bytes compressed or 65 uncompressed).
+ * @param pubkey_len  33 or 65; any other length fails immediately.
+ * @return true iff the signature is valid for (hash32, pubkey).
+ */
+bool ECDSA_verify_secp256k1(const unsigned char hash32[32],
+                            const unsigned char* sig, std::size_t sig_len,
+                            const unsigned char* pubkey, std::size_t pubkey_len);
+
+/**
+ * Sign `hash32` with `privkey32` and write a DER-encoded signature to `out`.
+ *
+ * libsecp256k1 uses RFC 6979 deterministic nonces, so signature bytes will
+ * differ from OpenSSL's random-nonce output for the same key+hash, but any
+ * resulting signature is equally valid. Low-S is enforced automatically.
+ *
+ * @param out         Output buffer; must be at least `*out_len` bytes.
+ *                    libsecp256k1 produces at most 72 bytes of DER.
+ * @param out_len     In: capacity of `out`. Out: bytes actually written.
+ * @param hash32      32-byte message hash to sign.
+ * @param privkey32   32-byte secret scalar.
+ * @return true on success.
+ */
+bool ECDSA_sign_secp256k1(unsigned char* out, std::size_t* out_len,
+                          const unsigned char hash32[32],
+                          const unsigned char privkey32[32]);
+
+/**
+ * Produce a 65-byte recoverable compact signature.
+ *
+ * Output layout matches the existing wire format:
+ *   out[0]      = 27 + recid + (fCompressed ? 4 : 0)
+ *   out[1..33)  = R (big-endian, 32 bytes)
+ *   out[33..65) = S (big-endian, 32 bytes)
+ *
+ * @param out65        65-byte output buffer.
+ * @param hash32       32-byte message hash to sign.
+ * @param privkey32    32-byte secret scalar.
+ * @param fCompressed  Whether the matching public key is compressed; affects
+ *                     the recid offset in the header byte.
+ * @return true on success.
+ */
+bool ECDSA_sign_compact_secp256k1(unsigned char out65[65],
+                                  const unsigned char hash32[32],
+                                  const unsigned char privkey32[32],
+                                  bool fCompressed);
+
+/**
+ * Recover the signing public key from a 65-byte compact signature (as produced
+ * by ECDSA_sign_compact_secp256k1) and a message hash.
+ *
+ * The header byte's "compressed" flag determines whether the recovered key is
+ * serialized as 33 bytes (compressed) or 65 bytes (uncompressed).
+ *
+ * @param pubkey_out      Output buffer; needs at least 65 bytes capacity.
+ * @param pubkey_len_out  Receives the actual serialized length (33 or 65).
+ * @param hash32          32-byte message hash that was signed.
+ * @param sig65           65-byte compact signature.
+ * @return true if recovery succeeded.
+ */
+bool ECDSA_recover_compact_secp256k1(unsigned char* pubkey_out,
+                                     std::size_t* pubkey_len_out,
+                                     const unsigned char hash32[32],
+                                     const unsigned char sig65[65]);
+
+/** Return true iff `privkey32` is a valid secp256k1 secret (in (0, n)). */
+bool ECDSA_seckey_verify_secp256k1(const unsigned char privkey32[32]);
+
+/** Return true iff `pubkey/pubkey_len` parses as a valid secp256k1 point. */
+bool ECDSA_pubkey_verify_secp256k1(const unsigned char* pubkey, std::size_t pubkey_len);
+
+/**
+ * Derive the public key for `privkey32` and serialize it.
+ * @param out          Output buffer; must be at least 65 bytes.
+ * @param out_len_out  Receives the actual length (33 or 65).
+ * @param privkey32    32-byte secret scalar.
+ * @param fCompressed  Whether to serialize compressed (33B) or uncompressed (65B).
+ * @return true on success.
+ */
+bool ECDSA_pubkey_from_privkey_secp256k1(unsigned char* out, std::size_t* out_len_out,
+                                         const unsigned char privkey32[32],
+                                         bool fCompressed);
+
+/**
+ * SEC1/RFC-5915 DER ECPrivateKey encoder/decoder for the secp256k1 curve.
+ * Output bytes match the layout produced by OpenSSL's i2d_ECPrivateKey on this
+ * curve (compressed = 214 bytes, uncompressed = 279 bytes), so wallet.dat
+ * records written by previous OpenSSL-EC builds remain readable, and records
+ * we write remain readable by older OpenSSL-based builds.
+ */
+bool ECDSA_privkey_export_der_secp256k1(unsigned char* out, std::size_t* out_len_out,
+                                        const unsigned char privkey32[32],
+                                        bool fCompressed);
+bool ECDSA_privkey_import_der_secp256k1(unsigned char privkey32_out[32],
+                                        const unsigned char* der, std::size_t der_len);
+
+#endif // TRIANGLES_CRYPTO_ECDSA_H
@@ -8,16 +8,15 @@
 #include "util.h"
 #include "main.h"
 #include "ui_interface.h"
-#include <boost/filesystem.hpp>
-#include <boost/filesystem/fstream.hpp>
+#include <filesystem>
+#include <fstream>

 #ifndef WIN32
 #include "sys/stat.h"
 #endif

 using namespace std;
-using namespace boost;
-namespace fs = boost::filesystem;
+namespace fs = std::filesystem;


 unsigned int nWalletDBUpdated;
@@ -79,7 +78,7 @@ bool CDBEnv::Open(fs::path pathEnv_)
    if (GetBoolArg("-privdb", true))
        nEnvFlags |= DB_PRIVATE;

-    int nDbCache = GetArg("-dbcache", 128);
+    int nDbCache = GetArg("-dbcache", 2048);
    dbenv.set_lg_dir(pathLogDir.string().c_str());
    dbenv.set_cachesize(nDbCache / 1024, (nDbCache % 1024)*1048576, 1);
    dbenv.set_lg_bsize(1048576);
@@ -134,7 +133,7 @@ void CDBEnv::MakeMock()
 #ifdef DB_LOG_IN_MEMORY
    dbenv.log_set_config(DB_LOG_IN_MEMORY, 1);
 #endif
-    int ret = dbenv.open(NULL,
+    int ret = dbenv.open(nullptr,
                     DB_CREATE     |
                     DB_INIT_LOCK  |
                     DB_INIT_LOG   |
@@ -156,10 +155,10 @@ CDBEnv::VerifyResult CDBEnv::Verify(std::string strFile, bool (*recoverFunc)(CDB
    assert(mapFileUseCount.count(strFile) == 0);

    Db db(&dbenv, 0);
-    int result = db.verify(strFile.c_str(), NULL, NULL, 0);
+    int result = db.verify(strFile.c_str(), nullptr, nullptr, 0);
    if (result == 0)
        return VERIFY_OK;
-    else if (recoverFunc == NULL)
+    else if (recoverFunc == nullptr)
        return RECOVER_FAIL;

    // Try to recover:
@@ -179,7 +178,7 @@ bool CDBEnv::Salvage(std::string strFile, bool fAggressive,
    stringstream strDump;

    Db db(&dbenv, 0);
-    int result = db.verify(strFile.c_str(), NULL, &strDump, flags);
+    int result = db.verify(strFile.c_str(), nullptr, &strDump, flags);
    if (result == DB_VERIFY_BAD)
    {
        printf("Error: Salvage found errors, all data may not be recoverable.\n");
@@ -232,10 +231,10 @@ void CDBEnv::CheckpointLSN(std::string strFile)


 CDB::CDB(const char *pszFile, const char* pszMode) :
-    pdb(NULL), activeTxn(NULL)
+    pdb(nullptr), activeTxn(nullptr)
 {
    int ret;
-    if (pszFile == NULL)
+    if (pszFile == nullptr)
        return;

    fReadOnly = (!strchr(pszMode, '+') && !strchr(pszMode, 'w'));
@@ -252,7 +251,7 @@ CDB::CDB(const char *pszFile, const char* pszMode) :
        strFile = pszFile;
        ++bitdb.mapFileUseCount[strFile];
        pdb = bitdb.mapDb[strFile];
-        if (pdb == NULL)
+        if (pdb == nullptr)
        {
            pdb = new Db(&bitdb.dbenv, 0);

@@ -265,8 +264,8 @@ CDB::CDB(const char *pszFile, const char* pszMode) :
                    throw runtime_error(strprintf("CDB() : failed to configure for no temp file backing for database %s", pszFile));
            }

-            ret = pdb->open(NULL,      // Txn pointer
-                            fMockDb ? NULL : pszFile,   // Filename
+            ret = pdb->open(nullptr,      // Txn pointer
+                            fMockDb ? nullptr : pszFile,   // Filename
                            "main",    // Logical db name
                            DB_BTREE,  // Database type
                            nFlags,    // Flags
@@ -275,7 +274,7 @@ CDB::CDB(const char *pszFile, const char* pszMode) :
            if (ret != 0)
            {
                delete pdb;
-                pdb = NULL;
+                pdb = nullptr;
                --bitdb.mapFileUseCount[strFile];
                strFile = "";
                throw runtime_error(strprintf("CDB() : can't open database file %s, error %d", pszFile, ret));
@@ -308,8 +307,8 @@ void CDB::Close()
        return;
    if (activeTxn)
        activeTxn->abort();
-    activeTxn = NULL;
-    pdb = NULL;
+    activeTxn = nullptr;
+    pdb = nullptr;

    // Flush database activity from memory pool to disk log
    unsigned int nMinutes = 0;
@@ -332,13 +331,13 @@ void CDBEnv::CloseDb(const string& strFile)
 {
    {
        LOCK(cs_db);
-        if (mapDb[strFile] != NULL)
+        if (mapDb[strFile] != nullptr)
        {
            // Close the database handle
            Db* pdb = mapDb[strFile];
            pdb->close(0);
            delete pdb;
-            mapDb[strFile] = NULL;
+            mapDb[strFile] = nullptr;
        }
    }
 }
@@ -348,7 +347,7 @@ bool CDBEnv::RemoveDb(const string& strFile)
    this->CloseDb(strFile);

    LOCK(cs_db);
-    int rc = dbenv.dbremove(NULL, strFile.c_str(), NULL, DB_AUTO_COMMIT);
+    int rc = dbenv.dbremove(nullptr, strFile.c_str(), nullptr, DB_AUTO_COMMIT);
    return (rc == 0);
 }

@@ -372,7 +371,7 @@ bool CDB::Rewrite(const string& strFile, const char* pszSkip)
                    CDB db(strFile.c_str(), "r");
                    Db* pdbCopy = new Db(&bitdb.dbenv, 0);

-                    int ret = pdbCopy->open(NULL,                 // Txn pointer
+                    int ret = pdbCopy->open(nullptr,                 // Txn pointer
                                            strFileRes.c_str(),   // Filename
                                            "main",    // Logical db name
                                            DB_BTREE,  // Database type
@@ -413,7 +412,7 @@ bool CDB::Rewrite(const string& strFile, const char* pszSkip)
                            }
                            Dbt datKey(&ssKey[0], ssKey.size());
                            Dbt datValue(&ssValue[0], ssValue.size());
-                            int ret2 = pdbCopy->put(NULL, &datKey, &datValue, DB_NOOVERWRITE);
+                            int ret2 = pdbCopy->put(nullptr, &datKey, &datValue, DB_NOOVERWRITE);
                            if (ret2 > 0)
                                fSuccess = false;
                        }
@@ -429,10 +428,10 @@ bool CDB::Rewrite(const string& strFile, const char* pszSkip)
                if (fSuccess)
                {
                    Db dbA(&bitdb.dbenv, 0);
-                    if (dbA.remove(strFile.c_str(), NULL, 0))
+                    if (dbA.remove(strFile.c_str(), nullptr, 0))
                        fSuccess = false;
                    Db dbB(&bitdb.dbenv, 0);
-                    if (dbB.rename(strFileRes.c_str(), NULL, strFile.c_str(), 0))
+                    if (dbB.rename(strFileRes.c_str(), nullptr, strFile.c_str(), 0))
                        fSuccess = false;
                }
                if (!fSuccess)
@@ -479,7 +478,7 @@ void CDBEnv::Flush(bool fShutdown)
            else
                mi++;
        }
-        printf("DBFlush(%s)%s ended %15"PRId64"ms\n", fShutdown ? "true" : "false", fDbEnvInit ? "" : " db not started", GetTimeMillis() - nStart);
+        printf("DBFlush(%s)%s ended %15" PRId64 "ms\n", fShutdown ? "true" : "false", fDbEnvInit ? "" : " db not started", GetTimeMillis() - nStart);
        if (fShutdown)
        {
            char** listp;
@@ -7,6 +7,7 @@

 #include "main.h"

+#include <filesystem>
 #include <map>
 #include <string>
 #include <vector>
@@ -28,6 +29,7 @@ extern unsigned int nWalletDBUpdated;

 void ThreadFlushWalletDB(void* parg);
 bool BackupWallet(const CWallet& wallet, const std::string& strDest);
+bool AutoBackupWallet(const std::filesystem::path& walletPath);


 class CDBEnv
@@ -36,7 +38,7 @@ private:
    bool fDetachDB;
    bool fDbEnvInit;
    bool fMockDb;
-    boost::filesystem::path pathEnv;
+    std::filesystem::path pathEnv;
    std::string strPath;

    void EnvShutdown();
@@ -70,7 +72,7 @@ public:
    typedef std::pair<std::vector<unsigned char>, std::vector<unsigned char> > KeyValPair;
    bool Salvage(std::string strFile, bool fAggressive, std::vector<KeyValPair>& vResult);

-    bool Open(boost::filesystem::path pathEnv_);
+    bool Open(std::filesystem::path pathEnv_);
    void Close();
    void Flush(bool fShutdown);
    void CheckpointLSN(std::string strFile);
@@ -82,10 +84,10 @@ public:

    DbTxn *TxnBegin(int flags=DB_TXN_WRITE_NOSYNC)
    {
-        DbTxn* ptxn = NULL;
-        int ret = dbenv.txn_begin(NULL, &ptxn, flags);
+        DbTxn* ptxn = nullptr;
+        int ret = dbenv.txn_begin(nullptr, &ptxn, flags);
        if (!ptxn || ret != 0)
-            return NULL;
+            return nullptr;
        return ptxn;
    }
 };
@@ -128,7 +130,7 @@ protected:
        datValue.set_flags(DB_DBT_MALLOC);
        int ret = pdb->get(activeTxn, &datKey, &datValue, 0);
        memset(datKey.get_data(), 0, datKey.get_size());
-        if (datValue.get_data() == NULL)
+        if (datValue.get_data() == nullptr)
            return false;

        // Unserialize value
@@ -220,11 +222,11 @@ protected:
    Dbc* GetCursor()
    {
        if (!pdb)
-            return NULL;
-        Dbc* pcursor = NULL;
-        int ret = pdb->cursor(NULL, &pcursor, 0);
+            return nullptr;
+        Dbc* pcursor = nullptr;
+        int ret = pdb->cursor(nullptr, &pcursor, 0);
        if (ret != 0)
-            return NULL;
+            return nullptr;
        return pcursor;
    }

@@ -248,7 +250,7 @@ protected:
        int ret = pcursor->get(&datKey, &datValue, fFlags);
        if (ret != 0)
            return ret;
-        else if (datKey.get_data() == NULL || datValue.get_data() == NULL)
+        else if (datKey.get_data() == nullptr || datValue.get_data() == nullptr)
            return 99999;

        // Convert to streams
@@ -284,7 +286,7 @@ public:
        if (!pdb || !activeTxn)
            return false;
        int ret = activeTxn->commit(0);
-        activeTxn = NULL;
+        activeTxn = nullptr;
        return (ret == 0);
    }

@@ -293,7 +295,7 @@ public:
        if (!pdb || !activeTxn)
            return false;
        int ret = activeTxn->abort();
-        activeTxn = NULL;
+        activeTxn = nullptr;
        return (ret == 0);
    }

@@ -308,7 +310,7 @@ public:
        return Write(std::string("version"), nVersion);
    }

-    bool static Rewrite(const std::string& strFile, const char* pszSkip = NULL);
+    bool static Rewrite(const std::string& strFile, const char* pszSkip = nullptr);
 };


@@ -316,7 +318,7 @@ public:
 class CAddrDB
 {
 private:
-    boost::filesystem::path pathAddr;
+    std::filesystem::path pathAddr;
 public:
    CAddrDB();
    bool Write(const CAddrMan& addr);
@@ -6,9 +6,10 @@
 #define TRIANGLES_INIT_H

 #include "wallet.h"
-#include <tor/anonymize.h>
+#include "tor_embed_hooks.h"
+#include <memory>

-extern CWallet* pwalletMain;
+extern std::unique_ptr<CWallet> pwalletMain;
 extern std::string strWalletFileName;
 void StartShutdown();
 bool ShutdownRequested();
@@ -1,405 +0,0 @@
-// Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2012 The Bitcoin developers
-// Distributed under the MIT/X11 software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#include "irc.h"
-#include "net.h"
-#include "strlcpy.h"
-#include "base58.h"
-
-using namespace std;
-using namespace boost;
-
-int nGotIRCAddresses = 0;
-
-void ThreadIRCSeed2(void* parg);
-
-
-
-
-#pragma pack(push, 1)
-struct ircaddr
-{
-    struct in_addr ip;
-    short port;
-};
-#pragma pack(pop)
-
-string EncodeAddress(const CService& addr)
-{
-    struct ircaddr tmp;
-    if (addr.GetInAddr(&tmp.ip))
-    {
-        tmp.port = htons(addr.GetPort());
-
-        vector<unsigned char> vch(UBEGIN(tmp), UEND(tmp));
-        return string("u") + EncodeBase58Check(vch);
-    }
-    return "";
-}
-
-bool DecodeAddress(string str, CService& addr)
-{
-    vector<unsigned char> vch;
-    if (!DecodeBase58Check(str.substr(1), vch))
-        return false;
-
-    struct ircaddr tmp;
-    if (vch.size() != sizeof(tmp))
-        return false;
-    memcpy(&tmp, &vch[0], sizeof(tmp));
-
-    addr = CService(tmp.ip, ntohs(tmp.port));
-    return true;
-}
-
-
-
-
-
-
-static bool Send(SOCKET hSocket, const char* pszSend)
-{
-    if (strstr(pszSend, "PONG") != pszSend)
-        printf("IRC SENDING: %s\n", pszSend);
-    const char* psz = pszSend;
-    const char* pszEnd = psz + strlen(psz);
-    while (psz < pszEnd)
-    {
-        int ret = send(hSocket, psz, pszEnd - psz, MSG_NOSIGNAL);
-        if (ret < 0)
-            return false;
-        psz += ret;
-    }
-    return true;
-}
-
-bool RecvLineIRC(SOCKET hSocket, string& strLine)
-{
-    while (true)
-    {
-        bool fRet = RecvLine(hSocket, strLine);
-        if (fRet)
-        {
-            if (fShutdown)
-                return false;
-            vector<string> vWords;
-            ParseString(strLine, ' ', vWords);
-            if (vWords.size() >= 1 && vWords[0] == "PING")
-            {
-                strLine[1] = 'O';
-                strLine += '\r';
-                Send(hSocket, strLine.c_str());
-                continue;
-            }
-        }
-        return fRet;
-    }
-}
-
-int RecvUntil(SOCKET hSocket, const char* psz1, const char* psz2=NULL, const char* psz3=NULL, const char* psz4=NULL)
-{
-    while(true)
-    {
-        string strLine;
-        strLine.reserve(10000);
-        if (!RecvLineIRC(hSocket, strLine))
-            return 0;
-        printf("IRC %s\n", strLine.c_str());
-        if (psz1 && strLine.find(psz1) != string::npos)
-            return 1;
-        if (psz2 && strLine.find(psz2) != string::npos)
-            return 2;
-        if (psz3 && strLine.find(psz3) != string::npos)
-            return 3;
-        if (psz4 && strLine.find(psz4) != string::npos)
-            return 4;
-    }
-}
-
-bool Wait(int nSeconds)
-{
-    if (fShutdown)
-        return false;
-    printf("IRC waiting %d seconds to reconnect\n", nSeconds);
-    for (int i = 0; i < nSeconds; i++)
-    {
-        if (fShutdown)
-            return false;
-        MilliSleep(1000);
-    }
-    return true;
-}
-
-bool RecvCodeLine(SOCKET hSocket, const char* psz1, string& strRet)
-{
-    strRet.clear();
-    while (true)
-    {
-        string strLine;
-        if (!RecvLineIRC(hSocket, strLine))
-            return false;
-
-        vector<string> vWords;
-        ParseString(strLine, ' ', vWords);
-        if (vWords.size() < 2)
-            continue;
-
-        if (vWords[1] == psz1)
-        {
-            printf("IRC %s\n", strLine.c_str());
-            strRet = strLine;
-            return true;
-        }
-    }
-}
-
-bool GetIPFromIRC(SOCKET hSocket, string strMyName, CNetAddr& ipRet)
-{
-    Send(hSocket, strprintf("USERHOST %s\r", strMyName.c_str()).c_str());
-
-    string strLine;
-    if (!RecvCodeLine(hSocket, "302", strLine))
-        return false;
-
-    vector<string> vWords;
-    ParseString(strLine, ' ', vWords);
-    if (vWords.size() < 4)
-        return false;
-
-    string str = vWords[3];
-    if (str.rfind("@") == string::npos)
-        return false;
-    string strHost = str.substr(str.rfind("@")+1);
-
-    // Hybrid IRC used by lfnet always returns IP when you userhost yourself,
-    // but in case another IRC is ever used this should work.
-    printf("GetIPFromIRC() got userhost %s\n", strHost.c_str());
-    CNetAddr addr(strHost, true);
-    if (!addr.IsValid())
-        return false;
-    ipRet = addr;
-
-    return true;
-}
-
-
-
-void ThreadIRCSeed(void* parg)
-{
-    // Make this thread recognisable as the IRC seeding thread
-    RenameThread("Triangles-ircseed");
-
-    try
-    {
-        ThreadIRCSeed2(parg);
-    }
-    catch (std::exception& e) {
-        PrintExceptionContinue(&e, "ThreadIRCSeed()");
-    } catch (...) {
-        PrintExceptionContinue(NULL, "ThreadIRCSeed()");
-    }
-    printf("ThreadIRCSeed exited\n");
-}
-
-void ThreadIRCSeed2(void* parg)
-{
-    // Don't connect to IRC if we won't use IPv4 connections.
-    if (IsLimited(NET_IPV4))
-        return;
-
-    // ... or if we won't make outbound connections and won't accept inbound ones.
-    if (mapArgs.count("-connect") && fNoListen)
-        return;
-
-    // ... or if IRC is not enabled.
-    if (!GetBoolArg("-irc", false))
-        return;
-
-    printf("ThreadIRCSeed started\n");
-    int nErrorWait = 10;
-    int nRetryWait = 10;
-    int nNameRetry = 0;
-
-    while (!fShutdown)
-    {
-        CService addrConnect("92.243.23.21", 6667); // irc.lfnet.org
-
-        CService addrIRC("irc.lfnet.org", 6667, true);
-        if (addrIRC.IsValid())
-            addrConnect = addrIRC;
-
-        SOCKET hSocket;
-        if (!ConnectSocket(addrConnect, hSocket))
-        {
-            printf("IRC connect failed\n");
-            nErrorWait = nErrorWait * 11 / 10;
-            if (Wait(nErrorWait += 60))
-                continue;
-            else
-                return;
-        }
-
-        if (!RecvUntil(hSocket, "Found your hostname", "using your IP address instead", "Couldn't look up your hostname", "ignoring hostname"))
-        {
-            closesocket(hSocket);
-            hSocket = INVALID_SOCKET;
-            nErrorWait = nErrorWait * 11 / 10;
-            if (Wait(nErrorWait += 60))
-                continue;
-            else
-                return;
-        }
-
-        CNetAddr addrIPv4("1.2.3.4"); // arbitrary IPv4 address to make GetLocal prefer IPv4 addresses
-        CService addrLocal;
-        string strMyName;
-        // Don't use our IP as our nick if we're not listening
-        // or if it keeps failing because the nick is already in use.
-        if (!fNoListen && GetLocal(addrLocal, &addrIPv4) && nNameRetry<3)
-            strMyName = EncodeAddress(GetLocalAddress(&addrConnect));
-        if (strMyName == "")
-            strMyName = strprintf("x%"PRIu64"", GetRand(1000000000));
-
-        Send(hSocket, strprintf("NICK %s\r", strMyName.c_str()).c_str());
-        Send(hSocket, strprintf("USER %s 8 * : %s\r", strMyName.c_str(), strMyName.c_str()).c_str());
-
-        int nRet = RecvUntil(hSocket, " 004 ", " 433 ");
-        if (nRet != 1)
-        {
-            closesocket(hSocket);
-            hSocket = INVALID_SOCKET;
-            if (nRet == 2)
-            {
-                printf("IRC name already in use\n");
-                nNameRetry++;
-                Wait(10);
-                continue;
-            }
-            nErrorWait = nErrorWait * 11 / 10;
-            if (Wait(nErrorWait += 60))
-                continue;
-            else
-                return;
-        }
-        nNameRetry = 0;
-        MilliSleep(500);
-
-        // Get our external IP from the IRC server and re-nick before joining the channel
-        CNetAddr addrFromIRC;
-        if (GetIPFromIRC(hSocket, strMyName, addrFromIRC))
-        {
-            printf("GetIPFromIRC() returned %s\n", addrFromIRC.ToString().c_str());
-            // Don't use our IP as our nick if we're not listening
-            if (!fNoListen && addrFromIRC.IsRoutable())
-            {
-                // IRC lets you to re-nick
-                AddLocal(addrFromIRC, LOCAL_IRC);
-                strMyName = EncodeAddress(GetLocalAddress(&addrConnect));
-                Send(hSocket, strprintf("NICK %s\r", strMyName.c_str()).c_str());
-            }
-        }
-
-        if (fTestNet) {
-            Send(hSocket, "JOIN #TrianglesTEST\r");
-            Send(hSocket, "WHO #TrianglesTEST\r");
-        } else {
-            // randomly join
-            // int channel_number = GetRandInt(5);
-
-            // Channel number is always 0 for initial release
-            int channel_number = 0;
-            Send(hSocket, strprintf("JOIN #Triangles%02d\r", channel_number).c_str());
-            Send(hSocket, strprintf("WHO #Triangles%02d\r", channel_number).c_str());
-        }
-
-        int64_t nStart = GetTime();
-        string strLine;
-        strLine.reserve(10000);
-        while (!fShutdown && RecvLineIRC(hSocket, strLine))
-        {
-            if (strLine.empty() || strLine.size() > 900 || strLine[0] != ':')
-                continue;
-
-            vector<string> vWords;
-            ParseString(strLine, ' ', vWords);
-            if (vWords.size() < 2)
-                continue;
-
-            char pszName[10000];
-            pszName[0] = '\0';
-
-            if (vWords[1] == "352" && vWords.size() >= 8)
-            {
-                // index 7 is limited to 16 characters
-                // could get full length name at index 10, but would be different from join messages
-                strlcpy(pszName, vWords[7].c_str(), sizeof(pszName));
-                printf("IRC got who\n");
-            }
-
-            if (vWords[1] == "JOIN" && vWords[0].size() > 1)
-            {
-                // :username!username@50000007.F000000B.90000002.IP JOIN :#channelname
-                strlcpy(pszName, vWords[0].c_str() + 1, sizeof(pszName));
-                if (strchr(pszName, '!'))
-                    *strchr(pszName, '!') = '\0';
-                printf("IRC got join\n");
-            }
-
-            if (pszName[0] == 'u')
-            {
-                CAddress addr;
-                if (DecodeAddress(pszName, addr))
-                {
-                    addr.nTime = GetAdjustedTime();
-                    if (addrman.Add(addr, addrConnect, 51 * 60))
-                        printf("IRC got new address: %s\n", addr.ToString().c_str());
-                    nGotIRCAddresses++;
-                }
-                else
-                {
-                    printf("IRC decode failed\n");
-                }
-            }
-        }
-        closesocket(hSocket);
-        hSocket = INVALID_SOCKET;
-
-        if (GetTime() - nStart > 20 * 60)
-        {
-            nErrorWait /= 3;
-            nRetryWait /= 3;
-        }
-
-        nRetryWait = nRetryWait * 11 / 10;
-        if (!Wait(nRetryWait += 60))
-            return;
-    }
-}
-
-
-
-
-
-
-
-
-
-
-#ifdef TEST
-int main(int argc, char *argv[])
-{
-    WSADATA wsadata;
-    if (WSAStartup(MAKEWORD(2,2), &wsadata) != NO_ERROR)
-    {
-        printf("Error at WSAStartup()\n");
-        return false;
-    }
-
-    ThreadIRCSeed(NULL);
-
-    WSACleanup();
-    return 0;
-}
-#endif
@@ -1,12 +0,0 @@
-// Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2012 The Bitcoin developers
-// Distributed under the MIT/X11 software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-#ifndef TRIANGLES_IRC_H
-#define TRIANGLES_IRC_H
-
-void ThreadIRCSeed(void* parg);
-
-extern int nGotIRCAddresses;
-
-#endif
@@ -0,0 +1,284 @@
+// Copyright (c) 2024-2026 Triangles developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+//
+// Drop-in compatibility layer: json_spirit API backed by nlohmann/json.
+// Provides the same types (Value, Object, Array, Pair) and functions
+// (find_value, write_string, read_string) in the json_spirit namespace,
+// so existing RPC code compiles without changes.
+
+#ifndef JSON_COMPAT_H
+#define JSON_COMPAT_H
+
+#include "nlohmann_json.hpp"
+
+#include <cstdint>
+#include <map>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace json_spirit {
+
+// Use ordered_json to preserve insertion order (matches json_spirit's vector<Pair> behavior)
+typedef nlohmann::ordered_json json_internal;
+
+// ---------- Type enum (matches json_spirit exactly) ----------
+
+enum Value_type {
+    obj_type   = 0,
+    array_type = 1,
+    str_type   = 2,
+    bool_type  = 3,
+    int_type   = 4,
+    real_type  = 5,
+    null_type  = 6
+};
+
+inline const char* ValueTypeName(Value_type type)
+{
+    switch (type)
+    {
+    case obj_type:   return "obj";
+    case array_type: return "array";
+    case str_type:   return "str";
+    case bool_type:  return "bool";
+    case int_type:   return "int";
+    case real_type:  return "real";
+    case null_type:  return "null";
+    }
+    return "unknown";
+}
+
+// ---------- Forward declarations ----------
+
+class Value;
+struct Pair;
+
+// ---------- Value ----------
+
+class Value {
+    json_internal j_;
+
+    friend std::string write_string(const Value& val, bool pretty);
+    friend bool read_string(const std::string& s, Value& val);
+    friend bool read(const std::string& s, Value& val);
+
+public:
+    // Default: null
+    Value() : j_(nullptr) {}
+
+    // Primitives
+    Value(const char* s)        : j_(std::string(s)) {}
+    Value(const std::string& s) : j_(s) {}
+    Value(bool b)               : j_(b) {}
+    Value(int i)                : j_(static_cast<int64_t>(i)) {}
+    Value(unsigned int u)       : j_(static_cast<uint64_t>(u)) {}
+    Value(int64_t i)            : j_(i) {}
+    Value(uint64_t u)           : j_(u) {}
+    Value(double d)             : j_(d) {}
+
+    // Compound types (defined after Pair/Object/Array)
+    inline Value(const std::vector<Pair>& obj);
+    inline Value(const std::vector<Value>& arr);
+
+    // Type introspection
+    Value_type type() const {
+        if (j_.is_null())            return null_type;
+        if (j_.is_object())          return obj_type;
+        if (j_.is_array())           return array_type;
+        if (j_.is_string())          return str_type;
+        if (j_.is_boolean())         return bool_type;
+        if (j_.is_number_integer())  return int_type;
+        if (j_.is_number_float())    return real_type;
+        return null_type;
+    }
+
+    bool is_null()   const { return j_.is_null(); }
+    bool is_uint64() const { return j_.is_number_unsigned(); }
+
+    // Accessors (throw on type mismatch, matching json_spirit semantics)
+    const std::string& get_str() const {
+        if (!j_.is_string())
+            throw std::runtime_error("value type is not str");
+        return j_.get_ref<const std::string&>();
+    }
+
+    bool get_bool() const {
+        if (!j_.is_boolean())
+            throw std::runtime_error("value type is not bool");
+        return j_.get<bool>();
+    }
+
+    int get_int() const {
+        if (!j_.is_number_integer())
+            throw std::runtime_error("value type is not int");
+        return j_.get<int>();
+    }
+
+    int64_t get_int64() const {
+        if (!j_.is_number_integer())
+            throw std::runtime_error("value type is not int");
+        return j_.get<int64_t>();
+    }
+
+    uint64_t get_uint64() const {
+        if (!j_.is_number_integer())
+            throw std::runtime_error("value type is not int");
+        return j_.get<uint64_t>();
+    }
+
+    double get_real() const {
+        // json_spirit converts ints to double in get_real()
+        if (!j_.is_number())
+            throw std::runtime_error("value type is not numeric");
+        return j_.get<double>();
+    }
+
+    // Compound accessors (defined after Pair/Object/Array)
+    inline std::vector<Pair> get_obj() const;
+    inline std::vector<Value> get_array() const;
+
+    // Map-based object accessor for mValue compatibility
+    inline std::map<std::string, Value> get_map_obj() const;
+
+    // Template accessor (used by ConvertTo<T>)
+    template<typename T> T get_value() const;
+
+    // Static null constant (matches json_spirit::Value::null)
+    static const Value null;
+
+    bool operator==(const Value& o) const { return j_ == o.j_; }
+    bool operator!=(const Value& o) const { return j_ != o.j_; }
+};
+
+// Define the static member
+inline const Value Value::null{};
+
+// ---------- Pair ----------
+
+struct Pair {
+    std::string name_;
+    Value       value_;
+
+    Pair() {}
+    Pair(const std::string& name, const Value& value)
+        : name_(name), value_(value) {}
+
+    bool operator==(const Pair& o) const { return name_ == o.name_; }
+};
+
+// ---------- Object / Array typedefs ----------
+
+typedef std::vector<Pair>  Object;
+typedef std::vector<Value> Array;
+
+// ---------- Map-based aliases (mValue/mObject for messagemodel.cpp compat) ----------
+
+typedef Value mValue;
+typedef std::map<std::string, Value> mObject;
+
+// ---------- Value compound constructors ----------
+
+inline Value::Value(const std::vector<Pair>& obj) {
+    j_ = json_internal::object();
+    for (const auto& p : obj)
+        j_[p.name_] = p.value_.j_;
+}
+
+inline Value::Value(const std::vector<Value>& arr) {
+    j_ = json_internal::array();
+    for (const auto& v : arr)
+        j_.push_back(v.j_);
+}
+
+// ---------- Value compound accessors ----------
+
+inline std::vector<Pair> Value::get_obj() const {
+    if (!j_.is_object())
+        throw std::runtime_error("value type is not obj");
+    std::vector<Pair> result;
+    result.reserve(j_.size());
+    for (auto it = j_.begin(); it != j_.end(); ++it) {
+        Value v;
+        v.j_ = it.value();
+        result.emplace_back(it.key(), v);
+    }
+    return result;
+}
+
+inline std::vector<Value> Value::get_array() const {
+    if (!j_.is_array())
+        throw std::runtime_error("value type is not array");
+    std::vector<Value> result;
+    result.reserve(j_.size());
+    for (const auto& elem : j_) {
+        Value v;
+        v.j_ = elem;
+        result.push_back(v);
+    }
+    return result;
+}
+
+inline std::map<std::string, Value> Value::get_map_obj() const {
+    if (!j_.is_object())
+        throw std::runtime_error("value type is not obj");
+    std::map<std::string, Value> result;
+    for (auto it = j_.begin(); it != j_.end(); ++it) {
+        Value v;
+        v.j_ = it.value();
+        result[it.key()] = v;
+    }
+    return result;
+}
+
+// ---------- Template get_value specializations ----------
+
+template<> inline std::string Value::get_value<std::string>() const { return get_str(); }
+template<> inline bool        Value::get_value<bool>()        const { return get_bool(); }
+template<> inline int         Value::get_value<int>()         const { return get_int(); }
+template<> inline int64_t     Value::get_value<int64_t>()     const { return get_int64(); }
+template<> inline uint64_t    Value::get_value<uint64_t>()    const { return get_uint64(); }
+template<> inline double      Value::get_value<double>()      const { return get_real(); }
+template<> inline Object      Value::get_value<Object>()      const { return get_obj(); }
+template<> inline Array       Value::get_value<Array>()       const { return get_array(); }
+
+// ---------- Utility functions ----------
+
+inline const Value& find_value(const Object& obj, const std::string& name) {
+    for (const auto& p : obj)
+        if (p.name_ == name)
+            return p.value_;
+    static const Value null_value;
+    return null_value;
+}
+
+inline std::string write_string(const Value& val, bool pretty = false) {
+    return val.j_.dump(pretty ? 4 : -1);
+}
+
+inline bool read_string(const std::string& s, Value& val) {
+    try {
+        val.j_ = json_internal::parse(s);
+        return true;
+    } catch (const nlohmann::detail::parse_error&) {
+        return false;
+    }
+}
+
+// Alias matching json_spirit::read() signature (used by messagemodel.cpp)
+inline bool read(const std::string& s, Value& val) {
+    return read_string(s, val);
+}
+
+// Stream-based reader (used by test harness read_json)
+template<typename Istream>
+inline bool read_stream(Istream& is, Value& val) {
+    std::string s((std::istreambuf_iterator<char>(is)),
+                   std::istreambuf_iterator<char>());
+    return read_string(s, val);
+}
+
+} // namespace json_spirit
+
+#endif // JSON_COMPAT_H
@@ -1,18 +0,0 @@
-#ifndef JSON_SPIRIT
-#define JSON_SPIRIT
-
-//          Copyright John W. Wilkinson 2007 - 2009.
-// Distributed under the MIT License, see accompanying file LICENSE.txt
-
-// json spirit version 4.03
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-#include "json_spirit_value.h"
-#include "json_spirit_reader.h"
-#include "json_spirit_writer.h"
-#include "json_spirit_utils.h"
-
-#endif
@@ -1,54 +0,0 @@
-#ifndef JSON_SPIRIT_ERROR_POSITION
-#define JSON_SPIRIT_ERROR_POSITION
-
-//          Copyright John W. Wilkinson 2007 - 2009.
-// Distributed under the MIT License, see accompanying file LICENSE.txt
-
-// json spirit version 4.03
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-#include <string>
-
-namespace json_spirit
-{
-    // An Error_position exception is thrown by the "read_or_throw" functions below on finding an error.
-    // Note the "read_or_throw" functions are around 3 times slower than the standard functions "read" 
-    // functions that return a bool.
-    //
-    struct Error_position
-    {
-        Error_position();
-        Error_position( unsigned int line, unsigned int column, const std::string& reason );
-        bool operator==( const Error_position& lhs ) const;
-        unsigned int line_;
-        unsigned int column_;
-        std::string reason_;
-    };
-
-    inline Error_position::Error_position()
-    :   line_( 0 )
-    ,   column_( 0 )
-    {
-    }
-
-    inline Error_position::Error_position( unsigned int line, unsigned int column, const std::string& reason )
-    :   line_( line )
-    ,   column_( column )
-    ,   reason_( reason )
-    {
-    }
-
-    inline bool Error_position::operator==( const Error_position& lhs ) const
-    {
-        if( this == &lhs ) return true;
-
-        return ( reason_ == lhs.reason_ ) &&
-               ( line_   == lhs.line_ ) &&
-               ( column_ == lhs.column_ ); 
-}
-}
-
-#endif
@@ -1,137 +0,0 @@
-//          Copyright John W. Wilkinson 2007 - 2009.
-// Distributed under the MIT License, see accompanying file LICENSE.txt
-
-// json spirit version 4.03
-
-#include "json_spirit_reader.h"
-#include "json_spirit_reader_template.h"
-
-using namespace json_spirit;
-
-bool json_spirit::read( const std::string& s, Value& value )
-{
-    return read_string( s, value );
-}
-
-void json_spirit::read_or_throw( const std::string& s, Value& value )
-{
-    read_string_or_throw( s, value );
-}
-
-bool json_spirit::read( std::istream& is, Value& value )
-{
-    return read_stream( is, value );
-}
-
-void json_spirit::read_or_throw( std::istream& is, Value& value )
-{
-    read_stream_or_throw( is, value );
-}
-
-bool json_spirit::read( std::string::const_iterator& begin, std::string::const_iterator end, Value& value )
-{
-    return read_range( begin, end, value );
-}
-
-void json_spirit::read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, Value& value )
-{
-    begin = read_range_or_throw( begin, end, value );
-}
-
-#ifndef BOOST_NO_STD_WSTRING
-
-bool json_spirit::read( const std::wstring& s, wValue& value )
-{
-    return read_string( s, value );
-}
-
-void json_spirit::read_or_throw( const std::wstring& s, wValue& value )
-{
-    read_string_or_throw( s, value );
-}
-
-bool json_spirit::read( std::wistream& is, wValue& value )
-{
-    return read_stream( is, value );
-}
-
-void json_spirit::read_or_throw( std::wistream& is, wValue& value )
-{
-    read_stream_or_throw( is, value );
-}
-
-bool json_spirit::read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value )
-{
-    return read_range( begin, end, value );
-}
-
-void json_spirit::read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value )
-{
-    begin = read_range_or_throw( begin, end, value );
-}
-
-#endif
-
-bool json_spirit::read( const std::string& s, mValue& value )
-{
-    return read_string( s, value );
-}
-
-void json_spirit::read_or_throw( const std::string& s, mValue& value )
-{
-    read_string_or_throw( s, value );
-}
-
-bool json_spirit::read( std::istream& is, mValue& value )
-{
-    return read_stream( is, value );
-}
-
-void json_spirit::read_or_throw( std::istream& is, mValue& value )
-{
-    read_stream_or_throw( is, value );
-}
-
-bool json_spirit::read( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value )
-{
-    return read_range( begin, end, value );
-}
-
-void json_spirit::read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value )
-{
-    begin = read_range_or_throw( begin, end, value );
-}
-
-#ifndef BOOST_NO_STD_WSTRING
-
-bool json_spirit::read( const std::wstring& s, wmValue& value )
-{
-    return read_string( s, value );
-}
-
-void json_spirit::read_or_throw( const std::wstring& s, wmValue& value )
-{
-    read_string_or_throw( s, value );
-}
-
-bool json_spirit::read( std::wistream& is, wmValue& value )
-{
-    return read_stream( is, value );
-}
-
-void json_spirit::read_or_throw( std::wistream& is, wmValue& value )
-{
-    read_stream_or_throw( is, value );
-}
-
-bool json_spirit::read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value )
-{
-    return read_range( begin, end, value );
-}
-
-void json_spirit::read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value )
-{
-    begin = read_range_or_throw( begin, end, value );
-}
-
-#endif
@@ -1,62 +0,0 @@
-#ifndef JSON_SPIRIT_READER
-#define JSON_SPIRIT_READER
-
-//          Copyright John W. Wilkinson 2007 - 2009.
-// Distributed under the MIT License, see accompanying file LICENSE.txt
-
-// json spirit version 4.03
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-#include "json_spirit_value.h"
-#include "json_spirit_error_position.h"
-#include <iostream>
-
-namespace json_spirit
-{
-    // functions to reads a JSON values
-
-    bool read( const std::string& s, Value& value );
-    bool read( std::istream& is,     Value& value );
-    bool read( std::string::const_iterator& begin, std::string::const_iterator end, Value& value );
-
-    void read_or_throw( const std::string& s, Value& value );  
-    void read_or_throw( std::istream& is,     Value& value );
-    void read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, Value& value );
-
-#ifndef BOOST_NO_STD_WSTRING
-
-    bool read( const std::wstring& s, wValue& value );
-    bool read( std::wistream&  is,    wValue& value );
-    bool read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value );    
-
-    void read_or_throw( const std::wstring& s, wValue& value );
-    void read_or_throw( std::wistream& is,     wValue& value );
-    void read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value );
-
-#endif
-
-    bool read( const std::string& s, mValue& value );
-    bool read( std::istream& is,     mValue& value );
-    bool read( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value );
-
-    void read_or_throw( const std::string& s, mValue& value );  
-    void read_or_throw( std::istream& is,     mValue& value );
-    void read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value );
-
-#ifndef BOOST_NO_STD_WSTRING
-
-    bool read( const std::wstring& s, wmValue& value );
-    bool read( std::wistream& is,     wmValue& value );
-    bool read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value );    
-
-    void read_or_throw( const std::wstring& s, wmValue& value );
-    void read_or_throw( std::wistream& is,     wmValue& value );
-    void read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value );
-
-#endif
-}
-
-#endif
@@ -1,612 +0,0 @@
-#ifndef JSON_SPIRIT_READER_TEMPLATE
-#define JSON_SPIRIT_READER_TEMPLATE
-
-//          Copyright John W. Wilkinson 2007 - 2009.
-// Distributed under the MIT License, see accompanying file LICENSE.txt
-
-// json spirit version 4.03
-
-#include "json_spirit_value.h"
-#include "json_spirit_error_position.h"
-
-//#define BOOST_SPIRIT_THREADSAFE  // uncomment for multithreaded use, requires linking to boost.thread
-
-#include <boost/bind.hpp>
-#include <boost/function.hpp>
-#include <boost/version.hpp>
-
-#if BOOST_VERSION >= 103800
-    #include <boost/spirit/include/classic_core.hpp>
-    #include <boost/spirit/include/classic_confix.hpp>
-    #include <boost/spirit/include/classic_escape_char.hpp>
-    #include <boost/spirit/include/classic_multi_pass.hpp>
-    #include <boost/spirit/include/classic_position_iterator.hpp>
-    #define spirit_namespace boost::spirit::classic
-#else
-    #include <boost/spirit/core.hpp>
-    #include <boost/spirit/utility/confix.hpp>
-    #include <boost/spirit/utility/escape_char.hpp>
-    #include <boost/spirit/iterator/multi_pass.hpp>
-    #include <boost/spirit/iterator/position_iterator.hpp>
-    #define spirit_namespace boost::spirit
-#endif
-
-namespace json_spirit
-{
-    const spirit_namespace::int_parser < boost::int64_t >  int64_p  = spirit_namespace::int_parser < boost::int64_t  >();
-    const spirit_namespace::uint_parser< boost::uint64_t > uint64_p = spirit_namespace::uint_parser< boost::uint64_t >();
-
-    template< class Iter_type >
-    bool is_eq( Iter_type first, Iter_type last, const char* c_str )
-    {
-        for( Iter_type i = first; i != last; ++i, ++c_str )
-        {
-            if( *c_str == 0 ) return false;
-
-            if( *i != *c_str ) return false;
-        }
-
-        return true;
-    }
-
-    template< class Char_type >
-    Char_type hex_to_num( const Char_type c )
-    {
-        if( ( c >= '0' ) && ( c <= '9' ) ) return c - '0';
-        if( ( c >= 'a' ) && ( c <= 'f' ) ) return c - 'a' + 10;
-        if( ( c >= 'A' ) && ( c <= 'F' ) ) return c - 'A' + 10;
-        return 0;
-    }
-
-    template< class Char_type, class Iter_type >
-    Char_type hex_str_to_char( Iter_type& begin )
-    {
-        const Char_type c1( *( ++begin ) );
-        const Char_type c2( *( ++begin ) );
-
-        return ( hex_to_num( c1 ) << 4 ) + hex_to_num( c2 );
-    }       
-
-    template< class Char_type, class Iter_type >
-    Char_type unicode_str_to_char( Iter_type& begin )
-    {
-        const Char_type c1( *( ++begin ) );
-        const Char_type c2( *( ++begin ) );
-        const Char_type c3( *( ++begin ) );
-        const Char_type c4( *( ++begin ) );
-
-        return ( hex_to_num( c1 ) << 12 ) + 
-               ( hex_to_num( c2 ) <<  8 ) + 
-               ( hex_to_num( c3 ) <<  4 ) + 
-               hex_to_num( c4 );
-    }
-
-    template< class String_type >
-    void append_esc_char_and_incr_iter( String_type& s, 
-                                        typename String_type::const_iterator& begin, 
-                                        typename String_type::const_iterator end )
-    {
-        typedef typename String_type::value_type Char_type;
-             
-        const Char_type c2( *begin );
-
-        switch( c2 )
-        {
-            case 't':  s += '\t'; break;
-            case 'b':  s += '\b'; break;
-            case 'f':  s += '\f'; break;
-            case 'n':  s += '\n'; break;
-            case 'r':  s += '\r'; break;
-            case '\\': s += '\\'; break;
-            case '/':  s += '/';  break;
-            case '"':  s += '"';  break;
-            case 'x':  
-            {
-                if( end - begin >= 3 )  //  expecting "xHH..."
-                {
-                    s += hex_str_to_char< Char_type >( begin );  
-                }
-                break;
-            }
-            case 'u':  
-            {
-                if( end - begin >= 5 )  //  expecting "uHHHH..."
-                {
-                    s += unicode_str_to_char< Char_type >( begin );  
-                }
-                break;
-            }
-        }
-    }
-
-    template< class String_type >
-    String_type substitute_esc_chars( typename String_type::const_iterator begin, 
-                                   typename String_type::const_iterator end )
-    {
-        typedef typename String_type::const_iterator Iter_type;
-
-        if( end - begin < 2 ) return String_type( begin, end );
-
-        String_type result;
-        
-        result.reserve( end - begin );
-
-        const Iter_type end_minus_1( end - 1 );
-
-        Iter_type substr_start = begin;
-        Iter_type i = begin;
-
-        for( ; i < end_minus_1; ++i )
-        {
-            if( *i == '\\' )
-            {
-                result.append( substr_start, i );
-
-                ++i;  // skip the '\'
-             
-                append_esc_char_and_incr_iter( result, i, end );
-
-                substr_start = i + 1;
-            }
-        }
-
-        result.append( substr_start, end );
-
-        return result;
-    }
-
-    template< class String_type >
-    String_type get_str_( typename String_type::const_iterator begin, 
-                       typename String_type::const_iterator end )
-    {
-        assert( end - begin >= 2 );
-
-        typedef typename String_type::const_iterator Iter_type;
-
-        Iter_type str_without_quotes( ++begin );
-        Iter_type end_without_quotes( --end );
-
-        return substitute_esc_chars< String_type >( str_without_quotes, end_without_quotes );
-    }
-
-    inline std::string get_str( std::string::const_iterator begin, std::string::const_iterator end )
-    {
-        return get_str_< std::string >( begin, end );
-    }
-
-    inline std::wstring get_str( std::wstring::const_iterator begin, std::wstring::const_iterator end )
-    {
-        return get_str_< std::wstring >( begin, end );
-    }
-    
-    template< class String_type, class Iter_type >
-    String_type get_str( Iter_type begin, Iter_type end )
-    {
-        const String_type tmp( begin, end );  // convert multipass iterators to string iterators
-
-        return get_str( tmp.begin(), tmp.end() );
-    }
-
-    // this class's methods get called by the spirit parse resulting
-    // in the creation of a JSON object or array
-    //
-    // NB Iter_type could be a std::string iterator, wstring iterator, a position iterator or a multipass iterator
-    //
-    template< class Value_type, class Iter_type >
-    class Semantic_actions 
-    {
-    public:
-
-        typedef typename Value_type::Config_type Config_type;
-        typedef typename Config_type::String_type String_type;
-        typedef typename Config_type::Object_type Object_type;
-        typedef typename Config_type::Array_type Array_type;
-        typedef typename String_type::value_type Char_type;
-
-        Semantic_actions( Value_type& value )
-        :   value_( value )
-        ,   current_p_( 0 )
-        {
-        }
-
-        void begin_obj( Char_type c )
-        {
-            assert( c == '{' );
-
-            begin_compound< Object_type >();
-        }
-
-        void end_obj( Char_type c )
-        {
-            assert( c == '}' );
-
-            end_compound();
-        }
-
-        void begin_array( Char_type c )
-        {
-            assert( c == '[' );
-     
-            begin_compound< Array_type >();
-        }
-
-        void end_array( Char_type c )
-        {
-            assert( c == ']' );
-
-            end_compound();
-        }
-
-        void new_name( Iter_type begin, Iter_type end )
-        {
-            assert( current_p_->type() == obj_type );
-
-            name_ = get_str< String_type >( begin, end );
-        }
-
-        void new_str( Iter_type begin, Iter_type end )
-        {
-            add_to_current( get_str< String_type >( begin, end ) );
-        }
-
-        void new_true( Iter_type begin, Iter_type end )
-        {
-            assert( is_eq( begin, end, "true" ) );
-
-            add_to_current( true );
-        }
-
-        void new_false( Iter_type begin, Iter_type end )
-        {
-            assert( is_eq( begin, end, "false" ) );
-
-            add_to_current( false );
-        }
-
-        void new_null( Iter_type begin, Iter_type end )
-        {
-            assert( is_eq( begin, end, "null" ) );
-
-            add_to_current( Value_type() );
-        }
-
-        void new_int( boost::int64_t i )
-        {
-            add_to_current( i );
-        }
-
-        void new_uint64( boost::uint64_t ui )
-        {
-            add_to_current( ui );
-        }
-
-        void new_real( double d )
-        {
-            add_to_current( d );
-        }
-
-    private:
-
-        Semantic_actions& operator=( const Semantic_actions& ); 
-                                    // to prevent "assignment operator could not be generated" warning
-
-        Value_type* add_first( const Value_type& value )
-        {
-            assert( current_p_ == 0 );
-
-            value_ = value;
-            current_p_ = &value_;
-            return current_p_;
-        }
-
-        template< class Array_or_obj >
-        void begin_compound()
-        {
-            if( current_p_ == 0 )
-            {
-                add_first( Array_or_obj() );
-            }
-            else
-            {
-                stack_.push_back( current_p_ );
-
-                Array_or_obj new_array_or_obj;   // avoid copy by building new array or object in place
-
-                current_p_ = add_to_current( new_array_or_obj );
-            }
-        }
-
-        void end_compound()
-        {
-            if( current_p_ != &value_ )
-            {
-                current_p_ = stack_.back();
-                
-                stack_.pop_back();
-            }    
-        }
-
-        Value_type* add_to_current( const Value_type& value )
-        {
-            if( current_p_ == 0 )
-            {
-                return add_first( value );
-            }
-            else if( current_p_->type() == array_type )
-            {
-                current_p_->get_array().push_back( value );
-
-                return &current_p_->get_array().back(); 
-            }
-            
-            assert( current_p_->type() == obj_type );
-
-            return &Config_type::add( current_p_->get_obj(), name_, value );
-        }
-
-        Value_type& value_;             // this is the object or array that is being created
-        Value_type* current_p_;         // the child object or array that is currently being constructed
-
-        std::vector< Value_type* > stack_;   // previous child objects and arrays
-
-        String_type name_;              // of current name/value pair
-    };
-
-    template< typename Iter_type >
-    void throw_error( spirit_namespace::position_iterator< Iter_type > i, const std::string& reason )
-    {
-        throw Error_position( i.get_position().line, i.get_position().column, reason );
-    }
-
-    template< typename Iter_type >
-    void throw_error( Iter_type i, const std::string& reason )
-    {
-       throw reason;
-    }
-
-    // the spirit grammer 
-    //
-    template< class Value_type, class Iter_type >
-    class Json_grammer : public spirit_namespace::grammar< Json_grammer< Value_type, Iter_type > >
-    {
-    public:
-
-        typedef Semantic_actions< Value_type, Iter_type > Semantic_actions_t;
-
-        Json_grammer( Semantic_actions_t& semantic_actions )
-        :   actions_( semantic_actions )
-        {
-        }
-
-        static void throw_not_value( Iter_type begin, Iter_type end )
-        {
-    	    throw_error( begin, "not a value" );
-        }
-
-        static void throw_not_array( Iter_type begin, Iter_type end )
-        {
-    	    throw_error( begin, "not an array" );
-        }
-
-        static void throw_not_object( Iter_type begin, Iter_type end )
-        {
-    	    throw_error( begin, "not an object" );
-        }
-
-        static void throw_not_pair( Iter_type begin, Iter_type end )
-        {
-    	    throw_error( begin, "not a pair" );
-        }
-
-        static void throw_not_colon( Iter_type begin, Iter_type end )
-        {
-    	    throw_error( begin, "no colon in pair" );
-        }
-
-        static void throw_not_string( Iter_type begin, Iter_type end )
-        {
-    	    throw_error( begin, "not a string" );
-        }
-
-        template< typename ScannerT >
-        class definition
-        {
-        public:
-
-            definition( const Json_grammer& self )
-            {
-                using namespace spirit_namespace;
-
-                typedef typename Value_type::String_type::value_type Char_type;
-
-                // first we convert the semantic action class methods to functors with the 
-                // parameter signature expected by spirit
-
-                typedef boost::function< void( Char_type )            > Char_action;
-                typedef boost::function< void( Iter_type, Iter_type ) > Str_action;
-                typedef boost::function< void( double )               > Real_action;
-                typedef boost::function< void( boost::int64_t )       > Int_action;
-                typedef boost::function< void( boost::uint64_t )      > Uint64_action;
-
-                Char_action   begin_obj  ( boost::bind( &Semantic_actions_t::begin_obj,   &self.actions_, _1 ) );
-                Char_action   end_obj    ( boost::bind( &Semantic_actions_t::end_obj,     &self.actions_, _1 ) );
-                Char_action   begin_array( boost::bind( &Semantic_actions_t::begin_array, &self.actions_, _1 ) );
-                Char_action   end_array  ( boost::bind( &Semantic_actions_t::end_array,   &self.actions_, _1 ) );
-                Str_action    new_name   ( boost::bind( &Semantic_actions_t::new_name,    &self.actions_, _1, _2 ) );
-                Str_action    new_str    ( boost::bind( &Semantic_actions_t::new_str,     &self.actions_, _1, _2 ) );
-                Str_action    new_true   ( boost::bind( &Semantic_actions_t::new_true,    &self.actions_, _1, _2 ) );
-                Str_action    new_false  ( boost::bind( &Semantic_actions_t::new_false,   &self.actions_, _1, _2 ) );
-                Str_action    new_null   ( boost::bind( &Semantic_actions_t::new_null,    &self.actions_, _1, _2 ) );
-                Real_action   new_real   ( boost::bind( &Semantic_actions_t::new_real,    &self.actions_, _1 ) );
-                Int_action    new_int    ( boost::bind( &Semantic_actions_t::new_int,     &self.actions_, _1 ) );
-                Uint64_action new_uint64 ( boost::bind( &Semantic_actions_t::new_uint64,  &self.actions_, _1 ) );
-
-                // actual grammer
-
-                json_
-                    = value_ | eps_p[ &throw_not_value ]
-                    ;
-
-                value_
-                    = string_[ new_str ] 
-                    | number_ 
-                    | object_ 
-                    | array_ 
-                    | str_p( "true" ) [ new_true  ] 
-                    | str_p( "false" )[ new_false ] 
-                    | str_p( "null" ) [ new_null  ]
-                    ;
-
-                object_ 
-                    = ch_p('{')[ begin_obj ]
-                    >> !members_
-                    >> ( ch_p('}')[ end_obj ] | eps_p[ &throw_not_object ] )
-                    ;
-
-                members_
-                    = pair_ >> *( ',' >> pair_ )
-                    ;
-
-                pair_
-                    = string_[ new_name ]
-                    >> ( ':' | eps_p[ &throw_not_colon ] )
-                    >> ( value_ | eps_p[ &throw_not_value ] )
-                    ;
-
-                array_
-                    = ch_p('[')[ begin_array ]
-                    >> !elements_
-                    >> ( ch_p(']')[ end_array ] | eps_p[ &throw_not_array ] )
-                    ;
-
-                elements_
-                    = value_ >> *( ',' >> value_ )
-                    ;
-
-                string_ 
-                    = lexeme_d // this causes white space inside a string to be retained
-                      [
-                          confix_p
-                          ( 
-                              '"', 
-                              *lex_escape_ch_p,
-                              '"'
-                          ) 
-                      ]
-                    ;
-
-                number_
-                    = strict_real_p[ new_real   ] 
-                    | int64_p      [ new_int    ]
-                    | uint64_p     [ new_uint64 ]
-                    ;
-            }
-
-            spirit_namespace::rule< ScannerT > json_, object_, members_, pair_, array_, elements_, value_, string_, number_;
-
-            const spirit_namespace::rule< ScannerT >& start() const { return json_; }
-        };
-
-    private:
-
-        Json_grammer& operator=( const Json_grammer& ); // to prevent "assignment operator could not be generated" warning
-
-        Semantic_actions_t& actions_;
-    };
-
-    template< class Iter_type, class Value_type >
-    Iter_type read_range_or_throw( Iter_type begin, Iter_type end, Value_type& value )
-    {
-        Semantic_actions< Value_type, Iter_type > semantic_actions( value );
-     
-        const spirit_namespace::parse_info< Iter_type > info = 
-                            spirit_namespace::parse( begin, end, 
-                                                    Json_grammer< Value_type, Iter_type >( semantic_actions ), 
-                                                    spirit_namespace::space_p );
-
-        if( !info.hit )
-        {
-            assert( false ); // in theory exception should already have been thrown
-            throw_error( info.stop, "error" );
-        }
-
-        return info.stop;
-    }
-
-    template< class Iter_type, class Value_type >
-    void add_posn_iter_and_read_range_or_throw( Iter_type begin, Iter_type end, Value_type& value )
-    {
-        typedef spirit_namespace::position_iterator< Iter_type > Posn_iter_t;
-
-        const Posn_iter_t posn_begin( begin, end );
-        const Posn_iter_t posn_end( end, end );
-     
-        read_range_or_throw( posn_begin, posn_end, value );
-    }
-
-    template< class Iter_type, class Value_type >
-    bool read_range( Iter_type& begin, Iter_type end, Value_type& value )
-    {
-        try
-        {
-            begin = read_range_or_throw( begin, end, value );
-
-            return true;
-        }
-        catch( ... )
-        {
-            return false;
-        }
-    }
-
-    template< class String_type, class Value_type >
-    void read_string_or_throw( const String_type& s, Value_type& value )
-    {
-        add_posn_iter_and_read_range_or_throw( s.begin(), s.end(), value );
-    }
-
-    template< class String_type, class Value_type >
-    bool read_string( const String_type& s, Value_type& value )
-    {
-        typename String_type::const_iterator begin = s.begin();
-
-        return read_range( begin, s.end(), value );
-    }
-
-    template< class Istream_type >
-    struct Multi_pass_iters
-    {
-        typedef typename Istream_type::char_type Char_type;
-        typedef std::istream_iterator< Char_type, Char_type > istream_iter;
-        typedef spirit_namespace::multi_pass< istream_iter > Mp_iter;
-
-        Multi_pass_iters( Istream_type& is )
-        {
-            is.unsetf( std::ios::skipws );
-
-            begin_ = spirit_namespace::make_multi_pass( istream_iter( is ) );
-            end_   = spirit_namespace::make_multi_pass( istream_iter() );
-        }
-
-        Mp_iter begin_;
-        Mp_iter end_;
-    };
-
-    template< class Istream_type, class Value_type >
-    bool read_stream( Istream_type& is, Value_type& value )
-    {
-        Multi_pass_iters< Istream_type > mp_iters( is );
-
-        return read_range( mp_iters.begin_, mp_iters.end_, value );
-    }
-
-    template< class Istream_type, class Value_type >
-    void read_stream_or_throw( Istream_type& is, Value_type& value )
-    {
-        const Multi_pass_iters< Istream_type > mp_iters( is );
-
-        add_posn_iter_and_read_range_or_throw( mp_iters.begin_, mp_iters.end_, value );
-    }
-}
-
-#endif
@@ -1,70 +0,0 @@
-#ifndef JSON_SPIRIT_READ_STREAM
-#define JSON_SPIRIT_READ_STREAM
-
-//          Copyright John W. Wilkinson 2007 - 2009.
-// Distributed under the MIT License, see accompanying file LICENSE.txt
-
-// json spirit version 4.03
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-#include "json_spirit_reader_template.h"
-
-namespace json_spirit
-{
-    // these classes allows you to read multiple top level contiguous values from a stream,
-    // the normal stream read functions have a bug that prevent multiple top level values 
-    // from being read unless they are separated by spaces
-
-    template< class Istream_type, class Value_type >
-    class Stream_reader
-    {
-    public:
-
-        Stream_reader( Istream_type& is )
-        :   iters_( is )
-        {
-        }
-
-        bool read_next( Value_type& value )
-        {
-            return read_range( iters_.begin_, iters_.end_, value );
-        }
-
-    private:
-
-        typedef Multi_pass_iters< Istream_type > Mp_iters;
-
-        Mp_iters iters_;
-    };
-
-    template< class Istream_type, class Value_type >
-    class Stream_reader_thrower
-    {
-    public:
-
-        Stream_reader_thrower( Istream_type& is )
-        :   iters_( is )
-        ,    posn_begin_( iters_.begin_, iters_.end_ )
-        ,    posn_end_( iters_.end_, iters_.end_ )
-        {
-        }
-
-        void read_next( Value_type& value )
-        {
-            posn_begin_ = read_range_or_throw( posn_begin_, posn_end_, value );
-        }
-
-    private:
-
-        typedef Multi_pass_iters< Istream_type > Mp_iters;
-        typedef spirit_namespace::position_iterator< typename Mp_iters::Mp_iter > Posn_iter_t;
-
-        Mp_iters iters_;
-        Posn_iter_t posn_begin_, posn_end_;
-    };
-}
-
-#endif
@@ -1,61 +0,0 @@
-#ifndef JSON_SPIRIT_UTILS
-#define JSON_SPIRIT_UTILS
-
-//          Copyright John W. Wilkinson 2007 - 2009.
-// Distributed under the MIT License, see accompanying file LICENSE.txt
-
-// json spirit version 4.03
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-#include "json_spirit_value.h"
-#include <map>
-
-namespace json_spirit
-{ 
-    template< class Obj_t, class Map_t >
-    void obj_to_map( const Obj_t& obj, Map_t& mp_obj )
-    {
-        mp_obj.clear();
-
-        for( typename Obj_t::const_iterator i = obj.begin(); i != obj.end(); ++i )
-        {
-            mp_obj[ i->name_ ] = i->value_;
-        }
-    }
-
-    template< class Obj_t, class Map_t >
-    void map_to_obj( const Map_t& mp_obj, Obj_t& obj )
-    {
-        obj.clear();
-
-        for( typename Map_t::const_iterator i = mp_obj.begin(); i != mp_obj.end(); ++i )
-        {
-            obj.push_back( typename Obj_t::value_type( i->first, i->second ) );
-        }
-    }
-
-    typedef std::map< std::string, Value > Mapped_obj;
-
-#ifndef BOOST_NO_STD_WSTRING
-    typedef std::map< std::wstring, wValue > wMapped_obj;
-#endif
-
-    template< class Object_type, class String_type >
-    const typename Object_type::value_type::Value_type& find_value( const Object_type& obj, const String_type& name )
-    {
-        for( typename Object_type::const_iterator i = obj.begin(); i != obj.end(); ++i )
-        {
-            if( i->name_ == name )
-            {
-                return i->value_;
-            }
-        }
-
-        return Object_type::value_type::Value_type::null;
-    }
-}
-
-#endif
@@ -1,8 +0,0 @@
-/* Copyright (c) 2007 John W Wilkinson
-
-   This source code can be used for any purpose as long as
-   this comment is retained. */
-
-// json spirit version 2.00
-
-#include "json_spirit_value.h"
@@ -1,534 +0,0 @@
-#ifndef JSON_SPIRIT_VALUE
-#define JSON_SPIRIT_VALUE
-
-//          Copyright John W. Wilkinson 2007 - 2009.
-// Distributed under the MIT License, see accompanying file LICENSE.txt
-
-// json spirit version 4.03
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-#include <vector>
-#include <map>
-#include <string>
-#include <cassert>
-#include <sstream>
-#include <stdexcept>
-#include <boost/config.hpp> 
-#include <boost/cstdint.hpp> 
-#include <boost/shared_ptr.hpp> 
-#include <boost/variant.hpp> 
-
-namespace json_spirit
-{
-    enum Value_type{ obj_type, array_type, str_type, bool_type, int_type, real_type, null_type };
-    static const char* Value_type_name[]={"obj", "array", "str", "bool", "int", "real", "null"};
-
-    template< class Config >    // Config determines whether the value uses std::string or std::wstring and
-                                // whether JSON Objects are represented as vectors or maps
-    class Value_impl
-    {
-    public:
-
-        typedef Config Config_type;
-        typedef typename Config::String_type String_type;
-        typedef typename Config::Object_type Object;
-        typedef typename Config::Array_type Array;
-        typedef typename String_type::const_pointer Const_str_ptr;  // eg const char*
-
-        Value_impl();  // creates null value
-        Value_impl( Const_str_ptr      value ); 
-        Value_impl( const String_type& value );
-        Value_impl( const Object&      value );
-        Value_impl( const Array&       value );
-        Value_impl( bool               value );
-        Value_impl( int                value );
-        Value_impl( boost::int64_t     value );
-        Value_impl( boost::uint64_t    value );
-        Value_impl( double             value );
-
-        Value_impl( const Value_impl& other );
-
-        bool operator==( const Value_impl& lhs ) const;
-
-        Value_impl& operator=( const Value_impl& lhs );
-
-        Value_type type() const;
-
-        bool is_uint64() const;
-        bool is_null() const;
-
-        const String_type& get_str()    const;
-        const Object&      get_obj()    const;
-        const Array&       get_array()  const;
-        bool               get_bool()   const;
-        int                get_int()    const;
-        boost::int64_t     get_int64()  const;
-        boost::uint64_t    get_uint64() const;
-        double             get_real()   const;
-
-        Object& get_obj();
-        Array&  get_array();
-
-        template< typename T > T get_value() const;  // example usage: int    i = value.get_value< int >();
-                                                     // or             double d = value.get_value< double >();
-
-        static const Value_impl null;
-
-    private:
-
-        void check_type( const Value_type vtype ) const;
-
-        typedef boost::variant< String_type, 
-                                boost::recursive_wrapper< Object >, boost::recursive_wrapper< Array >, 
-                                bool, boost::int64_t, double > Variant;
-
-        Value_type type_;
-        Variant v_;
-        bool is_uint64_;
-    };
-
-    // vector objects
-
-    template< class Config >
-    struct Pair_impl
-    {
-        typedef typename Config::String_type String_type;
-        typedef typename Config::Value_type Value_type;
-
-        Pair_impl( const String_type& name, const Value_type& value );
-
-        bool operator==( const Pair_impl& lhs ) const;
-
-        String_type name_;
-        Value_type value_;
-    };
-
-    template< class String >
-    struct Config_vector
-    {
-        typedef String String_type;
-        typedef Value_impl< Config_vector > Value_type;
-        typedef Pair_impl < Config_vector > Pair_type;
-        typedef std::vector< Value_type > Array_type;
-        typedef std::vector< Pair_type > Object_type;
-
-        static Value_type& add( Object_type& obj, const String_type& name, const Value_type& value )
-        {
-            obj.push_back( Pair_type( name , value ) );
-
-            return obj.back().value_;
-        }
-                
-        static String_type get_name( const Pair_type& pair )
-        {
-            return pair.name_;
-        }
-                
-        static Value_type get_value( const Pair_type& pair )
-        {
-            return pair.value_;
-        }
-    };
-
-    // typedefs for ASCII
-
-    typedef Config_vector< std::string > Config;
-
-    typedef Config::Value_type  Value;
-    typedef Config::Pair_type   Pair;
-    typedef Config::Object_type Object;
-    typedef Config::Array_type  Array;
-
-    // typedefs for Unicode
-
-#ifndef BOOST_NO_STD_WSTRING
-
-    typedef Config_vector< std::wstring > wConfig;
-
-    typedef wConfig::Value_type  wValue;
-    typedef wConfig::Pair_type   wPair;
-    typedef wConfig::Object_type wObject;
-    typedef wConfig::Array_type  wArray;
-#endif
-
-    // map objects
-
-    template< class String >
-    struct Config_map
-    {
-        typedef String String_type;
-        typedef Value_impl< Config_map > Value_type;
-        typedef std::vector< Value_type > Array_type;
-        typedef std::map< String_type, Value_type > Object_type;
-        typedef typename Object_type::value_type Pair_type;
-
-        static Value_type& add( Object_type& obj, const String_type& name, const Value_type& value )
-        {
-            return obj[ name ] = value;
-        }
-                
-        static String_type get_name( const Pair_type& pair )
-        {
-            return pair.first;
-        }
-                
-        static Value_type get_value( const Pair_type& pair )
-        {
-            return pair.second;
-        }
-    };
-
-    // typedefs for ASCII
-
-    typedef Config_map< std::string > mConfig;
-
-    typedef mConfig::Value_type  mValue;
-    typedef mConfig::Object_type mObject;
-    typedef mConfig::Array_type  mArray;
-
-    // typedefs for Unicode
-
-#ifndef BOOST_NO_STD_WSTRING
-
-    typedef Config_map< std::wstring > wmConfig;
-
-    typedef wmConfig::Value_type  wmValue;
-    typedef wmConfig::Object_type wmObject;
-    typedef wmConfig::Array_type  wmArray;
-
-#endif
-
-    ///////////////////////////////////////////////////////////////////////////////////////////////
-    //
-    // implementation
-
-    template< class Config >
-    const Value_impl< Config > Value_impl< Config >::null;
-
-    template< class Config >
-    Value_impl< Config >::Value_impl()
-    :   type_( null_type )
-    ,   is_uint64_( false )
-    {
-    }
-
-    template< class Config >
-    Value_impl< Config >::Value_impl( const Const_str_ptr value )
-    :   type_( str_type )
-    ,   v_( String_type( value ) )
-    ,   is_uint64_( false )
-    {
-    }
-
-    template< class Config >
-    Value_impl< Config >::Value_impl( const String_type& value )
-    :   type_( str_type )
-    ,   v_( value )
-    ,   is_uint64_( false )
-    {
-    }
-
-    template< class Config >
-    Value_impl< Config >::Value_impl( const Object& value )
-    :   type_( obj_type )
-    ,   v_( value )
-    ,   is_uint64_( false )
-    {
-    }
-
-    template< class Config >
-    Value_impl< Config >::Value_impl( const Array& value )
-    :   type_( array_type )
-    ,   v_( value )
-    ,   is_uint64_( false )
-    {
-    }
-
-    template< class Config >
-    Value_impl< Config >::Value_impl( bool value )
-    :   type_( bool_type )
-    ,   v_( value )
-    ,   is_uint64_( false )
-    {
-    }
-
-    template< class Config >
-    Value_impl< Config >::Value_impl( int value )
-    :   type_( int_type )
-    ,   v_( static_cast< boost::int64_t >( value ) )
-    ,   is_uint64_( false )
-    {
-    }
-
-    template< class Config >
-    Value_impl< Config >::Value_impl( boost::int64_t value )
-    :   type_( int_type )
-    ,   v_( value )
-    ,   is_uint64_( false )
-    {
-    }
-
-    template< class Config >
-    Value_impl< Config >::Value_impl( boost::uint64_t value )
-    :   type_( int_type )
-    ,   v_( static_cast< boost::int64_t >( value ) )
-    ,   is_uint64_( true )
-    {
-    }
-
-    template< class Config >
-    Value_impl< Config >::Value_impl( double value )
-    :   type_( real_type )
-    ,   v_( value )
-    ,   is_uint64_( false )
-    {
-    }
-
-    template< class Config >
-    Value_impl< Config >::Value_impl( const Value_impl< Config >& other )
-    :   type_( other.type() )
-    ,   v_( other.v_ )
-    ,   is_uint64_( other.is_uint64_ )
-    {
-    }
-
-    template< class Config >
-    Value_impl< Config >& Value_impl< Config >::operator=( const Value_impl& lhs )
-    {
-        Value_impl tmp( lhs );
-
-        std::swap( type_, tmp.type_ );
-        std::swap( v_, tmp.v_ );
-        std::swap( is_uint64_, tmp.is_uint64_ );
-
-        return *this;
-    }
-
-    template< class Config >
-    bool Value_impl< Config >::operator==( const Value_impl& lhs ) const
-    {
-        if( this == &lhs ) return true;
-
-        if( type() != lhs.type() ) return false;
-
-        return v_ == lhs.v_; 
-    }
-
-    template< class Config >
-    Value_type Value_impl< Config >::type() const
-    {
-        return type_;
-    }
-
-    template< class Config >
-    bool Value_impl< Config >::is_uint64() const
-    {
-        return is_uint64_;
-    }
-
-    template< class Config >
-    bool Value_impl< Config >::is_null() const
-    {
-        return type() == null_type;
-    }
-
-    template< class Config >
-    void Value_impl< Config >::check_type( const Value_type vtype ) const
-    {
-        if( type() != vtype ) 
-        {
-            std::ostringstream os;
-
-            ///// triangles: Tell the types by name instead of by number
-            os << "value is type " << Value_type_name[type()] << ", expected " << Value_type_name[vtype];
-
-            throw std::runtime_error( os.str() );
-        }
-    }
-
-    template< class Config >
-    const typename Config::String_type& Value_impl< Config >::get_str() const
-    {
-        check_type(  str_type );
-
-        return *boost::get< String_type >( &v_ );
-    }
-
-    template< class Config >
-    const typename Value_impl< Config >::Object& Value_impl< Config >::get_obj() const
-    {
-        check_type( obj_type );
-
-        return *boost::get< Object >( &v_ );
-    }
-     
-    template< class Config >
-    const typename Value_impl< Config >::Array& Value_impl< Config >::get_array() const
-    {
-        check_type(  array_type );
-
-        return *boost::get< Array >( &v_ );
-    }
-     
-    template< class Config >
-    bool Value_impl< Config >::get_bool() const
-    {
-        check_type(  bool_type );
-
-        return boost::get< bool >( v_ );
-    }
-     
-    template< class Config >
-    int Value_impl< Config >::get_int() const
-    {
-        check_type(  int_type );
-
-        return static_cast< int >( get_int64() );
-    }
-    
-    template< class Config >
-    boost::int64_t Value_impl< Config >::get_int64() const
-    {
-        check_type(  int_type );
-
-        return boost::get< boost::int64_t >( v_ );
-    }
-    
-    template< class Config >
-    boost::uint64_t Value_impl< Config >::get_uint64() const
-    {
-        check_type(  int_type );
-
-        return static_cast< boost::uint64_t >( get_int64() );
-    }
-
-    template< class Config >
-    double Value_impl< Config >::get_real() const
-    {
-        if( type() == int_type )
-        {
-            return is_uint64() ? static_cast< double >( get_uint64() )
-                               : static_cast< double >( get_int64() );
-        }
-
-        check_type(  real_type );
-
-        return boost::get< double >( v_ );
-    }
-
-    template< class Config >
-    typename Value_impl< Config >::Object& Value_impl< Config >::get_obj()
-    {
-        check_type(  obj_type );
-
-        return *boost::get< Object >( &v_ );
-    }
-
-    template< class Config >
-    typename Value_impl< Config >::Array& Value_impl< Config >::get_array()
-    {
-        check_type(  array_type );
-
-        return *boost::get< Array >( &v_ );
-    }
-
-    template< class Config >
-    Pair_impl< Config >::Pair_impl( const String_type& name, const Value_type& value )
-    :   name_( name )
-    ,   value_( value )
-    {
-    }
-
-    template< class Config >
-    bool Pair_impl< Config >::operator==( const Pair_impl< Config >& lhs ) const
-    {
-        if( this == &lhs ) return true;
-
-        return ( name_ == lhs.name_ ) && ( value_ == lhs.value_ );
-    }
-
-    // converts a C string, ie. 8 bit char array, to a string object
-    //
-    template < class String_type >
-    String_type to_str( const char* c_str )
-    {
-        String_type result;
-
-        for( const char* p = c_str; *p != 0; ++p )
-        {
-            result += *p;
-        }
-
-        return result;
-    }
-
-    //
-
-    namespace internal_
-    {
-        template< typename T >
-        struct Type_to_type
-        {
-        };
-
-        template< class Value > 
-        int get_value( const Value& value, Type_to_type< int > )
-        {
-            return value.get_int();
-        }
-       
-        template< class Value > 
-        boost::int64_t get_value( const Value& value, Type_to_type< boost::int64_t > )
-        {
-            return value.get_int64();
-        }
-       
-        template< class Value > 
-        boost::uint64_t get_value( const Value& value, Type_to_type< boost::uint64_t > )
-        {
-            return value.get_uint64();
-        }
-       
-        template< class Value > 
-        double get_value( const Value& value, Type_to_type< double > )
-        {
-            return value.get_real();
-        }
-       
-        template< class Value > 
-        typename Value::String_type get_value( const Value& value, Type_to_type< typename Value::String_type > )
-        {
-            return value.get_str();
-        }
-       
-        template< class Value > 
-        typename Value::Array get_value( const Value& value, Type_to_type< typename Value::Array > )
-        {
-            return value.get_array();
-        }
-       
-        template< class Value > 
-        typename Value::Object get_value( const Value& value, Type_to_type< typename Value::Object > )
-        {
-            return value.get_obj();
-        }
-       
-        template< class Value > 
-        bool get_value( const Value& value, Type_to_type< bool > )
-        {
-            return value.get_bool();
-        }
-    }
-
-    template< class Config >
-    template< typename T > 
-    T Value_impl< Config >::get_value() const
-    {
-        return internal_::get_value( *this, internal_::Type_to_type< T >() );
-    }
-}
-
-#endif
@@ -1,95 +0,0 @@
-//          Copyright John W. Wilkinson 2007 - 2009.
-// Distributed under the MIT License, see accompanying file LICENSE.txt
-
-// json spirit version 4.03
-
-#include "json_spirit_writer.h"
-#include "json_spirit_writer_template.h"
-
-void json_spirit::write( const Value& value, std::ostream& os )
-{
-    write_stream( value, os, false );
-}
-
-void json_spirit::write_formatted( const Value& value, std::ostream& os )
-{
-    write_stream( value, os, true );
-}
-
-std::string json_spirit::write( const Value& value )
-{
-    return write_string( value, false );
-}
-
-std::string json_spirit::write_formatted( const Value& value )
-{
-    return write_string( value, true );
-}
-
-#ifndef BOOST_NO_STD_WSTRING
-
-void json_spirit::write( const wValue& value, std::wostream& os )
-{
-    write_stream( value, os, false );
-}
-
-void json_spirit::write_formatted( const wValue& value, std::wostream& os )
-{
-    write_stream( value, os, true );
-}
-
-std::wstring json_spirit::write( const wValue&  value )
-{
-    return write_string( value, false );
-}
-
-std::wstring json_spirit::write_formatted( const wValue&  value )
-{
-    return write_string( value, true );
-}
-
-#endif
-
-void json_spirit::write( const mValue& value, std::ostream& os )
-{
-    write_stream( value, os, false );
-}
-
-void json_spirit::write_formatted( const mValue& value, std::ostream& os )
-{
-    write_stream( value, os, true );
-}
-
-std::string json_spirit::write( const mValue& value )
-{
-    return write_string( value, false );
-}
-
-std::string json_spirit::write_formatted( const mValue& value )
-{
-    return write_string( value, true );
-}
-
-#ifndef BOOST_NO_STD_WSTRING
-
-void json_spirit::write( const wmValue& value, std::wostream& os )
-{
-    write_stream( value, os, false );
-}
-
-void json_spirit::write_formatted( const wmValue& value, std::wostream& os )
-{
-    write_stream( value, os, true );
-}
-
-std::wstring json_spirit::write( const wmValue&  value )
-{
-    return write_string( value, false );
-}
-
-std::wstring json_spirit::write_formatted( const wmValue&  value )
-{
-    return write_string( value, true );
-}
-
-#endif
@@ -1,50 +0,0 @@
-#ifndef JSON_SPIRIT_WRITER
-#define JSON_SPIRIT_WRITER
-
-//          Copyright John W. Wilkinson 2007 - 2009.
-// Distributed under the MIT License, see accompanying file LICENSE.txt
-
-// json spirit version 4.03
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-#include "json_spirit_value.h"
-#include <iostream>
-
-namespace json_spirit
-{
-    // functions to convert JSON Values to text, 
-    // the "formatted" versions add whitespace to format the output nicely
-
-    void         write          ( const Value& value, std::ostream&  os );
-    void         write_formatted( const Value& value, std::ostream&  os );
-    std::string  write          ( const Value& value );
-    std::string  write_formatted( const Value& value );
-
-#ifndef BOOST_NO_STD_WSTRING
-
-    void         write          ( const wValue& value, std::wostream& os );
-    void         write_formatted( const wValue& value, std::wostream& os );
-    std::wstring write          ( const wValue& value );
-    std::wstring write_formatted( const wValue& value );
-
-#endif
-
-    void         write          ( const mValue& value, std::ostream&  os );
-    void         write_formatted( const mValue& value, std::ostream&  os );
-    std::string  write          ( const mValue& value );
-    std::string  write_formatted( const mValue& value );
-
-#ifndef BOOST_NO_STD_WSTRING
-
-    void         write          ( const wmValue& value, std::wostream& os );
-    void         write_formatted( const wmValue& value, std::wostream& os );
-    std::wstring write          ( const wmValue& value );
-    std::wstring write_formatted( const wmValue& value );
-
-#endif
-}
-
-#endif
@@ -1,248 +0,0 @@
-#ifndef JSON_SPIRIT_WRITER_TEMPLATE
-#define JSON_SPIRIT_WRITER_TEMPLATE
-
-//          Copyright John W. Wilkinson 2007 - 2009.
-// Distributed under the MIT License, see accompanying file LICENSE.txt
-
-// json spirit version 4.03
-
-#include "json_spirit_value.h"
-
-#include <cassert>
-#include <sstream>
-#include <iomanip>
-
-namespace json_spirit
-{
-    inline char to_hex_char( unsigned int c )
-    {
-        assert( c <= 0xF );
-
-        const char ch = static_cast< char >( c );
-
-        if( ch < 10 ) return '0' + ch;
-
-        return 'A' - 10 + ch;
-    }
-
-    template< class String_type >
-    String_type non_printable_to_string( unsigned int c )
-    {
-        typedef typename String_type::value_type Char_type;
-
-        String_type result( 6, '\\' );
-
-        result[1] = 'u';
-
-        result[ 5 ] = to_hex_char( c & 0x000F ); c >>= 4;
-        result[ 4 ] = to_hex_char( c & 0x000F ); c >>= 4;
-        result[ 3 ] = to_hex_char( c & 0x000F ); c >>= 4;
-        result[ 2 ] = to_hex_char( c & 0x000F );
-
-        return result;
-    }
-
-    template< typename Char_type, class String_type >
-    bool add_esc_char( Char_type c, String_type& s )
-    {
-        switch( c )
-        {
-            case '"':  s += to_str< String_type >( "\\\"" ); return true;
-            case '\\': s += to_str< String_type >( "\\\\" ); return true;
-            case '\b': s += to_str< String_type >( "\\b"  ); return true;
-            case '\f': s += to_str< String_type >( "\\f"  ); return true;
-            case '\n': s += to_str< String_type >( "\\n"  ); return true;
-            case '\r': s += to_str< String_type >( "\\r"  ); return true;
-            case '\t': s += to_str< String_type >( "\\t"  ); return true;
-        }
-
-        return false;
-    }
-
-    template< class String_type >
-    String_type add_esc_chars( const String_type& s )
-    {
-        typedef typename String_type::const_iterator Iter_type;
-        typedef typename String_type::value_type     Char_type;
-
-        String_type result;
-
-        const Iter_type end( s.end() );
-
-        for( Iter_type i = s.begin(); i != end; ++i )
-        {
-            const Char_type c( *i );
-
-            if( add_esc_char( c, result ) ) continue;
-
-            const wint_t unsigned_c( ( c >= 0 ) ? c : 256 + c );
-
-            if( iswprint( unsigned_c ) )
-            {
-                result += c;
-            }
-            else
-            {
-                result += non_printable_to_string< String_type >( unsigned_c );
-            }
-        }
-
-        return result;
-    }
-
-    // this class generates the JSON text,
-    // it keeps track of the indentation level etc.
-    //
-    template< class Value_type, class Ostream_type >
-    class Generator
-    {
-        typedef typename Value_type::Config_type Config_type;
-        typedef typename Config_type::String_type String_type;
-        typedef typename Config_type::Object_type Object_type;
-        typedef typename Config_type::Array_type Array_type;
-        typedef typename String_type::value_type Char_type;
-        typedef typename Object_type::value_type Obj_member_type;
-
-    public:
-
-        Generator( const Value_type& value, Ostream_type& os, bool pretty )
-        :   os_( os )
-        ,   indentation_level_( 0 )
-        ,   pretty_( pretty )
-        {
-            output( value );
-        }
-
-    private:
-
-        void output( const Value_type& value )
-        {
-            switch( value.type() )
-            {
-                case obj_type:   output( value.get_obj() );   break;
-                case array_type: output( value.get_array() ); break;
-                case str_type:   output( value.get_str() );   break;
-                case bool_type:  output( value.get_bool() );  break;
-                case int_type:   output_int( value );         break;
-
-                /// triangles: Added std::fixed and changed precision from 16 to 8
-                case real_type:  os_ << std::showpoint << std::fixed << std::setprecision(8)
-                                     << value.get_real();     break;
-
-                case null_type:  os_ << "null";               break;
-                default: assert( false );
-            }
-        }
-
-        void output( const Object_type& obj )
-        {
-            output_array_or_obj( obj, '{', '}' );
-        }
-
-        void output( const Array_type& arr )
-        {
-            output_array_or_obj( arr, '[', ']' );
-        }
-
-        void output( const Obj_member_type& member )
-        {
-            output( Config_type::get_name( member ) ); space(); 
-            os_ << ':'; space(); 
-            output( Config_type::get_value( member ) );
-        }
-
-        void output_int( const Value_type& value )
-        {
-            if( value.is_uint64() )
-            {
-                os_ << value.get_uint64();
-            }
-            else
-            {
-               os_ << value.get_int64();
-            }
-        }
-
-        void output( const String_type& s )
-        {
-            os_ << '"' << add_esc_chars( s ) << '"';
-        }
-
-        void output( bool b )
-        {
-            os_ << to_str< String_type >( b ? "true" : "false" );
-        }
-
-        template< class T >
-        void output_array_or_obj( const T& t, Char_type start_char, Char_type end_char )
-        {
-            os_ << start_char; new_line();
-
-            ++indentation_level_;
-            
-            for( typename T::const_iterator i = t.begin(); i != t.end(); ++i )
-            {
-                indent(); output( *i );
-
-                typename T::const_iterator next = i;
-
-                if( ++next != t.end())
-                {
-                    os_ << ',';
-                }
-
-                new_line();
-            }
-
-            --indentation_level_;
-
-            indent(); os_ << end_char;
-        }
-        
-        void indent()
-        {
-            if( !pretty_ ) return;
-
-            for( int i = 0; i < indentation_level_; ++i )
-            { 
-                os_ << "    ";
-            }
-        }
-
-        void space()
-        {
-            if( pretty_ ) os_ << ' ';
-        }
-
-        void new_line()
-        {
-            if( pretty_ ) os_ << '\n';
-        }
-
-        Generator& operator=( const Generator& ); // to prevent "assignment operator could not be generated" warning
-
-        Ostream_type& os_;
-        int indentation_level_;
-        bool pretty_;
-    };
-
-    template< class Value_type, class Ostream_type >
-    void write_stream( const Value_type& value, Ostream_type& os, bool pretty )
-    {
-        Generator< Value_type, Ostream_type >( value, os, pretty );
-    }
-
-    template< class Value_type >
-    typename Value_type::String_type write_string( const Value_type& value, bool pretty )
-    {
-        typedef typename Value_type::String_type::value_type Char_type;
-
-        std::basic_ostringstream< Char_type > os;
-
-        write_stream( value, os, pretty );
-
-        return os.str();
-    }
-}
-
-#endif
@@ -2,8 +2,6 @@
 // Distributed under the MIT/X11 software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.

-#include <boost/assign/list_of.hpp>
-
 #include "kernel.h"
 #include "txdb.h"

@@ -16,13 +14,12 @@ extern unsigned int nTargetSpacing;
 // Set to 20-minute for production network
 //unsigned int nModifierInterval = MODIFIER_INTERVAL;

-typedef std::map<int, unsigned int> MapModifierCheckpoints;
+using MapModifierCheckpoints = std::map<int, unsigned int>;

 // Hard checkpoints of stake modifiers to ensure they are deterministic
-static std::map<int, unsigned int> mapStakeModifierCheckpoints =
-    boost::assign::map_list_of
-    (     0, 0x000000000e00670b )
-	;
+static std::map<int, unsigned int> mapStakeModifierCheckpoints = {
+    { 0, 0x000000000e00670b },
+};

 // Get time weight
 int64_t GetWeight(int64_t nIntervalBeginning, int64_t nIntervalEnd)
@@ -34,9 +31,13 @@ int64_t GetWeight(int64_t nIntervalBeginning, int64_t nIntervalEnd)
    if (nAge < 0)
        return 0;

-    // After v5 fork: remove max age cap so coins aged during the freeze can stake
+    // After v5 fork: use soft cap of 7 days instead of hard nStakeMaxAge.
+    // This prevents "stake surprise" where a whale who was offline for weeks
+    // comes back with massively amplified staking power and dominates blocks.
+    // The 7-day cap still allows generous accumulation while limiting abuse.
+    static const int64_t STAKE_AGE_SOFT_CAP = 7 * 24 * 60 * 60; // 7 days
    if (pindexBest && pindexBest->nHeight >= FORK_HEIGHT_V5)
-        return nAge;
+        return min(nAge, STAKE_AGE_SOFT_CAP);

    return min(nAge, (int64_t)nStakeMaxAge);
 }
@@ -80,7 +81,7 @@ static bool SelectBlockFromCandidates(vector<pair<int64_t, uint256> >& vSortedBy
    bool fSelected = false;
    uint256 hashBest = 0;
    *pindexSelected = (const CBlockIndex*) 0;
-    BOOST_FOREACH(const PAIRTYPE(int64_t, uint256)& item, vSortedByTimestamp)
+    for (const auto& item : vSortedByTimestamp)
    {
        if (!mapBlockIndex.count(item.second))
            return error("SelectBlockFromCandidates: failed to find block index for candidate block %s", item.second.ToString().c_str());
@@ -199,7 +200,7 @@ bool ComputeNextStakeModifier(const CBlockIndex* pindexPrev, uint64_t& nStakeMod
                strSelectionMap.replace(pindex->nHeight - nHeightFirstCandidate, 1, "=");
            pindex = pindex->pprev;
        }
-        BOOST_FOREACH(const PAIRTYPE(uint256, const CBlockIndex*)& item, mapSelectedBlocks)
+        for (const auto& item : mapSelectedBlocks)
        {
            // 'S' indicates selected proof-of-stake blocks
            // 'W' indicates selected proof-of-work blocks
@@ -337,9 +338,11 @@ bool CheckStakeKernelHash(unsigned int nBits, const CBlock& blockFrom, unsigned
    // Now check if proof-of-stake hash meets target protocol
    if (CBigNum(hashProofOfStake) > bnCoinDayWeight * bnTargetPerCoinDay)
    {
+        // Guard against null pindexBest during early startup / IBD
+        int nCurrentHeight = pindexBest ? pindexBest->nHeight : 0;
+
        // triangles fix: accept hash to get blockchain moving again with Pharao release (v 4.0.0.1) for first 10 blocks after release
-        //printf(">>>> pindexBest->nHeight %d\n",pindexBest->nHeight);
-        if (pindexBest->nHeight > CRAPCHAIN_CUTOFF_BLOCK)
+        if (nCurrentHeight > CRAPCHAIN_CUTOFF_BLOCK)
        {
            if(fDebug)
            {
@@ -352,8 +355,8 @@ bool CheckStakeKernelHash(unsigned int nBits, const CBlock& blockFrom, unsigned
        else
        {
            //accept hash
-            if (pindexBest->nHeight % 10000 == 0 || pindexBest->nHeight > 2186900)
-                printf(">>>> pindexBest->nHeight %d, Pharao release - hash accepted\n", pindexBest->nHeight);
+            if (nCurrentHeight % 10000 == 0 || nCurrentHeight > 2186900)
+                printf(">>>> pindexBest->nHeight %d, Pharao release - hash accepted\n", nCurrentHeight);
        }
    }

@@ -383,7 +386,7 @@ bool CheckProofOfStake(const CTransaction& tx, unsigned int nBits, uint256& hash
    const CTxIn& txin = tx.vin[0];

    // First try finding the previous transaction in database
-    CTxDB txdb("r");
+    auto txdb_holder = MakeChainDB("r"); CTxDBBase& txdb = *txdb_holder;
    CTransaction txPrev;
    CTxIndex txindex;
    if (!txPrev.ReadFromDisk(txdb, txin.prevout, txindex))
@@ -1,213 +1,33 @@
 // Copyright (c) 2009-2012 The Bitcoin developers
+// Copyright (c) 2026 The Triangles developers
 // Distributed under the MIT/X11 software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.

-#include <map>
+#include <cstring>

-#include <openssl/ecdsa.h>
-#include <openssl/obj_mac.h>
+#include <openssl/crypto.h>   // OPENSSL_cleanse for secure wipe of secret bytes
+#include <openssl/rand.h>     // RAND_bytes for new-key entropy

+#include "crypto_ecdsa.h"
 #include "key.h"

-// Generate a private key from just the secret parameter
-int EC_KEY_regenerate_key(EC_KEY *eckey, BIGNUM *priv_key)
+// ─────────────────────────────────────────────────────────────────────────────
+// Order-of-generator constants (still used by CheckSignatureElement, the only
+// caller into the BigEndian comparison helper below). Kept here so the file
+// remains self-contained.
+// ─────────────────────────────────────────────────────────────────────────────
+
+namespace {
+
+int CompareBigEndian(const unsigned char* c1, std::size_t c1len,
+                     const unsigned char* c2, std::size_t c2len)
 {
-    int ok = 0;
-    BN_CTX *ctx = NULL;
-    EC_POINT *pub_key = NULL;
-
-    if (!eckey) return 0;
-
-    const EC_GROUP *group = EC_KEY_get0_group(eckey);
-
-    if ((ctx = BN_CTX_new()) == NULL)
-        goto err;
-
-    pub_key = EC_POINT_new(group);
-
-    if (pub_key == NULL)
-        goto err;
-
-    if (!EC_POINT_mul(group, pub_key, priv_key, NULL, NULL, ctx))
-        goto err;
-
-    EC_KEY_set_private_key(eckey,priv_key);
-    EC_KEY_set_public_key(eckey,pub_key);
-
-    ok = 1;
-
-err:
-
-    if (pub_key)
-        EC_POINT_free(pub_key);
-    if (ctx != NULL)
-        BN_CTX_free(ctx);
-
-    return(ok);
-}
-
-// Perform ECDSA key recovery (see SEC1 4.1.6) for curves over (mod p)-fields
-// recid selects which key is recovered
-// if check is non-zero, additional checks are performed
-int ECDSA_SIG_recover_key_GFp(EC_KEY *eckey, ECDSA_SIG *ecsig, const unsigned char *msg, int msglen, int recid, int check)
-{
-    if (!eckey) return 0;
-
-    int ret = 0;
-    BN_CTX *ctx = NULL;
-
-    BIGNUM *x = NULL;
-    BIGNUM *e = NULL;
-    BIGNUM *order = NULL;
-    BIGNUM *sor = NULL;
-    BIGNUM *eor = NULL;
-    BIGNUM *field = NULL;
-    EC_POINT *R = NULL;
-    EC_POINT *O = NULL;
-    EC_POINT *Q = NULL;
-    BIGNUM *rr = NULL;
-    BIGNUM *zero = NULL;
-    int n = 0;
-    int i = recid / 2;
-
-    const EC_GROUP *group = EC_KEY_get0_group(eckey);
-    if ((ctx = BN_CTX_new()) == NULL) { ret = -1; goto err; }
-    BN_CTX_start(ctx);
-    const BIGNUM *sig_r, *sig_s;
-    ECDSA_SIG_get0(ecsig, &sig_r, &sig_s);
-    order = BN_CTX_get(ctx);
-    if (!EC_GROUP_get_order(group, order, ctx)) { ret = -2; goto err; }
-    x = BN_CTX_get(ctx);
-    if (!BN_copy(x, order)) { ret=-1; goto err; }
-    if (!BN_mul_word(x, i)) { ret=-1; goto err; }
-    if (!BN_add(x, x, sig_r)) { ret=-1; goto err; }
-    field = BN_CTX_get(ctx);
-    if (!EC_GROUP_get_curve_GFp(group, field, NULL, NULL, ctx)) { ret=-2; goto err; }
-    if (BN_cmp(x, field) >= 0) { ret=0; goto err; }
-    if ((R = EC_POINT_new(group)) == NULL) { ret = -2; goto err; }
-    if (!EC_POINT_set_compressed_coordinates_GFp(group, R, x, recid % 2, ctx)) { ret=0; goto err; }
-    if (check)
-    {
-        if ((O = EC_POINT_new(group)) == NULL) { ret = -2; goto err; }
-        if (!EC_POINT_mul(group, O, NULL, R, order, ctx)) { ret=-2; goto err; }
-        if (!EC_POINT_is_at_infinity(group, O)) { ret = 0; goto err; }
-    }
-    if ((Q = EC_POINT_new(group)) == NULL) { ret = -2; goto err; }
-    n = EC_GROUP_get_degree(group);
-    e = BN_CTX_get(ctx);
-    if (!BN_bin2bn(msg, msglen, e)) { ret=-1; goto err; }
-    if (8*msglen > n) BN_rshift(e, e, 8-(n & 7));
-    zero = BN_CTX_get(ctx);
-    BN_zero(zero);
-    if (!BN_mod_sub(e, zero, e, order, ctx)) { ret=-1; goto err; }
-    rr = BN_CTX_get(ctx);
-    if (!BN_mod_inverse(rr, sig_r, order, ctx)) { ret=-1; goto err; }
-    sor = BN_CTX_get(ctx);
-    if (!BN_mod_mul(sor, sig_s, rr, order, ctx)) { ret=-1; goto err; }
-    eor = BN_CTX_get(ctx);
-    if (!BN_mod_mul(eor, e, rr, order, ctx)) { ret=-1; goto err; }
-    if (!EC_POINT_mul(group, Q, eor, R, sor, ctx)) { ret=-2; goto err; }
-    if (!EC_KEY_set_public_key(eckey, Q)) { ret=-2; goto err; }
-
-    ret = 1;
-
-err:
-    if (ctx) {
-        BN_CTX_end(ctx);
-        BN_CTX_free(ctx);
-    }
-    if (R != NULL) EC_POINT_free(R);
-    if (O != NULL) EC_POINT_free(O);
-    if (Q != NULL) EC_POINT_free(Q);
-    return ret;
-}
-
-void CKey::SetCompressedPubKey()
-{
-    EC_KEY_set_conv_form(pkey, POINT_CONVERSION_COMPRESSED);
-    fCompressedPubKey = true;
-}
-
-void CKey::SetUnCompressedPubKey()
-{
-    EC_KEY_set_conv_form(pkey, POINT_CONVERSION_UNCOMPRESSED);
-    fCompressedPubKey = false;
-}
-
-EC_KEY* CKey::GetECKey()
-{
-    return pkey;
-}
-
-void CKey::Reset()
-{
-    fCompressedPubKey = false;
-    if (pkey != NULL)
-        EC_KEY_free(pkey);
-    pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
-    if (pkey == NULL)
-        throw key_error("CKey::CKey() : EC_KEY_new_by_curve_name failed");
-    fSet = false;
-}
-
-CKey::CKey()
-{
-    pkey = NULL;
-    Reset();
-}
-
-CKey::CKey(const CKey& b)
-{
-    pkey = EC_KEY_dup(b.pkey);
-    if (pkey == NULL)
-        throw key_error("CKey::CKey(const CKey&) : EC_KEY_dup failed");
-    fSet = b.fSet;
-}
-
-CKey& CKey::operator=(const CKey& b)
-{
-    if (!EC_KEY_copy(pkey, b.pkey))
-        throw key_error("CKey::operator=(const CKey&) : EC_KEY_copy failed");
-    fSet = b.fSet;
-    return (*this);
-}
-
-CKey::~CKey()
-{
-    EC_KEY_free(pkey);
-}
-
-bool CKey::IsNull() const
-{
-    return !fSet;
-}
-
-bool CKey::IsCompressed() const
-{
-    return fCompressedPubKey;
-}
-
-int CompareBigEndian(const unsigned char *c1, size_t c1len, const unsigned char *c2, size_t c2len) {
-    while (c1len > c2len) {
-        if (*c1)
-            return 1;
-        c1++;
-        c1len--;
-    }
-    while (c2len > c1len) {
-        if (*c2)
-            return -1;
-        c2++;
-        c2len--;
-    }
+    while (c1len > c2len) { if (*c1) return  1; c1++; c1len--; }
+    while (c2len > c1len) { if (*c2) return -1; c2++; c2len--; }
    while (c1len > 0) {
-        if (*c1 > *c2)
-            return 1;
-        if (*c2 > *c1)
-            return -1;
-        c1++;
-        c2++;
-        c1len--;
+        if (*c1 > *c2) return  1;
+        if (*c2 > *c1) return -1;
+        c1++; c2++; c1len--;
    }
    return 0;
 }
@@ -228,277 +48,332 @@ const unsigned char vchMaxModHalfOrder[32] = {
    0xDF,0xE9,0x2F,0x46,0x68,0x1B,0x20,0xA0
 };

-const unsigned char vchZero[0] = {};
+const unsigned char vchZero[1] = { 0 };

-bool CKey::CheckSignatureElement(const unsigned char *vch, int len, bool half) {
-    return CompareBigEndian(vch, len, vchZero, 0) > 0 &&
-           CompareBigEndian(vch, len, half ? vchMaxModHalfOrder : vchMaxModOrder, 32) <= 0;
+} // namespace
+
+bool CKey::CheckSignatureElement(const unsigned char* vchIn, int len, bool half)
+{
+    return CompareBigEndian(vchIn, len, vchZero, 0) > 0 &&
+           CompareBigEndian(vchIn, len, half ? vchMaxModHalfOrder : vchMaxModOrder, 32) <= 0;
 }

+// ─────────────────────────────────────────────────────────────────────────────
+// Lifecycle
+// ─────────────────────────────────────────────────────────────────────────────
+
+void CKey::Reset()
+{
+    OPENSSL_cleanse(vch, sizeof(vch));
+    vchPubKey.clear();
+    fSet              = false;
+    fHavePrivKey      = false;
+    fCompressedPubKey = false;
+}
+
+CKey::CKey()
+{
+    std::memset(vch, 0, sizeof(vch));
+    vchPubKey.clear();
+    fSet              = false;
+    fHavePrivKey      = false;
+    fCompressedPubKey = false;
+}
+
+CKey::CKey(const CKey& b)
+{
+    *this = b;
+}
+
+CKey& CKey::operator=(const CKey& b)
+{
+    if (this == &b) return *this;
+    std::memcpy(vch, b.vch, sizeof(vch));
+    vchPubKey         = b.vchPubKey;
+    fSet              = b.fSet;
+    fHavePrivKey      = b.fHavePrivKey;
+    fCompressedPubKey = b.fCompressedPubKey;
+    return *this;
+}
+
+CKey::~CKey()
+{
+    OPENSSL_cleanse(vch, sizeof(vch));
+}
+
+bool CKey::IsNull() const       { return !fSet; }
+bool CKey::IsCompressed() const { return fCompressedPubKey; }
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Compression toggle
+//
+// In the new model the pubkey is always cached at the current compression. If
+// we hold the private key we can re-derive trivially; if we only hold a public
+// key, callers don't toggle compression in practice in this codebase, so we
+// just flip the flag and rely on the next SetPubKey/SetSecret to refresh the
+// cache.
+// ─────────────────────────────────────────────────────────────────────────────
+
+void CKey::SetCompressedPubKey()
+{
+    if (fCompressedPubKey) return;
+    fCompressedPubKey = true;
+    if (fSet && fHavePrivKey) {
+        std::size_t len = 33;
+        vchPubKey.resize(len);
+        if (!ECDSA_pubkey_from_privkey_secp256k1(&vchPubKey[0], &len, vch, /*fCompressed=*/true)) {
+            Reset();
+            return;
+        }
+        vchPubKey.resize(len);
+    }
+}
+
+void CKey::SetUnCompressedPubKey()
+{
+    if (!fCompressedPubKey && fSet) return;
+    fCompressedPubKey = false;
+    if (fSet && fHavePrivKey) {
+        std::size_t len = 65;
+        vchPubKey.resize(len);
+        if (!ECDSA_pubkey_from_privkey_secp256k1(&vchPubKey[0], &len, vch, /*fCompressed=*/false)) {
+            Reset();
+            return;
+        }
+        vchPubKey.resize(len);
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Key generation / load / store
+// ─────────────────────────────────────────────────────────────────────────────
+
 void CKey::MakeNewKey(bool fCompressed)
 {
-    if (!EC_KEY_generate_key(pkey))
-        throw key_error("CKey::MakeNewKey() : EC_KEY_generate_key failed");
-    if (fCompressed)
-        SetCompressedPubKey();
-    fSet = true;
+    // Sample 32 bytes of entropy and reject any that fall outside (0, n).
+    // Probability of needing a retry is ~2^-128.
+    do {
+        if (RAND_bytes(vch, sizeof(vch)) != 1)
+            throw key_error("CKey::MakeNewKey() : RAND_bytes failed");
+    } while (!ECDSA_seckey_verify_secp256k1(vch));
+
+    fSet              = true;
+    fHavePrivKey      = true;
+    fCompressedPubKey = fCompressed;
+
+    std::size_t len = fCompressed ? 33 : 65;
+    vchPubKey.resize(len);
+    if (!ECDSA_pubkey_from_privkey_secp256k1(&vchPubKey[0], &len, vch, fCompressed)) {
+        Reset();
+        throw key_error("CKey::MakeNewKey() : failed to derive public key");
+    }
+    vchPubKey.resize(len);
 }

 bool CKey::SetPrivKey(const CPrivKey& vchPrivKey)
 {
-    const unsigned char* pbegin = &vchPrivKey[0];
-    if (d2i_ECPrivateKey(&pkey, &pbegin, vchPrivKey.size()))
-    {
-        // In testing, d2i_ECPrivateKey can return true
-        // but fill in pkey with a key that fails
-        // EC_KEY_check_key, so:
-        if (EC_KEY_check_key(pkey))
-        {
-            fSet = true;
-            return true;
-        }
+    unsigned char raw[32];
+    if (!ECDSA_privkey_import_der_secp256k1(raw, &vchPrivKey[0], vchPrivKey.size())) {
+        OPENSSL_cleanse(raw, sizeof(raw));
+        Reset();
+        return false;
    }
-    // If vchPrivKey data is bad d2i_ECPrivateKey() can
-    // leave pkey in a state where calling EC_KEY_free()
-    // crashes. To avoid that, set pkey to NULL and
-    // leak the memory (a leak is better than a crash)
-    pkey = NULL;
-    Reset();
-    return false;
+
+    // Carry the compressed flag out of the DER blob. The two valid sizes
+    // produced by ECDSA_privkey_export_der_secp256k1 are 214 (compressed) and
+    // 279 (uncompressed); foreign DER blobs are best-effort but those two
+    // cover every record this codebase has ever written.
+    bool fCompressed = (vchPrivKey.size() == 214);
+
+    CSecret secret(raw, raw + 32);
+    OPENSSL_cleanse(raw, sizeof(raw));
+    return SetSecret(secret, fCompressed);
 }

 bool CKey::SetSecret(const CSecret& vchSecret, bool fCompressed)
 {
-    EC_KEY_free(pkey);
-    pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
-    if (pkey == NULL)
-        throw key_error("CKey::SetSecret() : EC_KEY_new_by_curve_name failed");
    if (vchSecret.size() != 32)
        throw key_error("CKey::SetSecret() : secret must be 32 bytes");
-    BIGNUM *bn = BN_bin2bn(&vchSecret[0],32,BN_new());
-    if (bn == NULL)
-        throw key_error("CKey::SetSecret() : BN_bin2bn failed");
-    if (!EC_KEY_regenerate_key(pkey,bn))
-    {
-        BN_clear_free(bn);
-        throw key_error("CKey::SetSecret() : EC_KEY_regenerate_key failed");
+    if (!ECDSA_seckey_verify_secp256k1(&vchSecret[0]))
+        throw key_error("CKey::SetSecret() : secret is not a valid scalar");
+
+    std::memcpy(vch, &vchSecret[0], 32);
+    fSet              = true;
+    fHavePrivKey      = true;
+    // Preserve sticky-compression behaviour from the OpenSSL implementation:
+    // if either the explicit argument or the previously-set flag is true,
+    // the result is compressed.
+    bool fComp = fCompressed || fCompressedPubKey;
+    fCompressedPubKey = fComp;
+
+    std::size_t len = fComp ? 33 : 65;
+    vchPubKey.resize(len);
+    if (!ECDSA_pubkey_from_privkey_secp256k1(&vchPubKey[0], &len, vch, fComp)) {
+        Reset();
+        return false;
    }
-    BN_clear_free(bn);
-    fSet = true;
-    if (fCompressed || fCompressedPubKey)
-        SetCompressedPubKey();
+    vchPubKey.resize(len);
    return true;
 }

-CSecret CKey::GetSecret(bool &fCompressed) const
+CSecret CKey::GetSecret(bool& fCompressed) const
 {
-    CSecret vchRet;
-    vchRet.resize(32);
-    const BIGNUM *bn = EC_KEY_get0_private_key(pkey);
-    int nBytes = BN_num_bytes(bn);
-    if (bn == NULL)
-        throw key_error("CKey::GetSecret() : EC_KEY_get0_private_key failed");
-    int n=BN_bn2bin(bn,&vchRet[32 - nBytes]);
-    if (n != nBytes)
-        throw key_error("CKey::GetSecret(): BN_bn2bin failed");
+    if (!fSet || !fHavePrivKey)
+        throw key_error("CKey::GetSecret() : key is not set or has no private component");
+    CSecret out(vch, vch + 32);
    fCompressed = fCompressedPubKey;
-    return vchRet;
+    return out;
 }

 CPrivKey CKey::GetPrivKey() const
 {
-    int nSize = i2d_ECPrivateKey(pkey, NULL);
-    if (!nSize)
-        throw key_error("CKey::GetPrivKey() : i2d_ECPrivateKey failed");
-    CPrivKey vchPrivKey(nSize, 0);
-    unsigned char* pbegin = &vchPrivKey[0];
-    if (i2d_ECPrivateKey(pkey, &pbegin) != nSize)
-        throw key_error("CKey::GetPrivKey() : i2d_ECPrivateKey returned unexpected size");
-    return vchPrivKey;
+    if (!fSet || !fHavePrivKey)
+        throw key_error("CKey::GetPrivKey() : key is not set or has no private component");
+
+    // Max possible output: 279 bytes (uncompressed).
+    CPrivKey out(279, 0);
+    std::size_t out_len = out.size();
+    if (!ECDSA_privkey_export_der_secp256k1(&out[0], &out_len, vch, fCompressedPubKey))
+        throw key_error("CKey::GetPrivKey() : DER export failed");
+    out.resize(out_len);
+    return out;
 }

-bool CKey::SetPubKey(const CPubKey& vchPubKey)
+bool CKey::SetPubKey(const CPubKey& cpub)
 {
-    const unsigned char* pbegin = &vchPubKey.vchPubKey[0];
-    if (o2i_ECPublicKey(&pkey, &pbegin, vchPubKey.vchPubKey.size()))
-    {
-        fSet = true;
-        if (vchPubKey.vchPubKey.size() == 33)
-            SetCompressedPubKey();
-        return true;
+    const std::vector<unsigned char>& vchPub = cpub.vchPubKey;
+    if (vchPub.size() != 33 && vchPub.size() != 65) {
+        Reset();
+        return false;
    }
-    pkey = NULL;
-    Reset();
-    return false;
+    if (!ECDSA_pubkey_verify_secp256k1(&vchPub[0], vchPub.size())) {
+        Reset();
+        return false;
+    }
+    vchPubKey         = vchPub;
+    fSet              = true;
+    fHavePrivKey      = false;
+    fCompressedPubKey = (vchPub.size() == 33);
+    return true;
 }

 CPubKey CKey::GetPubKey() const
 {
-    int nSize = i2o_ECPublicKey(pkey, NULL);
-    if (!nSize)
-        throw key_error("CKey::GetPubKey() : i2o_ECPublicKey failed");
-    std::vector<unsigned char> vchPubKey(nSize, 0);
-    unsigned char* pbegin = &vchPubKey[0];
-    if (i2o_ECPublicKey(pkey, &pbegin) != nSize)
-        throw key_error("CKey::GetPubKey() : i2o_ECPublicKey returned unexpected size");
    return CPubKey(vchPubKey);
 }

+// ─────────────────────────────────────────────────────────────────────────────
+// Sign / verify / recover (all delegate to crypto_ecdsa wrappers)
+// ─────────────────────────────────────────────────────────────────────────────
+
 bool CKey::Sign(uint256 hash, std::vector<unsigned char>& vchSig)
 {
    vchSig.clear();
-    ECDSA_SIG *sig = ECDSA_do_sign((unsigned char*)&hash, sizeof(hash), pkey);
-    if (sig == NULL)
+    if (!fSet || !fHavePrivKey) return false;
+
+    // libsecp256k1's max DER output is 72 bytes; allocate that and shrink.
+    vchSig.resize(72);
+    std::size_t sig_len = vchSig.size();
+    if (!ECDSA_sign_secp256k1(&vchSig[0], &sig_len,
+                               reinterpret_cast<const unsigned char*>(&hash),
+                               vch))
+    {
+        vchSig.clear();
        return false;
-    BN_CTX *ctx = BN_CTX_new();
-    BN_CTX_start(ctx);
-    const EC_GROUP *group = EC_KEY_get0_group(pkey);
-    BIGNUM *order = BN_CTX_get(ctx);
-    BIGNUM *halforder = BN_CTX_get(ctx);
-    EC_GROUP_get_order(group, order, ctx);
-    BN_rshift1(halforder, order);
-    const BIGNUM *sig_r, *sig_s;
-    ECDSA_SIG_get0(sig, &sig_r, &sig_s);
-    if (BN_cmp(sig_s, halforder) > 0) {
-        // enforce low S values, by negating the value (modulo the order) if above order/2.
-        BIGNUM *new_s = BN_new();
-        BN_sub(new_s, order, sig_s);
-        BIGNUM *dup_r = BN_dup(sig_r);
-        ECDSA_SIG_set0(sig, dup_r, new_s);
    }
-    BN_CTX_end(ctx);
-    BN_CTX_free(ctx);
-    unsigned int nSize = ECDSA_size(pkey);
-    vchSig.resize(nSize); // Make sure it is big enough
-    unsigned char *pos = &vchSig[0];
-    nSize = i2d_ECDSA_SIG(sig, &pos);
-    ECDSA_SIG_free(sig);
-    vchSig.resize(nSize); // Shrink to fit actual size
+    vchSig.resize(sig_len);
    return true;
 }

-// create a compact signature (65 bytes), which allows reconstructing the used public key
-// The format is one header byte, followed by two times 32 bytes for the serialized r and s values.
-// The header byte: 0x1B = first key with even y, 0x1C = first key with odd y,
-//                  0x1D = second key with even y, 0x1E = second key with odd y
+// Compact signature (65 bytes): one header byte (encoding recid + compression)
+// followed by 32-byte r and 32-byte s.
 bool CKey::SignCompact(uint256 hash, std::vector<unsigned char>& vchSig)
 {
-    bool fOk = false;
-    ECDSA_SIG *sig = ECDSA_do_sign((unsigned char*)&hash, sizeof(hash), pkey);
-    if (sig==NULL)
-        return false;
    vchSig.clear();
-    vchSig.resize(65,0);
-    const BIGNUM *sig_r, *sig_s;
-    ECDSA_SIG_get0(sig, &sig_r, &sig_s);
-    int nBitsR = BN_num_bits(sig_r);
-    int nBitsS = BN_num_bits(sig_s);
-    if (nBitsR <= 256 && nBitsS <= 256)
+    if (!fSet || !fHavePrivKey) return false;
+
+    vchSig.resize(65, 0);
+    if (!ECDSA_sign_compact_secp256k1(&vchSig[0],
+                                       reinterpret_cast<const unsigned char*>(&hash),
+                                       vch,
+                                       fCompressedPubKey))
    {
-        int nRecId = -1;
-        for (int i=0; i<4; i++)
-        {
-            CKey keyRec;
-            keyRec.fSet = true;
-            if (fCompressedPubKey)
-                keyRec.SetCompressedPubKey();
-            if (ECDSA_SIG_recover_key_GFp(keyRec.pkey, sig, (unsigned char*)&hash, sizeof(hash), i, 1) == 1)
-                if (keyRec.GetPubKey() == this->GetPubKey())
-                {
-                    nRecId = i;
-                    break;
-                }
-        }
-
-        if (nRecId == -1)
-        {
-            ECDSA_SIG_free(sig);
-            throw key_error("CKey::SignCompact() : unable to construct recoverable key");
-        }
-
-        vchSig[0] = nRecId+27+(fCompressedPubKey ? 4 : 0);
-        BN_bn2bin(sig_r,&vchSig[33-(nBitsR+7)/8]);
-        BN_bn2bin(sig_s,&vchSig[65-(nBitsS+7)/8]);
-        fOk = true;
+        vchSig.clear();
+        return false;
    }
-    ECDSA_SIG_free(sig);
-    return fOk;
+    return true;
 }

-// reconstruct public key from a compact signature
-// This is only slightly more CPU intensive than just verifying it.
-// If this function succeeds, the recovered public key is guaranteed to be valid
-// (the signature is a valid signature of the given data for that key)
 bool CKey::SetCompactSignature(uint256 hash, const std::vector<unsigned char>& vchSig)
 {
-    if (vchSig.size() != 65)
-        return false;
+    if (vchSig.size() != 65) return false;
    int nV = vchSig[0];
-    if (nV<27 || nV>=35)
-        return false;
-    ECDSA_SIG *sig = ECDSA_SIG_new();
-    BIGNUM *sig_r = BN_bin2bn(&vchSig[1],32,NULL);
-    BIGNUM *sig_s = BN_bin2bn(&vchSig[33],32,NULL);
-    ECDSA_SIG_set0(sig, sig_r, sig_s);
+    if (nV < 27 || nV >= 35) return false;

-    EC_KEY_free(pkey);
-    pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
-    if (nV >= 31)
-    {
-        SetCompressedPubKey();
-        nV -= 4;
-    }
-    if (ECDSA_SIG_recover_key_GFp(pkey, sig, (unsigned char*)&hash, sizeof(hash), nV - 27, 0) == 1)
-    {
-        fSet = true;
-        ECDSA_SIG_free(sig);
-        return true;
-    }
-    ECDSA_SIG_free(sig);
-    return false;
+    unsigned char pubkey[65];
+    std::size_t pubkey_len = 0;
+    if (!ECDSA_recover_compact_secp256k1(pubkey, &pubkey_len,
+                                          reinterpret_cast<const unsigned char*>(&hash),
+                                          &vchSig[0]))
+        return false;
+
+    std::vector<unsigned char> vchPub(pubkey, pubkey + pubkey_len);
+    return SetPubKey(CPubKey(vchPub));
 }

 bool CKey::Verify(uint256 hash, const std::vector<unsigned char>& vchSig)
 {
-    // -1 = error, 0 = bad sig, 1 = good
-    if (ECDSA_verify(0, (unsigned char*)&hash, sizeof(hash), &vchSig[0], vchSig.size(), pkey) != 1)
-        return false;
+    if (vchSig.empty() || !fSet) return false;

-    return true;
+    return ECDSA_verify_secp256k1(
+        reinterpret_cast<const unsigned char*>(&hash),
+        &vchSig[0], vchSig.size(),
+        &vchPubKey[0], vchPubKey.size());
 }

 bool CKey::VerifyCompact(uint256 hash, const std::vector<unsigned char>& vchSig)
 {
    CKey key;
-    if (!key.SetCompactSignature(hash, vchSig))
-        return false;
-    if (GetPubKey() != key.GetPubKey())
-        return false;
-
-    return true;
+    if (!key.SetCompactSignature(hash, vchSig)) return false;
+    return GetPubKey() == key.GetPubKey();
 }

 bool CKey::IsValid()
 {
-    if (!fSet)
-        return false;
+    if (!fSet) return false;

-    if (!EC_KEY_check_key(pkey))
-        return false;
+    if (fHavePrivKey) {
+        if (!ECDSA_seckey_verify_secp256k1(vch)) return false;

-    bool fCompr;
-    CSecret secret = GetSecret(fCompr);
-    CKey key2;
-    key2.SetSecret(secret, fCompr);
-    return GetPubKey() == key2.GetPubKey();
+        // Re-derive the pubkey and check it matches the cache. This is the
+        // libsecp256k1 equivalent of OpenSSL's "consistency between priv and
+        // pub" check the original implementation performed.
+        unsigned char rederived[65];
+        std::size_t rederived_len = 0;
+        if (!ECDSA_pubkey_from_privkey_secp256k1(rederived, &rederived_len, vch, fCompressedPubKey))
+            return false;
+        if (rederived_len != vchPubKey.size()) return false;
+        return std::memcmp(rederived, &vchPubKey[0], rederived_len) == 0;
+    }
+
+    return ECDSA_pubkey_verify_secp256k1(&vchPubKey[0], vchPubKey.size());
 }

-bool ECC_InitSanityCheck() {
-    EC_KEY *pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
-    if(pkey == NULL)
-        return false;
-    EC_KEY_free(pkey);
+// ─────────────────────────────────────────────────────────────────────────────
+// Startup smoke test for the cryptography backend.
+// ─────────────────────────────────────────────────────────────────────────────

-    // TODO Is there more EC functionality that could be missing?
+bool ECC_InitSanityCheck()
+{
+    // Verify that libsecp256k1 can validate a trivially-known good secret
+    // (the scalar 1) and reject zero. If either of these fails, the linked
+    // library is broken and we should refuse to start.
+    static const unsigned char one[32]  = {
+        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1
+    };
+    static const unsigned char zero[32] = {0};
+    if (!ECDSA_seckey_verify_secp256k1(one))   return false;
+    if ( ECDSA_seckey_verify_secp256k1(zero))  return false;
    return true;
 }
@@ -13,8 +13,6 @@
 #include "uint256.h"
 #include "util.h"

-#include <openssl/ec.h> // for EC_KEY definition
-
 // secp160k1
 // const unsigned int PRIVATE_KEY_SIZE = 192;
 // const unsigned int PUBLIC_KEY_SIZE  = 41;
@@ -70,7 +68,7 @@ public:
    CPubKey() { }
    CPubKey(const std::vector<unsigned char> &vchPubKeyIn) : vchPubKey(vchPubKeyIn) { }
    friend bool operator==(const CPubKey &a, const CPubKey &b) { return a.vchPubKey == b.vchPubKey; }
-    friend bool operator!=(const CPubKey &a, const CPubKey &b) { return a.vchPubKey != b.vchPubKey; }
+    friend bool operator!=(const CPubKey &a, const CPubKey &b) = default;
    friend bool operator<(const CPubKey &a, const CPubKey &b) { return a.vchPubKey < b.vchPubKey; }

    IMPLEMENT_SERIALIZE(
@@ -101,24 +99,25 @@ public:

 // secure_allocator is defined in allocators.h
 // CPrivKey is a serialized private key, with all parameters included (279 bytes)
-typedef std::vector<unsigned char, secure_allocator<unsigned char> > CPrivKey;
-// CSecret is a serialization of just the secret parameter (32 bytes)
-typedef std::vector<unsigned char, secure_allocator<unsigned char> > CSecret;
+using CPrivKey = std::vector<unsigned char, secure_allocator<unsigned char>>;
+using CSecret = std::vector<unsigned char, secure_allocator<unsigned char>>;

-/** An encapsulated OpenSSL Elliptic Curve key (public and/or private) */
+/** An encapsulated secp256k1 elliptic-curve key (public and/or private). */
 class CKey
 {
 protected:
-    EC_KEY* pkey;
+    // 32-byte private scalar. Valid iff fSet && fHavePrivKey.
+    unsigned char vch[32];
+    // Cached serialized public key (33 or 65 bytes). Valid iff fSet.
+    std::vector<unsigned char> vchPubKey;
    bool fSet;
    bool fCompressedPubKey;
+    bool fHavePrivKey;

 public:
    void SetCompressedPubKey();
    void SetUnCompressedPubKey();
-    
-    EC_KEY* GetECKey();
-    
+
    void Reset();

    CKey();
--- a/Show More
+++ b/Show More