Repository navigation
v1.8.3
More verification speedups, faster legacy relay, and a few operator-facing changes. Check your config before upgrading.
Supported on Mainnet until block 3,643,309, around December 5, 2026. Upgrade warnings start about three days earlier.
Before you upgrade
- Generated configs and
peer_memory_budget_bytes.zakurad generateused to writepeer_memory_budget_bytes = 8589934592(8 GiB). That value now admits 43 native connections instead of 92, and 4 GiB or less won't start a node that runs native P2P. Raise[network.zakura] peer_memory_budget_bytesto at least 15 GiB, or delete the line to use the new 15 GiB default (#1884). - State tools moved into
zakurad. The standalonezakura-prune-stateandzakura-rollback-statebinaries are no longer shipped, including in Docker. Usezakurad prune-stateandzakurad rollback-state. They take the same arguments but loadzakura.toml, so pass--cache-dirto point at a specific state directory (#1997). - Managed zcashd needs system CA certificates. The managed
zcashddownload now trusts the system CA bundle, or the bundle named bySSL_CERT_FILE, instead of a built-in root list. Installca-certificates(or your platform's equivalent) on those hosts (#1995). - Plain-text logs. Log lines no longer contain color codes.
tracing.use_colorandtracing.force_use_colornow only control the startup screen-clear and logo (#1995). - Stricter config checks. Config load refuses
[network.zakura.quic] stream_receive_window_bytesbelow one block-sync frame (about 3 MiB) and[network.zakura.block_sync] bbr_max_cwnd_bytesabove about 246 MiB (#1620, #1884).
Highlights
- State disk reads and legacy TCP traffic are now bounded by byte budgets. A state read refused for capacity returns
notfoundto legacygetdata, and a retryable error fromgetblockandgetblockheader(#1868, #1882). - Verification is faster again. Transaction IDs are hashed in parallel for blocks with 64 or more transactions, Orchard proofs batch 128 actions at a time (a cold 1.9 MB Orchard block checks about 11% faster), and Common 5.2.0 speeds up Orchard batch verification and RedPallas (#2024, #2025, #2035, #2046).
- Note commitment trees are hashed in parallel with other chain updates, which speeds up blocks with shielded notes (#1952).
- RocksDB background flush and compaction now uses 2 to 16 jobs based on CPU cores, which removes write stalls during archive-mode initial sync (#1967).
- Legacy peer connections send each message as soon as it's written, so blocks reach peers tens of milliseconds sooner (#2011).
- A
getblocktemplatelong poll for an old tip now gets coinbase-only work on the new tip right away (#2038). - ARM64 Linux and macOS builds use hardware SHA-2 when the CPU supports it (#2015).
Full changelog
Added
- The
peer.block_gossip.advert_priority_writescounter: block announcements
written ahead of a peer's messages because those had kept the announcement
waiting (#2010).
Changed
-
Bounded native P2P raw frames and queued frames without another owner per
connection and stream kind. Each kind has a receive share and an output share
on every connection. A kind whose local consumers lag behind its share now
pauses that kind's readers or senders on that connection instead of retaining
more memory. No budget spans connections, so one peer's traffic cannot pause
another. Connection teardown now waits, for a bounded time, for its aborted
stream workers before returning its connection slot. A subscription's
terminal outcome now queues behind prior data without waiting for queue space
(#1620). -
Counted native P2P frames that the node has read but still keeps against the
peer's QUIC receive window, so a peer can't send more while the node holds
its earlier frames. A connection starts atquic.receive_window_bytes, and
after negotiation its window grows once by the receive share of each stream
kind it negotiated.quic.receive_window_bytesmay now be smaller than
quic.stream_receive_window_bytes
(#1620). -
Charged each native stream kind's receive share against
[network.zakura] peer_memory_budget_bytes, so a connection costs 144 MiB at
the default windows instead of 64 MiB. The default budget rises from 8 GiB
to 18,112 MiB and still admits 92 connections. A generated config that stores
peer_memory_budget_bytes = 8589934592now admits 23 connections; raise the
value or delete the line to use the default
(#1620). -
Refused a
[network.zakura.quic] stream_receive_window_bytesbelow one
block-sync frame (3 MiB plus its header) at config load, when the node runs
native P2P. Each stream kind receives at most one stream window
(#1620). -
Bounded connection teardown's wait for its stream workers to one deadline,
however many workers end during it. A request stream's response write now
also ends when its connection closes. A peer that reads responses slowly
can no longer hold its connection slot after the connection ends
(#1620). -
Returned an error from native endpoint startup, instead of panicking, when a
stream kind's receive or output share can't hold that kind's largest frame.
The check covers custom services' streams and configs built in code, and it
runs before the endpoint binds its QUIC socket
(#1620). -
Keep a configured
zakura.block_sync.max_inflight_block_bytesabove one worst-case block (about 2 MB). The node used to raise any value up to 32 MiB to just above 32 MiB (#1626). -
Cap each peer's block-sync byte congestion window at
zakura.block_sync.bbr_max_cwnd_bytes, 32 MiB by default, so the window never grants more than the block work queue admits. A peer at 1 Gbps and 250 ms still gets its full rate (#1630). -
Cap the block-request bytes one peer session may have outstanding at 32 MiB plus the floor bypass. The new
zakura.block_sync.bbr_max_cwnd_bytessetting sets the cap (#1864). -
Limit admitted blocking state reads across service clones.
Keep admission until cancelled jobs finish and reserve capacity for chain-tip reads
(#1868). -
Add one Tokio blocking thread per admitted state read to Tokio's default 512, so
saturated reads no longer delay other blocking work. -
Reserve the decoded bound of a disk read's recorded size before reading it, then
settle to the measured result and keep the charge through the last result handle.
Blocks, standalone transactions, headers and serialized blocks share one retained
byte budget. Report capacity refusal separately from missing data. Reserve
separate result capacity for chain-tip publication. -
Startup migrations, rollback, format checks and offline tools read without
network read admission. -
Add
read_result_byte_limit. When unset,zakuradderives it from the inbound
peer limit times the blocks onegetdatarequest can hold, clamped to
network.zakura.peer_memory_budget_bytes(8 GiB by default). -
Legacy
getdataanswers each block read refused for capacity withnotfound.
getblockheaderandgetblockreport a refusal as a retryable out-of-memory
error. The mempool no longer caches a transaction as rejected when the state
refuses its input lookup. -
Refuse to start when read or verification limits cannot fund their workers, or
when the effective verification limits exceed the node allowance. Log both
checked bounds at startup. -
Bound callers waiting for mempool outputs, and remove abandoned output and UTXO
waiters while the chain tip stalls. -
Bounded legacy TCP and compatibility ingress. Each outbound compatibility
exchange now funds its serialized frames from a gate its connection owns through
decode, and TCP decoders reserve at most 64 KiB before a message body arrives.
Decoded inbound gossip and requests share a byte budget until their handoff to the
inbound service, and a saturated budget refuses new work. Header responses now keep
their read admission through the send, and a separate charge covers their copied
bytes. Decoded TCPblockandtxmessages share a node-wide byte budget until the
connection hands them on. A response to this node's request never refuses, and a
saturated budget drops an unsolicited transaction.
The TCP decoder now continues past ignored Bloom and unknown commands to the next
message, so that message no longer waits for more bytes from the peer. An inbound
request stream now reserves its response's output from its stream kind's gate
before the service runs, so a peer that stops reading holds further requests of
that kind before they execute. The reservation counts each frame's overhead and
ignores a small frame cap, so a request whose response cannot fit its kind's
output share is refused before its service runs
(#1882). -
The derived state read result limit keeps its own 8 GiB ceiling, so the
larger peer memory budget does not raise it
(#1882). -
Native P2P now checks its combined resource limits at startup and refuses an
overflowing bound or an invalid decoded allowance. A new counter reports owner
counts above their bound
(#1884). -
The node-wide serving output budget now holds the budget of every session
that can serve at once, so conformant peers can no longer pause each other's
block and header serving. Those sessions are the inbound plus outbound peer
limits, clamped to the admitted connections. At the 92 default connections,
block sync and header sync can each reserve 5.75 GiB of unsent responses.
The new[network.zakura.block_sync] node_serve_output_bytesand
[network.zakura.header_sync] node_serve_output_bytessettings lower that
budget (#1884). -
Each native P2P connection's QUIC receive window now grants the handshake
window plus the receive share of each stream kind it negotiates, sized from
that reactor's own limits. The default peer memory budget changes from
18,112 MiB (#1620) to
15 GiB, so it funds the 92 default connections at those windows. The
default connection count stays 92
(#1884). -
Nodes that register custom P2P services through
zakurad::node::run_with_servicesnow charge each custom stream kind's
receive share to[network.zakura] peer_memory_budget_bytes, as the
connection's QUIC window grants it. At the same budget, such nodes admit
fewer native connections
(#1884). -
Operators with a generated config:
zakurad generatewrote
peer_memory_budget_bytes = 8589934592(8 GiB) into the config file. That
value now admits 43 native connections instead of 92, and a budget of 4 GiB
or less admits too few for a node that runs native P2P to start. Raise
[network.zakura] peer_memory_budget_bytesto at least 15 GiB, or delete the
line to use the default
(#1884). -
Config load now refuses a
[network.zakura.block_sync] bbr_max_cwnd_bytes
above about 246 MiB, because the block-sync receive share it derives must
fit QUIC's 256 MiB stream receive window. Such a config used to fail at bind
(#1884). -
[network.zakura.block_sync] max_inflight_block_bytesis now optional.
Unset, the node derives it from its block-sync connections and the cwnd cap:
2,944 MiB at the defaults, down from 6 GiB. Configs that set it keep their
value (#1884). -
New gauges
zakura.p2p.gate.held_bytesandzakura.p2p.gate.bound_bytes,
labeled by stream kind and gate, andzakura.p2p.compat_exchange.held_bytes
report the bytes each reactor holds, every 10 seconds
(#1884). -
Adding a block to the best chain now hashes the note commitment trees at the same time as
the other chain updates instead of one after the other, which makes accepting blocks
with shielded notes faster (#1952). -
Sized the state database's RocksDB background flush and compaction pool from
the available CPU cores (2 to 16 jobs) instead of RocksDB's default of two,
which removes write stalls during archive-mode initial sync
(#1967). -
zakuradlog lines are now plain text. Thetracing.use_colorand
tracing.force_use_colorsettings now only control the startup
screen-clear and logo
(#1995). -
The managed
zcashddownload now trusts the system CA bundle, or the PEM
bundle named bySSL_CERT_FILE, instead of a root list compiled into
zakurad. Hosts that use managedzcashdneed CA certificates installed,
for example theca-certificatespackage
(#1995). -
The standalone
zakura-prune-stateandzakura-rollback-statebinaries
are no longer shipped, including in the Docker image. Use
zakurad prune-stateandzakurad rollback-state, which take the same
arguments but start from the loadedzakura.tomlinstead of the default
state configuration; pass--cache-dirto choose the state directory
explicitly (#1997). -
Legacy peer connections send each message as soon as it is written, instead
of waiting for the peer to acknowledge earlier data. Blocks announced over a
new connection, and small blocks in general, reach peers tens of
milliseconds sooner (#2011). -
JSON-RPC 2.0 calls with one large string argument, such as
submitblock, now check that
argument for quotes and escapes with a vectorized search, which saves about 1.5 ms on a
1.9 MB block (#2021). -
Compute transaction IDs in parallel when verifying blocks with at least 64
transactions and multiple hashing workers, reducing hashing time for larger
blocks while keeping small blocks on the serial path
(#2024). -
Block verification hands transactions to the transaction verifier without waiting on it
for each one, which shortens verification of blocks with thousands of transactions
(#2025). -
Orchard proofs are now verified in batches of up to 128 actions instead of 64, which checks
a cold 1.9 MB Orchard block about 11% faster
(#2035). -
Reduced mempool polling work between blocks by checking transaction expiry
only when the best chain grows
(#2044). -
Updated Common dependencies to 5.2.0, bringing faster Orchard batch
verification, RedPallas signing and verification, and multiscalar
multiplication
(#2046). -
Reduced mempool TXID lookup work by selecting requested transactions
directly from the existing index
(#2047).
Fixed
- Fixed discovery admission so that a peer's replacement session in the other
direction no longer exceeds that direction's peer limit. The bug predates this
PR (#1621). - Query a reopened block gap first after a block-sync reset or a failed block apply, instead of finishing a stale body-size hint refresh (#1626).
- Restart a persistent body-unavailable alarm for a new supplier on the next block-sync re-query, even when the supplier's status notice was dropped (#1626).
- Stop a rejected block body that races a header-authority refresh from leaving other suppliers suppressed for that body (#1626).
- Grant the block-sync liveness congestion grace once per no-progress episode, so a peer can no longer renew it by briefly draining its outbound queue (#1630).
- Show no free block-sync slots for a peer at its no-progress request cap, so other peers no longer defer the download floor to a peer that refuses work (#1630).
- Preserve block-download capacity through cancellation and request transfer. Close admission and drain accepted block work for at most 30 seconds when accounting fails (#1864).
- Keep a reissued block request funded when a late body for that height's pre-reset hash arrives. The late body previously ended the replacement's reservation, which could stall block sync at that height (#1864).
- Keep native block-sync decoded payloads charged while downstream holders retain them.
Retry pending block decoding when holders release capacity.
Limit decoded bytes in the block-sync pipeline by a bound derived from its request budgets,
without refusing requested bodies or commit-window submissions
(#1865). - Keep block-sync peer reports from verification out of the action-channel slot reserved for needed-body queries and body-availability requests.
A tampering report waits for room beyond that slot instead of taking it
(#1865). - Keep a block that failed to apply within the decoded pipeline bound until verifier work that outlives the apply, such as queued script checks, releases it
(#1865). - Keep discovery connections open when another service takes ownership while
discovery waits for pending answers. Prevent discovery from missing exchange
completion notifications
(#1867). - Release discovery dial reservations and transport capacity when a candidate worker is cancelled
(#1867). - Keep a discovery query's reservation slot through verification and import of its answer, so a
slow verification cannot stack further answers. A closing discovery-only connection now waits, up
to its deadline, for answers the peer already delivered
(#1867). - Stop importing a
Peersanswer whose discovery session was replaced during its verification
(#1867). - Credit a discovery dial only for a registration that its own handshake authenticated. A
registration from another connection no longer scores the attempt or confirms the dialed record,
so this node no longer shares that record's addresses with other peers. A dial that this node's
admission limits refuse at registration now pauses discovery dialing instead of backing off the
peer
(#1867). - Hold a closing discovery-only connection, up to its deadline, for a
Helloin verification, so the
connection closes with the exchange counted as complete
(#1867). - Count in-flight discovery dials against the connection soft cap, so discovered peers no longer
take the slots reserved for bootstrap peers. The bug predates this PR
(#1867). - Keep a connection open when another service takes it while discovery closes a discovery-only
exchange. Discovery now checks the connection's owners last, with no wait before the close
(#1867). - Fixed Zakura-only nodes shutting down at startup with "genesis apply handoff
failed: illegal sync lifecycle transition" when the header runtime was ready
before block sync started
(#1965). - Fixed header sync letting a peer escape its penalties. Replacing a session no
longer resets the peer's unproductive-request strikes, and a reconnect within
one readmission cooldown resumes them. Invalid headers that arrive after their
request retired still hold back the peer's readmission
(#2001). - Fixed block sync crediting a peer's reliability for every late block body.
A late body now offsets only a timeout that the same session charged for its
height, and only once
(#2002). - A peer that always has a message ready can no longer keep this node's block
announcement queued on its connection: once its messages have held the
announcement back for a second, the announcement is written first, so such a peer
cannot spend a block's announcement
(#2010). - Enable runtime-detected SHA-2 acceleration on little-endian ARM64 Linux and
macOS builds, retaining the software fallback when CPU support is unavailable
(#2015). - A
getblocktemplatelong poll sent with an older tip's ID now gets
coinbase-only work on the new tip right away, instead of waiting for the
mempool to catch up and building a full template first
(#2038).
Security
- The managed
zcashddownload never trusts eMudhra (emSign) root
certificates, even when the system bundle includes them
(#1995).
Also in CHANGELOG.md.