<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/">
    <channel>
        <title>The Privacy Fellows</title>
        <link>https://paragraph.com/@Hisoka-Labs</link>
        <description>undefined</description>
        <lastBuildDate>Wed, 18 Nov 2026 04:23:38 GMT</lastBuildDate>
        <docs>https://validator.w3.org/feed/docs/rss2.html</docs>
        <generator>https://github.com/jpmonette/feed</generator>
        <language>en</language>
        <copyright>All rights reserved</copyright>
        <item>
            <title><![CDATA[NOX Architecture]]></title>
            <link>https://paragraph.com/@Hisoka-Labs/nox-architecture</link>
            <guid>m6DFS3OLgChV5VRg1cGc</guid>
            <pubDate>Tue, 16 Jun 2026 10:01:17 GMT</pubDate>
            <description><![CDATA[Sphinx packets Every message is wrapped in a Sphinx packet - a fixed-size (32 KB) encrypted blob with one encryption layer per node. Layered encryption - each node decrypts its layer, revealing only the next hop Fixed size - all packets are exactly 32,768 bytes, so you can't distinguish a small RPC call from a large transaction Unlinkable - the packet looks completely different at each hop; an observer watching two nodes can't tell they're handling the same message The SDK builds packets usin...]]></description>
            <content:encoded><![CDATA[<h2 id="h-sphinx-packets" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0"><strong>Sphinx packets</strong></h2><p>Every message is wrapped in a <strong>Sphinx packet</strong> - a fixed-size (32 KB) encrypted blob with one encryption layer per node.</p><ul><li><p><strong>Layered encryption</strong> - each node decrypts its layer, revealing only the next hop</p></li><li><p><strong>Fixed size</strong> - all packets are exactly 32,768 bytes, so you can't distinguish a small RPC call from a large transaction</p></li><li><p><strong>Unlinkable</strong> - the packet looks completely different at each hop; an observer watching two nodes can't tell they're handling the same message</p></li></ul><p>The SDK builds packets using the WASM crypto module (<code>@hisoka-io/nox-wasm</code>), which implements Sphinx packet construction and proof-of-work in Rust compiled to WebAssembly.</p><figure float="none" data-type="figure" class="img-center"><img src="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/3d288c0f144cff09b38045fa16569fa65fbbfee5a0c3c0505da721c9518a2905.png" blurdataurl="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAARCAIAAAAzPjmrAAAACXBIWXMAAAsTAAALEwEAmpwYAAAFZElEQVR4nC1UW2/jxhUeU6JoUiIpyiRnhkPdOLzoTkq07pZkyWvLkuNN5F1vupvdeIvEBXZRbAoEC+SCFm2BogVStM1TF81DW6BA0LwE6FvekjzlD/QpL/0LQYAWaB5SjFzgYDCXM/PN+c53DkjBslSqytFIDtpyvSs3uhJtpYN22tuOtMFOg7bkhdlSzQoikzZJNTZpE1fapNJBfrPQ6GULQcIo8GaRN4uCWd6FZQE6bI4pEMyiSBvKZCm1htnxrdziJTkam6d3tPmZOjqWu9N0PNPmZ9nJkkTDeLioRP3hfNkeTfcnt4aLs1p8EB+cOLV9kDGBipllIABZkNCBihgAb5bEHHHHR5X5utjuA94AEuIUJJultJHPYqpiJ2Pk2bUMBiLMWG2ZjGUyABkLiCbIICCYQEGcijnNAgpSMd3cf2N2ugEq3sUU7GhWodV79dvvHnz//flnn5saQohAZMXtuFZtRq1O1GxXg/peDkGILIQb858dXXw6mn8kwwCoKKnZSc3iNItTcXLPArxeiw/+9vd//OZ3fxRyhMcUAJUE0ej6sy9f++Kr11/8JasT3XaPTm/TShQPptOjtROE8+X5fHk+mS/9SuiM3+4df0Rvv5OhIZAM9rSGE1tLahbgTa/e++2Hf3r+3i95zRKQAwSzLOp23J0cLdZuJUpqloKc88tHfqvnNXuL1QY6taP1Zn76ciGIzFJ1/+BivHht8MqrGq0BCXIquQHYxoGBgnZ1+5V7r/cnx0AwJeyCXeSAhC4Zhb28DxTEuN4mAIgwH4Tx6BAolh2E+SAEQEnlSL4Slmuh3+yryPk/9Yz9LcbNXEFZTNNGHkhQtFyQgmUWWgYCEd5QCSSGwalY1AtZs8RlsKjbom4zeBUDEe2ohDmr5Ib9rXLYPhAgEBGvEqAwn4RisSQnjILmt93lncJkpa/uwvXl3nRlLjdSq5/pz/XVXWN9T52ulM4k7M4Gi7NqZ9ybrQaHq1SOPQQkrECqFyr5SuQ1e/kgTGo2z7DZhyRWB9DhVJy2vLTlCcgRiJ+wPGCWcKNrR0PBcuVSNU0bAvENP0SVTs6poqCFaEOGTkK1Jb1kB5EbdvvTW9OT87A/NQoB4FkonIJYBLuIggyWzVJ2WxCKThzHLYYHl09+reQI2CvvoIpgOIJekGpd0Q2F6gQEE9Vpt9rd2WJZbcZmvp7Zq2RRhdewoFuyWfKaQ8ttggyULAo4o2DV4s0/v774939P/voxjk7al29FV+9vfvEJ6N2l59eDx+8K0TFLDKtBi/YeTdbPdoOX7ePHvcsfG+M7tnu6Wj5tx/fTRz/kZverJw9e/Pnjn/7qD7xKWAQga9PO+OHX/7r45j93P/k02/0BWDzTF09B/2rn8Lqwvg4fPBeiY1G3FSYbQkdvdk+e6vFVYv5MOnwirZ5X9x/eOnyzHT8Uh1dg+qRz8ZMPfv/inZ9/IOiE1QEHy9Bp3L73+PLR9ex0I2h2Jke8elfYyilVClPeQMzX9yx6cvmG3VmkrZZSHiVyLq8QWu/J0NlVXT2YZO2QNQ/FkhG9+tFbR+s7W4pcIBAfCKaMHMtv3XSVenzQmxy7YW8rEiPBuhAses3D0w2kLcDngGLm/cb+eB72Jp3RoVuNktjhDLLtHFaOUFoJWQ4UlDCLQMAeUBHYy3OWy0MnAR21WMFBJBM/YRR50+HNEmcUcrRlNfsC8VPEl4hPWgMUtJEfQr+Fqx2mPc3mWJ2au8jN1oe67UW9GfRbgMde0iwJiKYsdpmNyE1AJ4VcAXs3liI+74ZJryP4keBHohexJXZ3zBIHHQ6WmQ/7TWnHIKqznz+4oNFgdnaJavH/AOQV8ZvBP5RJAAAAAElFTkSuQmCC" nextheight="1536" nextwidth="2816" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><h2 id="h-three-layer-routing" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0"><strong>Three-layer routing</strong></h2><p>Every request passes through exactly three nodes:</p><pre data-type="codeBlock" text="Client  →  Entry (layer 0)  →  Mix (layer 1)  →  Exit (layer 2)  →  Destination"><code>Client  →  Entry (layer <span class="hljs-number">0</span>)  →  Mix (layer <span class="hljs-number">1</span>)  →  Exit (layer <span class="hljs-number">2</span>)  →  Destination</code></pre><table><colgroup><col><col><col><col></colgroup><tbody><tr><th colspan="1" rowspan="1"><p><strong>Node</strong></p></th><th colspan="1" rowspan="1"><p><strong>Knows your IP?</strong></p></th><th colspan="1" rowspan="1"><p><strong>Knows the request?</strong></p></th><th colspan="1" rowspan="1"><p><strong>Role</strong></p></th></tr><tr><td colspan="1" rowspan="1"><p>Entry</p></td><td colspan="1" rowspan="1"><p>Yes</p></td><td colspan="1" rowspan="1"><p>No</p></td><td colspan="1" rowspan="1"><p>Accepts packets, holds responses</p></td></tr><tr><td colspan="1" rowspan="1"><p>Mix</p></td><td colspan="1" rowspan="1"><p>No</p></td><td colspan="1" rowspan="1"><p>No</p></td><td colspan="1" rowspan="1"><p>Relays and shuffles</p></td></tr><tr><td colspan="1" rowspan="1"><p>Exit</p></td><td colspan="1" rowspan="1"><p>No</p></td><td colspan="1" rowspan="1"><p>Yes</p></td><td colspan="1" rowspan="1"><p>Executes the request</p></td></tr></tbody></table><p>The SDK selects a random node from each layer for every request. Nodes are assigned layers based on their <code>role</code> value - relay nodes (role 1) serve layers 0–1, exit-capable nodes (roles 2–3) serve all layers.</p><h2 id="h-surbs-single-use-reply-blocks" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0"><strong>SURBs (Single-Use Reply Blocks)</strong></h2><p>The exit node doesn't know who you are - so how does it send the response back?</p><p>You include <strong>SURBs</strong> with your request. A SURB is a pre-built, encrypted return path:</p><ol><li><p>Before sending, the SDK generates SURBs containing encrypted routing instructions for the reverse path (Exit → Mix → Entry)</p></li><li><p>The exit node attaches the response to a SURB and sends it back through the network</p></li><li><p>Each return-path node strips its encryption layer</p></li><li><p>The entry node holds the encrypted response until the SDK picks it up</p></li><li><p>The SDK decrypts the final layer using keys it stored when creating the SURB</p></li></ol><p>Each SURB is single-use and carries ~30 KB of response data (<code>USABLE_RESPONSE_PER_SURB = 30,699 bytes</code>). A typical request includes 10 SURBs, supporting responses up to ~300 KB.</p><h3 id="h-surb-pool" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>SURB pool</strong></h3><p>The SDK maintains a <code>SurbPool</code> that tracks active SURBs and their decryption keys. When a response arrives, the pool matches it by SURB ID for O(1) decryption. After a request completes (or times out), its SURBs are cleaned up.</p><h2 id="h-fragmentation-and-fec" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0"><strong>Fragmentation and FEC</strong></h2><p>Responses larger than one SURB (~30 KB) are split into fragments by the exit node. The SDK reassembles them on the client side.</p><h3 id="h-how-fragmentation-works" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>How fragmentation works</strong></h3><ol><li><p>The exit node splits the response into chunks that fit in a single SURB</p></li><li><p>Each chunk becomes a <code>Fragment</code> with a <code>messageId</code>, <code>sequence</code> number, and <code>totalFragments</code> count</p></li><li><p>The SDK's <code>Reassembler</code> collects fragments and reconstructs the original message when all pieces arrive</p></li></ol><h3 id="h-forward-error-correction" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Forward Error Correction</strong></h3><p>Packets can be lost in transit. FEC (Reed-Solomon erasure coding) adds redundancy fragments so the client can reconstruct the response even if some are missing.</p><p>With <code>fecRatio: 0.3</code>, the exit node generates 30% extra parity fragments. If the response splits into 10 data fragments, 3 parity fragments are added - the client only needs any 10 of the 13 to reconstruct the full response.</p><table><colgroup><col><col><col></colgroup><tbody><tr><th colspan="1" rowspan="1"><p><code>fecRatio</code></p></th><th colspan="1" rowspan="1"><p><strong>Overhead</strong></p></th><th colspan="1" rowspan="1"><p><strong>Tolerates</strong></p></th></tr><tr><td colspan="1" rowspan="1"><p><code>0.0</code></p></td><td colspan="1" rowspan="1"><p>None</p></td><td colspan="1" rowspan="1"><p>No loss - all fragments must arrive</p></td></tr><tr><td colspan="1" rowspan="1"><p><code>0.2</code></p></td><td colspan="1" rowspan="1"><p>+20%</p></td><td colspan="1" rowspan="1"><p>~17% fragment loss</p></td></tr><tr><td colspan="1" rowspan="1"><p><code>0.3</code></p></td><td colspan="1" rowspan="1"><p>+30%</p></td><td colspan="1" rowspan="1"><p>~23% fragment loss (default)</p></td></tr><tr><td colspan="1" rowspan="1"><p><code>0.5</code></p></td><td colspan="1" rowspan="1"><p>+50%</p></td><td colspan="1" rowspan="1"><p>~33% fragment loss</p></td></tr></tbody></table><h3 id="h-reassembler-limits" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Reassembler limits</strong></h3><p>The <code>Reassembler</code> has built-in limits to prevent memory exhaustion:</p><ul><li><p><strong>Max buffer:</strong> 300 MB across all in-flight messages</p></li><li><p><strong>Max concurrent messages:</strong> 50</p></li><li><p><strong>Stale timeout:</strong> 120 seconds - incomplete messages are pruned</p></li></ul><h2 id="h-adaptive-surb-budgeting" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0"><strong>Adaptive SURB budgeting</strong></h2><p>The SDK doesn't always know how large a response will be. Sending too few SURBs means the response gets truncated. Sending too many wastes bandwidth.</p><p>The <code>AdaptiveSurbBudget</code> tracks an exponential moving average (EMA) of response sizes per operation type (e.g., <code>eth_blockNumber</code> vs. <code>eth_getLogs</code>). After the first request to an endpoint, subsequent requests automatically allocate the right number of SURBs.</p><p>For the first request to a new endpoint, the SDK uses:</p><ol><li><p><code>expectedResponseBytes</code> if you passed it in options</p></li><li><p><code>surbsPerRequest</code> from config (default: 10)</p></li></ol><h3 id="h-surb-replenishment" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>SURB replenishment</strong></h3><p>If the exit node runs out of SURBs mid-response, it sends a <code>NeedMoreSurbs</code> message back to the client. The SDK's <code>ReplenishmentManager</code> generates fresh SURBs and sends them in a <code>ReplenishSurbs</code> packet, allowing the exit node to continue sending fragments.</p><p>This happens transparently - you don't need to handle it.</p><h2 id="h-topology-verification" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0"><strong>Topology verification</strong></h2><p>The SDK verifies the node list it receives from seed nodes:</p><h3 id="h-self-consistency-check" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>Self-consistency check</strong></h3><p>The topology includes a <code>fingerprint</code> - the XOR of <code>keccak256(address)</code> for every node. The SDK recomputes this and rejects the topology if they don't match.</p><h3 id="h-on-chain-verification-optional" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>On-chain verification (optional)</strong></h3><p>When <code>ethRpcUrl</code> and <code>registryAddress</code> are configured, the SDK reads the fingerprint from the NoxRegistry smart contract and compares it to the seed node's fingerprint. This catches:</p><ul><li><p>Compromised seed nodes serving a fake topology</p></li><li><p>Stale seed nodes serving an outdated node list</p></li><li><p>Man-in-the-middle attacks modifying the topology in transit</p></li></ul><pre data-type="codeBlock" text="const client = await NoxClient.connect({  ethRpcUrl: &quot;https://arb-sepolia.g.alchemy.com/v2/YOUR_KEY&quot;,  registryAddress: &quot;0x8626aF80db409BeD3C19871FAdf9b0Ce7Aa641Bc&quot;,});"><code>const <span class="hljs-attr">client</span> = await NoxClient.connect({  ethRpcUrl: <span class="hljs-string">"https://arb-sepolia.g.alchemy.com/v2/YOUR_KEY"</span>,  registryAddress: <span class="hljs-string">"0x8626aF80db409BeD3C19871FAdf9b0Ce7Aa641Bc"</span>,})<span class="hljs-comment">;</span></code></pre><h2 id="h-cover-traffic" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0"><strong>Cover traffic</strong></h2><p>The <code>CoverTrafficController</code> sends dummy Sphinx packets at Poisson-distributed intervals. These packets are indistinguishable from real packets to any observer - they're the same size, go through the same three-hop route, and carry random padding.</p><p>The exit node recognizes dummy packets (they carry a <code>Dummy</code> payload) and discards them. The key property is that an observer watching your connection to the entry node can't distinguish real requests from noise.</p><p>See <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://docs.hisoka.io/cover-traffic"><u>Cover Traffic</u></a> for configuration details.</p><h2 id="h-transport" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0"><strong>Transport</strong></h2><p>The SDK communicates with entry nodes over HTTPS:</p><ul><li><p><strong>Sending:</strong> Sphinx packets are POSTed to the entry node</p></li><li><p><strong>Receiving:</strong> Responses are delivered via WebSocket (preferred) or HTTP polling (fallback)</p></li></ul><p>The SDK auto-detects WebSocket support. When available, it subscribes to SURB IDs for push-based delivery. When not available, it polls the entry node at regular intervals.</p>]]></content:encoded>
            <author>hisoka-labs@newsletter.paragraph.com (The Privacy Fellows)</author>
            <category>hisoka</category>
            <category>blockchain</category>
            <category>privacy</category>
            <category>nox</category>
            <category>ethereum</category>
            <category>web3</category>
            <category>tor</category>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/4cb9ce661cd322604eef70004f195171ddff386f40c59c2cbb96dfcef13f6893.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Off-chain privacy stack, Part 2: Introducing Raven]]></title>
            <link>https://paragraph.com/@Hisoka-Labs/off-chain-privacy-stack-part-2-introducing-raven</link>
            <guid>ruq7ZGzzi9LrWFAfvX4r</guid>
            <pubDate>Mon, 15 Jun 2026 12:01:39 GMT</pubDate>
            <description><![CDATA[The Nox post covered the network layer of off-chain privacy: hiding who you are when you talk to a blockchain. This one is about the other half of that gap, the part that survives even when your IP is perfectly hidden. Routing every request through a network like Tor or a mixnet hides where the connection came from. It does not hide the contents of the request. The RPC provider still sees the query itself: which records were asked for, which lookups were run. The IP is gone, but the question ...]]></description>
            <content:encoded><![CDATA[<p>The <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://hisoka.io/blog/introducing-nox/"><u>Nox post</u></a> covered the network layer of off-chain privacy: hiding who you are when you talk to a blockchain. This one is about the other half of that gap, the part that survives even when your IP is perfectly hidden.</p><p>Routing every request through a network like Tor or a mixnet hides where the connection came from. It does not hide the contents of the request. The RPC provider still sees the query itself: which records were asked for, which lookups were run. The IP is gone, but the question is still in plain view, and the question is often enough to figure out who asked it.</p><figure float="none" data-type="figure" class="img-center"><img src="https://storage.googleapis.com/papyrus_images/c6c6bd0925c8f660434756e105798fa00084f9146214313af87845cfed0e9dd3.svg" alt="RPC provider sees the contents of the query" blurdataurl="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAALCAIAAACRcxhWAAAACXBIWXMAAAsTAAALEwEAmpwYAAABVklEQVR4nGP48/3jj6/vyEZvXz559ujOs0d3Pr57cfXC6RtXz9+/ffXC2eNvXz6+cPbYn+8fGf79/vL/9zcaoX+/v9DLgn27t25atwIT7du9Fb8R+DUiLNi0bsWzR3cOHdj59uUTZP2b1q2As29evXDz6oWjB3ffv331w7vnp08dun7tzMpl848e2nvowM6P715gakSxQEJMUJCPg4GBAVnpJiQLsKJN61ZwsTEwMDD4eLpqaagoyEkJ8nFMnzIBiwWXzp26cuHUs0d3Lp07AQ+ZGZO6Lx7fhwc1lOYfOrDz0rlTa1cuPnRg542r53H6ABf6D9bw9N61JVN7b106tX7hjOXTJ756chciWJGbunjuDJDKtcs3rVuxevkiZI10TEX/saHVyxeFhwSkpyT4eLrWVJX6eLpWlRempyTUVJVWlRdGR4RABFcvX4TPAgpzMn705/tHAE3QjZJd7cpkAAAAAElFTkSuQmCC" nextheight="240" nextwidth="680" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><h3 id="h-what-a-wallet-actually-asks-for" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">What a wallet actually asks for</h3><p>To see why hiding the IP isn't enough, look at the reads a shielded wallet has to do. They aren't bulk scans of public state. They're targeted lookups, each one keyed by something private:</p><ul><li><p><strong>Checking a balance.</strong> For every shielded note the wallet owns, it asks the server about that specific commitment. Is this note still unspent? Which block did it appear in? Which compliance list is it on right now?</p></li><li><p><strong>Building a spend.</strong> The wallet fetches the Merkle siblings for the exact leaf it intends to spend. One request, one leaf index.</p></li><li><p><strong>Compliance check.</strong> Before transacting, the wallet asks whether a given commitment is in good standing on each compliance list it cares about. The request carries the commitment hash itself.</p></li></ul><p>This is the leak every shielded protocol inherits. Railgun, Privacy Pools, Tornado, Semaphore, Zcash. The cryptography hides what's in the proof. It doesn't hide the reads that built it.</p><p>This isn't a flaw in the cryptography. It's a gap in the infrastructure that undermines the privacy model the cryptography was built for.</p><p>Raven closes that gap on the query layer.</p><p>Raven is a PIR framework for off-chain reads, built so a wallet can fetch state from a chain without the server ever learning what state was fetched. The wallet sends an encrypted query. The Raven node answers without decrypting it. The wallet recovers the record locally. Same proofs, same wallet, same chain. The read that builds the proof is now blind.</p><p>The framework is built around the sidecar design proposed for <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://ethresear.ch/t/sharded-pir-design-for-the-ethereum-state/24552"><u>Ethereum state PIR</u></a>: a heavyweight engine over a stable snapshot of the database, paired with a small auxiliary engine that absorbs what the chain has changed in the last few blocks. iSimplePIR drives the main engine. InsPIRe is the scheme matched to the sidecar slot. The first deployment is built for Railgun, walked through in a <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://hisoka.io/blog/raven-railgun/"><u>follow-up post</u></a>.</p><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/hisoka-io/raven"><u>Open source</u></a>. Built for the Railgun wallet on Ethereum mainnet to fetch private reads. <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://demo.railgun.hisoka.io/"><u>Try the demo</u></a>.</p><p>How Raven works comes down to two parts. The cryptographic primitive that lets the server answer a query it can't read, and the engineering that keeps the database in sync with the chain so those queries return fresh data. Start with the primitive.</p><h2 id="h-private-information-retrieval" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Private Information Retrieval</h2><p>The goal of PIR is plain: fetch a record from a database without the server learning which record you asked for.</p><p>The naive version is to download the entire database and look up locally. Perfect privacy, terrible scaling. A million records means a million records on the wire every time.</p><p>Real PIR schemes do better. The client sends an encrypted query. The server runs computation over the database without ever decrypting which row is the target. The client decrypts the response and gets back exactly the record it wanted. The server's view of "what was asked" is mathematically blind.</p><h3 id="h-single-server-only" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Single-server only</h3><p>Multi-server PIR is faster, but it requires two or more servers that don't talk to each other. In practice, that assumption doesn't hold. Two providers in the same data center, the same cloud, or under the same legal jurisdiction can quietly collude. Single-server PIR removes the assumption entirely. That's where Raven lives.</p><h3 id="h-the-landscape" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">The landscape</h3><p>Several single-server PIR schemes have come out in the last few years. InsPIRe, HintlessPIR, YPIR, Plinko, SimplePIR, ChalametPIR. Each makes a different bet about where to spend cost. Some assume the database is static and trade fast queries for slow rebuilds. Some give up a stateless client for sublinear queries. Some keep bandwidth small and pay in server compute. The Ethereum Foundation maintains a <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://privreads.ethereum.foundation/docs/pir-benchmarks/"><u>public benchmark page</u></a> comparing them on real workloads, including blockchain reads.</p><p>Studying them surfaces the same conclusion. No single scheme is general-purpose. Each one wins on a few properties and gives up on others. There is a structural reason for that.</p><h3 id="h-the-pir-trilemma" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">The PIR trilemma</h3><figure float="none" data-type="figure" class="img-center"><img src="https://storage.googleapis.com/papyrus_images/3b3da6cb010aeead3315c3de4f28686310cf772bd47a0838717ccd7d3ff42c92.svg" alt="PIR Trilemma" blurdataurl="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAARCAIAAAAzPjmrAAAACXBIWXMAAAsTAAALEwEAmpwYAAABoElEQVR4nLWVTUsCQRjHBzztQcQvUCCChz2siOA9MATPXaICC6X6Ah0K6tCn6NKhY516IUIWYhFXRC1EQ9bc3WB3ZXddHDEGlgRDh2Qr1qa04c8wL8/z/8HMwwywUW/49jq7TE2WmnVTk01NFuoP1QpfKnCi8ARsBIcDNF0eAIKBBb+PijD02upKhKHx1BljI9jttPvQsBHEYzwlAgwHyDKUPJd9LOctQ9FVyTIUkiwbQVLAcCyeY3mOJY//NaAl1FpC7b8AfWiIQl0U6n1ozB9gI4jdsciziAA2gookOAGKJBAmEgGUD/dyIVcp8RPGfAC6KmHH7XQqndrYzWwdHx3gFV2VZgV0TXVyLMlEPBhYBAAkE/HJYtdU/w74crGii6YU1TQAobs4tahcATeXF2enJ7oqEeru6ryYY4kAlqHwHFutFPGb0+20fyyB7PXIXVclVW6YmuwKuGdvvZQHjBtDh2LRcGJ5ye+jYtFws1H9br2T2WToEADAS3kiDJ1OrQcDCwAAv4863N9zAlz/A01ujvqXZ9eAz1s43ikb9d4BWUO9udhDVncAAAAASUVORK5CYII=" nextheight="360" nextwidth="680" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><p>Single-server PIR sits inside a known tradeoff between three properties:</p><ol><li><p><strong>Stateless client.</strong> No large hints to download, no local state to keep in sync.</p></li><li><p><strong>Sublinear query.</strong> The server doesn't have to touch every record every time. Communication shrinks well below the database size.</p></li><li><p><strong>Dynamic updates.</strong> Adding or modifying records doesn't force a full rebuild.</p></li></ol><p>No known scheme gives all three. Pick two and you can have them. Pick the third and one of the others has to bend.</p><p>This is the open problem in PIR research. Stateless <em>and</em> sublinear <em>and</em> dynamic, all at once, is still out of reach.</p><h3 id="h-what-we-needed" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">What we needed</h3><figure float="none" data-type="figure" class="img-center"><img src="https://storage.googleapis.com/papyrus_images/0f9080a8045c3632804e9f867425fc2d0142d40a91a8c9c48b592d84d495d057.svg" alt="PIR requirements" blurdataurl="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAUCAIAAABj86gYAAAACXBIWXMAAAsTAAALEwEAmpwYAAACh0lEQVR4nK2VT2jTUBzHI548eBHPXuxhDhRFQfDgQSgMehBPO60Mi9SBh1EZtSC4g6NjUrZJg8X+w6brtpQwWqKsc3ZtGbzSkvVJocFCWglrSiXNDsHAKARZHz5i1bW2hh/h/fLyfp/3vr9ffiE6x6qmtke0VqOuqW1FlkSBP7HalxMT+CO5SWhqW+98H9EUWVJkCTG+SV+bhzV0V2RpUADkgCJLOBzkwCCrNLXdByAKPOQACicKfHwjwtBr1cpnhIQcEAW+P4BNxGORwO52MhYJoIHdZn2fYBiaMq5Hh+jZfrUCn8w8cr988fzZ01gkADkQ9pNhP/kLAHLAOTc78/ihy+kI+0mX02G3WaenJtepkPEorUYdjVuNuhGc3IrbbVb3wrzL6fB5V1Y9i+6FeaTnaRKVSwWsuG5wjbM4Kz2zA+UAh4BdrRl6rVwqJLdoNhHHLuQAWj4MAHKg1ahjuSEHQG6PjoaokA/k9nBE9NqQgCLIGoSmqSCZ+ciyzDoVJD+lWDxVBNlhANl0qlqB2B0fM50hiFs3ro6PmYjuZSykbDo1TA7Q8fWfrnd56SCfOchnvMtLeMtIxiElwhi962pqe4MKbUbDOKs49PAAvVtI5VJhnQqVSwX0oZVLBVRFI5VptQKxPrqB97uLOug/ADS1zeVziiwxNGV8iIMWQda4CnUUUeDxgf4AiEUClgnzg/uW69eunDtL3Ll98+KF86uexf3MjrFD7Gd2ep4UQdbldBAEYZkwowKbnpo0Xb5kvnfXOTfbv5vqXQVQqsulArZBWmn/di0K/GY0HIsEGJp64/WE/eTudjKT/uB9/YpNxN8FfWwi/pZcaR7WTgP8l1/m36xzrP4AG6WUGu6x2+UAAAAASUVORK5CYII=" nextheight="420" nextwidth="680" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><p>For a blockchain workload, the requirements are unforgiving.</p><p><strong>Blockchain state is dynamic.</strong> New commitments arrive every block. The PIR layer has to answer queries against state that's at most a few seconds old.</p><p><strong>Clients are constrained.</strong> Wallets run in browsers and on phones, not workstations. They can't carry gigabytes of preprocessing hints or keep a hint cache in sync while the database changes underneath. Statelessness is the only shape that fits.</p><p><strong>Setup has to be cheap.</strong> The rebuild interval bounds query freshness. A two-hour setup means a two-hour stale window, no matter how fast each query is.</p><p><strong>Latency has to feel like an RPC call.</strong> A typical Infura request finishes in 50 to 200 milliseconds. PIR has to sit in the same neighborhood or the wallet feels broken.</p><p>Most PIR schemes optimize for one or two of these. None optimize for all four. The remaining properties don't all have to come from the cryptography. Some can be supplied at the infrastructure layer instead. That is the bet Raven makes.</p><hr><h2 id="h-raven" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Raven</h2><p>Raven is a general-purpose single-server PIR framework. It's scheme-agnostic by design: today it ships with iSimplePIR and InsPIRe behind one API, and any scheme that fits the trait can plug in. The same engine drives query privacy for two very different shapes of data:</p><ul><li><p><strong>Key-value stores.</strong> Any append-mostly or static keyed dataset where clients want to fetch one value without revealing the key.</p></li><li><p><strong>Merkle trees.</strong> Blockchain commitment trees where clients fetch sibling paths or membership status without revealing which leaf is theirs.</p></li></ul><p>The framework handles the shared infrastructure once: indexing live chain state, sharding the encoded database, swapping fresh state in atomically, sticky sessions across rebuilds, and a wasm-friendly client. You bring the data model. Raven turns it into something the PIR server can serve queries against.</p><h3 id="h-the-sidecar-approach" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">The sidecar approach</h3><p>The hardest property to recover from the trilemma is dynamic updates. The PIR schemes that give us sublinear queries and stateless clients assume the database is fixed. New commitments break that assumption every twelve seconds.</p><p>The architecture Raven adopts comes from the <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://ethresear.ch/t/sharded-pir-design-for-the-ethereum-state/24552"><u>Sharded PIR design for Ethereum state</u></a> proposed on <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://ethresear.ch">ethresear.ch</a>. Credit for the pattern belongs there. Instead of rebuilding the whole database on every update, two engines run side by side, each tuned for a different update profile.</p><p>The <strong>main engine</strong> serves queries against a stable snapshot of the database. iSimplePIR drives this half: sublinear queries against preprocessed state, paid for by a heavy server-side build. As long as the snapshot doesn't move, the preprocessing carries forward and queries stay fast.</p><p>The <strong>sidecar engine</strong> handles only the entries that have changed since the snapshot. InsPIRe is the scheme matched to this slot: minimal server-side preprocessing, and a database small enough (a few thousand recent commitments instead of millions) that per-update cost is negligible. Rebuilding it for the latest block takes milliseconds.</p><p>The client queries both engines for the same record. If the record was changed since the snapshot, the sidecar returns the current value. Otherwise the main engine returns the snapshot value. Either way the server learns nothing about which record was asked for.</p><p>Every few thousand blocks, the sidecar's accumulated entries get folded into the main engine, the snapshot advances, and the sidecar resets to empty. Folding is where the blue-green pattern earns its keep.</p><h3 id="h-blue-green-rebuilds" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Blue-green rebuilds</h3><p>Folding the sidecar into the main engine means re-preprocessing the main engine at a new snapshot. That's the expensive step. Doing it inline would take the main engine offline for as long as the rebuild takes, which is unacceptable for a service that wants to keep answering queries.</p><p>Raven runs the rebuild on a parallel copy of the engine instead. The live copy keeps serving queries against the old snapshot. The other copy preprocesses the new snapshot in the background. When the rebuild is ready, the orchestrator atomically swaps in the new state. In-flight queries on the old state finish on their own copy; new queries route to the new state immediately. No restart, no downtime, no torn reads.</p><figure float="none" data-type="figure" class="img-center"><img src="https://storage.googleapis.com/papyrus_images/5831df5dfdf8eaea7e2f91a65f79191d6893aa01a15702f3b7f9f45fb74cc424.svg" alt="Blue-green rebuild pattern" blurdataurl="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAPCAIAAAAK4lpAAAAACXBIWXMAAAsTAAALEwEAmpwYAAABvElEQVR4nGP49/vL9y/vKEFvXjy+e/Pykwe3IOjU0QN3b14+f/rYtUtnnj28zfD9y/t/v79SjL4gMRDs71/eIyx4+uTR1i2bCaJrVy8SbzHIgjcvnly6eO7xg7t7du/MyStIyciqbWhYuWo5BC1evAjOhqPHD+5OmjRx4YL527ZsQTLrHXYL4D7Ys3unnb2dlJQkNw+HrJyssIiQsIgQEzNjZmYGmgVPHtwqLsyJjQpraqgpzM2Y0NsRGxWWmhg7obcDnwUvn90/cGAvQdTd2ojVsTiDCDmSHz+6dfvWhdu3Ljx+dB2PtvKq3JzC5JzC5CnTOrGiA/u2ISx4cPfqlcunbt+68O/316aGmrbWeh9P197utoa6yuLCnAA/r6z0pKWL5iBbEBUbxMvPCEEmpjoMDAxi4nx6BuobNy+HoCNHdmL3AZFo1Zr5a9ctxoPu3L5EkQX/SEqmpFrw/u1TItXcvXkFxYI3Lx4jZULs6NnD26+fP1w+fxqehHTv5sXTR/deOnNkcATR0UO7d25bv3XD6qWL5ixdNGfNisXrVy3duW39vt1bFs6ZNmfW5BNH9hOwgPLSFA/69/sLAFyS01WOO/SYAAAAAElFTkSuQmCC" nextheight="320" nextwidth="680" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><p>The rebuild stays cheap for two reasons. Only the shards that actually changed get re-encoded. Everything else carries forward from the previous build untouched. And most of the server's preprocessing survives the rebuild, because it depends on the shape of the database rather than its contents, and the shape rarely changes.</p><p>For the workloads Raven serves (shielded balance checks, membership lookups, path retrievals), queries hit data within a few seconds of chain head. Every response also carries a freshness signal, so a client that detects unusually stale data can fall back to a non-PIR provider for that one call.</p><hr><h2 id="h-turning-a-data-model-into-a-pir-table" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Turning a data model into a PIR table</h2><p>A PIR server doesn't see Merkle trees, lists, or key-value maps. It sees one thing: a flat array of fixed-width rows, sharded into chunks, indexed by row number. Anything you want to query privately has to be converted into that shape first.</p><p>PIR is also index-based. The protocol only knows how to fetch row N. Applications never query that way. They ask for the value at a key, the membership status of a commitment, the sibling path for a leaf. The bridge between "I have a key" and "give me row N" is where the data model lives, and Raven exposes it as an <strong>encoder</strong>.</p><p>An encoder is a pure function: given a logical store (a tree, a list, a map) and a shard id, it materializes the bytes for that shard. It also fixes how a logical query maps to a row index, so the client computes the index locally and issues a private read for it. Different encoders express different query shapes over the same underlying data.</p><p>For a key-value store, the encoder uses a <strong>binary fuse filter</strong> or <strong>cuckoo hashing</strong> to assign every key a deterministic row. The mapping is public and shared with the client. The client hashes its key, computes the row, and issues one PIR query for that index. The server only ever sees a private query for an opaque row number.</p><h3 id="h-pir-for-merkle-trees" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">PIR for Merkle trees</h3><p>A Merkle proof of membership needs one sibling hash per level of the tree: the sibling of the leaf, then the sibling of the parent, then the sibling of the grandparent, all the way up to the root. The wallet has to fetch all of them without telling the server which leaf they're for. That is harder than a plain private record lookup, because the <em>path</em>, not just the leaf, has to stay hidden.</p><p>The naive version is to ask the server for "the proof attached to this leaf." Perfect for the wallet, awful for privacy: the shape of the question leaks the answer.</p><p>The real version flattens the tree into a plain PIR database and lets the wallet assemble the proof on its own side.</p><p><strong>The Railgun tree.</strong> Railgun keeps shielded commitments in an append-only Merkle tree of depth 16. So every membership proof is exactly 16 sibling hashes long, one per level. New commitments are written left to right as leaves and never moved; the hashes along their paths to the root are computed at insert time. The tree holds up to <code>216 = 65,536</code> commitments, and a new tree opens when it fills. Every position <code>(level, position)</code> is well-defined and stable.</p><figure float="none" data-type="figure" class="img-center"><img src="https://storage.googleapis.com/papyrus_images/c3203cf029fbdfe0a2cbfce8be380ae3bd26f994626f4dca6cdbae08e7548859.svg" alt="Merkle proof path: wallet's leaf and the sibling hashes the wallet must fetch, one per tree level" blurdataurl="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAQCAIAAAD4YuoOAAAACXBIWXMAAAsTAAALEwEAmpwYAAACEUlEQVR4nGP4/f3jm5ePKUH3bl89dmjPji3rr148M3Na/7FDe2ZNn7hu1eJFc2fcvXWZ4c3Lx7+/f6QE/fr2/t7tq29ePv717f3Vi2euXjwDYb95+fj1i0dUsOA3bvTm5WOQBccO7bl68cy921dXLV947/ZVPKrv3rpMjgUE1S2eN72zpS48yItMH+CS3rV1bXiQV2dL3ZULpygKopaGmgVzpl29eAZZrjg3fcOqxcSYEhUbHxAaQbIPThzZW1teSND0t6+ezpo+dd3aFffvXCdsAZonnj24raogeerofvLCB2FBfU3ZvNlTc3Nz1bX1MRVt3bSS0jiAcEJCQi6dP33yxBFMdbkZ8VSwABMdPXrw2tULv79/vHLhFAMDA/kWHDu058Wze5AiZe+OzfDYi4iO6Z/Q9/v7R1CRwsBAZKIi1gdXL545fGD39i2bfn//eOzQng2rFpOajVEsYGBgCPTzZGVmiI0KjY0KhUhvXL+uu7NdR0stMy3R2sJEVJjX2sLE2sJk7qwpEGUMDAya6srN9VUTeztyM5PXrVqcmZZYVpQ7d9aUxNjIubOm7NiyHhSyb14+7myp27N944Se9lXLF27ZtAZSDp84cgDCndDTvmXTmrmzpsydNWVCT/vOrRtWLV84oae9paFmSn/nsUN7jh3ac+XCqQtnj69btXje7KnHDu1Zt2rxsUN7Xr94BAAmcS1vL3qZFAAAAABJRU5ErkJggg==" nextheight="340" nextwidth="680" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><p><strong>Layout.</strong> Raven uses what it calls the <strong>per-node</strong> encoder. Each tree node becomes one 32-byte row in a single flat array, with the rows arranged level by level. Leaves first at rows <code>[0, 216)</code>. Level-1 hashes follow at <code>[216, 216 + 215)</code>. Each subsequent level follows the previous, halving in size each time, up to a single root at the last row. Total: <code>217 - 1 = 131,071</code> rows. The mapping from <code>(level, position)</code> to row index is a closed-form formula known to both server and wallet.</p><figure float="none" data-type="figure" class="img-center"><img src="https://storage.googleapis.com/papyrus_images/f9a00322a5491a755391adbb2c6a4840e7abbf3463c328931850d266156a7a44.svg" alt="PIR database layout: tree nodes packed into a 2D matrix of records, with one target row and four sibling rows highlighted, indistinguishable to the server from any other row" blurdataurl="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAXCAIAAADlZ9q2AAAACXBIWXMAAAsTAAALEwEAmpwYAAACtUlEQVR4nLWWTWgTQRTHB8FbEHoRW/BQEayXBvHWW/Qg5FKh4EnxUm9evKg3L17tpVIoCyVQ24IVDLQLCSGYQCWJEgloRYk1S9Jd9ys7+5GdHXfIruyOjUtaS5O24U/YmbzkN++9/8su8AjyiH0cOVbb0kSCTUMTLU00NBEqgosgVASCLeATRLCJbUjfXWS4CHrE9rvOIEIHLZFPUADgm/Wf9W2Jb8gCJ7Z2drl6CDdptKFJA8IiooAsm15iFrJsmll8ucQsrK2k1lZSuczGm9evllPMErNwXEB0y7HaftfxiO0iSJdeWC6kK37XIdh0keF3HUsThwRE9Xz+aWwCxCbAlRujsQlw+8HN/TEugh1NQLqIdNH7bR0GMMJD0ZOG3zQePrsPxgA4A85eAuAiuJa8HM2MhnnE7mgCtlRsqfSjATJYXH4xmRyfTI7fujc1mRyffXKnWGaLZbatNnsx2NYEoS4IO7YpuQj2M6IAapueQekF2fMSwWa28BacA2AEpNbnaSfo/p73+Y4u9+L/C+gdoW+JbRgALgBwPgB0dPkEmtwnWWowq3PM6hzHbQ9jU9o3XeFpfagRLU2k1YDhvosMenYa5ncdTd51rHatWj6BDPyDBBW+Vi39+Pb5V2vnqACu9RWMBM2cuj4Gwpeh/LNNnwg2ocKrYpOmeBiA5i4LXIP7AsYC78evjoyGAE1qqmKLlpFWUha44ZvcVpvTs4np2cTjR3dnEvGZRLw3VgMrCsA27OURzGd40dFlOhC05y4yKAwqwsAA+kORP7vAPNj+e2+gS4LNvvkYpkQnKbKvyRLfOC2Af9oZ+KEMTdoq5Ar5TKVUrJSKWTatis1cZqPy/l0+x36qlmrV8vftWiGfyefYjx+2smy6Uirmc2ylVNxMr/dPA0HgkKcKejs7+rPFQfvoD/V06roGWd56AAAAAElFTkSuQmCC" nextheight="490" nextwidth="680" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><p>The tree's structure lives entirely on the wallet now. The server stores a 2D matrix of records and nothing else.</p><p><strong>The walk.</strong> To build a proof for leaf <code>L</code>, the wallet walks up the tree locally. At each level it XORs the current position with 1 to pick the sibling, computes the row index for <code>(level, sibling_position)</code>, and shifts right to climb. After 16 iterations, one per level of the depth-16 tree, it has 16 row indices.</p><p>It issues 16 parallel PIR queries against the same flat array, one query per row index. Each query is encrypted; the server runs PIR computation against the full 131k-row database and returns an encrypted response. The wallet decrypts the 16 responses, assembles them into the sibling path, and feeds the path into the spend proof.</p><p><strong>What the server learns.</strong> 16 opaque index reads against a 131k-row table. Nothing on the wire identifies the reads as a path, correlates them to a leaf, or recovers the tree's structure. The structure lives entirely on the client.</p><p>This is the read pattern every time a Railgun wallet builds a spend, walked through in <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://hisoka.io/blog/raven-railgun/"><u>Raven for Railgun</u></a>.</p><p>The per-node layout described above is one of three useful encoders for a commitment tree. The three make different bets on row size versus query count.</p><table><colgroup><col><col><col><col></colgroup><tbody><tr><th colspan="1" rowspan="1"><p><strong>Encoder</strong></p></th><th colspan="1" rowspan="1"><p><strong>Row at index </strong><code>i</code></p></th><th colspan="1" rowspan="1"><p><strong>Row size</strong></p></th><th colspan="1" rowspan="1"><p><strong>Used for</strong></p></th></tr><tr><td colspan="1" rowspan="1"><p><strong>per-leaf</strong></p></td><td colspan="1" rowspan="1"><p>Raw 32-byte commitment at leaf <code>i</code></p></td><td colspan="1" rowspan="1"><p>32 B</p></td><td colspan="1" rowspan="1"><p>"Is my commitment in the tree?"</p></td></tr><tr><td colspan="1" rowspan="1"><p><strong>per-path</strong></p></td><td colspan="1" rowspan="1"><p>16 sibling hashes along the path from leaf <code>i</code> to root</p></td><td colspan="1" rowspan="1"><p>512 B</p></td><td colspan="1" rowspan="1"><p>"Give me the proof I need for ZK."</p></td></tr><tr><td colspan="1" rowspan="1"><p><strong>per-node</strong></p></td><td colspan="1" rowspan="1"><p>One 32-byte internal node at flat index <code>i</code></p></td><td colspan="1" rowspan="1"><p>32 B</p></td><td colspan="1" rowspan="1"><p>Custom traversals, partial proofs.</p></td></tr></tbody></table><p>Same tree. Three layouts. The per-node encoder is what the Railgun deployment uses: 16 queries, a thin row, a small simple database. The per-path encoder gives the whole sibling vector in one round-trip but pays for it with a much wider row. The framework lets the operator pick the right tradeoff for the workload, and the encoder is the only thing that has to change.</p><p>Every encoder also declares a fixed <code>record_size</code> and <code>entries_per_shard</code>, which gives the framework a deterministic mapping from logical entry to physical shard and offset. That mapping is what makes incremental updates cheap. When an entry changes, the encoder reports the bounded set of shards it touches and the sidecar re-encodes only those. The same abstraction carries beyond trees and maps: any data model that can be flattened to fixed-width rows fits, with the same orchestrator, the same sidecar pattern, and the same client surface. The encoder is the only thing that changes.</p><hr><h2 id="h-whats-next" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What's next</h2><p>The first deployment is built for the Railgun wallet stack. The two specific query-side leaks in a Railgun client, and how Raven plugs in with a one-line swap, are walked through in <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://hisoka.io/blog/raven-railgun/"><u>Raven for Railgun</u></a>.</p><p>The same engine, with a different encoder, is what we'll point at the next workload: other shielded pools, identity sets, anything that's a tree or a keyed map sitting behind a public endpoint.</p><p>Combine Raven with Nox and you have both halves of the off-chain privacy stack: who you are, and what you're asking for, hidden together. The cryptography on-chain finally has infrastructure that matches it.</p>]]></content:encoded>
            <author>hisoka-labs@newsletter.paragraph.com (The Privacy Fellows)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/5836e9b38a270ed10d213f25e0def575ab0ad786eac75134c472d83b04575f5b.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Raven for Railgun]]></title>
            <link>https://paragraph.com/@Hisoka-Labs/raven-for-railgun</link>
            <guid>6aPKYXHqJ50H1FkRyogU</guid>
            <pubDate>Mon, 15 Jun 2026 11:58:17 GMT</pubDate>
            <description><![CDATA[Introducing Raven: a general-purpose private information retrieval (PIR) engine for Ethereum and web3.

Open source. Live mainnet demo @RAILGUN_PROJECT
More about Raven : https://hisoka.io/blog/introducing-raven/
]]></description>
            <content:encoded><![CDATA[<p>Raven is our private information retrieval framework for off-chain reads: a wallet fetches state from a server without the server ever learning which record it asked for. This post is about the first deployment, built for the Railgun wallet stack.</p><p>Railgun is one of the strongest shielded-transfer protocols on EVM. The on-chain anonymity story is already solved by ZK proofs and commitment Merkle trees. What still leaks is the query side. Before a wallet can build any proof, it has to read state from the chain and from the Proof of Innocence service, and those reads are keyed by the exact commitments the user owns. Whoever serves the reads sees every one of them.</p><h2 id="h-tldr" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">TL;DR</h2><ul><li><p>Two query-side leaks fingerprint a Railgun user today: full Merkle-tree sync, and POI-list fetching. Both survive the on-chain cryptography intact. The proofs are private. The lookups that feed them are not.</p></li><li><p>Raven sits where the RPC and POI node sit in the wallet's data path. Every query is encrypted before it leaves the client. The operator computes over the dataset without decrypting the request and never learns which entry was fetched.</p></li><li><p>Three wallet calls flip from cleartext to PIR through a drop-in interface implementation. The wallet, the proofs, and the Railgun protocol do not change.</p></li><li><p>Adoption is per wallet and reversible. No contract upgrade, no circuit recompile, no re-audit of the proving path.</p></li><li><p>Live against Ethereum mainnet: <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://demo.railgun.hisoka.io"><u>demo.railgun.hisoka.io</u></a>.</p></li></ul><h2 id="h-two-query-side-leaks-in-a-railgun-client" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Two query-side leaks in a Railgun client</h2><p>A Railgun client today has two query-side leaks that map directly onto a user's identity. Three wallet calls carry them, and all three are evidenced in the upstream code below.</p><h3 id="h-1-merkle-tree-sync" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">1. Merkle tree sync</h3><p>The Railgun contract holds multiple Merkle trees, each <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Privacy/contract/blob/9ec09123eb140fdaaf3a5ff1f29d634c353630cd/contracts/logic/Commitments.sol#L30"><u>fixed at depth 16</u></a>, so up to <code>216</code> (<a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Community/engine/blob/2550cd653d706a3897a9d905fe906f58a4e87a22/src/models/merkletree-types.ts#L8"><u>65,536</u></a>) leaves. A membership proof at depth 16 is exactly 16 sibling hashes, 32 bytes each, a 512-byte path. To produce it the wallet <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Community/engine/blob/2550cd653d706a3897a9d905fe906f58a4e87a22/src/merkletree/merkletree.ts#L489-L541"><u>rebuilds and persists every node of every tree locally</u></a> and then <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Community/engine/blob/2550cd653d706a3897a9d905fe906f58a4e87a22/src/merkletree/merkletree.ts#L128-L160"><u>reads the path back out</u></a>. Fetching only the leaf the user actually needs would tell the provider which leaf the user cares about, so the wallet is forced into the heavy path.</p><p>The heavy path is not abstract, and it is far bigger than the tree alone. A filled depth-16 tree is <code>217-1</code> = 131,071 node hashes, exactly 4 MiB of raw hash values. But the engine persists much more than the hashes: it stores the full data record of every commitment in the protocol, shield and transact ciphertext alike at roughly a kilobyte each, a second depth-16 transaction-id tree of the same shape, and every nullifier ever emitted, each under a padded key string that itself dwarfs the value. Real local state runs well over a hundred mebibytes per filled tree, and several hundred at mainnet's current trees. None of it is the user's own notes. A wallet that owns three notes still stores the entire protocol history.</p><p>It scales with the protocol, not the user, and it only grows: there is no pruning, no eviction, and no light or only-my-notes mode. At the throughput Railgun is targeting, on the order of ten thousand commitments a day, a 65,536-leaf tree fills in under a week, roughly 3.6 million new commitments a year, every one of them stored by every client forever. Railgun already optimizes the cold start with a hosted quick-sync indexer, and it is a real speedup, but it is a bandwidth shortcut, not a storage one: it streams the full ciphertext history from one endpoint, then the client still rebuilds and stores the whole tree locally and still trial-decrypts every commitment with its viewing key. This works for a desktop wallet. It is the structural reason a fully private Railgun client has not reached the browser and the edge devices where most users live.</p><h3 id="h-2-poi-list-fetching" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">2. POI list fetching</h3><p>When the wallet checks Private Proof of Innocence (POI) status it <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Community/wallet/blob/99c9a344c105eb44e6d4f0d1657d1a65254c52cb/src/services/poi/wallet-poi-node-interface.ts#L140-L189"><u>sends its own list of commitments</u></a> to the <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Community/private-proof-of-innocence/blob/4b1eaf6ef19099dbfd6b43b1ca78d2ce0132a752/packages/node/src/api/api.ts#L714"><u>POI node</u></a>, in <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Community/wallet/blob/99c9a344c105eb44e6d4f0d1657d1a65254c52cb/src/services/poi/wallet-poi-node-interface.ts#L32"><u>batches of twenty</u></a> from one connection. The operator now sees the full set of commitments that belong to one user. Across refreshes the set overlaps, so the cluster is stable even if the IP changes. The list provider already <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Community/private-proof-of-innocence/blob/4b1eaf6ef19099dbfd6b43b1ca78d2ce0132a752/packages/node/src/list-provider/list-provider.ts#L424-L456"><u>scans every shield</u></a> and <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Community/private-proof-of-innocence/blob/4b1eaf6ef19099dbfd6b43b1ca78d2ce0132a752/packages/node/src/list-provider/list-provider.ts#L479"><u>reads the depositor address</u></a>, so one shielded note in the cluster binds the rest to a real wallet.</p><p>It gets sharper at spend time. To build a spend the wallet asks the same node for the <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Community/wallet/blob/99c9a344c105eb44e6d4f0d1657d1a65254c52cb/src/services/poi/wallet-poi-node-interface.ts#L191-L203"><u>Merkle paths of exactly the inputs it is about to spend</u></a>, before the transaction exists anywhere else, and the request is <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Community/private-proof-of-innocence/blob/4b1eaf6ef19099dbfd6b43b1ca78d2ce0132a752/packages/node/src/config/query-limits.ts#L3"><u>capped at thirteen</u></a>, so larger spends split into correlatable calls. This is the most direct fingerprint of a Railgun user in the stack today. The operator only needs to know whether a commitment is innocent, a fact identical for every caller. It never needs the set, and it never needs to know who asked. PIR gives it exactly that and nothing more.</p><p>Both leaks survive the on-chain cryptography intact. The proofs are private. The lookups that feed them are not.</p><h2 id="h-how-raven-plugs-in" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">How Raven plugs in</h2><p>The wallet already isolates these calls behind one pluggable boundary: the engine consumes an <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Community/engine/blob/2550cd653d706a3897a9d905fe906f58a4e87a22/src/poi/poi-node-interface.ts#L11-L28"><u>abstract </u></a><code>POINodeInterface</code> that it never constructs itself, and the wallet <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Community/wallet/blob/99c9a344c105eb44e6d4f0d1657d1a65254c52cb/src/services/railgun/core/init.ts#L176-L177"><u>hands the concrete one in once at engine start</u></a>. Raven ships a drop-in implementation of that interface. Swapping the upstream POI client for a Raven-backed one is the one line at that injection point:</p><pre data-type="codeBlock" text="// startRailgunEngine, in place of the default WalletPOINodeInterface
const poiNodeInterface = new RavenPOINodeInterface({
  endpoint: &quot;https://raven.example.com&quot;,
  bearerToken: process.env.RAVEN_BEARER_TOKEN,
});
WalletPOI.init(poiNodeInterface, customPOILists ?? []);"><code><span class="hljs-comment">// startRailgunEngine, in place of the default WalletPOINodeInterface</span>
const poiNodeInterface <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> RavenPOINodeInterface({
  endpoint: <span class="hljs-string">"https://raven.example.com"</span>,
  bearerToken: process.env.RAVEN_BEARER_TOKEN,
});
WalletPOI.init(poiNodeInterface, customPOILists ?? []);</code></pre><p>Three calls flip from cleartext queries to PIR:</p><table><colgroup><col><col><col></colgroup><tbody><tr><th colspan="1" rowspan="1"><p><strong>Wallet call</strong></p></th><th colspan="1" rowspan="1"><p><strong>What it fetches</strong></p></th><th colspan="1" rowspan="1"><p><strong>Encoder</strong></p></th></tr><tr><td colspan="1" rowspan="1"><p><code>getPOIsPerList</code></p></td><td colspan="1" rowspan="1"><p>POI status for a UTXO under each list</p></td><td colspan="1" rowspan="1"><p>per-list-status</p></td></tr><tr><td colspan="1" rowspan="1"><p><code>getPOIMerkleProofs</code></p></td><td colspan="1" rowspan="1"><p>POI authentication path</p></td><td colspan="1" rowspan="1"><p>per-list-path</p></td></tr><tr><td colspan="1" rowspan="1"><p><code>getMerkleProof</code></p></td><td colspan="1" rowspan="1"><p>Commitment-tree authentication path</p></td><td colspan="1" rowspan="1"><p>per-leaf-path</p></td></tr></tbody></table><p>Two of those calls, POI status and POI Merkle proofs, flip through the interface above with nothing else touched. The commitment-tree path has no upstream RPC by design, so Raven routes it with one small hook at the wallet's local read site. Both are wallet-layer only; neither reaches the engine, the contracts, or the circuits.</p><p>The trust model does not move. Raven transports the path; the wallet verifies the returned siblings against the on-chain Merkle root, the same check it runs today, and still <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Community/engine/blob/2550cd653d706a3897a9d905fe906f58a4e87a22/src/poi/poi.ts#L50-L93"><u>buckets notes</u></a> and <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Community/engine/blob/2550cd653d706a3897a9d905fe906f58a4e87a22/src/transaction/transaction-batch.ts#L149-L157"><u>gates spends</u></a> on the same inputs it always did. A byte-identity test locks every recovered path against the on-chain oracle, so a Raven answer is provably the same bytes the proof would have used. PIR makes the query private, and the answer stays exactly as verifiable as before.</p><p>Submission paths (<code>submitPOI</code>, <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Community/private-proof-of-innocence/blob/4b1eaf6ef19099dbfd6b43b1ca78d2ce0132a752/packages/node/src/api/schemas.ts#L127-L154"><u>legacy transact proofs</u></a>) stay as upstream passthroughs. They are public write actions, and the network-layer metadata around them is closed by <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://hisoka.io/blog/introducing-nox/"><u>Nox</u></a>, the other half of the off-chain privacy stack, so the read side and the network side are both covered. Public-info channels like the commitment-to-index map are cached aggressively; they are the same for every wallet, so there is nothing private to protect.</p><p>The wallet doesn't change. The proofs don't change. The Railgun protocol doesn't change. The only thing that changes is that the node serving the lookups can no longer tell which UTXOs belong to whom.</p><h2 id="h-what-this-means-for-railgun" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What this means for Railgun</h2><p>The cost of adopting this is close to zero, because nothing in the protocol moves. No contract upgrade: Proof of Innocence is not enforced on chain. No circuit recompile and no circuit re-audit: the paths and roots the circuits consume are unchanged. No re-audit of the wallet's proving, decryption, or nullifier paths: they are untouched. Adoption is per wallet and reversible. A wallet that points its node URL at a Raven endpoint gets the privacy; one that does not is exactly as it is today; both coexist on the same contracts and circuits indefinitely. There is no flag day.</p><p>The payoff lands on distribution. As of <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railway-Wallet/Railway-Wallet/releases/tag/v5.24.4"><u>Railway Wallet v5.24.4</u></a> there are no more mobile application updates, stated by the team to be due to Google Play and Apple App Store policies, and desktop is the supported client going forward. Web apps and browser extensions are the natural next paths, and they are exactly where full-tree sync hurts most. With Raven in front of the POI node and the Merkle-proof endpoint the wallet stops downloading full trees: it asks for the one leaf or commitment it needs, as a single encrypted request in the round-trip budget of an ordinary RPC call, and the operator never learns which entry was fetched. The web app stops syncing hundreds of thousands of leaves on every page load, and the extension becomes practical.</p><p>Off-chain query privacy is the floor under any future shielded-protocol UX. For Railgun specifically, it is what makes the protocol shippable in the environments where users actually live.</p><h2 id="h-try-it" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Try it</h2><p>A live demo of Raven against Railgun is at <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://demo.railgun.hisoka.io"><u>demo.railgun.hisoka.io</u></a>. Source on <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/hisoka-io/raven"><u>GitHub</u></a>.</p><p>For the network-layer half of the off-chain privacy stack, hiding who you are when you talk to a chain, see <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://hisoka.io/blog/introducing-nox/"><u>Nox</u></a>.</p>]]></content:encoded>
            <author>hisoka-labs@newsletter.paragraph.com (The Privacy Fellows)</author>
            <category>hisoka</category>
            <category>privacy</category>
            <category>railgun</category>
            <category>ethereum</category>
            <category>blockchain</category>
            <category>web3</category>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/1d5feb07bf5c145fc3cf8699377918cfbd1130b2f6a8b2faf6a8c49d558ab124.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Nox for Railgun]]></title>
            <link>https://paragraph.com/@Hisoka-Labs/nox-for-railgun</link>
            <guid>mGrkfZxRsL2GUFhGJRuu</guid>
            <pubDate>Mon, 15 Jun 2026 11:54:27 GMT</pubDate>
            <description><![CDATA[Nox is our Sphinx mixnet for EVM blockchains: it hides who sent a request, when, and from where. This post is about the network-layer half of a private Railgun client, and it is the companion to Raven for Railgun, which closed the query layer. Railgun's on-chain anonymity is solved by ZK proofs and commitment Merkle trees. Raven made the off-chain reads blind, so the node serving a lookup can no longer tell which UTXO it was for. What is left is the packet itself. ]]></description>
            <content:encoded><![CDATA[<p>Nox is our Sphinx mixnet for EVM blockchains: it hides who sent a request, when, and from where. This post is about the network-layer half of a private Railgun client, and it is the companion to <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://hisoka.io/blog/raven-railgun/"><u>Raven for Railgun</u></a>, which closed the query layer.</p><p>Railgun's on-chain anonymity is solved by ZK proofs and commitment Merkle trees. Raven made the off-chain <em>reads</em> blind, so the node serving a lookup can no longer tell which UTXO it was for. What is left is the packet itself. Every read and every write a Railgun wallet makes still leaves the user's machine as an ordinary network request, carrying an IP and a timing signature to whoever is on the other end. The proof hides what you did. The connection still says who you are.</p><h2 id="h-tldr" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">TL;DR</h2><ul><li><p>Three network-layer channels fingerprint a Railgun user today: wallet sync, circuit-artifact fetch, and transaction submission. All three survive the on-chain cryptography intact, and all three are keyed to the user's IP and timing.</p></li><li><p>Two of them are live and you can watch them leak: a sync query that binds your real IP to a recipient address, and an artifact fetch that previews your transaction's shape to a single gateway roughly thirty seconds before it lands on chain.</p></li><li><p>Nox is a three-hop Sphinx mixnet. The same request leaves through a shared exit node, so the operator records a Nox exit IP instead of yours, with per-hop delay and cover traffic erasing the timing signal.</p></li><li><p>It drops into the wallet's transport seam. The calldata stays an opaque blob to Nox, so there is no contract upgrade, no circuit recompile, and no re-audit of the proving path. Adoption is per wallet and reversible.</p></li><li><p>Live, against the real Railgun infrastructure: <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://demo.railgun.hisoka.io"><u>demo.railgun.hisoka.io</u></a>.</p></li></ul><h2 id="h-where-your-ip-leaks-in-a-railgun-client" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Where your IP leaks in a Railgun client</h2><p>A shielded transaction is private on chain. Getting it there is not. Between opening the wallet and the transaction landing, the client makes three kinds of off-chain request, and each one is an ordinary connection to a small set of operators. Every claim below is evidenced in the upstream code.</p><h3 id="h-1-wallet-sync-the-smoking-gun" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">1. Wallet sync, the smoking gun</h3><p>When a wallet reconstructs its sent history it asks the indexer one direct question: which unshields went to address X. The recipient address rides in the query as a <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Community/wallet/blob/99c9a344c105eb44e6d4f0d1657d1a65254c52cb/src/services/railgun/railgun-txids/graphql/railgun-txids-query.graphql#L51-L78"><u>plaintext filter</u></a>, fired from the <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Community/wallet/blob/99c9a344c105eb44e6d4f0d1657d1a65254c52cb/src/services/railgun/railgun-txids/railgun-txid-sync-graph-v2.ts#L109-L132"><u>wallet's sync path</u></a> over the user's own connection. The indexer that answers it learns one tuple: this IP is interested in this address, at this time. The on-chain shielded events deliberately omit the sender, but the <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Community/subsquid-integration/blob/49922b3aa644a7fcafcc55e7264c020065302f0a/src/processor.ts#L77-L88"><u>indexer re-introduces </u></a><code>transaction.from</code>, so one match binds the rest to a real wallet.</p><p>It is served from a <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/railgun-reloaded/subsquid-client/blob/79283de509701d21781c86e815ae94a813cc1a4e/src/networks.ts#L2-L7"><u>single apex</u></a> across every chain, with no rotation, and the engine runs it on a loop: every scan cycle does an indexer <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Community/engine/blob/2550cd653d706a3897a9d905fe906f58a4e87a22/src/railgun-engine.ts#L603-L637"><u>quick-sync and then a fallback-RPC slow-sync</u></a>, so the same wake-up leaks on two providers at once. This is the most direct fingerprint of a Railgun user on the network: a stable IP-to-address link, refreshed on a schedule. You can fire it yourself at <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://demo.railgun.hisoka.io/leak/smoking-gun"><u>demo.railgun.hisoka.io/leak/smoking-gun</u></a> and watch your own IP show up next to the address you queried.</p><h3 id="h-2-artifact-fetch-the-variant-fingerprint" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">2. Artifact fetch, the variant fingerprint</h3><p>Before the wallet can build any shielded transaction it has to download the circuit artifacts to prove with. It fetches them with a <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Community/wallet/blob/99c9a344c105eb44e6d4f0d1657d1a65254c52cb/src/services/artifacts/artifact-downloader.ts#L73"><u>raw GET</u></a> from a <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Community/wallet/blob/99c9a344c105eb44e6d4f0d1657d1a65254c52cb/src/services/artifacts/artifact-util.ts#L7"><u>single hardcoded gateway</u></a>, the <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/railgun-reloaded/ipfs-artifact-fetcher/blob/8b8bf6c3db7f26a366d3e96b3324f06de65174ad/src/definitions.ts#L5"><u>same constant</u></a> the reloaded fetcher carries. The catch is which file it asks for. Railgun ships one artifact set per transaction shape, the <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Privacy/circuits-v2/blob/0aa2d13763a9fcfbb7b7ea9c02e004e71f1394bb/lib/circuitConfigs.js#L1-L13"><u>nullifier-count by commitment-count matrix</u></a>, and the shape is in the request path. So the gateway operator learns the exact input-output structure of the transaction you are about to send, tied to your IP, roughly thirty seconds before it appears on chain.</p><p>The artifacts are also fetched <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/railgun-reloaded/ipfs-artifact-fetcher/blob/8b8bf6c3db7f26a366d3e96b3324f06de65174ad/src/artifact-downloader.ts#L297"><u>without verifying their hash</u></a>, which is a separate integrity problem the Nox adapter can also close, but the leak here is the metadata: who is about to send what, and when. Pick a transaction shape at <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://demo.railgun.hisoka.io/leak/variant-fingerprint"><u>demo.railgun.hisoka.io/leak/variant-fingerprint</u></a> and watch the four real artifact requests go out with your IP attached.</p><h3 id="h-3-submission-the-broadcaster" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">3. Submission, the broadcaster</h3><p>To submit without paying gas from a fresh address, the wallet hands its signed transaction to a broadcaster over Waku. The broadcaster <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Community/ppoi-safe-broadcaster-example/blob/ec49691533b4edc2dafefbd8cdb5f611290b2115/src/server/transactions/execute-transaction.ts#L93"><u>signs and submits it</u></a> on chain, so it sees the full transaction before anyone else and the relay set is small enough to be a censorship and correlation point. Waku is honest about the bound: its own client README says it gossips messages <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/Railgun-Community/waku-broadcaster-client/blob/8f854ef9c9bf83306af5b5469114febe54bf760a/README.md#L46"><u>"without revealing the user's IP address or identity to the Broadcaster directly."</u></a> The phrase "to the Broadcaster directly" is the tell. The IP is hidden from the broadcaster operator, not from Waku peers, store nodes, or anyone watching the wire. Waku is gossip, not a mixnet: no per-hop delay, no cover traffic, no decorrelation of when you sent from when the transaction appeared.</p><p>All three survive the on-chain cryptography intact. The proof hides what you did. The packets around it say who, when, and from where.</p><h2 id="h-how-nox-plugs-in" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">How Nox plugs in</h2><p>Nox is a three-hop Sphinx mixnet. A request leaves the client wrapped in fixed-size onion-encrypted packets, passes through an entry, a mix, and an exit node, each stripping one layer and holding for a random interval, and exits to the same endpoint the wallet would have called directly. The operator on the far side sees a Nox exit IP, shared across every Nox user, and the per-hop delay plus cover traffic leaves no timing signal to line up against the chain.</p><p>The reads above route through it with no protocol change, because they are ordinary HTTPS. The same indexer query or artifact fetch goes out through the Nox SDK instead of a direct call:</p><pre data-type="codeBlock" text="// the same Railgun read, carried by the mixnet instead of a direct fetch
const client = await NoxClient.init();
const raw = await client.httpRequest(&quot;POST&quot;, subsquidUrl,
  [[&quot;content-type&quot;, &quot;application/json&quot;]],
  encode(query),
  { expectedResponseBytes: 200_000 });
// the indexer logs a Nox exit IP, not yours. Same response bytes."><code><span class="hljs-comment">// the same Railgun read, carried by the mixnet instead of a direct fetch</span>
const client <span class="hljs-operator">=</span> await NoxClient.init();
const raw <span class="hljs-operator">=</span> await client.httpRequest(<span class="hljs-string">"POST"</span>, subsquidUrl,
  [[<span class="hljs-string">"content-type"</span>, <span class="hljs-string">"application/json"</span>]],
  encode(query),
  { expectedResponseBytes: <span class="hljs-number">200_000</span> });
<span class="hljs-comment">// the indexer logs a Nox exit IP, not yours. Same response bytes.</span></code></pre><p>This is exactly what the demo does today: the "Before" pane fires the real request straight at the Railgun infrastructure and your IP lands in the log; the "After" pane sends the identical request through Nox and the log shows a shared exit node instead.</p><p>Submission plugs in at the same seam Waku uses. The engine produces a proved transaction and stops; handing it to a transport is delegated upward to a broadcaster client. A Nox broadcaster transport satisfies that same interface, so swapping it in is a single line at the wiring point, and the signed transaction travels to the exit node as an opaque blob that Nox never parses:</p><pre data-type="codeBlock" text="// in place of the default Waku broadcaster transport
const transport = await NoxBroadcasterTransport.start({
  seed: &quot;https://api.hisoka.io/seed/topology&quot;,
});
setBroadcasterTransport(transport);"><code><span class="hljs-comment">// in place of the default Waku broadcaster transport</span>
const transport <span class="hljs-operator">=</span> await NoxBroadcasterTransport.start({
  seed: <span class="hljs-string">"https://api.hisoka.io/seed/topology"</span>,
});
setBroadcasterTransport(transport);</code></pre><p>Nothing on chain has to move for any of this. The Railgun relay contract's <code>relay()</code> has no broadcaster-identity check and routes fees to the treasury, so the chain neither knows nor cares whether Waku or Nox carried the transaction. The trust model does not move either: Nox transports the bytes, the exit node never learns who sent them, and the transaction that lands is byte-identical to the one the wallet built.</p><h2 id="h-what-this-means-for-railgun" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What this means for Railgun</h2><p>The two halves of off-chain privacy are now both built for Railgun. Raven hides what you asked for; Nox hides who asked. Stacked on Railgun's on-chain ZK, the read is blind, the sender is anonymous, and the proof is private, all at once.</p><p>This closes a gap Railgun's own stack scopes out rather than solves. The Waku client hides your IP from the broadcaster operator and stops there; nothing in the path adds mixing, delay, or cover. Network-layer correlation against shielded systems is not theoretical. Timing analysis recovers senders from low-latency onion routing at high accuracy, shown by <a target="_blank" rel="noopener" class="dont-break-out" href="https://arxiv.org/abs/1808.07285"><u>DeepCorr</u></a> and, more recently and under noise, <a target="_blank" rel="noopener" class="dont-break-out" href="https://arxiv.org/html/2512.00436v1"><u>RECTor</u></a>. A mixnet is the construction designed against exactly that, and it is what Nox adds.</p><p>The cost of adopting it is close to zero. No contract upgrade, no circuit recompile, no re-audit of the proving, decryption, or nullifier paths, because none of them are touched. Adoption is per wallet and reversible: a wallet that points its transport at Nox gets the network-layer privacy, one that does not is exactly as it is today, and both coexist on the same contracts and circuits. There is no flag day. It also removes a centralization liability: a small broadcaster set is a single choke point for censorship and correlation, and a staked, permissionless mixnet with no privileged relay is a better answer for both privacy and resilience.</p><h2 id="h-try-it" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Try it</h2><p>The two live leaks, and the same operations routed through Nox, are at <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://demo.railgun.hisoka.io"><u>demo.railgun.hisoka.io</u></a> under the Transport Layer section. Each demo fires the real request against the real Railgun infrastructure, shows your actual IP in the "Before" pane, and shows a shared Nox exit IP in the "After" pane, with the same result on the other end.</p><p>Nox source is on <a target="_blank" rel="noopener" class="dont-break-out" href="https://github.com/hisoka-io/nox"><u>GitHub</u></a>, the protocol paper is <a target="_blank" rel="noopener" class="dont-break-out" href="https://papers.hisoka.io/nox.pdf"><u>here</u></a>, and the network is live on Arbitrum Sepolia with a setup guide for <a target="_blank" rel="noopener" class="dont-break-out" href="https://github.com/hisoka-io/run-nox"><u>running a node</u></a>.</p><p>For the query-layer half of the same stack, hiding which records a wallet reads, see <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://hisoka.io/blog/raven-railgun/"><u>Raven for Railgun</u></a>. For the design of the mixnet itself, see <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://hisoka.io/blog/introducing-nox/"><u>Introducing Nox</u></a>.</p>]]></content:encoded>
            <author>hisoka-labs@newsletter.paragraph.com (The Privacy Fellows)</author>
            <category>nox</category>
            <category>railgun</category>
            <category>privacy</category>
            <category>ethereum</category>
            <category>hisoka</category>
            <category>blockchain</category>
            <category>web3</category>
            <category>crypto</category>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/e8c2b0b39cb0b32e439157d246a13c0862be23e438d461b0ccdb70222435a2bc.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Introducing Nox]]></title>
            <link>https://paragraph.com/@Hisoka-Labs/introducing-nox</link>
            <guid>WC9V0wRIjbjsWvQSvlGl</guid>
            <pubDate>Mon, 15 Jun 2026 11:37:47 GMT</pubDate>
            <description><![CDATA[Introducing Nox - A mixnet for EVM blockchains with anonymous transaction relay

Blockchain transactions leak a lot of metadata. ZK primitives hide content effectively but the network layer remains exposed.

Your RPC provider sees your IP, query patterns and timing. We fixed it.]]></description>
            <content:encoded><![CDATA[<p>Privacy protocols on EVM blockchains have gotten good at hiding what a transaction does. Shielded pools, ZK proofs, encrypted notes. The cryptography works.</p><p>What these systems don't cover is the act of submitting it. Your IP goes to the RPC provider. The timing of your transaction hitting the mempool correlates with your network activity. The relay fee narrows who could have sent it. You can encrypt everything inside a transaction and still be fully identifiable from everything around it.</p><h2 id="h-two-layers-of-off-chain-privacy" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Two layers of off-chain privacy</h2><p>Interacting with a blockchain privately requires hiding two separate things:</p><table><colgroup><col><col><col></colgroup><tbody><tr><th colspan="1" rowspan="1"><p><strong>Layer</strong></p></th><th colspan="1" rowspan="1"><p><strong>What leaks</strong></p></th><th colspan="1" rowspan="1"><p><strong>What hides it</strong></p></th></tr><tr><td colspan="1" rowspan="1"><p><strong>Network layer</strong></p></td><td colspan="1" rowspan="1"><p>Your IP, request timing, submission patterns</p></td><td colspan="1" rowspan="1"><p>Mixnets</p></td></tr><tr><td colspan="1" rowspan="1"><p><strong>Query layer</strong></p></td><td colspan="1" rowspan="1"><p>What data you're requesting</p></td><td colspan="1" rowspan="1"><p>PIR, ORAM, TEE</p></td></tr></tbody></table><p>Both matter. Network privacy without query privacy means the provider knows what you asked for, just not who you are. Query privacy without network privacy means the provider can't see what you want, but they know your identity.</p><p>Nox solves the network layer.</p><p>Nox is a Sphinx mix network co-designed with an anonymous transaction relay layer for EVM blockchains. Encrypted packets pass through three mix nodes, each stripping a layer and holding for a random interval. The exit node submits your transaction on-chain. The gas fee is paid through a zero-knowledge proof from a shielded note. No IP logged, no on-chain payment linking back to you, no timing correlation in the mempool.</p><p><a target="_blank" rel="noopener" class="dont-break-out" href="https://github.com/hisoka-io/nox"><u>Open source.</u></a> Deployed on Arbitrum Sepolia. <a target="_blank" rel="noopener" class="dont-break-out" href="https://papers.hisoka.io/nox.pdf"><u>Full paper here.</u></a></p><h2 id="h-why-not-just-use-tor-a-relayer" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Why not just use Tor + a relayer?</h2><p>Some projects try to fix metadata leakage by composing existing tools. Route through Tor or Nym, hand off to an independent relayer, hope the seam between systems doesn't leak.</p><p>It does. Packet timing at the exit of the anonymity layer matches transaction appearance in the mempool. Two independent privacy systems will always have a boundary, and that boundary is a correlation point. The <a target="_blank" rel="noopener" class="dont-break-out" href="https://privreads.ethereum.foundation/workstreams/torjs/"><u>Ethereum Foundation has explored this path</u></a> from the Tor side, but Tor only covers IP privacy. Query content, timing patterns, and transaction submission are still exposed.</p><p>Tor is an onion router, not a mixnet. It forwards packets immediately to keep latency low. That preserves timing patterns. <a target="_blank" rel="noopener" class="dont-break-out" href="https://arxiv.org/abs/1808.07285"><u>DeepCorr</u></a> achieves 96% deanonymization accuracy with 900 packets. <a target="_blank" rel="noopener" class="dont-break-out" href="https://arxiv.org/html/2512.00436v1"><u>RECTor</u></a> works even under noise. In 2024, German police confirmed this in practice: self-operated relays, timing surveillance, court-ordered ISP records. KAX17 showed a single operator can compromise enough relays for broad correlation.</p><p>Nox adds what Tor deliberately omits: per-hop random delay, Poisson mixing, and cover traffic. No timing signal left to correlate.</p><p>Nox builds both layers as one system. The node that decrypts your packet is the node that submits your transaction. No boundary, no seam.</p><table><colgroup><col><col><col><col><col></colgroup><tbody><tr><th colspan="1" rowspan="1"><p><strong>Factor</strong></p></th><th colspan="1" rowspan="1"><p><strong>Tor</strong></p></th><th colspan="1" rowspan="1"><p><strong>Nym</strong></p></th><th colspan="1" rowspan="1"><p><strong>VPN</strong></p></th><th colspan="1" rowspan="1"><p><strong>Nox</strong></p></th></tr><tr><td colspan="1" rowspan="1"><p>IP hidden from RPC</p></td><td colspan="1" rowspan="1"><p>Partial</p></td><td colspan="1" rowspan="1"><p>Yes</p></td><td colspan="1" rowspan="1"><p>Partial</p></td><td colspan="1" rowspan="1"><p>Yes</p></td></tr><tr><td colspan="1" rowspan="1"><p>Timing decorrelation</p></td><td colspan="1" rowspan="1"><p>No</p></td><td colspan="1" rowspan="1"><p>Yes</p></td><td colspan="1" rowspan="1"><p>No</p></td><td colspan="1" rowspan="1"><p>Yes</p></td></tr><tr><td colspan="1" rowspan="1"><p>Gas fingerprint resistance</p></td><td colspan="1" rowspan="1"><p>No</p></td><td colspan="1" rowspan="1"><p>No</p></td><td colspan="1" rowspan="1"><p>No</p></td><td colspan="1" rowspan="1"><p>Yes</p></td></tr><tr><td colspan="1" rowspan="1"><p>Sender timing decorrelated from mempool</p></td><td colspan="1" rowspan="1"><p>No</p></td><td colspan="1" rowspan="1"><p>No</p></td><td colspan="1" rowspan="1"><p>No</p></td><td colspan="1" rowspan="1"><p>Yes</p></td></tr><tr><td colspan="1" rowspan="1"><p>Sender/receiver unlinkability</p></td><td colspan="1" rowspan="1"><p>No</p></td><td colspan="1" rowspan="1"><p>Yes</p></td><td colspan="1" rowspan="1"><p>No</p></td><td colspan="1" rowspan="1"><p>Yes</p></td></tr><tr><td colspan="1" rowspan="1"><p>Anonymous responses (SURB)</p></td><td colspan="1" rowspan="1"><p>No</p></td><td colspan="1" rowspan="1"><p>Yes</p></td><td colspan="1" rowspan="1"><p>No</p></td><td colspan="1" rowspan="1"><p>Yes</p></td></tr><tr><td colspan="1" rowspan="1"><p>Native TX execution</p></td><td colspan="1" rowspan="1"><p>No</p></td><td colspan="1" rowspan="1"><p>No</p></td><td colspan="1" rowspan="1"><p>No</p></td><td colspan="1" rowspan="1"><p>Yes</p></td></tr></tbody></table><p>Tor and VPN are marked partial for IP hiding because exit node IPs are publicly listed and frequently blocked by RPC providers.</p><hr><h2 id="h-how-a-private-transaction-works" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">How a private transaction works</h2><p><em>Packets flow through three independent layers. Each node strips a layer of encryption and delays randomly before forwarding.</em></p><p>Your client generates a ZK proof that you can cover the relay fee, without revealing who you are. That proof is bound to the exact operation: specific contract, specific calldata, specific fee. Single-use. Can't be redirected, replayed, or reused.</p><p>The client wraps everything into an encrypted packet and sends it to a random entry node. Three hops later, the exit node has the plaintext transaction and the proof. It checks that the fee covers gas, submits both atomically, and collects the payment from a reward pool.</p><p>The exit node earns revenue. It never learns who paid.</p><hr><h2 id="h-reads-are-private-too" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Reads are private too</h2><p>This part gets less attention, but it matters just as much.</p><p>A balance check, a contract call, a log query. All of these go through your RPC provider today, and the provider sees your IP, the addresses you're querying, how often you check. With Nox, the same query routes through the mix network. The provider sees the exit node. Never you.</p><p>Reads don't modify state, so no gas payment is needed. No on-chain trace at all. You can monitor wallets, check DeFi positions, scan for transfers, and nobody can correlate those queries back to you.</p><hr><h2 id="h-getting-replies-back-anonymously" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Getting replies back anonymously</h2><p>Sending a request anonymously is one thing. Getting a response back without revealing who asked? Harder.</p><p>Before sending a request, your client builds single-use reply envelopes with a return path encrypted at every hop. The exit node puts its response in the envelope and sends it back through the network. Three hops later, you have the answer. The exit node never learned where it went.</p><p>For large responses, we split data across multiple envelopes with error correction baked in. The client can reconstruct the original even when packets get lost. At 10% packet loss, delivery goes from 31% to 98%. We chose upfront redundancy over retransmission because retransmission patterns are themselves a timing side channel.</p><hr><h2 id="h-fast-enough-for-defi" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Fast enough for DeFi</h2><p>Every node delays every packet by a random interval, so output timing is independent of input. Nodes also generate cover traffic: loop packets and drop packets that keep baseline volume constant. Quiet periods don't reveal when real activity happens. All packets are 32 KB and structurally identical, whether they carry a swap, a health check, or noise.</p><p>In benchmarks: 58.6 microseconds per hop, 372 packets per second across ten nodes, zero loss. At production delay settings, expected end-to-end latency sits around 300 ms. Ethereum's block time is 12 seconds. Plenty of room.</p><p><a target="_blank" rel="noopener" class="dont-break-out" href="https://github.com/hisoka-io/nox/releases/tag/v0.1.0-benchmarks"><u>Full benchmark data here.</u></a></p><hr><h2 id="h-running-a-node" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Running a node</h2><p>Nodes register on-chain with a stake, which publishes their public key and service URL. Layer assignment is deterministic from the address, so every participant computes the same topology without coordination.</p><p>Exit nodes earn fees by relaying transactions. The economics: simulate before submitting, check the proof's payment against gas cost, submit if profitable, skip if not. Only state-changing operations require payment. Reads and cover traffic are free, because more traffic means a larger anonymity set for everyone.</p><p>If you want to run a node: <a target="_blank" rel="noopener" class="dont-break-out" href="https://github.com/hisoka-io/run-nox"><u>setup guide here</u></a>. Questions or issues? <a target="_blank" rel="noopener" class="dont-break-out" href="https://github.com/hisoka-io/run-nox/issues"><u>Open a GitHub issue.</u></a></p><hr><h2 id="h-building-on-nox" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Building on Nox</h2><p>Nox can route through the mixnet:</p><ul><li><p>Any HTTPS request</p></li><li><p>EVM transactions</p></li><li><p>Smart contract calls</p></li><li><p>RPC queries</p></li><li><p>ZK proof submissions</p></li></ul><p>The SDK supports all of these with drop-in integration. No UX change for your users.</p><p>We've integrated <a target="_blank" rel="noopener" class="dont-break-out" href="https://noir-lang.org/"><u>Noir</u></a> proofs into the mixnet. You can submit on-chain verification requests through Nox and pay for gas anonymously using our ZK payment circuit. The prover's identity never touches the chain. The gas-payment circuit itself is written in Noir and is modular, so alternative payment schemes can plug in without changing the routing layer.</p><p><a target="_blank" rel="noopener" class="dont-break-out" href="https://docs.hisoka.io/"><u>Documentation and SDK reference.</u></a></p><hr><h2 id="h-whats-next" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What's next</h2><p>Nox solves the network layer. The other half is the query layer. We're building Raven, a private information retrieval service that hides what data you're requesting from the server. Combined with Nox, both who you are and what you're asking for are hidden. More on that soon.</p><p>In parallel, we're taking the mixnet to production. If you want to try querying through the mixnet, the <a target="_blank" rel="noopener" class="dont-break-out" href="https://demo.nox.hisoka.io/"><u>Nox Explorer</u></a> lets you fetch balances and submit private transactions right now.</p><hr><h2 id="h-links" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Links</h2><ul><li><p><a target="_blank" rel="noopener" class="dont-break-out" href="https://papers.hisoka.io/nox.pdf"><u>Nox Paper</u></a></p></li><li><p><a target="_blank" rel="noopener" class="dont-break-out" href="https://github.com/hisoka-io/nox"><u>Source Code</u></a></p></li><li><p><a target="_blank" rel="noopener" class="dont-break-out" href="https://docs.hisoka.io/"><u>Documentation</u></a></p></li><li><p><a target="_blank" rel="noopener" class="dont-break-out" href="https://map.hisoka.io/"><u>Live Map</u></a></p></li><li><p><a target="_blank" rel="noopener" class="dont-break-out" href="https://demo.nox.hisoka.io/"><u>Nox Example App</u></a></p></li><li><p><a target="_blank" rel="noopener" class="dont-break-out" href="https://github.com/hisoka-io/run-nox"><u>Run a Node</u></a></p></li><li><p><a target="_blank" rel="noopener" class="dont-break-out" href="https://github.com/hisoka-io/nox/releases/tag/v0.1.0-benchmarks"><u>Benchmarks</u></a></p></li></ul><br>]]></content:encoded>
            <author>hisoka-labs@newsletter.paragraph.com (The Privacy Fellows)</author>
            <category>privacy</category>
            <category>hisoka</category>
            <category>ethereum</category>
            <category>blockchain</category>
            <category>web3</category>
            <category>nox</category>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/12f2d3180011488a389a478c942196c389d7909418e6038bcaf485ce0f83bcc0.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[The PIR Trilemma]]></title>
            <link>https://paragraph.com/@Hisoka-Labs/pir-trilemma</link>
            <guid>TIK7ke6Oyo17mUvKY8ee</guid>
            <pubDate>Mon, 15 Jun 2026 08:08:43 GMT</pubDate>
            <description><![CDATA[PIR isn't one thing , it's a family with hard tradeoffs on client storage, server compute, and live updates. We mapped the 4 families, the trilemma, and why InsPIRe + sidecar fits live, mobile Ethereum state best.

Next: iSimplePIR + VIA.

Full breakdown → https://hisoka.io/raven
Raven on GitHub → https://github.com/hisoka-io/raven

]]></description>
            <content:encoded><![CDATA[<p>More about Raven: <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://hisoka.io/raven"><u>https://hisoka.io/raven</u></a></p><p>"Just use PIR" has become the stock answer to read privacy on Ethereum. It hides a real decision.</p><p>Private Information Retrieval is not one algorithm. It is a family of constructions, and the members disagree on almost everything that matters: </p><ul><li><p>how much the client stores, </p></li><li><p>how much the server computes, </p></li><li><p>and what happens when the database changes. </p></li></ul><p>Choose the wrong member for your workload and you ship something that melts the server, drains the phone, or serves stale state every block.</p><p>This post is the map. What PIR actually computes, the four families it splits into, the three-way tradeoff that forces every scheme to surrender something, what each leading scheme is good and bad at, the route we took through it while building Raven, the changes we made to our engine along the way, and the two engines we are bringing in next.</p><p><strong>What PIR computes</strong></p><p>The guarantee is narrow and strong. You read entry <code>i</code> from a server's database, and the server never learns <code>i</code>. Your query goes out encrypted, the server computes over the plaintext database without ever decrypting your request, and it returns a ciphertext that only you can open.</p><p>In practice the schemes that matter are lattice-based, built on LWE and RLWE. Two patterns cover most of the field.</p><p>The first is a plain matrix-vector product, which is what <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://eprint.iacr.org/2022/949">SimplePIR  </a>does. Lay the database out as a matrix <code>D</code>. Your query is an encrypted unit vector: zero everywhere except a one at the column you want. The server computes the product <code>D * q</code> under encryption and hands back the result. It multiplied through every entry and still has no idea which column carried your one.</p><p>The second pattern keeps the query tiny and makes the server expand it. Spiral and Respire send a small RLWE or GSW ciphertext that the server homomorphically unfolds into the full selection vector before the inner product. The bytes on the wire shrink, and the per-operation compute grows.</p><p>Every scheme is the same shape underneath: encrypt, compute blind, decrypt. The interesting differences are all about what gets precomputed, and who has to hold it.</p><p><strong>Four families</strong></p><p>The useful way to sort PIR schemes is not by their algebra. It is by where state lives. Two questions split the entire field into four boxes.</p><p><strong>Does the client hold a hint derived from the database?</strong> If no, the scheme is client-stateless. If yes, it is client-stateful.</p><p>Inside client-stateless, ask a second question: <strong>does the server keep per-client state?</strong></p><ul><li><p><strong>Server-stateful</strong> schemes cache your evaluation keys on the server. SealPIR, MulPIR, Spiral, Respire, and VIA-C live here. The catch is linkability: because the server holds material tied to you, your queries become correlatable across sessions even when a mixnet hides your IP.</p></li><li><p><strong>Server-stateless</strong> schemes keep nothing per client. HintlessPIR, YPIR, InsPIRe, and VIA live here. This is the clean quadrant. The server preprocesses the database once into a shared structure that every client uses, and no query can be tied back to a previous one.</p></li></ul><p>Inside client-stateful, the second question is about hint generation: <strong>does building the hint require a round trip with the server?</strong></p><ul><li><p><strong>Download-hint</strong> schemes ship the hint server-to-client and nothing more. SimplePIR and DoublePIR are the examples. The client downloads a hint once, stores it, and queries cheaply afterward.</p></li><li><p><strong>Interactive-hint</strong> schemes need the client to stream the database and compress it into a local hint. Piano, RMS24, and Plinko are here. This is the most demanding setup to run, and it is also the only family that achieves a sublinear server: after the hint exists, the server touches far fewer than all <code>N</code> entries per query.</p></li></ul><figure float="none" data-type="figure" class="img-center"><img src="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/330fef6c695af36d47f6d6d11701f019d9a08cd716023b4b4c0402f9f8c6e016.png" blurdataurl="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAUCAIAAABj86gYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAD/UlEQVR4nK1U0U4bRxQ1arPpwwqvzezuwAADO7D2rvEYj+2xPbBQB7zJprgJBIcoKiDIAzKBqi/YVkNLH6omLa2U9qWRqvYP2v5D1ao/0F9ov6DvrbwD1hb8EqlHV/au1t5z75xzbkzrIZ7U4oY+MgbhWzdvxkIoiqL9H4hpmvb1V19+8P7Rabf9yWm322nv7++fnZ1xzoeG3lAH4fUIVFX96Nmzb16+fPXq2/Pz8x++/+7nn3787ddfWq0DAADGGCGEQ8gLhNBrT4Axdl3XDkEuQSmtViulUrFUKnqeJ4RgjC0uLjLGkiMjw/Hh4Xhc07SBI0Zn7REMD3qgqqqiKPL2zRs3NC2+ury45ImlBRH49Y17a+89blbLfIZYs4TMEpKyZ52UfaUMXe8R9JFMJAaOCQCYwpO724+PDg/b7ZPTDzt//vH7P3//5TgphNA4QjOEjCNk6Hq/komENYVniPUfAglVVUEI+WoAAIQw8Ou3/fr6+vruzk4Q3Hn4sFmrLW892vI8r1Z7mzGGMY6egaIooxAOIFBVFWP8zt27rdZBt9Op11ez2TnGCo6TLhVyGddxUvYsITmazbhOmRfyOZrPUSdlZ1wnR115K6tUmB9HYwMIstk5zrkQosx5OpVOO84MIYzln/Ts+/H5+RfdTidl29nsXMa9AKU0m52jlNoRUEoxxj2CqLUVRSnzAkJj0iQAgGQiASFcuVWr1WqNxtpKfaXRaMzTec45pZQxVuGVjJspc56ybXk4iqIMDQ0BAAghMfllmiaEcHJyAmNc5lwKEEEcACCEqFYrjpNeEIJS6nk9ywoh6vVVSqkQItq+bduu6yKEYsPx+O7OzucvXrTbJ3t7u43G2vr6/WsEGgDA0HUAAELIMI2JyQmExmToQlOM9B0RxUUOms3N588/63Y6pVKRsfzKrVtXCFRVNXT9wcb9rUdbzebmg42N5aUlmb5+MGeulW3bEMILDWKxWJim3nWx0NOgnzI1bHAK42Zzs90+OTo8fLK/LwdCCBFCpi3LsqYhhFd6xxj3NLg8gRE5pqqqOUqlPeQnxngUwiC44/v+3t7uvXfX6vXV7e3tIAgYY5zzYqnIOUcIXSewrOnBNvV9v9ncbLUOXNclhHDObdv2PK9arVSrFSHEQig46yEvi3MuH0XRE3ngbnBdN/wzs23bcdKWNb0gRCjVp8fHT4+Pn06MT/S3LCGkv26jjcofDCaImkfTNEPXF4QIguC27wdB0Gg0qtWK7/skVDK6iaOrAkJ4oYHcNv3jgyEM00gmEoZpGKYpO2Isf5lc13HSjOWlfyxrWpbki+bgwkVyllH5YgjlsAghGT2pXjKRuG5zuThN0+yn5HoO/gWLJxVn5105HQAAAABJRU5ErkJggg==" nextheight="563" nextwidth="900" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><p>This taxonomy is not ours. It comes from <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://ethresear.ch/t/sharded-pir-design-for-the-ethereum-state/24552">Ali Atiia and Keewoo Lee's  post</a>, and it is the vocabulary the rest of this discussion uses.</p><p><strong>The trilemma</strong></p><br><figure float="none" data-type="figure" class="img-center"><img src="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/8fb40f535b7c48321e95a870edcc74097334f8f09d843be619a954c18f558d34.jpg" blurdataurl="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAUCAIAAABj86gYAAAACXBIWXMAAAsTAAALEwEAmpwYAAADp0lEQVR4nKWUz28bRRTHdytWqSdmnUky6drOOJ12u+rE63jiXe/aY7d16sStoaWx2qAqCUnqBMlZilUB6QH1wIWqK35cMIgTqFW4oPbAlUPVQpA4cSoSf0EkxF9QcQBlhywWOEkLX81hZnfmfd57M+9J6r6CEA4NDoyg4aHBwZj6Ylw7IpZx7UgwtNj+51VVOmiDuvza/IWXzp0+Vbr51o2rc43Xm0v1c7W8xUq8OJExIYT/EQACSZLUarUe3P/61q13t7Yet9vtzc3NH7a+v3v3y+8ePfL922IbAOD5AAAAXdfr9fPNayuL81fb171abYYQ0pi9eOliPW/bJV50HLtcLjtOvuA6hmHsxdgzAghhIpEYS6UwxoSMYYwlSfr2/he//rwlSVJc01AgTdPE/LlTJOJQFAUAIMuyYRi+f8e//X77uuf7PmNMluUwk//rkoUghLp+nAUihGiaFtoFoH8fzLMCQHDecWzOXYSQoijhrxGEMB4dQSjaC9MDACFkLJu3rdFkUhwAAEAIOS8yZpomLZdLCKHg4wAA4IRO5q7MNmZfmaqciWuaqu6AegDEi9Z13fPWPW/d9+8wlg09dRzbsiZMk4rBeRFCGHjcf0InpXL5fP1C3ilqiWRfJEII+ScAAEAIKbiFTCYT1zTGmGXlMMbChGXlLIsFpk9SapgmZcx0HFscPHo09c1Xn//2y48/PXzwdPvJ+upCVI2FBfh3BN0lE04UpS+TyXDuhsmpVM4EpHQQU05su/Ty9Bur862VV99cXbAnTVk+9EyXrCh9lJ50HJsxM5FIqKq6sfH2xx99KJ5/wMgxlhUFH0qWD3U3qD0BiqLous55kVKDMZMxVqvNXL7cWFxYmJmetu08YyalBueuaaajIAp3dfArEsIYc+6KjE9kxxnLmmZ695LTwXJnTqlRKNq6flxVoz3t9AREJfmFSqVS4gXOXc7dgusUXIdz13FsUQrdo+A61erZw5GdcjsYIBLa8d+bOlXsi0S0LiGEEoF2+k8iHn5X1ViaGvc++0D0lR6A8P0AAAzDIOTY79tPWs3FATgsCko0JYxxtXq2xItjqZSwJTQ0PFydOv3H021KaY87gBASQjDGwrV2u/1pp7O80lxbW7u58Q6lVFEUCCFCaO5Ko3ltxfNay0tLx3ZLSVGUWm3mRru97nmdzie5ycnuLvIXQFgXAISQeAyRyOHAzX5R5OnxcYTQaDI5lkohNGJZudBZEV8sgP07RX8COhD0GIYXZuAAAAAASUVORK5CYII=" nextheight="563" nextwidth="900" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><p>Underneath those four boxes is a tradeoff that no single-server scheme escapes. Three properties everyone wants:</p><p>1. <strong>Stateless client.</strong> Nothing database-derived to download or store. This is what makes a scheme viable on a phone and what lets it survive frequent updates.</p><p>2. <strong>Sublinear server.</strong> The server does not touch all <code>N</code> entries per query. This is what keeps latency low as the database grows into the tens of gigabytes.</p><p>3. <strong>Live updates.</strong> The database can change every block without forcing a rebuild or a fresh download.</p><p>You get two of the three. The reason is mechanical, not a matter of engineering effort.</p><p>To answer a query in less than <code>O(N)</code> work, the server needs a precomputed index that lets it skip most of the database. But a server-side index keyed to your specific query would reveal the query. So the index has to be blinded, which means it lives on the client as a hint. <strong>Sublinear forces a client hint, which breaks statelessness.</strong></p><p>A hint is a snapshot of the database at one moment. The instant the data changes, the hint is stale and has to be refreshed over the wire. <strong>A hint breaks live updates,</strong> or makes them expensive.</p><p>Run the logic the other way. To stay stateless and instantly fresh, the server has to compute over the current database with no precomputed shortcut, which means it reads every entry. <strong>Statelessness plus freshness forces a linear server.</strong></p><p>There is one construction that sidesteps all three at once. Doubly Efficient PIR (DEPIR) builds a server-side oblivious data structure that gives a stateless client sublinear access with no hint. It exists, and it is orders of magnitude slower than practical PIR schemes today. DEPIR is the corner that, the day it becomes concretely efficient, deletes this trilemma. Until then it is a result on paper.</p><p><strong>Best in its domain</strong></p><p>Because no scheme wins on every axis, you do not pick "the best PIR." You pick the best one for the shape of your data. The numbers below are published-paper figures, and they make the specialization obvious.</p><ul><li><p><strong>Smallest communication, static database: Respire.</strong> Around 6 KB of total traffic per query at 256 MB. It pays for that with a stateful server and a respond path measured in seconds (about 3.5 s at 1 GB).</p></li><li><p><strong>Highest throughput, large static database: YPIR.</strong> Double-stateless, zero client hint, about 12.1 GB/s at 32 GB. That headline rides on AVX-512; the pure-Rust fallback throughput is unpublished.</p></li><li><p><strong>Communication-optimal at scale: VIA.</strong> <code>O(log N)</code> online communication, about 690 KB at 32 GB, with zero offline communication. The catch is maturity, covered below.</p></li><li><p><strong>Sublinear server: Piano.</strong> About 73 ms of server time at 100 GB, the only scheme with sublinear online server cost. The cost is a client hint of about 839 MB at that scale (closer to 750 MB once you extrapolate down to Ethereum's roughly 87 GB), and the requirement to stream the entire database to build it.</p></li><li><p><strong>Throughput baseline: SimplePIR.</strong> About 10 GB/s per core, near memory bandwidth. The hint is about 121 MB and grows with the square root of <code>N</code>, and every update forces the client to resync.</p></li><li><p><strong>Cheapest download hint: DoublePIR.</strong> A roughly 16 MB hint that does not grow with <code>N</code>, at about 7.4 GB/s per core. The hint still has to be refreshed when the database updates.</p></li><li><p><strong>Live, mutating, mobile: InsPIRe.</strong> Hintless, natively incremental, with a 152 KB WASM client.</p></li></ul><p>Read that list as the trilemma in motion. Every "best at" column has a "but" column directly beside it.</p><p><strong>Our problem: live state, thin client</strong></p><p>When we sat down to serve Ethereum state, the trilemma stopped being academic.</p><p>Two facts about the workload settled the design. The state trie mutates roughly every twelve seconds, so the data is live. The client is a wallet running in a browser or on a phone, so it cannot hold a multi-hundred-megabyte hint that goes stale on the next block.</p><p>Live plus thin client means properties one and three are not optional. We have to keep the stateless client, and we have to keep live updates. The trilemma then leaves us no choice on the third axis: we surrender the sublinear server and accept that the server reads linearly per query. No scheme rescues us from that. The only open question is how we pay the bill.</p><p><strong>## What we picked: InsPIRe</strong></p><p>We chose [InsPIRe]  implementation. It is the rare construction that is hintless and client-stateless, and natively incremental: one changed account re-encodes one shard, at a cost proportional to the number of dirty shards and constant in the total database size. That is exactly the stateless-client-plus-live-updates corner a chain workload demands.</p><p>One honest detail on statelessness. In the way we run it, InsPIRe is server-stateless too: each query carries its keys inline, so the server holds nothing per client and cannot link two queries from the same wallet. That unlinkability is the property the sidecar role depends on, so we keep it.</p><p>A snapshot-based engine still hates a database that never stops moving, so we run the main-plus-sidecar pattern from the Sharded PIR Design. A large main engine is preprocessed at a snapshot and re-preprocessed lazily in the background while the old version keeps serving. A small client-stateless sidecar absorbs the writes since that snapshot. The client queries both legs in parallel and consumes both responses, so a network observer cannot tell which engine held the answer from response timing. Every <code>E</code> blocks the sidecar folds into the main and resets.</p><p>We have also put real work into making our fork lighter and safer to run in a browser: a much smaller one-time download, a warm cache that lets a returning wallet skip the heavy setup, an optional parallel server path, and a correctness fix we contributed back. That part is engineering, not cryptography, and it is most of where the effort goes.<br></p><figure float="none" data-type="figure" class="img-center"><img src="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/b832018c1ae0a8ce9839cefd4fba168ac57635624c3ac0ee5742e6e75e7bcde8.jpg" blurdataurl="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAUCAIAAABj86gYAAAACXBIWXMAAAsTAAALEwEAmpwYAAADO0lEQVR4nKWVT08TQRjGt4kidIIDDjCdbVecumS7Hehgq1MCrlJkojEtpSxQYwkcMF40ahr1ajxwMDEa/yRGNFFjSAzBaLx59eBXMXwE9WJ2B5a1Viv6O2zebabzzPvMM7MahBBjjBDC28BfAKCDYBzD2IjHe3t6etEBIx7v7uraD1ujIYQYY6ZpUkp1H4RQeER7NFoqFudnK3mRO5rjc7MVd3rqxNjIIEv/xfxQCy1zi/ArhFDTtHdvNzY3vzxffco5f/Tw4fdvXz98eL++/qatra3hX38SaEAIkcvlCoVxxzkuhDjpOFKeymaPCB/Hx389JqUU4tiuBdR+6D5+2afrOqXUaEbTnWshEDReKBQq09OlYlHKU5RSy7LMLQYsy2KMcc7/xaJAxnGcmzdv3L596+LFC0mvgwSl/aZpGoYBQAeEkDH2hxk8AdCcTgCAnHAq0yUppetWXHdmcbFWLk8tLtbmZl3XnWHMBgDY6XSLDjDGQeOUUn91ibhODh1MJOmhkXx+mGcymaFhzhizGbOHORtkacZs5f5EYby7qytsbFhPAwBQSjGOcc7v37srhEAIZbNHxka8qEAIldHqyZitCjuVslMpVZ8YG01SCmE3xtgwDBWKnZQrAV3XOeeuOyOEwDjGmM05LxWLGPeFw97WDE3T1F0gpbxer1++dKlanTdNU9f1HYsCc9RzwDQPJ/sjkQgAnWo5qv0guGHUNaOKmHehYEKI7wreSVEwhaI9GiWEZPkgQmh0dLRery8tLVy7eoVz3nACKE2qHxFCDSFpEdP9vp6ccErFs7Va7Vx1bnl5WQhhGMb2fngbAwCwLKtFTH8HAIAQMpLPe4ZRSmn/IEsP84ydSm2fNc9Sxtj/HLTOGCGBIboejycSKioKVe+ig4bNCAjHJhKJBNEKZ6xpH40ChBCEkFqaii+EECHU71uvYMzGuA8A4CXGz35Aw7fkJ4H2aHTATH7+uLGysrK0tFAojJfLU0dzOU3Tzs+VP318t/rs2dra6+erT16/evngwb09e/c9vnNr7cXTarV65szpyckJKWWQ6d92oK5lCKFyIxhtGAl1krlPJjOEPA4QQtRgZdevFv0AsdPk/aXZBAAAAAAASUVORK5CYII=" nextheight="563" nextwidth="900" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><p><strong>## The next two engines: iSimplePIR and VIA</strong></p><p>A framework with one scheme is not a framework. Two engines are coming next, and they answer different questions, so it is worth being precise about which slot each fills.iSimplePI, the incremental variant of the SimplePIR line, is good at exactly one thing the others are not: true per-entry incremental updates. A modification or deletion costs <code>O(n)</code> work independent of database size, with no noise accumulation over repeated edits, and an insert adds about 4 KB to the hint without regrowing the rest of it. It is plain LWE, WASM-clean, and rides the SimplePIR backbone at about 10 GB/s per core with a server query around 95 ms at 1 GB. Where it hurts is the family it belongs to: it is client-stateful, download-hint, so the client carries a hint of about 121 MB at 1 GB that grows with the square root of <code>N</code> (roughly 716 MB at 32 GB). That is a real mobile cold-start cost. Its role in Raven is a benchmarked alternative main engine and our second scheme, the one that forces the generic scheme abstraction to be real rather than designed in advance. It is not a candidate for the sidecar, because a client-stateful scheme would make every client resync its hint on every fold, which is the exact failure the architecture is built to avoid.</p><p>VIA is the opposite profile. It is double-stateless like InsPIRe, and it is communication-optimal: <code>O(log N)</code> online communication, about 690 KB at 32 GB with zero offline communication, several times tighter than YPIR and an order of magnitude tighter than HintlessPIR. Its preprocessing is the cheapest of the hintless schemes, around 33 s at 32 GB. The catches are real and we state them plainly: there is no Rust or WASM implementation yet, the published parameters sit at about 110-bit classical security rather than 128, the single-thread server is slow (around 10 s at 32 GB), and it has no native incremental update, so a change means a full re-encode. That re-encode is lazy and client-transparent, but it is still <code>O(N)</code>.</p><p>So is VIA better than iSimplePIR? The question assumes they compete for one slot. They do not. Both are main-engine candidates, and neither is the sidecar. VIA wins on communication and on double-statelessness. iSimplePIR wins on native incremental updates and on being deployable today, in-tree, WASM-clean. VIA is the long game for very large state, where client bandwidth rather than server compute becomes the wall, and a Rust and WASM port of it is the natural contribution back to the people who wrote it. The sidecar stays InsPIRe, because the sidecar has exactly one hard requirement, client-statelessness with cheap updates, and InsPIRe is the engine that meets it.</p><p><strong>The rest of the field, briefly</strong></p><p>The schemes we did not pick are not bad. They are good at other shapes of data. A fast tour, with the one property that wins each and the one that rules it out for live Ethereum state:</p><figure float="none" data-type="figure" class="img-center"><img src="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/6eeaba28748b1cce0fe9f5964e37a23e92e3651d923c90aa0d984c2679707f75.png" blurdataurl="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAUCAIAAABj86gYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAEGUlEQVR4nKVVTWsbRxiWoGRpqrW9cjybkTySs5Ym0kIGorE1tneqrG0peGUtiC1aGcvBS2KBZdfgyE0/aGkxvcfQ5mLcmEIPhUIPPTk9hKTtpQTqe39Cf0GPLbtjD6pLc3Cf08zszPvxPO/7bkzTtNGkpoMxAMaGh4ZisVg8Ho8NQFEU7X8gpmna9999++knH76/9/Dro6Nut+u6bhAE+/v7vd7me3sPLWsuHo9f3oGqqgcHj4+Pjw8PD09Pf/v55YunT4+enZw8Ozl59erXF8+fe56XTqUMw7h8Brl87ibGhWIBY2yaZrFYMAwjm8mYpokQ4pxXq4uMMQDAJR1omgYAUFVV00YE48KWEuJNVR0Sd9QBAAAghLqun291YeECzhwwxhbm5xHKjoHrhWKRc75cry8sLpAItm3frdWW63VKS+KEECLSsu0KxpgQUq0uzs7M5CZzgoCb0aFpmqEDAMY+/+zjJ0++/OnHH/7684/NbtBqtTyvaVlztl2xrLlOZ3VnZ3u5Xrftyrx9x7Yrtl3pdFZ6vc1eb7Pf33WcpSBY7/d3P/rgUaezurHxYGPjgec1GSufOXh3q9vv737z1Re/n/7S9t9xnCXHWZouTzNWprTkuo1er+s4S7dLtyktMVZmrOy6y0Gw7vv+vbVO5U7F85qR6fuOs+S6DddtVKuLhNw6q6JIw7Ko+hFNMwwDIQTOgTHOZjK6rlNKhdQAgHw+l8+HhGCMIYSEEMuawxgbhpHP5xDKimuhA0VRIjZsVVV1XR8eGmKsjDEWEqmqOj01TWkJwuuzMzOcc1EC1uysbduu6zqOAwDgnPf7u5xzQgillBDyjyoyTRNCKI8QQhBCGQKKtrKK5J1sJjtphBBZCoURGkcRpMGQIs65YRgyZMbYpGEoinI1kbiaSHDOTdNUFEVaBwC8za1ardbprHpeE0LoOM79IFhptwWNjDHZmGEGGGPLmpN9BCEsFguE3CKEiHoXDUgIkc/SqRRC6I0rV0TfiAuTkXgC0lqYgec1+/2+zIBS6rputbooomNhzTRqUSswVh4eGRatw1hZURRhyPO8qDS9QrFAKbVtW1ISGwhZKjOi67oQRlVVw5iIFm8hNC6ZlWmJrVibpinIkWSeZeC6jYODx73epvgAdX2Klny/NT01pSgK55zSkg7GFubnCSHiDiHE85qu2xBWfL+1s9O7t7a2vbVVq9UuzqJ0KgUAkHP/WvLaaDIJIUQICUlFHwxWkdBGPoHnOJ9pAw5UVV1pt4NgXX7QdX3SuLHSbt+t1a4mEtFgWEVoPJ1KyWeMMd9vSSV933+0t7e9tRUE6xcpEuGIiNLj6cFYxKFY67o+mky+ZiwL8f+N0EFUV2GDRL+BbNREGVlwEzcmouExnkyOvsbBf+FvfsEpeo5GfUkAAAAASUVORK5CYII=" nextheight="563" nextwidth="900" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><ul><li><p><strong>YPIR</strong> Double-stateless and very fast (12.1 GB/s at 32 GB), with zero hint. Ruled out for live state by epoch-based re-preprocessing: it has no dirty-shard incremental, so every block forces a full rebuild.</p></li><li><p><strong>HintlessPIR</strong> Double-stateless, and its 4-thread number (about 232 ms at 1.07 GB) is the only measured frontier datapoint that crosses sub-200 ms. Ruled out by a full <code>O(N)</code> server re-preprocess per update and a heavy response (about 1.5 MB), with a C++ implementation that resists a WASM client.</p></li><li><p><strong>Respire and Spiral</strong> The smallest communication in the field. Ruled out by a stateful server, which links a client's queries across sessions even behind a mixnet, plus a respond path in the seconds and no native updates.</p></li><li><p><strong>SimplePIR</strong> The throughput baseline at 10 GB/s per core. Ruled out by a per-update client resync (the server sends the changed hint rows back to the client) and a hint that grows with the database.</p></li><li><p><strong>DoublePIR</strong> Shrinks the hint to an <code>N</code>-independent 16 MB. Ruled out by the same per-update client resync.</p></li><li><p><strong>Piano</strong> The only sublinear-server option (73 ms at 100 GB). Ruled out by a large client hint, a whole-database stream to build it, and a dynamic-update variant that is asymptotics-only, not implemented.</p></li><li><p><strong>Plinko</strong> The first updatable PIR with a worst-case near-constant per-entry update, transparent and MIT-licensed, with GPU benchmarks at mainnet scale. Held back by being interactive-hint with no measured online latency above 1 GB yet. It is the most interesting scheme to watch on the update axis.</p></li></ul><p><strong>Keyword PIR and the addressing layer</strong></p><p>There is a detail most PIR papers skip. PIR fetches by index. You do not know your row number. You know your address.</p><p>Bridging that gap is keyword PIR, and it needs an addressing layer that maps a key to a slot with no stored keyset and almost no collisions. The classic route is cuckoo hashing. The compact modern route is a binary fuse filter, which we built as its own crate. A binary fuse filter is a key-free probabilistic map at about 1.13 times the data size, the construction ChalametPIR uses, and it turns "give me row <code>i</code>" into "give me <code>balance(addr)</code>" without exposing the address space.</p><p>The harder version of this problem is still open, and the IPTF team framed it well recently: plain PIR only solves the known-index fetch. Private selection, finding your note in a crowd of ciphertexts or finding a neighbor leaf in a nullifier tree, is the real unsolved piece. Filters and PIR compose toward it, and a good part of our next thinking lives there.</p><p><strong>The unglamorous half</strong></p><p>Because we are forced to eat a linear server, the whole engineering problem becomes how fast the server can scan. That moves the center of gravity away from the cryptography and toward the parts nobody writes papers about.</p><p>Hardware does most of the work. AVX-512 is what gets YPIR to 12 GB/s. GPUs are the lever for the lowest-latency respond: GPIR demonstrates it, and PSE's LeanPIR targets the same class (no public paper yet). Multicore with rayon is the first and cheapest lever. All three attack the same linear-server tax directly.</p><p>Below that sit the kernels (NTT, RLWE arithmetic, modulus switching, packing) and the systems layer (the sidecar fold, a write-ahead log with snapshots, blue-green swap during re-preprocessing). PIR is a cryptography result. A shippable PIR is a systems and hardware result.</p><p><strong>How these schemes become exceptional</strong></p><p>Each engine has clear headroom, and the headroom is the roadmap.</p><p>For InsPIRe, the remaining work is shrinking the client further (a smaller one-time download and a warm cache the wallet can keep) and beating the linear-scan tax on the server with multicore and GPU, which is the cheap lever that turns an extrapolated latency into a measured one.</p><p>For iSimplePIR, the target is that cold-start hint: known techniques shrink it by roughly eight times and cut its setup cost by an order of magnitude. For VIA, the work is a Rust and WASM build, a bump to 128-bit security, and a multicore server, after which it becomes a genuinely deployable communication-optimal main engine.</p><p>Across all of them the same two frontier items recur: verifiable reads, where the client proves the server returned honest bytes by retrieving a Merkle witness under PIR, and concretely efficient DEPIR, which would end the trilemma for everyone.</p><p><strong>Closing</strong></p><p>PIR is a trilemma, not a checkbox. There is no best scheme, only the best one for the shape of your data and the device of your client. Ethereum's shape is live and mobile, so we built for that corner with InsPIRe, we engineer around the linear-server tax with hardware and a sidecar, and we are bringing in iSimplePIR and VIA to cover the shapes InsPIRe does not.</p><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/hisoka-io/raven">Raven </a>is the what axis: hiding which item you read. Nox is the who axis: hiding your network identity. Run them together and a chain read becomes anonymous in origin and private in content. That is the whole point.  More about Raven:<a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://hisoka.io/raven"><u>https://hisoka.io/raven</u></a></p>]]></content:encoded>
            <author>hisoka-labs@newsletter.paragraph.com (The Privacy Fellows)</author>
            <category>pir</category>
            <category>ethereum</category>
            <category>privacy</category>
            <category>raven</category>
            <category>hisoka</category>
            <category>web3</category>
            <category>blockchain</category>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/2acfa8b869c5d80692e924e70ae3a774d0bd1d8db986c2b26b8f3347a6be8527.jpg" length="0" type="image/jpg"/>
        </item>
    </channel>
</rss>