Skip to content

0.22.2

Choose a tag to compare

@garethtdavies garethtdavies released this 18 Nov 03:38
v0.22.2
317f6ec

minanode 0.22.2 release notes

0.22.2 fixes how the node verifies and fetches blocks with many zkApp proofs.
Upgrade every node you run before proof-heavy zkApp traffic reaches mainnet. On
devnet, a 0.22.1 node fell behind the chain on blocks with 180 zkApp proofs. A
fresh node with 0.22.1's limits could not sync while such blocks were recent.
Three more fixes make proof and block checks match OCaml. The node also verifies
each transaction and zkApp proof once. 0.22.2 is a beta release. The web node
runs on devnet only. Use only devnet keys in it.

Blocks with many zkApp proofs

Four changes let the node and the web node handle blocks full of
proof-authorized zkApp commands.

  • Batched zkApp proof verification. The node verifies the zkApp proofs in a
    block in batches that share one verifier setup. 0.22.1 built the setup again
    for each proof (#50).
  • Verification jobs one at a time. Each verification service runs its jobs
    on the Rayon thread pool one at a time. Pool threads get a 64 MiB stack. In
    0.22.1, a burst of SNARK work and transactions could nest verification jobs on
    one pool thread until its 2 MiB stack overflowed. A stack overflow aborts the
    node. This happened on an ARM64 mainnet node (#49).
  • Larger block answers. The node reads block and best tip answers from peers
    up to 32 MiB, the block gossip limit. 0.22.1 stopped at 3.5 MB. A block with
    180 zkApp proofs is about 3.7 MB. A running node gets new blocks by gossip,
    but a fresh node, or one that missed a block, fetches blocks from peers. With
    the 3.5 MB limit, such a node can't sync while a larger block is among the
    last 290 blocks. Mainnet peers have already sent best tip answers of up to 6
    MB. Answers above 3.5 MB share a 64 MiB budget across the node, and each
    answer's buffer grows only to the length its peer declared (#54).
  • Larger staged ledger messages in the web node. The web node reads staged
    ledger messages from relays up to 128 MiB. 0.22.1 stopped at 16 MiB. The
    root's staged ledger arrives one scan-state tree per message. A tree full of
    proof-heavy zkApp commands reached 37.3 MB on devnet. While such a tree was in
    the root's scan state, a new 0.22.1 web node could not sync (#55).

A test on public devnet on 2026-11-15 sent 324 zkApp commands, each with 15
proof-authorized account updates. They filled 28 consecutive blocks, most with
12 commands, 180 proofs and about 3.7 MB.

  • A 0.22.1 node took 370 s and 326 s to apply the first two of these blocks. It
    then fell 27 blocks behind.
  • Nodes with the verification fixes applied every block in under 4 s. They
    stayed synced, and their best chains matched an OCaml node's at every height.
  • A fresh node with 0.22.1's 3.5 MB limit stopped at 281 of 291 blocks. It had
    not synced when it was stopped after about 30 minutes. A fresh node built from
    this release's code synced in about 2 minutes.
  • On 2026-11-16, the root's scan state held trees of 25 to 37 MB. A web node
    with 0.22.1's 16 MiB limit had not synced after 8 minutes. A web node built
    from this release's code synced in 152 s and kept up with the chain.

Each proof verified once

The node verifies each transaction proof and each zkApp proof once (#57).

  • SNARK work. The node verifies a transaction proof when the work reaches
    its snark pool. 0.22.1 verified the proof again in every block that bought the
    work. 0.22.2 skips it there.
  • zkApp proofs. The node verifies a zkApp proof when the command enters its
    transaction pool. 0.22.1 verified the proof again in the block that included
    the command. 0.22.2 skips it there.
  • What is kept. For each proof it accepted, the node keeps a SHA-256 digest
    of the statement and the proof. A zkApp proof's digest also covers its
    verification key. Transaction proofs are skipped only under the node's own
    transaction verification key. The node holds the 65,536 most recent digests in
    memory, an estimated 10 MiB. It keeps none across restarts.
  • What still runs. A proof with another statement, fee or prover gets no
    match and is verified as before. So does a zkApp proof under another
    verification key. A proof whose digest the node no longer holds is verified
    again. Signatures, a work's fee and prover, and the verification key in the
    block's ledger are checked every time.
  • Switch. MINA_VERIFY_EVERY_PROOF, set when the node starts, verifies
    every proof each time, as 0.22.1 did.

The first 1,252 Mesa mainnet blocks, replayed in order with full verification on
an 8-vCPU VM, took 116 to 121 s to apply before this change and 30 to 31 s
after. That is the best case: the snark pool had verified every work in each
block first. A median block with SNARK work took about 700 ms before and 80 ms
after.

Checks that match OCaml

  • The node refuses a block or transaction proof whose bulletproof does not have
    the wrap circuit's 15 rounds. It refuses the proof before it runs the
    verifier, as OCaml does (#51).
  • The node refuses a block, transaction or zkApp proof whose step messages hold
    more than two entries, or two lists of different lengths. OCaml refuses such a
    proof when it decodes it (#52).
  • The node hashes a block's VRF output at any length, as OCaml does. It checks
    block proofs against the state hash that OCaml computes for the protocol state
    (#53).

Other changes

  • The node no longer serves POST /make_heartbeat or builds the signed
    heartbeat behind it. Both were left over from the web node leaderboard. The
    external SNARK worker module, which was never compiled, is also gone (#47).
  • A minaweb.org link shared in a chat app or on a social site shows an image, a
    title and a description (#48).

Upgrade from 0.22.1

Replace the binary as the
install guide describes. Start
the node with the same work directory and flags. 0.22.2 needs no state
migration. If a script of yours calls POST /make_heartbeat, remove that call.
0.22.2 doesn't have the route.

With Docker, pull ghcr.io/minanode/mina-rust:0.22.2 and check its digest, as
Docker describes.

mina-web-0.22.2.tar.gz runs this release's web node from your own computer,
through the minaweb.org relays.
Run the web node yourself has the
steps.

Known issues

  • The fixes were measured on devnet. They have not been measured under heavy
    zkApp traffic on mainnet.
  • Memory rises with proof-heavy blocks. In the devnet test, nodes that did not
    produce blocks used up to 0.8 GiB more memory at peak. After the traffic
    ended, they stayed 0.3 to 0.7 GiB above where they started.
  • A node waits 8 s for a block from a peer before it asks another peer. In the
    devnet test, a fresh node took up to 6.5 s to fetch a 3.7 MB block. OCaml
    waits 15 s.
  • Proof skipping was measured on replayed mainnet blocks. The share of a block's
    proofs that a live node has already verified was not measured. A proof the
    node did not see before the block is verified as before.
  • The web node's 128 MiB limit is about 3.6 times the largest scan-state tree
    measured on devnet. It is not a proven maximum for a tree.
  • The
    0.22.0 known issues
    still apply.

Checksums

SHA256SUMS lists the release archives:

cdfa7190925f0393fe4ba841e5c925203a8e530cfdef1be03e781a85bcf500cc  mina-0.22.2-linux-x86_64.tar.gz
b29b968e8f6fb75d291963cdb75b811bcac645188e93887158c9e7673307e657  mina-0.22.2-linux-arm64.tar.gz
92ce9450139342f1f07199957f7226f788a4e9ae8098a6740132d3a29d321d7e  mina-web-0.22.2.tar.gz
Docker: ghcr.io/minanode/mina-rust:0.22.2
(ghcr.io/minanode/mina-rust@sha256:c67b91930ac96d6032fecec9126b0c49332ffe738f6aa3dce8887fcc89a7e4ae)

SHA256SUMS.sig is the SSH signature of SHA256SUMS by release@minanode.org.
Obtain allowed_signers from minanode.org and compare its fingerprint with the
install guide. Verify before
unpacking:

ssh-keygen -Y verify -f allowed_signers -I release@minanode.org \
  -n file -s SHA256SUMS.sig < SHA256SUMS &&
sha256sum --check --ignore-missing SHA256SUMS