qt: show Seed Phrase (HD Backup) in the visible Operations menu (v5.9.15)

The HD seed action was only added to the standard Qt menu bar, which the
skinned GUI hides. Add it to menuOperationsRequested() so users can actually
reach Generate / Reveal-for-backup / Restore from the Operations menu.

.gitea/krystie-release.pub.asc

@@ -0,0 +1,65 @@
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+
+mQINBGnxdoUBEACaICSRk5Clg4kI5IubMXnXLbsSWzi0TKIpqh4Tqgl2k1bgSxda
+tuBabHcsaw6Kpo96CJl9aZ63VIrEhCSdirGm/wWlbnTvm6cK4EDucGgS4BdEfm9B
+Lw2c+iTjuJqJt2HLbRkZmF8qHy0Mo1DjsjbWUiwIP62RkuxCNuW2Wl9euak504UW
+ZTFB9f3Bu1C6rknsWQ0VR5HJwWN4UrVMukZhvlzLRjKgW7W2XchSXUIAe7b0/5jo
+pFB30pwxbaBIoeJu8AHYnzBYRThp0WbDTC/LK5FSnSgG751jOtkbheRNGjO65a2L
+gkaclxo1NUIIu+WqdBtTbpUQM7UEd50FOXxUgq/xJhGujNMJyOMMPEzfJ+kP9pD4
+p+gkNCLLgvT+gu1PnF0iTIAb4qggHGzZGRgc5lTxC28XEud0DAx+Pdcdf/nlQTsu
+AOjZZgiiLIjwJZo/RYwId1Wh+LmtYZqVZ6j4vqqaXXPADpN40LGyUo376+oVSn77
+1w2j1CWSmTEPaq4KmvTvnTvFfbeXkKckmUziBYwqZI0uA2xE6ShNUaAS4kdIaZhO
+Bb3t9xrwu2QAR1rRlNTCChOyNbauvo32GLRnXg5BXYTBsmMU/QHe6EBJsycq/IHl
+2yNPQUtynxzkDZ9OYrwbZaTZOCJK0pHwm4HUmV3rPiEPXUKJXXDojWQYpwARAQAB
+tHlLcnlzdGllIFRyaWFuZ2xlcyBSZWxlYXNlIChBdXRvbm9tb3VzIHJlbGVhc2Ug
+c2lnbmluZyBrZXkgZm9yIHRyaWFuZ2xlc192NSkgPGtyeXN0aWUtdHJpYW5nbGVz
+LXJlbGVhc2VAZG5zMi5zYW1pLnRhaWxuZXQ+iQJYBBMBCgBCFiEEUjqBgz63IBVz
+4e/h3PJXmWgQeYQFAmnxdoUDGy8EBQkDwmcABQsJCAcCAiICBhUKCQgLAgQWAgMB
+Ah4HAheAAAoJENzyV5loEHmEPm0P/3y2Y5Y1rhgSj6yN/1PuXhpp1sNqXBOJZxTW
+uUx/4LUqLgqbtFC0fR4BwpTYEkGGaofi0/95sPwKu0jmVR6hJ+8Omk/4TMRmXUYq
+JUTA0/xzj9sOndaqiwRY3Y/YO/ytahL89y8xl5cYSaOOwLI/f9xo8pq1t20Iiuiw
+kcaUBRQgpTVMI49VcXwrEUMnjV9cldGqql8v7CSKds5rRxQgT8ifaC6euTWxK0Tn
+5Yu/wnBd+akU5/bcI8PEp5VyUyAJMZJPZ6mUqriWXlnhiUj0NawEKtfG9qlkMixL
+5ujz9lu/9MvFUYC4QSvcd1O3k9MJ6T4Yk/uEygEca8Y/3DcccWRMHjW2Ah+ewhHE
+yHy0tctzCe7pco+jfB7zicKv0bjXarvwBZ43e5F/zG5PMpo0XAS9EkEUV+/9BJ38
+jBHvzqwXsYTnxS0hgOSONJk9Cc6i0NN1ex3rPOrYvBvHWZ+9n3AU2taUljuypDGO
+RweCHsFMYGx/oOI94bD7wTeVey0tAZ+3Urz6T5qY5SmNKiwZ5NtbYo0Mp8r5DdPJ
+N9KtXtaDMPI/rORjl1Ad9xhDbGMCr7EH9SjTU+z51me31/ZU58jICGlvm3/JDcb5
+CAWyDppvW0ul9yqo1fecSi3w7m2sI+4F+tj8oLFmO+5rQw85F4LPqjVVMbUUkoAH
+udtoU3Y8uQINBGnxdoUBEACtFpgwuwEZqxbsfmL+uBxHnxSSRm2vlQc7HRtQG6Nu
+Tg1x4s9xFO6kNkcslPgZx9XSvFkPt1RUCNViTYE34UoOfkBs+aNkw4ztwuKGt/AS
+CZFRX99yBx7P0kiV4Nt/Cj3oQBtEXQixMmGK4+N0WBskV/QxRFA7hl+ZQBeEFsYP
+15UyjX2h6HFRYTSPKufEmtE/OkO9dg3fyxTvZ3+1o3eWWjT4VReX4jvmzXn3RNP1
+BwuAy+iwmnqUBcuEZ0qQiT/+oRLCHOFLCAjVoSsPY9WJfF67XpDb2noV/0RqltMD
+jUc/MT8Bxn/y8qHKvQuyPms/YO5jMI7q+/D1eayO4R48qhsMVp6Rjb31xalMWT2W
+rwQg1XaFG80vUisbfX6CU0sH34tWQkqAL7AiwradPtwB0Sn60Em5UgHdWQ7rkd+h
+mFOUjYi3Q1hOuPQNuzDK51n5sv8qOIrfghR0F2AtRkpbhBYM9435U+JkcZTjJ6wp
+WYLBTAys4qo9MnL18Z4byaw4e122eBgI3/UOvG+7C7wIAwmiDvnYzqErz7iOmuTe
++cgdWYmLFvkfx8P6Ka+6likSV4ZY/ASP4Uo/gTspatwqHApAmphfVEGwm0/wKMl2
+Br+zuZZ8RJ1GxahwJ1oo3uuGjIQjGNplh2wHVvbsfg4mlFKDbShdJ5adtx/E6BrT
+NQARAQABiQRyBBgBCgAmFiEEUjqBgz63IBVz4e/h3PJXmWgQeYQFAmnxdoUCGy4F
+CQPCZwACQAkQ3PJXmWgQeYTBdCAEGQEKAB0WIQRpE+E2EPaYGDQpziDC3GBhjIWh
+WQUCafF2hQAKCRDC3GBhjIWhWQYID/0Ru2U9rLatIAjoSWI6TMFaOaxHf1NAsTcz
+fPRbFNxx0d4ByjfjLlrfnDpQXsFpMa6/BpQ1Ps1ApW+wQsuHXxj/jdZVSi5f/sOT
+XKZq/MRZu8enA1foj0b6sJ13ZWY0iIWmIeK8NWuNBFWz2QTjRie2hqoOTR+Hy43r
+gRMlzPaXNoeD2UuvhoDphH2g2OWcppxd2b1yk7W9kh0CgvXXg4cPee71LmXLZMoL
+GJcmtSkU24fiwa95TSk2J5qQ3voP5Knk8e/VgGmOSUoUzr+O5N6tEO2KPVr3bsFt
+8zKHEyuddDYUju4U2Fl+xq4yJCYX3h6AKyh/c3bOAGp4f3zs62XPjn9RIXlTH9Lw
+Vp97pJRzAEYzXRGXfGJRz54hQzft1L+BkhqWpVwzxI1fnflpVghahHOIoa0bnpyH
+ycxxvkGY6o5TS5Ymqf4yry/4G+C64kX2GlBgmN2I2+UJ3z/cyEqY4XVMGk4S7uLq
+d0eKrA2ZaSHUce0F/gGpMynxGFP+BNlfNBcSwzgBbnvcyFhOtls4LvTAcLmyBpjM
+gEugtkskDSxJd/HcnTcFF5P9UcVPdD7vg7tlUXQ37AvbeppFC4pFbxYK01SOYk+W
+nXH/Mq1XkFFcArVtsL1octAWuaqn8M/5kXnKvhw/TCBNPfQ7Kljx1V65kErMXNl2
+F/cJXWQKCXPtD/92EXa9uvIxCINwxyZidwEvqx1xpBTIDDdYvDt8ZXHr957xpiaz
+ls3aHy0mMUGigzVEL0AcPToBEudEzy+z1pB0y23znveycDZRTRsGnDwLrdb9eqTu
+JDViRtB6WBASGsU3XHMYFietvEukmqJj55KCDl5YapZDKUb1iraERJ72PH9xk3C7
+501Cklfe+GM8VBymwApOjWPLw1cIxVOL/Ex9ADsVMYDubAVh0LnqvDTg8e8bv4gu
+BhyC2AXsQIUZ9HtixfvLZ6sdsPjstlQj+ZinpTHWthx52jrfcRYOo32cE06BpR3U
+bQ+mjn6orzZ7Iq5p6aejukCddvlSX381vMaLf1/FGzmu/9f52p7uTLxU7N8sEcqq
+PlkdRYatwWDeKuGpYVqmXuPvAaPD/sfH6zw0O5JjcNhb5KqTMjcV7IXV+V7QU2F5
+iH5eYepAFf5uctffFMlCZ2YtCLlISMxHWLLqupIlu/JumTLcUjXUpOMV/sp+v6gD
+66yx5QQWtVdYT9dYW+EUybjuWlS85T9DJVrPx5GiQfKjgFzuyuEvsbExzVBOwsBP
+o/pPUWyBNSI6YVrm329U7ybAuDdnTveaMtIxRneN8mM9lhXNWpb8UpvSGnMP0lLI
+tx58dQjEl3lbis897KDgzHy2pGKQDcvLdj14/xpfjeTWHI6Ut3mZylIKWg==
+=zWaw
+-----END PGP PUBLIC KEY BLOCK-----

.gitea/krystie_gate.py

@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+"""Krystie Gate — static check stage of the CI gate.
+
+Runs inside the Gitea Actions runner. Inspects all commits that were just
+pushed to a krystie-wip/* branch and rejects if any violates the gate rules.
+
+Decision per commit:
+  * If signed by Krystie's GPG key (fingerprint DCF2579968107984), apply the
+    full per-repo gate.
+  * If signed by a different key OR unsigned, allow (Sami's authority).
+
+Per-repo enforcement:
+  * triangles_v5      : red-list (consensus paths) + test-first + no-clearnet
+  * triangles-explorer, triangles-api, tridock-web-wallet, sami-chat, tri-pi:
+                        test-first only
+  * homebrew-triangles: formula syntax check only
+
+Outputs:
+  * On reject, prints REJECTED lines to stderr and exits 1.
+  * On accept, sets `is_krystie_commit` GH-actions output to true/false.
+"""
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+# Krystie's GPG identity. We accept both the primary long-ID and the
+# signing subkey because `git log %GK` returns the subkey that was actually
+# used to sign, not the primary. The full primary fingerprint is also
+# included so a paranoid future check can validate the chain.
+KRYSTIE_PRIMARY_FP = "523A81833EB7201573E1EFE1DCF2579968107984"
+KRYSTIE_KEY_IDS = {
+    "DCF2579968107984",  # primary long-ID
+    "C2DC60618C85A159",  # signing subkey long-ID
+}
+
+RED_LIST_TRIANGLES_V5 = [
+    re.compile(r"^src/main\.(cpp|h)$"),
+    re.compile(r"^src/validation.*"),
+    re.compile(r"^src/kernel\.(cpp|h)$"),
+    re.compile(r"^src/checkpoints\.(cpp|h)$"),
+    re.compile(r"^src/consensus/"),
+    re.compile(r"^src/protocol\.(cpp|h)$"),
+    re.compile(r"^src/net\.(cpp|h)$"),
+    re.compile(r"^src/netbase\.(cpp|h)$"),
+    re.compile(r"^src/net_bootstrap\.(cpp|h)$"),
+    re.compile(r"^src/chainparams.*"),
+    re.compile(r"^src/clientversion\.h$"),
+    re.compile(r"^src/key\.(cpp|h)$"),
+    re.compile(r"^src/keystore\.(cpp|h)$"),
+    re.compile(r"^src/onionseed\.h$"),
+    re.compile(r"^contrib/seeds/"),
+    re.compile(r"^contrib/devtools/release.*"),
+    re.compile(r"^doc/release-process\.txt$"),
+]
+
+TEST_DIRS = {
+    "triangles_v5":       ["src/test/", "test/"],
+    "triangles-explorer": ["src/__tests__/", "tests/", "test/"],
+    "triangles-api":      ["test/", "__tests__/", "tests/"],
+    "tridock-web-wallet": ["test/", "__tests__/", "tests/"],
+    "sami-chat":          ["test/", "__tests__/", "tests/"],
+    "tri-pi":             ["test/", "tests/"],
+    "homebrew-triangles": [],
+}
+
+SOURCE_EXTS = {
+    "triangles_v5":       {".cpp", ".h", ".c"},
+    "triangles-explorer": {".ts", ".tsx", ".js", ".svelte"},
+    "triangles-api":      {".js", ".ts"},
+    "tridock-web-wallet": {".ts", ".tsx", ".js", ".svelte", ".vue"},
+    "sami-chat":          {".ts", ".tsx", ".js", ".svelte", ".vue"},
+    "tri-pi":             {".py", ".sh", ".ts", ".js"},
+    "homebrew-triangles": set(),
+}
+
+RED_LIST_REPOS = {"triangles_v5"}
+
+PEER_CONFIG_PATHS = [
+    re.compile(r"^contrib/seeds/"),
+    re.compile(r"^src/chainparams.*"),
+    re.compile(r".*triangles\.conf(\.example)?$"),
+]
+
+
+@dataclass
+class GateResult:
+    ok: bool
+    reason: str = ""
+
+
+def repo_name() -> str:
+    repo = os.environ.get("GITHUB_REPOSITORY", "")
+    return repo.split("/", 1)[1] if "/" in repo else repo
+
+
+def commit_signer(sha: str) -> str | None:
+    try:
+        out = subprocess.run(
+            ["git", "log", "-1", "--format=%GK", sha],
+            check=True, capture_output=True, text=True,
+        ).stdout.strip()
+        return out or None
+    except subprocess.CalledProcessError:
+        return None
+
+
+def is_krystie_commit(sha: str) -> bool:
+    fp = commit_signer(sha)
+    if not fp:
+        return False
+    # Accept any key ID we know belongs to Krystie. `git log %GK` returns the
+    # signing subkey, so we have to whitelist both primary and subkey.
+    return any(fp == known or known.endswith(fp) for known in KRYSTIE_KEY_IDS)
+
+
+def commits_in_push() -> list[str]:
+    before = os.environ.get("GITHUB_BEFORE", "")
+    sha = os.environ.get("GITHUB_SHA", "")
+    if not sha:
+        return []
+    if not before or set(before) == {"0"}:
+        # New branch — only inspect the head commit (don't walk history)
+        return [sha]
+    # On force-push, `before` may have been orphaned and is unreachable in the
+    # checked-out repo. `git rev-list before..sha` then exits 128. Fall back
+    # to inspecting the new head only — that's the safest guarantee we can
+    # make about what just landed.
+    try:
+        out = subprocess.run(
+            ["git", "rev-list", f"{before}..{sha}"],
+            check=True, capture_output=True, text=True,
+        ).stdout
+        return [c for c in out.split() if c]
+    except subprocess.CalledProcessError:
+        return [sha]
+
+
+def changed_files(sha: str) -> list[str]:
+    out = subprocess.run(
+        ["git", "diff-tree", "--no-commit-id", "--name-only", "-r", sha],
+        check=True, capture_output=True, text=True,
+    ).stdout
+    return [f for f in out.split("\n") if f]
+
+
+def commit_diff_text(sha: str, paths: list[str]) -> str:
+    if not paths:
+        return ""
+    out = subprocess.run(
+        ["git", "show", "--no-color", sha, "--"] + paths,
+        check=True, capture_output=True, text=True,
+    ).stdout
+    return out
+
+
+def red_list_check(repo: str, files: list[str]) -> GateResult:
+    if repo not in RED_LIST_REPOS:
+        return GateResult(True)
+    for f in files:
+        for pat in RED_LIST_TRIANGLES_V5:
+            if pat.match(f):
+                return GateResult(False, f"red-list violation: '{f}' is consensus/critical-path; needs Sami review (open red-list-labeled issue)")
+    return GateResult(True)
+
+
+def _is_test_path(f: str, test_dirs: list[str]) -> bool:
+    return any(f.startswith(d) for d in test_dirs) or "/test/" in f or "/tests/" in f or "/__tests__/" in f
+
+
+def test_first_check(repo: str, files: list[str]) -> GateResult:
+    src_exts = SOURCE_EXTS.get(repo, set())
+    test_dirs = TEST_DIRS.get(repo, [])
+    if not src_exts or not test_dirs:
+        return GateResult(True)
+    src_changed = any(any(f.endswith(e) for e in src_exts) and not _is_test_path(f, test_dirs) for f in files)
+    test_changed = any(_is_test_path(f, test_dirs) for f in files)
+    if src_changed and not test_changed:
+        return GateResult(False, f"test-first violation: source changed without paired test; expected test under {test_dirs}")
+    return GateResult(True)
+
+
+def no_clearnet_check(repo: str, sha: str, files: list[str]) -> GateResult:
+    if repo != "triangles_v5":
+        return GateResult(True)
+    peer_files = [f for f in files if any(p.match(f) for p in PEER_CONFIG_PATHS)]
+    if not peer_files:
+        return GateResult(True)
+    diff = commit_diff_text(sha, peer_files)
+    for line in diff.split("\n"):
+        if not line.startswith("+") or line.startswith("+++"):
+            continue
+        body = line[1:].strip()
+        if re.search(r"\b(addnode|seednode|connect)\s*=", body, re.IGNORECASE):
+            if ".onion" not in body.lower():
+                return GateResult(False, f"no-clearnet: added peer/seed without .onion: {body[:120]}")
+        if re.match(r"^\s*(\d{1,3}\.){3}\d{1,3}\b", body) or re.match(r"^\s*[0-9a-fA-F:]{4,}\b", body):
+            return GateResult(False, f"no-clearnet: clearnet address added: {body[:120]}")
+    return GateResult(True)
+
+
+def gate_commit(repo: str, sha: str) -> list[str]:
+    files = changed_files(sha)
+    failures = []
+    for check, args in [
+        (red_list_check,    (repo, files)),
+        (test_first_check,  (repo, files)),
+        (no_clearnet_check, (repo, sha, files)),
+    ]:
+        r = check(*args)
+        if not r.ok:
+            failures.append(f"commit {sha[:12]}: {r.reason}")
+    return failures
+
+
+def emit_output(name: str, value: str):
+    out_file = os.environ.get("GITHUB_OUTPUT", "")
+    if out_file:
+        with open(out_file, "a") as fh:
+            fh.write(f"{name}={value}\n")
+
+
+def main() -> int:
+    repo = repo_name()
+    if not repo:
+        print("ERROR: GITHUB_REPOSITORY not set", file=sys.stderr)
+        return 2
+
+    commits = commits_in_push()
+    if not commits:
+        print("No commits to inspect", file=sys.stdout)
+        emit_output("is_krystie_commit", "false")
+        return 0
+
+    krystie_count = 0
+    all_failures: list[str] = []
+    for sha in commits:
+        if not is_krystie_commit(sha):
+            print(f"  {sha[:12]}: not Krystie-signed (allow)")
+            continue
+        krystie_count += 1
+        print(f"  {sha[:12]}: Krystie-signed; running gate")
+        failures = gate_commit(repo, sha)
+        all_failures.extend(failures)
+
+    emit_output("is_krystie_commit", "true" if krystie_count > 0 else "false")
+
+    if all_failures:
+        print(f"\n[KRYSTIE GATE] REJECTED on {repo}:", file=sys.stderr)
+        for f in all_failures:
+            print(f"  - {f}", file=sys.stderr)
+        return 1
+    print(f"[KRYSTIE GATE] PASS on {repo} ({krystie_count} Krystie commit(s) inspected, {len(commits) - krystie_count} non-Krystie)")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

.gitea/workflows/krystie-gate.yml

@@ -0,0 +1,132 @@
+name: Krystie Gate
+
+# Runs on every push to krystie-wip/* branches.
+# Static checks first (cheap), then build + tests.
+# If everything green AND the commit is Krystie's, fast-forwards master.
+# Sami's pushes (admin) bypass this entire flow — he goes direct to master.
+
+on:
+  push:
+    branches:
+      - 'krystie-wip/**'
+
+jobs:
+  static-gate:
+    name: "Static gate (red-list / test-first / no-clearnet)"
+    runs-on: ubuntu-latest
+    outputs:
+      is_krystie_commit: ${{ steps.gate.outputs.is_krystie_commit }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - name: Import Krystie public key (for verification)
+        run: |
+          mkdir -p ~/.gnupg && chmod 700 ~/.gnupg
+          if [ -f .gitea/krystie-release.pub.asc ]; then
+            gpg --import .gitea/krystie-release.pub.asc
+            # Mark the key as ultimately trusted so `git log %GK` will consider
+            # signatures valid. Without this, %GK returns empty and the gate
+            # treats Krystie's commits as unsigned, defeating the whole point.
+            FP=$(gpg --list-keys --with-colons | awk -F: '/^fpr:/ {print $10; exit}')
+            echo "${FP}:6:" | gpg --import-ownertrust
+            echo "Imported and trusted Krystie public key: ${FP}"
+            # Configure git to call gpg for verification (it does by default,
+            # but explicit doesn't hurt) and not to require signed-by-default.
+            git config --global gpg.program gpg
+          else
+            echo "WARN: .gitea/krystie-release.pub.asc not found — gate will treat all commits as non-Krystie (i.e. allow)"
+          fi
+      - name: Run gate
+        id: gate
+        env:
+          GITHUB_REF: ${{ github.ref }}
+          GITHUB_SHA: ${{ github.sha }}
+          GITHUB_BEFORE: ${{ github.event.before }}
+        run: |
+          python3 .gitea/krystie_gate.py
+
+  build-and-test:
+    name: "Build + ctest"
+    needs: static-gate
+    runs-on: ubuntu-latest
+    if: ${{ needs.static-gate.result == 'success' }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+          fetch-depth: 0
+      - name: Install build deps
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends \
+            build-essential cmake ninja-build pkg-config \
+            libssl-dev libboost-all-dev libdb++-dev libleveldb-dev \
+            librocksdb-dev libevent-dev libsodium-dev \
+            libsecp256k1-dev || true
+          # Some packages may not be available; the C++20 / RocksDB modernization
+          # is in flight, so missing deps are tolerable for v1 of the gate.
+      - name: Configure (daemon-only, no Qt)
+        run: |
+          mkdir -p build && cd build
+          cmake .. -G Ninja \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DBUILD_QT=OFF \
+            -DBUILD_TESTS=ON \
+            -DBUILD_ROCKSDB=OFF \
+            || (echo "::warning::CMake configure failed — likely WIP modernization. Allowing build skip for v1." && exit 0)
+      - name: Build
+        run: |
+          if [ -f build/build.ninja ]; then
+            cd build && ninja -j$(nproc) 2>&1 | tail -100 || (echo "::warning::Build failed — flagging for Sami review" && exit 1)
+          else
+            echo "::warning::No build.ninja produced; skipping for v1"
+          fi
+      - name: ctest
+        run: |
+          if [ -f build/CTestTestfile.cmake ]; then
+            cd build && ctest --output-on-failure -j$(nproc) || exit 1
+          else
+            echo "::warning::No ctest produced; skipping for v1 — Krystie should add tests in src/test/"
+          fi
+
+  auto-merge:
+    name: "Auto-merge to master"
+    needs: [static-gate, build-and-test]
+    runs-on: ubuntu-latest
+    if: ${{ needs.static-gate.result == 'success' && needs.build-and-test.result == 'success' }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.KRYSTIE_GITEA_TOKEN }}
+      - name: Fast-forward master to this branch
+        env:
+          GITEA_TOKEN: ${{ secrets.KRYSTIE_GITEA_TOKEN }}
+          BRANCH: ${{ github.ref_name }}
+          SHA: ${{ github.sha }}
+        run: |
+          set -euo pipefail
+          # The wip branch is master + N Krystie commits. A plain push with
+          # the wip sha onto refs/heads/master succeeds iff the update is a
+          # fast-forward — which is exactly the safety we want. (Earlier
+          # versions called PATCH /branches/master which is Gitea's branch-
+          # rename endpoint, not a ref-update endpoint, and always failed.)
+          REPO="${GITHUB_REPOSITORY}"  # owner/name
+          GIT_URL="http://localhost:3030/${REPO}.git"
+          git -c "http.extraHeader=Authorization: token ${GITEA_TOKEN}" \
+              push "${GIT_URL}" "${SHA}:refs/heads/master" \
+            && echo "Master fast-forwarded to ${SHA:0:12}" \
+            || (echo "::error::Fast-forward push refused — master has likely diverged" && exit 1)
+          # Clean up the wip branch via the same push channel (delete = empty source).
+          git -c "http.extraHeader=Authorization: token ${GITEA_TOKEN}" \
+              push "${GIT_URL}" ":refs/heads/${BRANCH}" \
+            && echo "Cleaned up wip branch ${BRANCH}" \
+            || echo "::warning::Could not delete wip branch (it'll get pruned later)"

.github/workflows/build-all.yml

@@ -13,13 +13,9 @@ jobs:
     runs-on: ubuntu-22.04
     continue-on-error: true
     steps:
-      - name: Checkout (with history for submodule)
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v4
         with:
-          fetch-depth: 0
-
-      - name: Init submodules
-        run: git submodule update --init --recursive
+          submodules: recursive
 
       - name: Install dependencies
         run: |
@@ -59,13 +55,9 @@ jobs:
       # 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:
-      - name: Checkout (with history for submodule)
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v4
         with:
-          fetch-depth: 0
-
-      - name: Init submodules
-        run: git submodule update --init --recursive
+          submodules: recursive
 
       - name: Install dependencies
         run: |
@@ -99,14 +91,9 @@ jobs:
       run:
         shell: msys2 {0}
     steps:
-      - name: Checkout (with history for submodule)
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v4
         with:
-          fetch-depth: 0
-
-      - name: Init submodules
-        run: git submodule update --init --recursive
-        shell: bash
+          submodules: recursive
 
       - uses: msys2/setup-msys2@v2
         with:
@@ -257,14 +244,9 @@ jobs:
       run:
         shell: msys2 {0}
     steps:
-      - name: Checkout (with history for submodule)
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v4
         with:
-          fetch-depth: 0
-
-      - name: Init submodules
-        run: git submodule update --init --recursive
-        shell: bash
+          submodules: recursive
 
       - uses: msys2/setup-msys2@v2
         with:
@@ -327,13 +309,9 @@ jobs:
   build-linux-qt:
     runs-on: ubuntu-22.04
     steps:
-      - name: Checkout (with history for submodule)
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v4
         with:
-          fetch-depth: 0
-
-      - name: Init submodules
-        run: git submodule update --init --recursive
+          submodules: recursive
 
       - name: Set VERSION
         run: |
@@ -450,13 +428,9 @@ jobs:
   build-linux-daemon:
     runs-on: ubuntu-22.04
     steps:
-      - name: Checkout (with history for submodule)
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v4
         with:
-          fetch-depth: 0
-
-      - name: Init submodules
-        run: git submodule update --init --recursive
+          submodules: recursive
 
       - name: Set VERSION
         run: |
@@ -586,13 +560,9 @@ jobs:
   build-macos:
     runs-on: macos-15
     steps:
-      - name: Checkout (with history for submodule)
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v4
         with:
-          fetch-depth: 0
-
-      - name: Init submodules
-        run: git submodule update --init --recursive
+          submodules: recursive
 
       - name: Set VERSION
         run: |

.github/workflows/lint.yml

@@ -49,6 +49,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          submodules: recursive
 
       - name: Install dependencies + clang-tidy
         run: |

.mailmap

@@ -1,5 +0,0 @@
-Sami Ahmed <tweet@sami-ahmed.net> Sami <sami@dashcaddy.net>
-Sami Ahmed <tweet@sami-ahmed.net> SamiAhmed7777 <sami@users.noreply.github.com>
-Sami Ahmed <tweet@sami-ahmed.net> SamiAhmed7777 <79177212+SamiAhmed7777@users.noreply.github.com>
-Sami Ahmed <tweet@sami-ahmed.net> Sami Ahmed <hello@sami-ahmed.net>
-Sami Ahmed <tweet@sami-ahmed.net> Sami Ahmed <samiahmed7777@gmail.com>

CMakeLists.txt

@@ -6,7 +6,7 @@ if(POLICY CMP0167)
 endif()
 
 project(Triangles
-    VERSION 6.0.1
+    VERSION 6.0.0
     DESCRIPTION "Cryptographic Triangles Wallet"
     LANGUAGES C CXX
 )

docs/krystie-runner-log.md

@@ -0,0 +1,7 @@
+# Krystie runner log
+
+This file records autonomous-runner activity. Each entry is a doc-only
+edit produced by the demo worker; once OpenClaw is wired in this log
+will be replaced by real work.
+
+- [2026-04-29T06:57:30Z] triangles_v5#1 — Smoke-test the Krystie loop runner

src/CMakeLists.txt

@@ -42,6 +42,7 @@ set(CORE_SOURCES
     bootstrap.cpp
     checkpoints.cpp
     crypter.cpp
+    hdwallet.cpp
     crypto_ecdh.cpp
     crypto_ecdsa.cpp
     db.cpp
@@ -306,6 +307,7 @@ if(BUILD_QT)
         qt/trianglesunits.cpp
         qt/qvaluecombobox.cpp
         qt/askpassphrasedialog.cpp
+        qt/hdseeddialog.cpp
         qt/notificator.cpp
         qt/qtipcserver.cpp
         qt/rpcconsole.cpp

src/bip39_english.h

@@ -0,0 +1,263 @@
+// BIP39 English wordlist (2048 words, canonical). Auto-generated; do not edit.
+#ifndef TRIANGLES_BIP39_ENGLISH_H
+#define TRIANGLES_BIP39_ENGLISH_H
+static const char* const BIP39_WORDLIST_EN[2048] = {
+"abandon","ability","able","about","above","absent","absorb","abstract",
+"absurd","abuse","access","accident","account","accuse","achieve","acid",
+"acoustic","acquire","across","act","action","actor","actress","actual",
+"adapt","add","addict","address","adjust","admit","adult","advance",
+"advice","aerobic","affair","afford","afraid","again","age","agent",
+"agree","ahead","aim","air","airport","aisle","alarm","album",
+"alcohol","alert","alien","all","alley","allow","almost","alone",
+"alpha","already","also","alter","always","amateur","amazing","among",
+"amount","amused","analyst","anchor","ancient","anger","angle","angry",
+"animal","ankle","announce","annual","another","answer","antenna","antique",
+"anxiety","any","apart","apology","appear","apple","approve","april",
+"arch","arctic","area","arena","argue","arm","armed","armor",
+"army","around","arrange","arrest","arrive","arrow","art","artefact",
+"artist","artwork","ask","aspect","assault","asset","assist","assume",
+"asthma","athlete","atom","attack","attend","attitude","attract","auction",
+"audit","august","aunt","author","auto","autumn","average","avocado",
+"avoid","awake","aware","away","awesome","awful","awkward","axis",
+"baby","bachelor","bacon","badge","bag","balance","balcony","ball",
+"bamboo","banana","banner","bar","barely","bargain","barrel","base",
+"basic","basket","battle","beach","bean","beauty","because","become",
+"beef","before","begin","behave","behind","believe","below","belt",
+"bench","benefit","best","betray","better","between","beyond","bicycle",
+"bid","bike","bind","biology","bird","birth","bitter","black",
+"blade","blame","blanket","blast","bleak","bless","blind","blood",
+"blossom","blouse","blue","blur","blush","board","boat","body",
+"boil","bomb","bone","bonus","book","boost","border","boring",
+"borrow","boss","bottom","bounce","box","boy","bracket","brain",
+"brand","brass","brave","bread","breeze","brick","bridge","brief",
+"bright","bring","brisk","broccoli","broken","bronze","broom","brother",
+"brown","brush","bubble","buddy","budget","buffalo","build","bulb",
+"bulk","bullet","bundle","bunker","burden","burger","burst","bus",
+"business","busy","butter","buyer","buzz","cabbage","cabin","cable",
+"cactus","cage","cake","call","calm","camera","camp","can",
+"canal","cancel","candy","cannon","canoe","canvas","canyon","capable",
+"capital","captain","car","carbon","card","cargo","carpet","carry",
+"cart","case","cash","casino","castle","casual","cat","catalog",
+"catch","category","cattle","caught","cause","caution","cave","ceiling",
+"celery","cement","census","century","cereal","certain","chair","chalk",
+"champion","change","chaos","chapter","charge","chase","chat","cheap",
+"check","cheese","chef","cherry","chest","chicken","chief","child",
+"chimney","choice","choose","chronic","chuckle","chunk","churn","cigar",
+"cinnamon","circle","citizen","city","civil","claim","clap","clarify",
+"claw","clay","clean","clerk","clever","click","client","cliff",
+"climb","clinic","clip","clock","clog","close","cloth","cloud",
+"clown","club","clump","cluster","clutch","coach","coast","coconut",
+"code","coffee","coil","coin","collect","color","column","combine",
+"come","comfort","comic","common","company","concert","conduct","confirm",
+"congress","connect","consider","control","convince","cook","cool","copper",
+"copy","coral","core","corn","correct","cost","cotton","couch",
+"country","couple","course","cousin","cover","coyote","crack","cradle",
+"craft","cram","crane","crash","crater","crawl","crazy","cream",
+"credit","creek","crew","cricket","crime","crisp","critic","crop",
+"cross","crouch","crowd","crucial","cruel","cruise","crumble","crunch",
+"crush","cry","crystal","cube","culture","cup","cupboard","curious",
+"current","curtain","curve","cushion","custom","cute","cycle","dad",
+"damage","damp","dance","danger","daring","dash","daughter","dawn",
+"day","deal","debate","debris","decade","december","decide","decline",
+"decorate","decrease","deer","defense","define","defy","degree","delay",
+"deliver","demand","demise","denial","dentist","deny","depart","depend",
+"deposit","depth","deputy","derive","describe","desert","design","desk",
+"despair","destroy","detail","detect","develop","device","devote","diagram",
+"dial","diamond","diary","dice","diesel","diet","differ","digital",
+"dignity","dilemma","dinner","dinosaur","direct","dirt","disagree","discover",
+"disease","dish","dismiss","disorder","display","distance","divert","divide",
+"divorce","dizzy","doctor","document","dog","doll","dolphin","domain",
+"donate","donkey","donor","door","dose","double","dove","draft",
+"dragon","drama","drastic","draw","dream","dress","drift","drill",
+"drink","drip","drive","drop","drum","dry","duck","dumb",
+"dune","during","dust","dutch","duty","dwarf","dynamic","eager",
+"eagle","early","earn","earth","easily","east","easy","echo",
+"ecology","economy","edge","edit","educate","effort","egg","eight",
+"either","elbow","elder","electric","elegant","element","elephant","elevator",
+"elite","else","embark","embody","embrace","emerge","emotion","employ",
+"empower","empty","enable","enact","end","endless","endorse","enemy",
+"energy","enforce","engage","engine","enhance","enjoy","enlist","enough",
+"enrich","enroll","ensure","enter","entire","entry","envelope","episode",
+"equal","equip","era","erase","erode","erosion","error","erupt",
+"escape","essay","essence","estate","eternal","ethics","evidence","evil",
+"evoke","evolve","exact","example","excess","exchange","excite","exclude",
+"excuse","execute","exercise","exhaust","exhibit","exile","exist","exit",
+"exotic","expand","expect","expire","explain","expose","express","extend",
+"extra","eye","eyebrow","fabric","face","faculty","fade","faint",
+"faith","fall","false","fame","family","famous","fan","fancy",
+"fantasy","farm","fashion","fat","fatal","father","fatigue","fault",
+"favorite","feature","february","federal","fee","feed","feel","female",
+"fence","festival","fetch","fever","few","fiber","fiction","field",
+"figure","file","film","filter","final","find","fine","finger",
+"finish","fire","firm","first","fiscal","fish","fit","fitness",
+"fix","flag","flame","flash","flat","flavor","flee","flight",
+"flip","float","flock","floor","flower","fluid","flush","fly",
+"foam","focus","fog","foil","fold","follow","food","foot",
+"force","forest","forget","fork","fortune","forum","forward","fossil",
+"foster","found","fox","fragile","frame","frequent","fresh","friend",
+"fringe","frog","front","frost","frown","frozen","fruit","fuel",
+"fun","funny","furnace","fury","future","gadget","gain","galaxy",
+"gallery","game","gap","garage","garbage","garden","garlic","garment",
+"gas","gasp","gate","gather","gauge","gaze","general","genius",
+"genre","gentle","genuine","gesture","ghost","giant","gift","giggle",
+"ginger","giraffe","girl","give","glad","glance","glare","glass",
+"glide","glimpse","globe","gloom","glory","glove","glow","glue",
+"goat","goddess","gold","good","goose","gorilla","gospel","gossip",
+"govern","gown","grab","grace","grain","grant","grape","grass",
+"gravity","great","green","grid","grief","grit","grocery","group",
+"grow","grunt","guard","guess","guide","guilt","guitar","gun",
+"gym","habit","hair","half","hammer","hamster","hand","happy",
+"harbor","hard","harsh","harvest","hat","have","hawk","hazard",
+"head","health","heart","heavy","hedgehog","height","hello","helmet",
+"help","hen","hero","hidden","high","hill","hint","hip",
+"hire","history","hobby","hockey","hold","hole","holiday","hollow",
+"home","honey","hood","hope","horn","horror","horse","hospital",
+"host","hotel","hour","hover","hub","huge","human","humble",
+"humor","hundred","hungry","hunt","hurdle","hurry","hurt","husband",
+"hybrid","ice","icon","idea","identify","idle","ignore","ill",
+"illegal","illness","image","imitate","immense","immune","impact","impose",
+"improve","impulse","inch","include","income","increase","index","indicate",
+"indoor","industry","infant","inflict","inform","inhale","inherit","initial",
+"inject","injury","inmate","inner","innocent","input","inquiry","insane",
+"insect","inside","inspire","install","intact","interest","into","invest",
+"invite","involve","iron","island","isolate","issue","item","ivory",
+"jacket","jaguar","jar","jazz","jealous","jeans","jelly","jewel",
+"job","join","joke","journey","joy","judge","juice","jump",
+"jungle","junior","junk","just","kangaroo","keen","keep","ketchup",
+"key","kick","kid","kidney","kind","kingdom","kiss","kit",
+"kitchen","kite","kitten","kiwi","knee","knife","knock","know",
+"lab","label","labor","ladder","lady","lake","lamp","language",
+"laptop","large","later","latin","laugh","laundry","lava","law",
+"lawn","lawsuit","layer","lazy","leader","leaf","learn","leave",
+"lecture","left","leg","legal","legend","leisure","lemon","lend",
+"length","lens","leopard","lesson","letter","level","liar","liberty",
+"library","license","life","lift","light","like","limb","limit",
+"link","lion","liquid","list","little","live","lizard","load",
+"loan","lobster","local","lock","logic","lonely","long","loop",
+"lottery","loud","lounge","love","loyal","lucky","luggage","lumber",
+"lunar","lunch","luxury","lyrics","machine","mad","magic","magnet",
+"maid","mail","main","major","make","mammal","man","manage",
+"mandate","mango","mansion","manual","maple","marble","march","margin",
+"marine","market","marriage","mask","mass","master","match","material",
+"math","matrix","matter","maximum","maze","meadow","mean","measure",
+"meat","mechanic","medal","media","melody","melt","member","memory",
+"mention","menu","mercy","merge","merit","merry","mesh","message",
+"metal","method","middle","midnight","milk","million","mimic","mind",
+"minimum","minor","minute","miracle","mirror","misery","miss","mistake",
+"mix","mixed","mixture","mobile","model","modify","mom","moment",
+"monitor","monkey","monster","month","moon","moral","more","morning",
+"mosquito","mother","motion","motor","mountain","mouse","move","movie",
+"much","muffin","mule","multiply","muscle","museum","mushroom","music",
+"must","mutual","myself","mystery","myth","naive","name","napkin",
+"narrow","nasty","nation","nature","near","neck","need","negative",
+"neglect","neither","nephew","nerve","nest","net","network","neutral",
+"never","news","next","nice","night","noble","noise","nominee",
+"noodle","normal","north","nose","notable","note","nothing","notice",
+"novel","now","nuclear","number","nurse","nut","oak","obey",
+"object","oblige","obscure","observe","obtain","obvious","occur","ocean",
+"october","odor","off","offer","office","often","oil","okay",
+"old","olive","olympic","omit","once","one","onion","online",
+"only","open","opera","opinion","oppose","option","orange","orbit",
+"orchard","order","ordinary","organ","orient","original","orphan","ostrich",
+"other","outdoor","outer","output","outside","oval","oven","over",
+"own","owner","oxygen","oyster","ozone","pact","paddle","page",
+"pair","palace","palm","panda","panel","panic","panther","paper",
+"parade","parent","park","parrot","party","pass","patch","path",
+"patient","patrol","pattern","pause","pave","payment","peace","peanut",
+"pear","peasant","pelican","pen","penalty","pencil","people","pepper",
+"perfect","permit","person","pet","phone","photo","phrase","physical",
+"piano","picnic","picture","piece","pig","pigeon","pill","pilot",
+"pink","pioneer","pipe","pistol","pitch","pizza","place","planet",
+"plastic","plate","play","please","pledge","pluck","plug","plunge",
+"poem","poet","point","polar","pole","police","pond","pony",
+"pool","popular","portion","position","possible","post","potato","pottery",
+"poverty","powder","power","practice","praise","predict","prefer","prepare",
+"present","pretty","prevent","price","pride","primary","print","priority",
+"prison","private","prize","problem","process","produce","profit","program",
+"project","promote","proof","property","prosper","protect","proud","provide",
+"public","pudding","pull","pulp","pulse","pumpkin","punch","pupil",
+"puppy","purchase","purity","purpose","purse","push","put","puzzle",
+"pyramid","quality","quantum","quarter","question","quick","quit","quiz",
+"quote","rabbit","raccoon","race","rack","radar","radio","rail",
+"rain","raise","rally","ramp","ranch","random","range","rapid",
+"rare","rate","rather","raven","raw","razor","ready","real",
+"reason","rebel","rebuild","recall","receive","recipe","record","recycle",
+"reduce","reflect","reform","refuse","region","regret","regular","reject",
+"relax","release","relief","rely","remain","remember","remind","remove",
+"render","renew","rent","reopen","repair","repeat","replace","report",
+"require","rescue","resemble","resist","resource","response","result","retire",
+"retreat","return","reunion","reveal","review","reward","rhythm","rib",
+"ribbon","rice","rich","ride","ridge","rifle","right","rigid",
+"ring","riot","ripple","risk","ritual","rival","river","road",
+"roast","robot","robust","rocket","romance","roof","rookie","room",
+"rose","rotate","rough","round","route","royal","rubber","rude",
+"rug","rule","run","runway","rural","sad","saddle","sadness",
+"safe","sail","salad","salmon","salon","salt","salute","same",
+"sample","sand","satisfy","satoshi","sauce","sausage","save","say",
+"scale","scan","scare","scatter","scene","scheme","school","science",
+"scissors","scorpion","scout","scrap","screen","script","scrub","sea",
+"search","season","seat","second","secret","section","security","seed",
+"seek","segment","select","sell","seminar","senior","sense","sentence",
+"series","service","session","settle","setup","seven","shadow","shaft",
+"shallow","share","shed","shell","sheriff","shield","shift","shine",
+"ship","shiver","shock","shoe","shoot","shop","short","shoulder",
+"shove","shrimp","shrug","shuffle","shy","sibling","sick","side",
+"siege","sight","sign","silent","silk","silly","silver","similar",
+"simple","since","sing","siren","sister","situate","six","size",
+"skate","sketch","ski","skill","skin","skirt","skull","slab",
+"slam","sleep","slender","slice","slide","slight","slim","slogan",
+"slot","slow","slush","small","smart","smile","smoke","smooth",
+"snack","snake","snap","sniff","snow","soap","soccer","social",
+"sock","soda","soft","solar","soldier","solid","solution","solve",
+"someone","song","soon","sorry","sort","soul","sound","soup",
+"source","south","space","spare","spatial","spawn","speak","special",
+"speed","spell","spend","sphere","spice","spider","spike","spin",
+"spirit","split","spoil","sponsor","spoon","sport","spot","spray",
+"spread","spring","spy","square","squeeze","squirrel","stable","stadium",
+"staff","stage","stairs","stamp","stand","start","state","stay",
+"steak","steel","stem","step","stereo","stick","still","sting",
+"stock","stomach","stone","stool","story","stove","strategy","street",
+"strike","strong","struggle","student","stuff","stumble","style","subject",
+"submit","subway","success","such","sudden","suffer","sugar","suggest",
+"suit","summer","sun","sunny","sunset","super","supply","supreme",
+"sure","surface","surge","surprise","surround","survey","suspect","sustain",
+"swallow","swamp","swap","swarm","swear","sweet","swift","swim",
+"swing","switch","sword","symbol","symptom","syrup","system","table",
+"tackle","tag","tail","talent","talk","tank","tape","target",
+"task","taste","tattoo","taxi","teach","team","tell","ten",
+"tenant","tennis","tent","term","test","text","thank","that",
+"theme","then","theory","there","they","thing","this","thought",
+"three","thrive","throw","thumb","thunder","ticket","tide","tiger",
+"tilt","timber","time","tiny","tip","tired","tissue","title",
+"toast","tobacco","today","toddler","toe","together","toilet","token",
+"tomato","tomorrow","tone","tongue","tonight","tool","tooth","top",
+"topic","topple","torch","tornado","tortoise","toss","total","tourist",
+"toward","tower","town","toy","track","trade","traffic","tragic",
+"train","transfer","trap","trash","travel","tray","treat","tree",
+"trend","trial","tribe","trick","trigger","trim","trip","trophy",
+"trouble","truck","true","truly","trumpet","trust","truth","try",
+"tube","tuition","tumble","tuna","tunnel","turkey","turn","turtle",
+"twelve","twenty","twice","twin","twist","two","type","typical",
+"ugly","umbrella","unable","unaware","uncle","uncover","under","undo",
+"unfair","unfold","unhappy","uniform","unique","unit","universe","unknown",
+"unlock","until","unusual","unveil","update","upgrade","uphold","upon",
+"upper","upset","urban","urge","usage","use","used","useful",
+"useless","usual","utility","vacant","vacuum","vague","valid","valley",
+"valve","van","vanish","vapor","various","vast","vault","vehicle",
+"velvet","vendor","venture","venue","verb","verify","version","very",
+"vessel","veteran","viable","vibrant","vicious","victory","video","view",
+"village","vintage","violin","virtual","virus","visa","visit","visual",
+"vital","vivid","vocal","voice","void","volcano","volume","vote",
+"voyage","wage","wagon","wait","walk","wall","walnut","want",
+"warfare","warm","warrior","wash","wasp","waste","water","wave",
+"way","wealth","weapon","wear","weasel","weather","web","wedding",
+"weekend","weird","welcome","west","wet","whale","what","wheat",
+"wheel","when","where","whip","whisper","wide","width","wife",
+"wild","will","win","window","wine","wing","wink","winner",
+"winter","wire","wisdom","wise","wish","witness","wolf","woman",
+"wonder","wood","wool","word","work","world","worry","worth",
+"wrap","wreck","wrestle","wrist","write","wrong","yard","year",
+"yellow","you","young","youth","zebra","zero","zone","zoo",
+
+};
+#endif

src/checkpoints.cpp

@@ -25,13 +25,18 @@ namespace Checkpoints
         {  2101, uint256("0xd4ea1ac45b63c8162a7fc8033cec441db8d532ba988202849d7831e32fe2d059")},
         {  2847, uint256("0xb5015e2835f13fd3bb6135cff9b31ac33310c9b77d694bdb592b8680d98d018e")},
         {  3589, uint256("0xb12a2ca3db4e288cada98aa2139768532bd4474c49dd7b8158031032dac08d51")},
-        {  3935, uint256("0xe16290c9757d1368b8d7c35de4f8f70c2c9f9c785b667df0c3bff85086ca6")},
+        {  3935, uint256("0xe16290c9757d1368b8d7c35de07d4f8f70c2c9f9c785b667df0c3bff85086ca6")},
         {  5703, uint256("0x587db07bb2172ad7db72c5fabc2518262a1b27f503f99417510b2c6fafa6557b")},
         {  9000, uint256("0x00000000019ef6b2f5e7c324c7d083ee94502305aabc7e9cd73a7fb2a57bb8db")},
         {  9001, uint256("0x6d5c6c5f201cc9e59659ee0da30d1430dc6bf3b12a8ff4c3864ab8d6286b0007")},
         {  9002, uint256("0xa1e20fb1d44688b763690cf74d6aefe859e4cc32981f9e3f2b2ae9702bbcf249")},
         { 10881, uint256("0x4b6554c45e1e6764a6f3c309c47baf53c9edd81f624e52b072518cd15da237e6")},
         { 17650, uint256("0x224940e1f986a202209b8e762728d1452ab45870c308abf84905674acf326a47")},
+        // Recent finality pin (PoS era). Closes the long unchecked span from
+        // 17650 to the live tip so stale-bootstrap / low-trust forks below
+        // this height are rejected outright. Hash from the canonical chain.
+        { 2205000, uint256("0x6bdd3c5e5a32e1dd9a70e705f1a28d1dd84929f89579bd2696d41bc87f39446f")},
+        { 2206004, uint256("0xb34e8e6a7bb7f52167d81aaad4d26f87a876898fdd0fce860916fc1aaf9a2a46")},
     };
 
     // Published UTXO snapshot file SHA256, keyed by snapshot height.
@@ -43,6 +48,7 @@ namespace Checkpoints
     // here. The corresponding (height, blockhash) must already exist in
     // mapCheckpoints / mapCheckpointsTestnet.
     static std::map<int, uint256> mapSnapshotHashes = {
+        { 2206004, uint256("0x1419282dae817315ee1b955543f6248233fe5800f5e8488734a0ece5bd6781ea")},
     };
 
     static std::map<int, uint256> mapSnapshotHashesTestnet = {
@@ -54,7 +60,7 @@ namespace Checkpoints
         {  2101, uint256("0xd4ea1ac45b63c8162a7fc8033cec441db8d532ba988202849d7831e32fe2d059")},
         {  2847, uint256("0xb5015e2835f13fd3bb6135cff9b31ac33310c9b77d694bdb592b8680d98d018e")},
         {  3589, uint256("0xb12a2ca3db4e288cada98aa2139768532bd4474c49dd7b8158031032dac08d51")},
-        {  3935, uint256("0xe16290c9757d1368b8d7c35de4f8f70c2c9f9c785b667df0c3bff85086ca6")},
+        {  3935, uint256("0xe16290c9757d1368b8d7c35de07d4f8f70c2c9f9c785b667df0c3bff85086ca6")},
         {  5703, uint256("0x587db07bb2172ad7db72c5fabc2518262a1b27f503f99417510b2c6fafa6557b")},
         {  9000, uint256("0x00000000019ef6b2f5e7c324c7d083ee94502305aabc7e9cd73a7fb2a57bb8db")},
         {  9001, uint256("0x6d5c6c5f201cc9e59659ee0da30d1430dc6bf3b12a8ff4c3864ab8d6286b0007")},

src/clientversion.h

@@ -6,9 +6,9 @@
 //
 
 // These need to be macros, as version.cpp's and triangles-qt.rc's voodoo requires it
-#define CLIENT_VERSION_MAJOR       6
-#define CLIENT_VERSION_MINOR       0
-#define CLIENT_VERSION_REVISION    1
+#define CLIENT_VERSION_MAJOR       5
+#define CLIENT_VERSION_MINOR       9
+#define CLIENT_VERSION_REVISION    15
 #define CLIENT_VERSION_BUILD       0
 
 // Converts the parameter X to a string after macro replacement on X has been performed.

src/hdwallet.cpp

@@ -0,0 +1,223 @@
+// Copyright (c) 2026 The Triangles developers
+// Distributed under the MIT/X11 software license.
+#include "hdwallet.h"
+#include "bip39_english.h"
+
+#include <cstring>
+#include <algorithm>
+
+#include <openssl/sha.h>
+#include <openssl/hmac.h>
+#include <openssl/evp.h>
+#include <openssl/rand.h>
+
+#include <secp256k1.h>
+
+namespace hd {
+
+// ---- secp256k1 context (self-contained; independent of crypto_ecdsa) ------
+static secp256k1_context* HDContext()
+{
+    static secp256k1_context* ctx = NULL;
+    if (!ctx)
+        ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
+    return ctx;
+}
+
+static void HmacSha512(const unsigned char* key, size_t keylen,
+                       const unsigned char* data, size_t datalen,
+                       unsigned char out[64])
+{
+    unsigned int len = 64;
+    HMAC(EVP_sha512(), key, (int)keylen, data, datalen, out, &len);
+}
+
+// Binary search the (lexicographically sorted) BIP39 English wordlist.
+static int WordIndex(const std::string& w)
+{
+    int lo = 0, hi = 2047;
+    while (lo <= hi) {
+        int mid = (lo + hi) / 2;
+        int c = w.compare(BIP39_WORDLIST_EN[mid]);
+        if (c == 0) return mid;
+        if (c < 0) hi = mid - 1; else lo = mid + 1;
+    }
+    return -1;
+}
+
+static std::vector<std::string> SplitWords(const std::string& s)
+{
+    std::vector<std::string> out;
+    size_t i = 0, n = s.size();
+    while (i < n) {
+        while (i < n && (s[i] == ' ' || s[i] == '\t' || s[i] == '\n' || s[i] == '\r')) i++;
+        size_t j = i;
+        while (j < n && !(s[j] == ' ' || s[j] == '\t' || s[j] == '\n' || s[j] == '\r')) j++;
+        if (j > i) out.push_back(s.substr(i, j - i));
+        i = j;
+    }
+    return out;
+}
+
+// ---- BIP39 ----------------------------------------------------------------
+std::string GenerateMnemonic(int strengthBits)
+{
+    if (strengthBits != 128 && strengthBits != 256) strengthBits = 256;
+    int entBytes = strengthBits / 8;
+    std::vector<unsigned char> ent(entBytes);
+    if (RAND_bytes(&ent[0], entBytes) != 1) return std::string();
+
+    // checksum = first (ENT/32) bits of SHA256(entropy)
+    unsigned char hash[32];
+    SHA256(&ent[0], entBytes, hash);
+    int csBits = strengthBits / 32;
+
+    // bit buffer = entropy || checksum bits
+    std::vector<unsigned char> bits = ent;
+    bits.push_back(hash[0]); // up to 8 checksum bits live in hash[0]
+
+    int totalBits = strengthBits + csBits;
+    int words = totalBits / 11;
+    std::string out;
+    for (int i = 0; i < words; i++) {
+        int idx = 0;
+        for (int b = 0; b < 11; b++) {
+            int bitpos = i * 11 + b;
+            int byte = bitpos / 8, off = 7 - (bitpos % 8);
+            int bit = (bits[byte] >> off) & 1;
+            idx = (idx << 1) | bit;
+        }
+        if (i) out += ' ';
+        out += BIP39_WORDLIST_EN[idx];
+    }
+    return out;
+}
+
+bool CheckMnemonic(const std::string& mnemonic)
+{
+    std::vector<std::string> w = SplitWords(mnemonic);
+    size_t nw = w.size();
+    if (nw != 12 && nw != 15 && nw != 18 && nw != 21 && nw != 24) return false;
+
+    int totalBits = (int)nw * 11;
+    int csBits = totalBits / 33;
+    int entBits = totalBits - csBits;
+    if (entBits % 8 != 0) return false;
+    int entBytes = entBits / 8;
+
+    // unpack 11-bit indices into a bit buffer
+    std::vector<unsigned char> buf((totalBits + 7) / 8, 0);
+    for (size_t i = 0; i < nw; i++) {
+        int idx = WordIndex(w[i]);
+        if (idx < 0) return false;
+        for (int b = 0; b < 11; b++) {
+            int bit = (idx >> (10 - b)) & 1;
+            int bitpos = (int)i * 11 + b;
+            int byte = bitpos / 8, off = 7 - (bitpos % 8);
+            if (bit) buf[byte] |= (1 << off);
+        }
+    }
+    std::vector<unsigned char> ent(buf.begin(), buf.begin() + entBytes);
+    unsigned char hash[32];
+    SHA256(&ent[0], entBytes, hash);
+    // compare csBits checksum bits
+    for (int b = 0; b < csBits; b++) {
+        int bitpos = entBits + b;
+        int byte = bitpos / 8, off = 7 - (bitpos % 8);
+        int got = (buf[byte] >> off) & 1;
+        int want = (hash[b / 8] >> (7 - (b % 8))) & 1;
+        if (got != want) return false;
+    }
+    return true;
+}
+
+bool MnemonicToSeed(const std::string& mnemonic, const std::string& passphrase,
+                    unsigned char seed64[64])
+{
+    std::string salt = "mnemonic" + passphrase;
+    int rc = PKCS5_PBKDF2_HMAC(mnemonic.c_str(), (int)mnemonic.size(),
+                               (const unsigned char*)salt.c_str(), (int)salt.size(),
+                               2048, EVP_sha512(), 64, seed64);
+    return rc == 1;
+}
+
+// ---- BIP32 ----------------------------------------------------------------
+bool MasterFromSeed(const unsigned char* seed, size_t seedlen, ExtKey& out)
+{
+    unsigned char I[64];
+    HmacSha512((const unsigned char*)"Bitcoin seed", 12, seed, seedlen, I);
+    memcpy(out.key, I, 32);
+    memcpy(out.chaincode, I + 32, 32);
+    if (!secp256k1_ec_seckey_verify(HDContext(), out.key)) return false;
+    out.valid = true;
+    return true;
+}
+
+bool CKDpriv(const ExtKey& parent, uint32_t index, ExtKey& child)
+{
+    if (!parent.valid) return false;
+    secp256k1_context* ctx = HDContext();
+    unsigned char data[37];
+    size_t dlen = 0;
+    if (index & HARDENED) {
+        data[0] = 0x00;
+        memcpy(data + 1, parent.key, 32);
+        dlen = 33;
+    } else {
+        // serP(point(parent.key)) = 33-byte compressed pubkey
+        secp256k1_pubkey pk;
+        if (!secp256k1_ec_pubkey_create(ctx, &pk, parent.key)) return false;
+        size_t plen = 33;
+        secp256k1_ec_pubkey_serialize(ctx, data, &plen, &pk, SECP256K1_EC_COMPRESSED);
+        dlen = 33;
+    }
+    data[dlen + 0] = (index >> 24) & 0xff;
+    data[dlen + 1] = (index >> 16) & 0xff;
+    data[dlen + 2] = (index >> 8) & 0xff;
+    data[dlen + 3] = index & 0xff;
+    dlen += 4;
+
+    unsigned char I[64];
+    HmacSha512(parent.chaincode, 32, data, dlen, I);
+
+    memcpy(child.key, parent.key, 32);
+    // child = (IL + parent) mod n ; rejects invalid (IL>=n or result 0)
+    if (!secp256k1_ec_seckey_tweak_add(ctx, child.key, I)) return false;
+    memcpy(child.chaincode, I + 32, 32);
+    child.valid = true;
+    return true;
+}
+
+bool DerivePath(const ExtKey& master, const std::vector<uint32_t>& path, ExtKey& out)
+{
+    ExtKey cur = master;
+    for (size_t i = 0; i < path.size(); i++) {
+        ExtKey nxt;
+        if (!CKDpriv(cur, path[i], nxt)) return false;
+        cur = nxt;
+    }
+    out = cur;
+    return true;
+}
+
+bool DeriveTriangles(const std::string& mnemonic, const std::string& passphrase,
+                     uint32_t account, uint32_t change, uint32_t index,
+                     unsigned char privOut[32])
+{
+    unsigned char seed[64];
+    if (!MnemonicToSeed(mnemonic, passphrase, seed)) return false;
+    ExtKey master;
+    if (!MasterFromSeed(seed, 64, master)) return false;
+    std::vector<uint32_t> path;
+    path.push_back(44u | HARDENED);
+    path.push_back(TRI_COIN_TYPE | HARDENED);
+    path.push_back(account | HARDENED);
+    path.push_back(change);
+    path.push_back(index);
+    ExtKey leaf;
+    if (!DerivePath(master, path, leaf)) return false;
+    memcpy(privOut, leaf.key, 32);
+    return true;
+}
+
+} // namespace hd

src/hdwallet.h

@@ -0,0 +1,50 @@
+// Copyright (c) 2026 The Triangles developers
+// Distributed under the MIT/X11 software license.
+//
+// Native BIP39 (mnemonic) + BIP32 (HD) key derivation for Triangles.
+// Produces keys identical to the TRIdock web wallet (derivation path
+// m/44'/2222'/0'/0/i, coin type 2222), so a 24-word phrase round-trips
+// between the Qt/daemon wallet and the web wallet.
+#ifndef TRIANGLES_HDWALLET_H
+#define TRIANGLES_HDWALLET_H
+
+#include <string>
+#include <vector>
+#include <cstdint>
+#include <cstddef>
+
+namespace hd {
+
+static const uint32_t HARDENED      = 0x80000000u;
+static const uint32_t TRI_COIN_TYPE = 2222u;   // matches triWallet.js
+
+// A BIP32 extended private key (private scalar + chain code).
+struct ExtKey {
+    unsigned char key[32];
+    unsigned char chaincode[32];
+    bool valid;
+    ExtKey() : valid(false) { }
+};
+
+// ---- BIP39 ----------------------------------------------------------------
+// Generate a new mnemonic. strengthBits must be 128 (12 words) or 256 (24).
+std::string GenerateMnemonic(int strengthBits = 256);
+// Validate word membership + checksum.
+bool CheckMnemonic(const std::string& mnemonic);
+// PBKDF2-HMAC-SHA512(mnemonic, "mnemonic"+passphrase, 2048) -> 64-byte seed.
+bool MnemonicToSeed(const std::string& mnemonic, const std::string& passphrase,
+                    unsigned char seed64[64]);
+
+// ---- BIP32 ----------------------------------------------------------------
+bool MasterFromSeed(const unsigned char* seed, size_t seedlen, ExtKey& out);
+bool CKDpriv(const ExtKey& parent, uint32_t index, ExtKey& child);
+bool DerivePath(const ExtKey& master, const std::vector<uint32_t>& path, ExtKey& out);
+
+// ---- High level -----------------------------------------------------------
+// Derive the 32-byte private scalar for m/44'/coinType'/account'/change/index.
+bool DeriveTriangles(const std::string& mnemonic, const std::string& passphrase,
+                     uint32_t account, uint32_t change, uint32_t index,
+                     unsigned char privOut[32]);
+
+} // namespace hd
+#endif // TRIANGLES_HDWALLET_H

src/init.cpp

@@ -1081,6 +1081,37 @@ bool AppInit2()
     if (!LoadBlockIndex())
         return InitError(_("Error loading blkindex.dat"));
 
+    // triangles fix (pitfall #61): initialize pindexFinalized from the
+    // hardcoded checkpoint on startup, BEFORE the daemon opens any peer
+    // connections or processes any block messages.
+    //
+    // Without this, pindexFinalized stays NULL on a fresh restart even when
+    // we have 2.2M blocks on disk, because the auto-checkpoint code in
+    // ActivateBestChain() at main.cpp:2459 only sets it when
+    // !IsInitialBlockDownload(). If the chain tip is more than 24h stale
+    // (which happens on every restart with a synced chain), IsInitialBlockDownload()
+    // returns true and pindexFinalized never gets set.
+    //
+    // The downstream reorg guard at main.cpp:2198 short-circuits when
+    // pindexFinalized is NULL, which allowed a 3,755-block minority fork
+    // to overwrite a healthy 2,206,004-block chain on 2026-06-16. Loading
+    // the hardcoded checkpoint from checkpoints.cpp (block 2,205,000) on
+    // startup means the reorg guard is always active whenever the
+    // checkpointed block is in our local mapBlockIndex.
+    {
+        CBlockIndex* pCheckpoint = Checkpoints::GetLastCheckpoint(mapBlockIndex);
+        if (pCheckpoint && pCheckpoint != pindexFinalized)
+        {
+            pindexFinalized = pCheckpoint;
+            printf("STARTUP-CHECKPOINT: pindexFinalized set to block %d (%s) from hardcoded checkpoint\n",
+                pindexFinalized->nHeight, pindexFinalized->GetBlockHash().ToString().substr(0,20).c_str());
+        }
+        else if (!pCheckpoint)
+        {
+            printf("STARTUP-CHECKPOINT: WARNING — hardcoded checkpoint not in local block index, pindexFinalized remains NULL\n");
+        }
+    }
+
     // If the block index is empty but blk0001.dat exists (bootstrap download),
     // fast-import: build the index directly from the block file without re-writing
     // data. Batches LevelDB commits every 200K blocks for speed.

src/kernel.cpp

@@ -36,8 +36,18 @@ int64_t GetWeight(int64_t nIntervalBeginning, int64_t nIntervalEnd)
     // 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
+    // Activation gate: the soft cap shipped 2026-04-20 without a height/time
+    // gate, retroactively invalidating earlier blocks staked with long-aged
+    // coins (e.g. coins idle through the 2022-2026 freeze).  Apply the cap
+    // only to stakes after the activation timestamp; historical stakes
+    // validate under the rules they were created with (uncapped age).
+    static const int64_t STAKE_AGE_SOFT_CAP_ACTIVATION = 1776000000; // 2026-04-12 ~13:20 UTC
     if (pindexBest && pindexBest->nHeight >= FORK_HEIGHT_V5)
-        return min(nAge, STAKE_AGE_SOFT_CAP);
+    {
+        if (nIntervalEnd >= STAKE_AGE_SOFT_CAP_ACTIVATION)
+            return min(nAge, STAKE_AGE_SOFT_CAP);
+        return nAge;
+    }
 
     return min(nAge, (int64_t)nStakeMaxAge);
 }

src/main.cpp

@@ -1324,10 +1324,12 @@ bool IsInitialBlockDownload()
         pindexLastBest = pindexBest;
         nLastUpdate = GetTime();
     }
-    // IBD is complete once we've passed the checkpoint height estimate.
-    // The previous >24h block-time check incorrectly kept IBD true when the
-    // chain was synced but simply stalled (no new blocks arriving), which
-    // prevented the stake miner from ever proceeding.
+    // IBD is complete once we've passed the checkpoint AND the chain tip is
+    // recent (within 24h). This prevents a stall AFTER checkpoint from
+    // permanently disabling header fetching. The forcestaking path above
+    // handles the specific staking-broker scenario.
+    if (GetTime() - nLastUpdate > 24 * 60 * 60)
+        return true;
     return false;
 }
 
@@ -2820,7 +2822,12 @@ bool CBlock::CheckBlock(bool fCheckPOW, bool fCheckMerkleRoot, bool fCheckSig) c
             return DoS(100, error("CheckBlock() : more than one coinbase"));
 
     // Check coinbase timestamp
-    if (GetBlockTime() > FutureDrift((int64_t)vtx[0].nTime))
+    // NOTE: Must use the pre-fork (10-minute) drift tolerance here because
+    // CheckBlock() is context-free (no nHeight) and can be called on blocks
+    // at any height, including during chain reorgs from old fork chains.
+    // The tight 90-second drift for post-fork blocks is enforced separately
+    // in AcceptBlock/ConnectBlock with proper height context.
+    if (GetBlockTime() > (int64_t)vtx[0].nTime + 10 * 60)
         return DoS(50, error("CheckBlock() : coinbase timestamp is too early"));
 
     if (IsProofOfStake())
@@ -3064,7 +3071,7 @@ bool ProcessBlock(CNode* pfrom, CBlock* pblock)
     // triangles: check proof-of-stake
     // Limited duplicity on stake: prevents block flood attack
     // Duplicate stake allowed only when there is orphan child block
-    if (pblock->IsProofOfStake() && setStakeSeen.count(pblock->GetProofOfStake()) && !mapOrphanBlocksByPrev.count(hash))
+    if (pblock->IsProofOfStake() && !GetBoolArg("-ignoredupstake", false) && setStakeSeen.count(pblock->GetProofOfStake()) && !mapOrphanBlocksByPrev.count(hash))
         return error("ProcessBlock() : duplicate proof-of-stake (%s, %d) for block %s", pblock->GetProofOfStake().first.ToString().c_str(), pblock->GetProofOfStake().second, hash.ToString().c_str());
 
     // Preliminary checks
@@ -3122,13 +3129,15 @@ bool ProcessBlock(CNode* pfrom, CBlock* pblock)
         {
             // Limited duplicity on stake: prevents block flood attack
             // Duplicate stake allowed only when there is orphan child block
-            if (setStakeSeenOrphan.count(pblock2->GetProofOfStake()) && !mapOrphanBlocksByPrev.count(hash))
+            if (!GetBoolArg("-ignoredupstake", false) && setStakeSeenOrphan.count(pblock2->GetProofOfStake()) && !mapOrphanBlocksByPrev.count(hash))
                 return error("ProcessBlock() : duplicate proof-of-stake (%s, %d) for orphan block %s", pblock2->GetProofOfStake().first.ToString().c_str(), pblock2->GetProofOfStake().second, hash.ToString().c_str());
             else
                 setStakeSeenOrphan.insert(pblock2->GetProofOfStake());
         }
+        uint256 hashPrevOrphan = pblock2->hashPrevBlock;
+        CBlock* pblock2raw = pblock2.get();
         mapOrphanBlocks.insert(make_pair(hash, std::move(pblock2)));
-        mapOrphanBlocksByPrev.insert(make_pair(pblock2->hashPrevBlock, pblock2.get()));
+        mapOrphanBlocksByPrev.insert(make_pair(hashPrevOrphan, pblock2raw));
         dequeOrphanOrder.push_back(hash);  // track insertion order for FIFO eviction
 
         // Limit orphan blocks to prevent memory exhaustion.
@@ -3140,11 +3149,11 @@ bool ProcessBlock(CNode* pfrom, CBlock* pblock)
         // Ask this guy to fill in what we're missing
         if (pfrom && pindexBest)
         {
-            pfrom->PushGetBlocks(pindexBest, GetOrphanRoot(pblock2.get()));
+            pfrom->PushGetBlocks(pindexBest, GetOrphanRoot(pblock2raw));
             // triangles: getblocks may not obtain the ancestor block rejected
             // earlier by duplicate-stake check so we ask for it again directly
             if (!IsInitialBlockDownload())
-                pfrom->AskFor(CInv(MSG_BLOCK, WantedByOrphan(pblock2.get())));
+                pfrom->AskFor(CInv(MSG_BLOCK, WantedByOrphan(pblock2raw)));
         }
         return true;
     }
@@ -4043,14 +4052,23 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv)
         // parallelism. Multiple peers sending overlapping inv ranges is harmless
         // (AlreadyHave filters duplicates) but ensures we discover and download
         // blocks from the fastest available source.
+        // NOTE: nStartingHeight from version messages is unverified. Peers can
+        // claim any height. During IBD we always ask all eligible peers rather
+        // than filtering on a claim that may be wrong (a stunted node could be
+        // reporting the full chain height while only serving the tail of its
+        // own fork). Use nBestKnownHeight (updated from actual block responses)
+        // for peer capability assessment instead.
         static int nAskedForBlocks = 0;
         bool fIBD = IsInitialBlockDownload();
-        bool fBehindPeer = (pfrom->nStartingHeight > nBestHeight);
+        // During IBD: ask every non-client peer unconditionally to maximise
+        // download sources. Post-IBD: use traditional height-check logic.
         bool fShouldAsk = !pfrom->fClient && !pfrom->fOneShot &&
-            (pfrom->nStartingHeight > (nBestHeight - 144)) &&
+            (fIBD ||
+             pfrom->nStartingHeight > (nBestHeight - 144) ||
+             pfrom->nStartingHeight > nBestHeight) &&
             (pfrom->nVersion < NOBLKS_VERSION_START ||
              pfrom->nVersion >= NOBLKS_VERSION_END) &&
-             (fIBD || nAskedForBlocks < 1 || vNodes.size() <= 1 || fBehindPeer);
+             (fIBD || nAskedForBlocks < 1 || vNodes.size() <= 1 || pfrom->nStartingHeight > nBestHeight);
         printf("IBD-DIAG: version handler: peer=%s height=%d ourHeight=%d fClient=%d fOneShot=%d shouldAsk=%d nAskedForBlocks=%d IBD=%d\n",
             pfrom->addr.ToString().c_str(), pfrom->nStartingHeight, nBestHeight,
             pfrom->fClient, pfrom->fOneShot, fShouldAsk, nAskedForBlocks, fIBD);
@@ -4361,19 +4379,25 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv)
         // GetBlockIndex() fell through to genesis (no locator hash matched
         // our main chain). If the peer's tip isn't our genesis,
         // they're on a completely different fork.
+        //
+        // triangles fix: instead of banning or disconnecting, always respond
+        // with our main chain blocks so a fork node can learn the canonical
+        // chain and reorganize. The fork node's client will automatically
+        // reorg when it receives blocks that form a longer or higher-work chain.
         if (!locator.IsNull() && pindex == pindexGenesisBlock &&
             pindexGenesisBlock && locator.GetTipHash() != pindexGenesisBlock->GetBlockHash())
         {
             pfrom->nIncompatibleGetblocks++;
-            if (pfrom->nIncompatibleGetblocks >= 3)
-            {
-                printf("WARNING: peer %s sent %d getblocks with no common blocks — disconnecting (incompatible fork)\n",
-                    pfrom->addr.ToString().c_str(), pfrom->nIncompatibleGetblocks);
-                pfrom->Misbehaving(100);
-                return true;
-            }
-            printf("WARNING: peer %s getblocks locator has no common blocks (%d/3 before ban)\n",
+            // triangles: after many failed attempts, reset — the peer may now be
+            // on the correct chain and we don't want to ban a node that's just
+            // learning about the main chain from us.
+            if (pfrom->nIncompatibleGetblocks > 10)
+                pfrom->nIncompatibleGetblocks = 0;
+            // triangles: NO return/ban here — fall through and serve main chain
+            // blocks so the forking peer can reorg to our chain.
+            printf("WARNING: peer %s getblocks locator has no common blocks — serving main chain from genesis (counter=%d, will reset after 10)\\n",
                 pfrom->addr.ToString().c_str(), pfrom->nIncompatibleGetblocks);
+            pindex = pindexGenesisBlock;
         }
         else if (pindex && pindex != pindexGenesisBlock)
         {
@@ -4433,8 +4457,60 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv)
         {
             // Find the last block the caller has in the main chain
             pindex = locator.GetBlockIndex();
+
+            // triangles fix: handle broken pnext chain.
+            // GetBlockIndex() returns pindexGenesisBlock when no locator
+            // hash matches our main chain (peer is on a different fork or
+            // a stale local state). pindexGenesisBlock->pnext is always
+            // null, which would cause the for-loop below to send ZERO
+            // headers, leaving the peer stuck (logged as "getheaders -1").
+            //
+            // Mirror the getblocks handler: if the locator matches nothing
+            // on our main chain, serve our headers from genesis so the peer
+            // can discover the canonical chain. Then fall back to a tip-
+            // backwards walk if pnext is null for any other reason (this
+            // happens when LoadBlockIndex() didn't fully heal pnext links,
+            // or the chain was bootstrapped from a snapshot).
+            //
+            // pitfall #61 guard: if pindexFinalized is set (from the startup
+            // hardcoded-checkpoint init in init.cpp), serve from there instead
+            // of genesis. This prevents a fork peer from feeding us their
+            // short chain back via getheaders — the peer only learns our
+            // canonical chain from the finalized point forward, and their
+            // conflicting fork gets rejected at the reorg check in
+            // Reorganize() because the fork point is below pindexFinalized.
+            if (!locator.IsNull() && pindex == pindexGenesisBlock &&
+                pindexGenesisBlock && locator.GetTipHash() != pindexGenesisBlock->GetBlockHash())
+            {
+                if (pindexFinalized && pindexFinalized->pnext)
+                {
+                    printf("getheaders: fork detected from peer %s, serving headers from finalized block %d (not genesis) — pitfall #61 guard\n",
+                        pfrom->addr.ToString().c_str(), pindexFinalized->nHeight);
+                    pindex = pindexFinalized;
+                }
+                else
+                {
+                    printf("WARNING: peer getheaders locator has no common blocks — serving headers from genesis (peer may be on a fork)\n");
+                    pindex = pindexGenesisBlock;
+                }
+            }
+
             if (pindex)
-                pindex = pindex->pnext;
+            {
+                if (pindex->pnext)
+                {
+                    pindex = pindex->pnext;
+                }
+                else
+                {
+                    // pnext is null — fall back to walking from pindexBest
+                    // backwards to find the block immediately after pindex
+                    CBlockIndex* pWalk = pindexBest;
+                    while (pWalk && pWalk->pprev != pindex)
+                        pWalk = pWalk->pprev;
+                    pindex = pWalk;  // null if pindex is already the tip
+                }
+            }
         }
 
         vector<CBlock> vHeaders;

src/qt/hdseeddialog.cpp

@@ -0,0 +1,142 @@
+// Copyright (c) 2026 The Triangles developers
+// Distributed under the MIT/X11 software license.
+#include "hdseeddialog.h"
+#include "walletmodel.h"
+
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QPushButton>
+#include <QPlainTextEdit>
+#include <QLabel>
+#include <QMessageBox>
+#include <QFont>
+
+HDSeedDialog::HDSeedDialog(QWidget *parent)
+    : QDialog(parent), model(0), seedText(0), statusLabel(0)
+{
+    setWindowTitle(tr("HD Seed Phrase (BIP39)"));
+    resize(560, 360);
+
+    QVBoxLayout *layout = new QVBoxLayout(this);
+
+    QLabel *intro = new QLabel(tr(
+        "A 24-word seed phrase is a complete backup of this wallet. Anyone who has it "
+        "can spend your coins. Write it down on paper and keep it offline."), this);
+    intro->setWordWrap(true);
+    layout->addWidget(intro);
+
+    seedText = new QPlainTextEdit(this);
+    seedText->setPlaceholderText(tr(
+        "Your 24-word phrase appears here when you generate or reveal it. "
+        "To restore, paste an existing 24-word phrase here and click 'Restore from Phrase'."));
+    QFont mono("monospace");
+    mono.setStyleHint(QFont::Monospace);
+    seedText->setFont(mono);
+    layout->addWidget(seedText);
+
+    statusLabel = new QLabel(this);
+    statusLabel->setWordWrap(true);
+    layout->addWidget(statusLabel);
+
+    QHBoxLayout *btns = new QHBoxLayout();
+    QPushButton *genBtn = new QPushButton(tr("Generate New"), this);
+    QPushButton *showBtn = new QPushButton(tr("Reveal for Backup"), this);
+    QPushButton *restoreBtn = new QPushButton(tr("Restore from Phrase"), this);
+    QPushButton *closeBtn = new QPushButton(tr("Close"), this);
+    btns->addWidget(genBtn);
+    btns->addWidget(showBtn);
+    btns->addWidget(restoreBtn);
+    btns->addStretch();
+    btns->addWidget(closeBtn);
+    layout->addLayout(btns);
+
+    connect(genBtn, SIGNAL(clicked()), this, SLOT(onGenerate()));
+    connect(showBtn, SIGNAL(clicked()), this, SLOT(onShow()));
+    connect(restoreBtn, SIGNAL(clicked()), this, SLOT(onRestore()));
+    connect(closeBtn, SIGNAL(clicked()), this, SLOT(accept()));
+}
+
+void HDSeedDialog::setModel(WalletModel *modelIn)
+{
+    model = modelIn;
+    refreshStatus();
+}
+
+void HDSeedDialog::refreshStatus()
+{
+    if (!model || !statusLabel) return;
+    if (model->hdEnabled())
+        statusLabel->setText(tr("Status: HD seed is ACTIVE. Use 'Reveal for Backup' to view your phrase."));
+    else
+        statusLabel->setText(tr("Status: no HD seed yet. Use 'Generate New' to create one."));
+}
+
+void HDSeedDialog::onGenerate()
+{
+    if (!model) return;
+    if (model->hdEnabled()) {
+        QMessageBox::warning(this, tr("HD seed already set"),
+            tr("This wallet already has an HD seed. Use 'Reveal for Backup' to view it."));
+        return;
+    }
+    if (QMessageBox::question(this, tr("Generate new seed"),
+            tr("Generate a new 24-word HD seed for this wallet?"),
+            QMessageBox::Yes | QMessageBox::No) != QMessageBox::Yes)
+        return;
+
+    WalletModel::UnlockContext ctx(model->requestUnlock());
+    if (!ctx.isValid()) return;
+
+    QString mnemonic, err;
+    if (!model->hdNew(mnemonic, err)) {
+        QMessageBox::critical(this, tr("Error"), err);
+        return;
+    }
+    seedText->setPlainText(mnemonic);
+    QMessageBox::information(this, tr("Write this down"),
+        tr("Your new 24-word seed phrase is shown above. Write it on paper and store it safely "
+           "and offline. This is the only backup of this wallet."));
+    refreshStatus();
+}
+
+void HDSeedDialog::onShow()
+{
+    if (!model) return;
+    WalletModel::UnlockContext ctx(model->requestUnlock());
+    if (!ctx.isValid()) return;
+
+    QString mnemonic, err;
+    if (!model->hdShow(mnemonic, err)) {
+        QMessageBox::critical(this, tr("Error"), err);
+        return;
+    }
+    seedText->setPlainText(mnemonic);
+}
+
+void HDSeedDialog::onRestore()
+{
+    if (!model) return;
+    QString phrase = seedText->toPlainText().trimmed();
+    if (phrase.isEmpty()) {
+        QMessageBox::warning(this, tr("No phrase"),
+            tr("Paste a 24-word phrase into the box first."));
+        return;
+    }
+    if (QMessageBox::question(this, tr("Restore from phrase"),
+            tr("Restore the HD seed from the phrase in the box and rescan the chain? "
+               "This replaces the current HD seed."),
+            QMessageBox::Yes | QMessageBox::No) != QMessageBox::Yes)
+        return;
+
+    WalletModel::UnlockContext ctx(model->requestUnlock());
+    if (!ctx.isValid()) return;
+
+    QString err;
+    if (!model->hdRestore(phrase, err)) {
+        QMessageBox::critical(this, tr("Error"), err);
+        return;
+    }
+    QMessageBox::information(this, tr("Restored"),
+        tr("HD seed restored and the chain was rescanned for your funds."));
+    refreshStatus();
+}

src/qt/hdseeddialog.h

@@ -0,0 +1,34 @@
+// Copyright (c) 2026 The Triangles developers
+// Distributed under the MIT/X11 software license.
+#ifndef HDSEEDDIALOG_H
+#define HDSEEDDIALOG_H
+
+#include <QDialog>
+
+class WalletModel;
+QT_BEGIN_NAMESPACE
+class QPlainTextEdit;
+class QLabel;
+QT_END_NAMESPACE
+
+/** Generate, reveal (for backup), and restore the wallet's BIP39 HD seed phrase. */
+class HDSeedDialog : public QDialog
+{
+    Q_OBJECT
+public:
+    explicit HDSeedDialog(QWidget *parent = 0);
+    void setModel(WalletModel *model);
+
+private:
+    WalletModel *model;
+    QPlainTextEdit *seedText;
+    QLabel *statusLabel;
+    void refreshStatus();
+
+private slots:
+    void onGenerate();
+    void onShow();
+    void onRestore();
+};
+
+#endif // HDSEEDDIALOG_H

src/qt/trianglesgui.cpp

@@ -31,6 +31,7 @@
 #include "trianglesunits.h"
 #include "guiconstants.h"
 #include "askpassphrasedialog.h"
+#include "hdseeddialog.h"
 #include "notificator.h"
 #include "guiutil.h"
 #include "rpcconsole.h"
@@ -484,6 +485,8 @@ void TrianglesGUI::createActions(bool fIsTestnet)
     backupWalletAction->setStatusTip(tr("Backup wallet to another location"));
     changePassphraseAction = new QAction(QIcon(":/menu_16/passphrase"), tr("&Change Passphrase..."), this);
     changePassphraseAction->setStatusTip(tr("Change the passphrase used for wallet encryption"));
+    hdSeedAction = new QAction(QIcon(":/menu_16/passphrase"), tr("&Seed Phrase (HD Backup)..."), this);
+    hdSeedAction->setStatusTip(tr("Generate, restore, or back up your 24-word HD seed phrase"));
     unlockWalletAction = new QAction(QIcon(":/menu_16/unlock"), tr("&Unlock Wallet..."), this);
     unlockWalletAction->setStatusTip(tr("Unlock wallet"));
     unlockWalletStakingAction = new QAction(QIcon(":/menu_16/unlock"), tr("&Unlock Wallet for staking..."), this);
@@ -509,6 +512,7 @@ void TrianglesGUI::createActions(bool fIsTestnet)
     connect(encryptWalletAction, SIGNAL(triggered(bool)), this, SLOT(encryptWallet(bool)));
     connect(backupWalletAction, SIGNAL(triggered()), this, SLOT(backupWallet()));
     connect(changePassphraseAction, SIGNAL(triggered()), this, SLOT(changePassphrase()));
+    connect(hdSeedAction, SIGNAL(triggered()), this, SLOT(hdSeedManager()));
     connect(unlockWalletAction, SIGNAL(triggered()), this, SLOT(unlockWallet()));
     connect(unlockWalletStakingAction, SIGNAL(triggered()), this, SLOT(unlockWalletStaking()));
     connect(lockWalletAction, SIGNAL(triggered()), this, SLOT(lockWallet()));
@@ -538,6 +542,7 @@ void TrianglesGUI::createMenuBar()
     QMenu *settings = appMenuBar->addMenu(tr("&Settings"));
     settings->addAction(encryptWalletAction);
     settings->addAction(changePassphraseAction);
+    settings->addAction(hdSeedAction);
     settings->addAction(unlockWalletAction);
     settings->addAction(lockWalletAction);
     settings->addSeparator();
@@ -1448,6 +1453,7 @@ void TrianglesGUI::menuOperationsRequested()
     QAction* unlockWalletStaking = menu.addAction(QIcon(":/menu_16/unlock"), tr("&Unlock Wallet...").remove('&').remove("..."));
     QAction* lockWallet = menu.addAction(QIcon(":/menu_16/lock"), tr("&Lock Wallet...").remove('&').remove("..."));
     QAction* changePassword = menu.addAction(QIcon(":/menu_16/passphrase"), tr("&Change Passphrase...").remove('&').remove("..."));
+    QAction* hdSeed = menu.addAction(QIcon(":/menu_16/passphrase"), tr("Seed Phrase (HD Backup)..."));
     QAction* signMessage = menu.addAction(QIcon(":/menu_16/sign"), tr("Sign &message...").remove('&').remove("..."));
     QAction* verifySignature = menu.addAction(QIcon(":/menu_16/verify"), tr("&Verify message...").remove('&').remove("..."));
 
@@ -1508,6 +1514,10 @@ void TrianglesGUI::menuOperationsRequested()
         if (walletModel->getEncryptionStatus() == WalletModel::Unlocked || walletModel->getEncryptionStatus() == WalletModel::Locked)
             changePassphrase();
     }
+    else if (selected == hdSeed)
+    {
+        hdSeedManager();
+    }
     else if (selected == signMessage)
     {
         gotoSignMessageTab();
@@ -1614,6 +1624,15 @@ void TrianglesGUI::changePassphrase()
     dlg.exec();
 }
 
+void TrianglesGUI::hdSeedManager()
+{
+    if (!walletModel)
+        return;
+    HDSeedDialog dlg(this);
+    dlg.setModel(walletModel);
+    dlg.exec();
+}
+
 
 void TrianglesGUI::unlockWalletStaking()
 {

src/qt/trianglesgui.h

@@ -131,6 +131,7 @@ private:
     QAction *encryptWalletAction;
     QAction *backupWalletAction;
     QAction *changePassphraseAction;
+    QAction *hdSeedAction;
     QAction *unlockWalletAction;
     QAction *unlockWalletStakingAction;
     QAction *lockWalletAction;
@@ -243,6 +244,8 @@ private slots:
     void backupWallet();
     /** Change encrypted wallet passphrase */
     void changePassphrase();
+    /** Open the HD seed phrase (generate/restore/backup) dialog */
+    void hdSeedManager();
     /** Ask for passphrase to unlock wallet temporarily */
     void unlockWallet();
     /** Ask for passphrase to unlock wallet temporarily - FOR STAKING ONLY */

src/qt/walletmodel.cpp

@@ -676,3 +676,49 @@ void WalletModel::listLockedCoins(std::vector<COutPoint>& vOutpts)
 {
     return;
 }
+
+
+// ---- HD wallet (BIP39/BIP32) ----
+bool WalletModel::hdEnabled() const
+{
+    return wallet->IsHDEnabled();
+}
+
+bool WalletModel::hdNew(QString &mnemonicOut, QString &errorOut)
+{
+    std::string mnemonic, strError;
+    if (!wallet->SetHDSeed("", "", true, mnemonic, strError)) {
+        errorOut = QString::fromStdString(strError);
+        return false;
+    }
+    wallet->TopUpKeyPool();
+    mnemonicOut = QString::fromStdString(mnemonic);
+    return true;
+}
+
+bool WalletModel::hdRestore(const QString &mnemonic, QString &errorOut)
+{
+    std::string out, strError;
+    if (!wallet->SetHDSeed(mnemonic.toStdString(), "", false, out, strError)) {
+        errorOut = QString::fromStdString(strError);
+        return false;
+    }
+    wallet->TopUpKeyPool();
+    {
+        LOCK2(cs_main, wallet->cs_wallet);
+        wallet->ScanForWalletTransactions(pindexGenesisBlock, true);
+        wallet->ReacceptWalletTransactions();
+    }
+    return true;
+}
+
+bool WalletModel::hdShow(QString &mnemonicOut, QString &errorOut)
+{
+    std::string mnemonic;
+    if (!wallet->GetHDMnemonic(mnemonic)) {
+        errorOut = QObject::tr("Wallet has no HD seed (use 'Generate New').");
+        return false;
+    }
+    mnemonicOut = QString::fromStdString(mnemonic);
+    return true;
+}

src/qt/walletmodel.h

@@ -103,6 +103,12 @@ public:
     // Wallet backup
     bool backupWallet(const QString &filename);
 
+    // ---- HD wallet (BIP39/BIP32) ----
+    bool hdEnabled() const;
+    bool hdNew(QString &mnemonicOut, QString &errorOut);
+    bool hdRestore(const QString &mnemonic, QString &errorOut);
+    bool hdShow(QString &mnemonicOut, QString &errorOut);
+
     // RAI object for unlocking wallet, returned by requestUnlock()
     class UnlockContext
     {

src/rpcwallet.cpp

@@ -1858,3 +1858,78 @@ Value makekeypair(const Array& params, bool fHelp)
     result.push_back(Pair("PublicKey", HexStr(key.GetPubKey().Raw())));
 return result;
 }
+
+
+Value hdinfo(const Array& params, bool fHelp)
+{
+    if (fHelp || params.size() != 0)
+        throw runtime_error("hdinfo\nReturns HD (BIP39/BIP32) wallet status.");
+    Object obj;
+    obj.push_back(Pair("hdenabled", pwalletMain->IsHDEnabled()));
+    obj.push_back(Pair("coin_type", 2222));
+    obj.push_back(Pair("derivation_path", "m/44'/2222'/0'/0/i"));
+    obj.push_back(Pair("nextindex", (int64_t)pwalletMain->nHDChainIndex));
+    return obj;
+}
+
+Value hdnew(const Array& params, bool fHelp)
+{
+    if (fHelp || params.size() > 1)
+        throw runtime_error(
+            "hdnew [passphrase]\n"
+            "Generate a NEW 24-word HD seed phrase, activate it as this wallet's\n"
+            "deterministic seed, and return the phrase. WRITE IT DOWN: it is the\n"
+            "only backup of every address this wallet derives.");
+    EnsureWalletIsUnlocked();
+    if (pwalletMain->IsHDEnabled())
+        throw JSONRPCError(RPC_WALLET_ERROR, "Wallet already has an HD seed; use 'hdshow' to back it up.");
+    string passphrase = params.size() > 0 ? params[0].get_str() : "";
+    string mnemonic, strError;
+    if (!pwalletMain->SetHDSeed("", passphrase, true, mnemonic, strError))
+        throw JSONRPCError(RPC_WALLET_ERROR, strError);
+    pwalletMain->TopUpKeyPool();
+    Object obj;
+    obj.push_back(Pair("mnemonic", mnemonic));
+    obj.push_back(Pair("words", 24));
+    obj.push_back(Pair("warning", "Write these 24 words down and keep them secret and offline. Anyone with them can spend your coins."));
+    return obj;
+}
+
+Value hdrestore(const Array& params, bool fHelp)
+{
+    if (fHelp || params.size() < 1 || params.size() > 2)
+        throw runtime_error(
+            "hdrestore \"mnemonic\" [passphrase]\n"
+            "Activate an HD seed from an existing 24-word phrase, derive the keypool\n"
+            "and rescan the chain for funds on the derived addresses.");
+    EnsureWalletIsUnlocked();
+    string mnemonic = params[0].get_str();
+    string passphrase = params.size() > 1 ? params[1].get_str() : "";
+    string out, strError;
+    if (!pwalletMain->SetHDSeed(mnemonic, passphrase, false, out, strError))
+        throw JSONRPCError(RPC_WALLET_ERROR, strError);
+    pwalletMain->TopUpKeyPool();
+    {
+        LOCK2(cs_main, pwalletMain->cs_wallet);
+        pwalletMain->ScanForWalletTransactions(pindexGenesisBlock, true);
+        pwalletMain->ReacceptWalletTransactions();
+    }
+    Object obj;
+    obj.push_back(Pair("restored", true));
+    return obj;
+}
+
+Value hdshow(const Array& params, bool fHelp)
+{
+    if (fHelp || params.size() != 0)
+        throw runtime_error(
+            "hdshow\nReveal the wallet's HD mnemonic for backup. The wallet must be unlocked.");
+    EnsureWalletIsUnlocked();
+    string mnemonic;
+    if (!pwalletMain->GetHDMnemonic(mnemonic))
+        throw JSONRPCError(RPC_WALLET_ERROR, "Wallet has no HD seed (use 'hdnew' to create one).");
+    Object obj;
+    obj.push_back(Pair("mnemonic", mnemonic));
+    obj.push_back(Pair("warning", "Keep these words secret and offline."));
+    return obj;
+}

src/tor/tor_embedded.cpp

@@ -16,6 +16,8 @@
 #include <thread>
 #include <fstream>
 #include <cstring>
+#include <chrono>
+#include <ctime>
 #include <vector>
 #include <string>
 
@@ -122,11 +124,59 @@ bool CTorEmbedded::Start(int socks, int hsPort, bool enableHiddenService)
     // Prepare Tor data directory under the wallet's data dir
     torDataDir = (::GetDataDir() / "tor_data").string();
     fs::create_directories(torDataDir);
+    // CRITICAL: Tor refuses to use a DataDirectory readable by other users.
+    // Without 0700, tor_run_main() returns -1 and the embedded Tor never starts.
+    fs::permissions(torDataDir, fs::perms::owner_all, fs::perm_options::replace);
+
+    // triangles fix: auto-repair `state`-as-file corruption (pitfall #19).
+    // Tor's atomic state-write pattern is: write `state.tmp` → rename to `state`.
+    // If the daemon is killed or the process crashes mid-write, the rename can
+    // fail and `state` may be left as a regular file (or a partial file). On
+    // next start, Tor sees "State file ... is not a file? Failing." and dies
+    // with code -1 ("Reading config failed"). This was hit on DNS3 on
+    // 2026-05-24 and on the TRI-LAPTOP GUI wallet on 2026-06-15. The user-facing
+    // symptom is "Tor failed to start. Triangles requires Tor to operate." and
+    // the only fix was manually renaming the corrupt file. Detect this state
+    // here and auto-rename so the daemon is self-healing.
+    {
+        fs::path statePath = fs::path(torDataDir) / "state";
+        std::error_code ec;
+        if (fs::exists(statePath, ec) && !fs::is_directory(statePath, ec)) {
+            // state is a file (or symlink to one) — quarantine it
+            auto now = std::chrono::system_clock::now();
+            auto t = std::chrono::system_clock::to_time_t(now);
+            char ts[32];
+            std::strftime(ts, sizeof(ts), "%Y%m%d-%H%M%S", std::gmtime(&t));
+            fs::path quarantine = fs::path(torDataDir) /
+                (std::string("state.corrupt-") + ts);
+            try {
+                fs::rename(statePath, quarantine, ec);
+                if (ec) {
+                    // rename can fail on Windows if dest exists; remove then rename
+                    fs::remove(quarantine, ec);
+                    fs::rename(statePath, quarantine, ec);
+                }
+                printf("Tor state was a file (corrupt) — quarantined to %s for inspection. Tor will recreate state/ as a directory.\n",
+                       quarantine.filename().string().c_str());
+            } catch (const std::exception& e) {
+                printf("WARNING: could not quarantine corrupt Tor state file %s: %s\n",
+                       statePath.string().c_str(), e.what());
+                // Last resort: try to remove it so Tor can proceed
+                fs::remove(statePath, ec);
+            }
+        }
+    }
 
     std::string hsDir;
     if (hiddenServiceEnabled) {
         hsDir = (fs::path(torDataDir) / "hidden_service").string();
         fs::create_directories(hsDir);
+        // CRITICAL: Tor rejects hidden service directories that are not 0700
+        // ("Permissions on directory ... are too permissive") and aborts config
+        // validation with code -1. This was the root cause of "Embedded Tor
+        // exited with code -1" — fs::create_directories honors umask (0022 on
+        // most Linux systems), leaving the dir at 0755. Force 0700 after creation.
+        fs::permissions(hsDir, fs::perms::owner_all, fs::perm_options::replace);
     }
 
     // Build the argv for tor_run_main

src/trianglesrpc.cpp

@@ -305,6 +305,10 @@ static const CRPCCommand vRPCCommands[] =
     { "settxfee",               &settxfee,               false,  false },
     { "listsinceblock",         &listsinceblock,         false,  false },
     { "dumpprivkey",            &dumpprivkey,            false,  false },
+    { "hdnew",                  &hdnew,                  false,  false },
+    { "hdrestore",              &hdrestore,              false,  false },
+    { "hdshow",                 &hdshow,                 false,  false },
+    { "hdinfo",                 &hdinfo,                 true,   false },
     { "dumpwallet",             &dumpwallet,             true,   false },
     { "importwallet",           &importwallet,           false,  false },
     { "importprivkey",          &importprivkey,          false,  false },

src/trianglesrpc.h

@@ -155,6 +155,10 @@ extern json_spirit::Value getwalletinfo(const json_spirit::Array& params, bool f
 extern json_spirit::Value dumpwallet(const json_spirit::Array& params, bool fHelp);
 extern json_spirit::Value importwallet(const json_spirit::Array& params, bool fHelp);
 extern json_spirit::Value dumpprivkey(const json_spirit::Array& params, bool fHelp); // in rpcdump.cpp
+extern json_spirit::Value hdnew(const json_spirit::Array& params, bool fHelp);
+extern json_spirit::Value hdrestore(const json_spirit::Array& params, bool fHelp);
+extern json_spirit::Value hdshow(const json_spirit::Array& params, bool fHelp);
+extern json_spirit::Value hdinfo(const json_spirit::Array& params, bool fHelp);
 extern json_spirit::Value importprivkey(const json_spirit::Array& params, bool fHelp);
 
 extern json_spirit::Value getsubsidy(const json_spirit::Array& params, bool fHelp);

src/txdb-leveldb.cpp

@@ -514,6 +514,20 @@ bool CTxDB::LoadBlockIndex()
     nBestHeight = pindexBest->nHeight;
     nBestChainTrust = pindexBest->nChainTrust;
 
+    // Heal pnext pointers along the active chain.  Persisted hashNext can be
+    // stale or zeroed by crash-interrupted reorgs, which breaks
+    // GetKernelStakeModifier()'s forward walk and causes valid new
+    // proof-of-stake blocks to be rejected with "check kernel failed".
+    {
+        int nHealed = 0;
+        for (CBlockIndex* p = pindexBest; p && p->pprev; p = p->pprev)
+        {
+            if (p->pprev->pnext != p) { p->pprev->pnext = p; nHealed++; }
+        }
+        if (nHealed > 0)
+            printf("LoadBlockIndex(): healed %d pnext links on active chain\n", nHealed);
+    }
+
     printf("STARTUP-PERF: best_chain %" PRId64 "ms\n", GetTimeMillis() - nPhaseStart);
 
     nPhaseStart = GetTimeMillis();

src/txdb-rocksdb.cpp

@@ -542,6 +542,20 @@ bool CRocksTxDB::LoadBlockIndex()
     nBestHeight = pindexBest->nHeight;
     nBestChainTrust = pindexBest->nChainTrust;
 
+    // Heal pnext pointers along the active chain.  Persisted hashNext can be
+    // stale or zeroed by crash-interrupted reorgs, which breaks
+    // GetKernelStakeModifier()'s forward walk and causes valid new
+    // proof-of-stake blocks to be rejected with "check kernel failed".
+    {
+        int nHealed = 0;
+        for (CBlockIndex* p = pindexBest; p && p->pprev; p = p->pprev)
+        {
+            if (p->pprev->pnext != p) { p->pprev->pnext = p; nHealed++; }
+        }
+        if (nHealed > 0)
+            printf("LoadBlockIndex(): healed %d pnext links on active chain\n", nHealed);
+    }
+
     printf("STARTUP-PERF: best_chain %" PRId64 "ms\n", GetTimeMillis() - nPhaseStart);
 
     nPhaseStart = GetTimeMillis();

src/wallet.cpp

@@ -7,12 +7,14 @@
 #include "wallet.h"
 #include "walletdb.h"
 #include "crypter.h"
+#include "hdwallet.h"
 #include "ui_interface.h"
 #include "base58.h"
 #include "kernel.h"
 #include "coincontrol.h"
 #include "addressindex.h"
 #include "util.h"
+#include <cstring>
 #include <memory>
 #include <algorithm>
 #include <random>
@@ -129,7 +131,12 @@ CPubKey CWallet::GenerateNewKey()
 
     RandAddSeedPerfmon();
     CKey key;
-    key.MakeNewKey(fCompressed);
+    bool fUsedHD = false;
+    if (fHDEnabled && !hdMnemonic.empty()) {
+        if (DeriveHDKey(nHDChainIndex, key)) { fUsedHD = true; fCompressed = true; }
+    }
+    if (!fUsedHD)
+        key.MakeNewKey(fCompressed);
 
     // Compressed public keys were introduced in version 0.6.0
     if (fCompressed)
@@ -145,6 +152,11 @@ CPubKey CWallet::GenerateNewKey()
 
     if (!AddKey(key))
         throw std::runtime_error("CWallet::GenerateNewKey() : AddKey failed");
+    if (fUsedHD) {
+        nHDChainIndex++;
+        if (fFileBacked)
+            CWalletDB(strWalletFile).WriteHDChain(nHDChainIndex);
+    }
     return key.GetPubKey();
 }
 
@@ -209,6 +221,9 @@ bool CWallet::Lock()
     if (fDebug)
         printf("Locking wallet.\n");
 
+    if (IsCrypted())
+        hdMnemonic.clear(); // keep only the encrypted copy while locked
+
     {
         LOCK(cs_wallet);
         CWalletDB wdb(strWalletFile);
@@ -233,8 +248,14 @@ bool CWallet::Unlock(const SecureString& strWalletPassphrase)
                 return false;
             if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, vMasterKey))
                 return false;
-            if (CCryptoKeyStore::Unlock(vMasterKey))
+            if (CCryptoKeyStore::Unlock(vMasterKey)) {
+                if (fHDEnabled && hdMnemonic.empty() && !vchCryptedHDMnemonic.empty()) {
+                    CSecret sec;
+                    if (DecryptSecret(vMasterKey, vchCryptedHDMnemonic, hdMnemonicIV, sec))
+                        hdMnemonic.assign(sec.begin(), sec.end());
+                }
                 return true;
+            }
         }
 
         SecureMsgWalletUnlocked();
@@ -407,6 +428,15 @@ bool CWallet::EncryptWallet(const SecureString& strWalletPassphrase)
                 return false;
             }
 
+            if (fHDEnabled && !hdMnemonic.empty()) {
+                CSecret sec(hdMnemonic.begin(), hdMnemonic.end());
+                uint256 iv = GetRandHash();
+                std::vector<unsigned char> cipher;
+                if (!EncryptSecret(vMasterKey, sec, iv, cipher)) { dbEnc->TxnAbort(); return false; }
+                hdMnemonicIV = iv; vchCryptedHDMnemonic = cipher;
+                dbEnc->WriteHDCryptedMnemonic(iv, cipher);
+            }
+
             SetMinVersion(WalletFeature::WalletCrypt, dbEnc.get(), true);
 
             if (!dbEnc->TxnCommit())
@@ -2848,3 +2878,66 @@ void CWallet::GetKeyBirthTimes(std::map<CKeyID, int64_t> &mapKeyBirth) const {
 }
 
 
+// ---- HD wallet (BIP39/BIP32) implementation ----
+bool CWallet::DeriveHDKey(int64_t index, CKey& keyOut) const
+{
+    if (hdMnemonic.empty())
+        return false;
+    unsigned char priv[32];
+    if (!hd::DeriveTriangles(hdMnemonic, "", 0, 0, (uint32_t)index, priv))
+        return false;
+    CSecret secret(priv, priv + 32);
+    memset(priv, 0, sizeof(priv));
+    keyOut.SetSecret(secret, true); // HD keys are compressed
+    return true;
+}
+
+bool CWallet::GetHDMnemonic(std::string& mnemonicOut) const
+{
+    if (!fHDEnabled || hdMnemonic.empty())
+        return false;
+    mnemonicOut = hdMnemonic;
+    return true;
+}
+
+bool CWallet::SetHDSeed(const std::string& mnemonicIn, const std::string& passphrase, bool fGenerate, std::string& mnemonicOut, std::string& strError)
+{
+    LOCK(cs_wallet);
+    if (IsLocked()) { strError = "Wallet is locked; unlock it before setting an HD seed."; return false; }
+
+    std::string m = mnemonicIn;
+    if (m.empty()) {
+        if (!fGenerate) { strError = "No mnemonic supplied."; return false; }
+        m = hd::GenerateMnemonic(256);
+        if (m.empty()) { strError = "Failed to generate mnemonic."; return false; }
+    }
+    if (!hd::CheckMnemonic(m)) { strError = "Invalid mnemonic (unknown word or bad checksum)."; return false; }
+
+    unsigned char priv[32];
+    if (!hd::DeriveTriangles(m, passphrase, 0, 0, 0, priv)) { strError = "Key derivation failed."; return false; }
+    memset(priv, 0, sizeof(priv));
+
+    hdMnemonic = m;
+    fHDEnabled = true;
+    nHDChainIndex = 0;
+
+    if (fFileBacked) {
+        CWalletDB wdb(strWalletFile);
+        if (IsCrypted()) {
+            CSecret sec(m.begin(), m.end());
+            uint256 iv = GetRandHash();
+            std::vector<unsigned char> cipher;
+            if (!EncryptSecret(vMasterKey, sec, iv, cipher)) { strError = "Failed to encrypt seed."; return false; }
+            hdMnemonicIV = iv; vchCryptedHDMnemonic = cipher;
+            wdb.WriteHDCryptedMnemonic(iv, cipher);
+        } else {
+            wdb.WriteHDMnemonic(m);
+        }
+        wdb.WriteHDChain(nHDChainIndex);
+    }
+    // Replace any pre-existing (random) keypool with HD-derived keys so that
+    // getnewaddress immediately hands out deterministic m/44'/2222'/0'/0/i keys.
+    NewKeyPool();
+    mnemonicOut = m;
+    return true;
+}

src/wallet.h

@@ -105,6 +105,8 @@ public:
         fFileBacked = false;
         nMasterKeyMaxID = 0;
         pwalletdbEncryption = nullptr;
+        fHDEnabled = false;
+        nHDChainIndex = 0;
         nOrderPosNext = 0;
         nCachedStakeWeight = 0;
         nCachedStakeWeightTime = 0;
@@ -124,6 +126,13 @@ public:
     CPubKey vchDefaultKey;
     int64_t nTimeFirstKey;
 
+    // ---- HD (BIP39/BIP32) wallet state ----
+    bool fHDEnabled;                              // an HD seed has been set
+    int64_t nHDChainIndex;                        // next external index (m/44'/2222'/0'/0/n)
+    std::string hdMnemonic;                       // in-memory phrase (present when unlocked/unencrypted)
+    std::vector<unsigned char> vchCryptedHDMnemonic; // encrypted phrase (loaded, decrypted on unlock)
+    uint256 hdMnemonicIV;                         // IV for the encrypted phrase
+
     // check whether we are allowed to upgrade (or already support) to the named feature
     bool CanSupportFeature(WalletFeature wf) { return nWalletMaxVersion >= static_cast<int>(wf); }
 
@@ -133,6 +142,14 @@ public:
     // keystore implementation
     // Generate a new key
     CPubKey GenerateNewKey();
+
+    // ---- HD wallet (BIP39/BIP32) ----
+    bool IsHDEnabled() const { return fHDEnabled; }
+    bool SetHDSeed(const std::string& mnemonicIn, const std::string& passphrase, bool fGenerate, std::string& mnemonicOut, std::string& strError);
+    bool GetHDMnemonic(std::string& mnemonicOut) const;
+    bool DeriveHDKey(int64_t index, CKey& keyOut) const;
+    bool LoadHDMnemonic(const std::string& m) { hdMnemonic = m; fHDEnabled = true; return true; }
+    bool LoadCryptedHDMnemonic(const uint256& iv, const std::vector<unsigned char>& cipher) { hdMnemonicIV = iv; vchCryptedHDMnemonic = cipher; fHDEnabled = true; return true; }
     // Adds a key to the store, and saves it to disk.
     bool AddKey(const CKey& key);
     // Adds a key to the store, without saving it to disk (used by LoadWallet)

src/walletdb.cpp

@@ -429,6 +429,24 @@ ReadKeyValue(CWallet* pwallet, CDataStream& ssKey, CDataStream& ssValue,
                 pwallet->mapKeyMetadata[keyid] = CKeyMetadata(keypool.nTime);
 
         }
+        else if (strType == "hdmnemonic")
+        {
+            std::string m;
+            ssValue >> m;
+            pwallet->LoadHDMnemonic(m);
+        }
+        else if (strType == "hdcmnemonic")
+        {
+            std::pair<uint256, std::vector<unsigned char> > cm;
+            ssValue >> cm;
+            pwallet->LoadCryptedHDMnemonic(cm.first, cm.second);
+        }
+        else if (strType == "hdchain")
+        {
+            int64_t n;
+            ssValue >> n;
+            pwallet->nHDChainIndex = n;
+        }
         else if (strType == "version")
         {
             ssValue >> wss.nFileVersion;
@@ -461,7 +479,8 @@ ReadKeyValue(CWallet* pwallet, CDataStream& ssKey, CDataStream& ssValue,
 static bool IsKeyType(string strType)
 {
     return (strType== "key" || strType == "wkey" ||
-            strType == "mkey" || strType == "ckey");
+            strType == "mkey" || strType == "ckey" ||
+            strType == "hdmnemonic" || strType == "hdcmnemonic");
 }
 
 DBErrors CWalletDB::LoadWallet(CWallet* pwallet)

src/walletdb.h

@@ -169,6 +169,21 @@ public:
         return Write(std::string("defaultkey"), vchPubKey.Raw());
     }
 
+    bool WriteHDMnemonic(const std::string& mnemonic) {
+        nWalletDBUpdated++;
+        Erase(std::string("hdcmnemonic"));
+        return Write(std::string("hdmnemonic"), mnemonic);
+    }
+    bool WriteHDCryptedMnemonic(const uint256& iv, const std::vector<unsigned char>& cipher) {
+        nWalletDBUpdated++;
+        Erase(std::string("hdmnemonic"));
+        return Write(std::string("hdcmnemonic"), std::make_pair(iv, cipher));
+    }
+    bool WriteHDChain(int64_t nIndex) {
+        nWalletDBUpdated++;
+        return Write(std::string("hdchain"), nIndex);
+    }
+
     bool ReadPool(int64_t nPool, CKeyPool& keypool)
     {
         return Read(std::make_pair(std::string("pool"), nPool), keypool);