agorise/hidden-rpc
Watch
1
0
Fork
You've already forked hidden-rpc
 0
Code Issues Pull requests Projects Releases 10 Packages Wiki Activity Actions
10 releases 10 tags
  • v0.1.17 b0ed2734bf

    hidden-rpc v0.1.17 Stable

    agorise released this 2026-08-26 17:54:28 +00:00 | 0 commits to main since this release

    hidden-rpc v0.1.17

    Adds an optional, opt-in name for a node — so an operator who wants to be
    identifiable (e.g. to be pinged when their node needs a reboot) can be, while
    anonymity-preferring operators simply leave it blank and leak nothing. No change
    to how the node runs; already-synced nodes are unaffected.

    What's new in v0.1.17

    • --name <handle> — an optional public handle for this node. Set one with
      --name oldpc (or a Blurt @handle); clear it with --name "". It's blank by
      default. When set, the name:
      • shows in --status and --show-addresses, so you can tell which machine you're on;
      • is saved into node-addresses.json alongside the .onion / .b32.i2p, so the
        node's directory entry is copy-paste ready.
        The handle is validated to a safe, chain-friendly charset (1–32 of letters,
        digits, and . _ - @) — the SAME rules Morphit's on-chain RPC-directory accepts,
        so a name set here can be pinned as-is. It's a cosmetic label only and never
        changes how the node is reached.

    Carried over: --watch animates during replay and returns to the prompt once
    fully synced; runnable command paths; empty snapshot-folder cleanup; minimum
    requirements in the notes; trustless on-chain bootstrap; --mirror-only.

    Minimum requirements

    • Operating system: 64-bit Linux in the Debian / Ubuntu / Linux Mint family
      (uses apt). Tested on Linux Mint 22 and Ubuntu 24.04.

    • Architecture: amd64 / x86_64. ARM is not supported yet.

    • Memory: ~4 GB RAM minimum (~3 GB used by the node); 8 GB comfortable.

    • Free disk space: about 100 GB for a first-time setup; far less later. An
      SSD is strongly recommended — the one-time replay is far faster on an SSD.

    • Internet: normal broadband. A serving node keeps a clearnet p2p connection
      on port 1776 to stay in sync; only the RPC reads are hidden over Tor and I2P.

    • Installed automatically if missing: Docker, Tor, i2pd, and small tools.

    • Repository: https://git.agorise.net/agorise/hidden-rpc

    • License: AGPL-3.0-or-later

    Downloads
  • v0.1.16 abbd4355ec

    hidden-rpc v0.1.16 Stable

    agorise released this 2026-08-24 19:59:00 +00:00 | 1 commits to main since this release

    hidden-rpc v0.1.16

    Setup- and monitoring-experience polish. No change to the node itself; already-synced nodes are
    unaffected.

    What's new

    • --watch behaves properly end to end. While the node replays the block_log (before the RPC
      answers), --watch now shows a live braille spinner, a "take a break — your CPU will be busy for
      a few hours" message, and a live (block N of ~N) readout pulled from the node's own logs. Once
      the RPC is up it shows the catch-up percentage. And the moment the node is fully synced, --watch
      prints a confirmation and returns you to the prompt automatically       — no more sitting on a static
      screen waiting to press Ctrl-C.
    • Suggested commands are copy-paste runnable. End-of-setup hints (and the "check progress" /
      "not running yet" messages) print the full absolute path the installer was launched from —
      e.g. bash /home/you/hidden-rpc/installer/hidden-rpc-setup.sh --status — with a trailing
      # comment so pasting the whole line still runs.
    • The empty snapshot download folder is removed after the download is unpacked and deleted
      (via rmdir, which only deletes an already-empty directory).

    Minimum requirements

    • Operating system: 64-bit Linux in the Debian / Ubuntu / Linux Mint family (anything that uses
      apt). Tested on Linux Mint 22 and Ubuntu 24.04; other recent Debian-based distros should work.

    • Architecture: amd64 / x86_64 (a standard 64-bit PC). ARM is not supported yet.

    • Memory: ~4 GB RAM minimum (the node itself uses about 3 GB); 8 GB is comfortable.

    • Free disk space: about 100 GB for a first-time setup (the download plus the state the node
      rebuilds while replaying); far less on later runs. An SSD is strongly recommended — the
      one-time replay is dramatically faster on an SSD than on a spinning hard drive.

    • Internet: a normal broadband connection. A serving node keeps a clearnet peer-to-peer
      connection on port 1776 to stay in sync; only the RPC reads are hidden over Tor and I2P.

    • Time: the one-time trustless replay re-verifies every block and keeps the CPU busy for several
      hours on first setup. After that the node keeps up on its own with negligible load.

    • Installed automatically if missing: Docker, Tor, i2pd, and a few small command-line tools — no
      manual setup required.

    • Repository: https://git.agorise.net/agorise/hidden-rpc

    • License: AGPL-3.0-or-later

    Downloads
  • v0.1.14 4bbdf14208

    hidden-rpc v0.1.14 Stable

    agorise released this 2026-08-24 06:22:07 +00:00 | 2 commits to main since this release

    hidden-rpc v0.1.14

    A documentation-accuracy and audit release. No behavior change from v0.1.13 — this makes the docs
    match how the installer actually works now (trustless by default), records the genesis finding, and
    ships a clean full-audit pass. Already-synced nodes are unaffected.

    What's in this release

    • Docs now describe the real default flow. installer/README.md, docs/MANUAL-SETUP.md, and the
      top-level README.md were updated: the default is the trustless bootstrap (signed on-chain
      chain_snapshot_v1 pointer → SHA-256-verified block_log from IPFS/mirror → genesis file →
      replay), with --trusted-state as the fast presynced-state opt-in. --check-snapshot and
      --mirror-only are documented, and the genesis-file requirement is written down.
    • Decisions log updated with the genesis-required-for-replay finding and the publisher action
      item (bundle snapshot.json in the pinned archive, or host it with genesis_cid+genesis_sha256
      in the op).
    • Full audit pass: every script shellcheck-clean (info level) and bash -n clean; the pointer
      validator compiles and passes its unit tests; no orphaned/unwired functions; embedded fallback
      config matches the shipped config.ini (loopback, no witness, follow_api, identical seeds).

    Carried over: dead IPFS gateway removed and graceful failure when the genesis can't be fetched
    (v0.1.13); genesis placement (v0.1.12); spinner-on-every-step UX (v0.1.11); --mirror-only and real
    IPFS_GATEWAYS="" (v0.1.10); live progress + fast fail-over (v0.1.9); trustless bootstrap
    (v0.1.6–v0.1.8).

    Reliable path today

    Public IPFS gateways don't yet reliably serve Blurt's genesis file, so a from-scratch trustless
    replay can't always complete until the snapshot publisher bundles the genesis. For a guaranteed
    setup right now, use the mirror-backed fast path:

    bash installer/hidden-rpc-setup.sh --trusted-state

    Important

    Tor and I2P hide where you read, not whether what you read is true — cross-check across
    independent nodes. RPC-only (no witness / block production).

    Downloads
  • v0.1.8 7065efe7c2

    hidden-rpc v0.1.8 Stable

    agorise released this 2026-08-21 04:40:22 +00:00 | 3 commits to main since this release

    Signed by agorise
    GPG key ID: 53524E1F1017EB9C

    hidden-rpc v0.1.8

    Makes the trustless download robust no matter how a snapshot is pinned or how busy the IPFS network
    is. Small, download-path-only changes; nodes already synced are unaffected.

    What's new in v0.1.8

    • Works whether the snapshot CID is a bare file or a wrapped directory. The current snapshot is
      a raw file CID (so it already worked), but future or community-pinned snapshots might be wrapped.
      The installer now also tries <gateway>/ipfs/<cid>/block_log-<block_height>.tar.zst, so either
      layout resolves. All sources serve identical bytes; the SHA-256 gate remains the final check.
    • Prompt failover to the mirror. IPFS gateways now have connect and inactivity timeouts, so a
      slow or not-yet-propagated gateway hands off to the Forgejo mirror quickly instead of stalling —
      and once your node has the file, it helps reseed IPFS for the next person.

    Carried over: trustless block_log bootstrap from the signed on-chain chain_snapshot_v1 pointer
    (cross-checked across RPCs, SHA-256 gated, replayed and re-verified), zstd/.tar.zst support,
    the --trusted-state opt-in, --check-snapshot, and the clearnet p2p disclosure at setup.

    Verify the live pointer (no download)

    bash installer/hidden-rpc-setup.sh --check-snapshot

    Important

    Tor and I2P hide where you read, not whether what you read is true — cross-check across
    independent nodes. RPC-only (no witness / block production).

    Downloads
  • v0.1.6 af258c791a

    hidden-rpc v0.1.6 Stable

    agorise released this 2026-08-18 20:16:21 +00:00 | 4 commits to main since this release

    Signed by agorise
    GPG key ID: 53524E1F1017EB9C

    hidden-rpc v0.1.6

    Adds a trustless blockchain bootstrap: new nodes now load the chain from a signed on-chain
    pointer     instead of a hardcoded URL, verify it, and let the node re-check every block. Existing
    synced nodes are unaffected (they skip bootstrap entirely).

    hidden-rpc turns an ordinary computer — an old laptop is plenty — into a
    censorship-resistant Blurt RPC node, reachable privately over Tor (.onion v3) and
    I2P (.b32.i2p).

    What's new in v0.1.6

    • Trustless bootstrap (new default). A fresh node reads the latest chain_snapshot_v1 pointer
      from @morphit on-chain, cross-checked across at least two public RPCs (highest height wins; a
      same-height checksum conflict stops the install rather than guessing). It downloads the block_log
      from IPFS (with an https mirror fallback), verifies its SHA-256 before using it, then lets the
      node replay and re-verify every block. Nothing about the download host has to be trusted.
    • Fast path is now an explicit, honest opt-in. The old presynced-state setup (minutes, but you
      trust whoever built the state) is still available as --trusted-state. It is never advertised
      on-chain. Trustless is the default; trusted is a conscious choice.
    • --check-snapshot. Inspect the current signed on-chain pointer (height, size, CID, checksum,
      mirror) without downloading anything.
    • Up-front network disclosure. Setup now states plainly that a serving node keeps a normal
      clearnet connection on p2p port 1776 (its IP is visible to peers) and that only the RPC reads are
      hidden — so anyone on a sensitive network chooses consciously.
    • Verified pointer validation. The on-chain pointer validator mirrors Morphit's schema exactly
      and ships with unit tests (installer/snap_core_test.py).

    Note: replaying the full block_log is a one-time job that runs unattended for several hours the
    first time — that's the cost of trustlessness. Watch it with --watch.

    Requirements & commands

    bash installer/hidden-rpc-setup.sh                  # trustless setup (default)
bash installer/hidden-rpc-setup.sh --trusted-state  # fast presynced-state setup (you trust the publisher)
bash installer/hidden-rpc-setup.sh --check-snapshot  # show the signed on-chain pointer
bash installer/hidden-rpc-setup.sh --status          # running? how far behind? addresses
bash installer/hidden-rpc-setup.sh --watch           # calm, live progress
bash installer/hidden-rpc-setup.sh --cleanup         # reclaim disk space (safe)

    64-bit Linux (Debian/Ubuntu/Mint), amd64. Docker, Tor, and i2pd install automatically if missing.

    Important

    Tor and I2P hide where you read, not whether what you read is true. Reaching a node does not
    make its data trustworthy — cross-checking across independent nodes is the reader's job. RPC-only
    (no witness / block production).

    Downloads
  • v0.1.5 19f0d55ec9

    hidden-rpc v0.1.5 Stable

    agorise released this 2026-08-14 05:24:05 +00:00 | 5 commits to main since this release

    Signed by agorise
    GPG key ID: 53524E1F1017EB9C

    hidden-rpc v0.1.5

    A hardening and cleanup release from a full code + security audit. No behavior changes for a
    healthy node; everything below makes the tool safer, tidier, and more honest. Your chain data and
    addresses are never touched.

    hidden-rpc turns an ordinary computer — an old laptop is plenty — into a
    censorship-resistant Blurt RPC node, reachable privately over Tor (.onion v3) and
    I2P (.b32.i2p). No public IP, no port-forwarding, no DNS, no registrar, no hosting company.

    What's new in v0.1.5

    • Disk cleanup is now surgical. It only reclaims what this tool itself creates — dangling
      Docker image layers, Docker build cache, apt's download cache, and old i2pd crash dumps. It no
      longer runs a broad Docker prune (which could remove unrelated stopped containers) and no longer
      vacuums system logs that aren't ours.
    • Publishing no longer prompts for a password. The release tool now authenticates git with
      your token and can never hang on a username/password prompt. The token is also kept out of the
      process list (passed via a private config file, not the command line).
    • Docs match reality. The manual reference was rewritten to reflect the current setup
      (official PurpleI2P i2pd, address read from the key file, loopback enforced on the command line,
      reboot recovery). Stale plugin lists and the old web-console step were removed. The roadmap and
      status now reflect what's actually shipped.
    • Reboot recovery verified. Docker, Tor, and i2pd run as enabled services and the node
      container restarts itself — after a reboot the node comes back and catches up on its own.

    Carried over: official PurpleI2P i2pd with auto-restart (v0.1.2); smart disk check with automatic
    cleanup and a --cleanup command (v0.1.3); correct detection of an already-synced chain so it
    never re-downloads (v0.1.4).

    Setup / repair / everyday

    bash installer/hidden-rpc-setup.sh                  # set up or repair (idempotent)
bash installer/hidden-rpc-setup.sh --status         # running? how far behind? addresses
bash installer/hidden-rpc-setup.sh --watch          # calm, live sync progress
bash installer/hidden-rpc-setup.sh --show-addresses # reprint .onion / .b32.i2p
bash installer/hidden-rpc-setup.sh --cleanup        # reclaim disk space (safe)

    Requirements

    • 64-bit Linux (Debian / Ubuntu / Mint family), amd64.
    • ~100 GB free for first-time setup (much less afterward). Docker, Tor, and i2pd install
      automatically if missing.

    Important: what this does and does not do

    Tor and I2P hide where you read, not whether what you read is true. Reaching a node does
    not make its data trustworthy — cross-checking answers across independent nodes is the reader's
    job. This release is RPC-only (no witness / block production).

    Links

    Downloads
  • v0.1.3 c57793ea53

    hidden-rpc v0.1.3 Stable

    agorise released this 2026-08-14 03:58:36 +00:00 | 6 commits to main since this release

    Signed by agorise
    GPG key ID: 53524E1F1017EB9C

    hidden-rpc v0.1.3

    A disk-space and reliability release. If you're already running an earlier version, just run the
    installer again — it tidies up wasted space, skips the big disk check when your chain is already
    loaded, and never touches your chain data or addresses.

    hidden-rpc turns an ordinary computer — an old laptop is plenty — into a
    censorship-resistant Blurt RPC node, reachable privately over Tor (.onion v3) and
    I2P (.b32.i2p). No public IP, no port-forwarding, no DNS, no registrar, no hosting company.

    What's new in v0.1.3

    • No more false "out of disk space" on re-runs. The installer used to demand ~90 GB free
      every single time. It now recognizes when your blockchain is already loaded and only needs a
      little headroom — so re-running on a working node just proceeds.
    • Automatic cleanup. Once the chain is loaded, the ~27 GB snapshot download is deleted (it's
      no longer needed), and leftover Docker image layers, build cache, apt cache, and old crash dumps
      are cleared. This alone reclaims tens of GB on nodes set up with earlier versions.
    • New --cleanup command. Run ./installer/hidden-rpc-setup.sh --cleanup anytime to reclaim
      space on demand. It reports before/after free space and never touches your chain or addresses.

    Carried over from v0.1.2: I2P now installs from the official PurpleI2P source (fixing the i2pd
    startup crash on Ubuntu/Mint), auto-restarts on failure, and the .onion/.b32.i2p are read
    reliably from each service's key file.

    One-step setup (or repair)

    From the repository folder:

    ./installer/hidden-rpc-setup.sh

    Everyday commands:

    ./installer/hidden-rpc-setup.sh --watch           # calm, live sync progress
./installer/hidden-rpc-setup.sh --status          # quick summary
./installer/hidden-rpc-setup.sh --show-addresses  # reprint .onion / .b32.i2p
./installer/hidden-rpc-setup.sh --cleanup         # reclaim disk space (safe)

    Requirements

    • 64-bit Linux (Debian / Ubuntu / Mint family), amd64.
    • About 100 GB of free disk space for the first-time setup (less afterward). Docker, Tor, and
      i2pd are installed automatically if missing.

    Important: what this does and does not do

    Tor and I2P hide where you read, not whether what you read is true. Reaching a node does
    not make its data trustworthy — cross-checking answers across independent nodes is the reader's
    job. This release is RPC-only (no witness / block production).

    Links

    Downloads
  • v0.1.2 bcb7baad12

    hidden-rpc v0.1.2 Stable

    agorise released this 2026-08-14 03:41:23 +00:00 | 7 commits to main since this release

    Signed by agorise
    GPG key ID: 53524E1F1017EB9C

    hidden-rpc v0.1.2

    An I2P reliability release. If you're already running an earlier version, just run the installer
    again — it upgrades I2P, repairs the address, and never touches your chain data.

    hidden-rpc turns an ordinary computer — an old laptop is plenty — into a
    censorship-resistant Blurt RPC node, reachable privately over Tor (.onion v3) and
    I2P (.b32.i2p). No public IP, no port-forwarding, no DNS, no registrar, no hosting
    company.

    What's new in v0.1.2

    • Fixed the I2P address never appearing on some machines. The version of i2pd shipped by
      Ubuntu/Mint (2.49.x) crashes on startup on certain hardware, so the .b32.i2p address never
      became available. The installer now installs i2pd from the official PurpleI2P source, which
      resolves the crash.
    • I2P now auto-recovers. i2pd is configured to restart itself automatically if it ever stops,
      so a transient hiccup no longer leaves your node without its I2P address.
    • Address is now read reliably from the key file. Your .onion and .b32.i2p are derived
      directly from each service's key material, so they appear immediately and correctly instead of
      depending on a web console that wasn't always reachable.
    • Honest status. If I2P can't start on a given machine, the installer now says so plainly and
      points out that your node still works fully over Tor — instead of leaving you waiting on an
      address that isn't coming.

    Your addresses do not change across this upgrade — the key material is preserved.

    One-step setup (or repair)

    From the repository folder:

    ./installer/hidden-rpc-setup.sh

    It installs/repairs everything, starts the node bound to localhost, brings up the Tor and I2P
    hidden services, and prints your two addresses. Safe to run again anytime.

    Everyday commands:

    ./installer/hidden-rpc-setup.sh --watch           # calm, live sync progress
./installer/hidden-rpc-setup.sh --status          # quick summary
./installer/hidden-rpc-setup.sh --show-addresses  # reprint .onion / .b32.i2p

    Requirements

    • 64-bit Linux (Debian / Ubuntu / Mint family), amd64.
    • About 100 GB of free disk space. Docker, Tor, and i2pd are installed automatically if missing.

    Important: what this does and does not do

    Tor and I2P hide where you read, not whether what you read is true. Reaching a node does
    not make its data trustworthy — cross-checking answers across independent nodes is the reader's
    job. This release is RPC-only (no witness / block production).

    Links

    Downloads
  • v0.1.1 ae0073dd36

    hidden-rpc v0.1.1 Stable

    agorise released this 2026-08-14 03:01:04 +00:00 | 8 commits to main since this release

    Signed by agorise
    GPG key ID: 53524E1F1017EB9C

    hidden-rpc v0.1.1

    A small hardening and correctness release. If you're already running v0.1.0, just run the
    installer again — it applies the changes with a gentle restart and never touches your chain data.

    hidden-rpc turns an ordinary computer — an old laptop is plenty — into a
    censorship-resistant Blurt RPC node, reachable privately over Tor (.onion v3) and
    I2P (.b32.i2p). No public IP, no port-forwarding, no DNS, no registrar, no hosting
    company.

    What's new in v0.1.1

    • Extra privacy safeguard. The RPC's loopback binding is now enforced on the node's
      command line as well as in its config file, so it stays private (127.0.0.1 only) even if a
      future upstream image were to change its default. Command line wins over config.
    • follow_api confirmed and documented correctly. Earlier notes carried a stale warning
      about follow_api. It has now been verified end-to-end on a live, fully-synced node (it
      serves follower data and the node stays healthy), so it remains enabled to match the official
      snapshot. The contradictory warning has been removed from the docs.
    • Two-node validation. The full one-command setup was reproduced on a second, different
      laptop, and a node has synced all the way to the live head — confirming the process is
      genuinely repeatable, not a one-off.

    One-step setup

    From the repository folder:

    ./installer/hidden-rpc-setup.sh

    It downloads everything it needs (including the ~27 GB presynced chain, with a live progress
    bar and time estimates), starts the node bound to localhost, turns on the Tor and I2P hidden
    services, and prints your two addresses. Safe to run again anytime.

    Everyday commands:

    ./installer/hidden-rpc-setup.sh --watch           # calm, live sync progress
./installer/hidden-rpc-setup.sh --status          # quick summary
./installer/hidden-rpc-setup.sh --show-addresses  # reprint .onion / .b32.i2p

    Requirements

    • 64-bit Linux (Debian / Ubuntu / Mint family), amd64.
    • About 100 GB of free disk space. Docker, Tor, and i2pd are installed automatically if missing.

    Good to know

    • After setup the node keeps catching up to the current block in the background; this is normal.
      Watch it calmly with --watch. Your I2P address takes a couple of minutes to appear on the
      first run.
    • If you ever look at the raw node logs, lines like Error when pushing block ... too old during
      catch-up are normal and harmless — duplicate blocks from multiple peers being rejected.

    Important: what this does and does not do

    Tor and I2P hide where you read, not whether what you read is true. Reaching a node does
    not make its data trustworthy — cross-checking answers across independent nodes is the reader's
    job. This release is RPC-only (no witness / block production).

    Links

    Downloads
  • v0.1.0 65f47066dd

    hidden-rpc v0.1.0 Stable

    agorise released this 2026-08-14 00:52:52 +00:00 | 9 commits to main since this release

    Signed by agorise
    GPG key ID: 53524E1F1017EB9C

    hidden-rpc v0.1.0

    First public release.

    hidden-rpc turns an ordinary computer — an old laptop is plenty — into a
    censorship-resistant Blurt RPC node, reachable privately over Tor (.onion v3) and
    I2P (.b32.i2p). No public IP, no port-forwarding, no DNS, no registrar, no hosting
    company.

    One-step setup

    From the repository folder:

    ./installer/hidden-rpc-setup.sh

    That's the whole thing. It downloads everything it needs, loads a presynced blockchain
    snapshot, starts the node bound to localhost, turns on the Tor and I2P hidden services,
    and prints your two addresses. It is safe to run again anytime — it never undoes finished
    work and never changes your addresses.

    Highlights

    • One command, no fuss. No prompts beyond your password once. Calm, reassuring output
      designed so a first-time operator never sees a scary error.
    • Downloads everything automatically — including the ~27 GB presynced chain (resumable),
      with a live progress bar and time estimates, plus spinners and elapsed timers on the
      longer steps.
    • Private by design. The RPC is bound to 127.0.0.1 only — reachable through Tor and
      I2P, never exposed on your local network or the clear net. Outbound-only hidden services
      mean no CGNAT/ISP problems.
    • Fast, multi-peer catch-up from current Blurt seed nodes.
    • Resilient. Auto-restarts after a reboot; graceful on hiccups — if anything is
      interrupted, just run it again and it continues.
    • Wraps the official upstream blurtd — no forks, no re-implementation.

    Requirements

    • 64-bit Linux (Debian / Ubuntu / Mint family), amd64.
    • About 100 GB of free disk space.
    • Docker, Tor, and i2pd are installed automatically if missing.

    Good to know

    • After setup, the node keeps catching up to the current block in the background. This can
      take a while and is completely normal. Watch it calmly with
      ./installer/hidden-rpc-setup.sh --watch.
    • Your I2P address takes a couple of minutes to become reachable on the first run. Re-run
      ./installer/hidden-rpc-setup.sh --show-addresses to print it once it's ready.
    • If you ever look at the raw node logs, lines like Error when pushing block ... too old
      during catch-up are normal and harmless — duplicate blocks from multiple peers being
      rejected. The chain keeps advancing right through them.

    Important: what this does and does not do

    Tor and I2P hide where you read, not whether what you read is true. Reaching a node
    does not make its data trustworthy — cross-checking answers across independent nodes is the
    reader's job. This release is RPC-only (no witness / block production).

    Links

    Downloads