Repository navigation
0.22.2
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_heartbeator 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