Skip to main content

Hash-based data availability

A rollup publishes data so independent participants can reconstruct its state. Syscoin’s Proof of Data Availability (PoDA) gives the batch two paths. The publisher sends the bytes to Syscoin Core, where another participant can fetch and check them. It sends their ordered hashes to Gateway, where settlement can identify the same data without carrying a second copy. The zkSYS code calls the Core publication path “Bitcoin DA” because Core uses Bitcoin-compatible merge mining. The blob payloads travel over the Syscoin network. Core 5.1.0 release notes · zkSYS batch publication

Design scenario. The diagram uses zkSYS v0.24.4 compact references and assumes the candidate PQ ChainLock rules are active. The settlement path can check whether the publication belongs to a locked Core history. A reader who retrieves and rehashes the blob checks the bytes they received. Core #609 · Geth #42 · Network and release status

How much crosses Gateway?​

A 5 MiB Edge batch illustrates what changes for the aggregator. Core receives 5,242,911 bytes, including the 31-byte length prefix, split across three blobs. In the earlier full-data design, Gateway would have carried the Edge payload in a 5,243,040-byte relay message. The v0.24.4 Edge commit supplies three ordered BLAKE2s digests totaling 96 bytes. Gateway adds the batch context and forwards a 288-byte relay message. Core still propagates the payload, and readers still need it for replay. Earlier full-data relay · Current blob encoder · Current relay encoder

Edge public dataCore blobs in v0.24.4Edge commit DA field, earlier → compactGateway relay message, earlier → compact
1 KiB11,154 → 32 B1,184 → 224 B
2 MiB minus 31 B12,097,251 → 32 B2,097,312 → 224 B
Exactly 2 MiB22,097,346 → 64 B2,097,312 → 256 B
5 MiB35,243,138 → 96 B5,243,040 → 288 B
64 MiB minus 31 B (encoder limit)3267,110,947 → 1,024 B67,109,024 → 1,216 B

These are byte counts from the two encoders for the same application input. The earlier Edge commit field included the payload and per-blob headers. Its Gateway relay used a 160-byte ABI header and rounded the payload up to a 32-byte boundary. The compact Edge field uses 32 bytes per blob. Its relay adds 192 bytes for the version, chain, batch, commitment, and dynamic-array encoding. The two fields belong to successive hops. Each excludes the surrounding transaction, proof, and other Gateway state changes. Earlier commit field · Current commit field · Current relay message layout

At the upper encoding bound, the Gateway relay message shrinks from 67,109,024 to 1,216 bytes, a ratio of about 55,188 to 1. The host and proving guest enforce the 31-byte prefix, which is why exactly 2 MiB of application data already needs two digests. Gateway also caps all forwarded references in one batch at 32. The saving is on the Gateway hop. Core still carries the full payload and settlement still waits for publication and proof. Gateway limits · Capacity and settlement tradeoffs

Why BLAKE2s fits the prover​

Edge proofs must bind execution to the batch bytes that readers can retrieve. In Syscoin’s V8 proving guest, the batch program computes standard BLAKE2s-256 over each chunk of the length-prefixed batch. The full payload takes this hash path. Airbender’s proving library can delegate its BLAKE2s round work to a specialized circuit. An ordinary Core node or archive reader can verify the identical 32-byte digest with a conventional BLAKE2s implementation. Guest commitment calculation · Proving and ordinary implementations · Delegated round processing

The guest then applies Keccak-256 to the ordered list of blob digests. For the 5 MiB example, this outer hash processes 96 bytes. Gateway binds the references to their chain and batch and hashes them into its ordered root. The SNARK wrapper verifies aggregated execution proof work at settlement and brings its own assumptions. This division places the prover-friendly hash on the largest input while preserving the commitment format expected by the settlement contracts. Edge commitment · Gateway reference binding · Settlement wrapper

We measured RISC-V commitment cycles on the same nine blobs and shared the counts on April 13, 2026. Our estimate for the combined input size was roughly 1.1 MiB. Figure 7 of the June 30 v31 testnet update uses those counts. The v0.24.4 encoder fits that much application data in one Syscoin blob, and Core allows up to 32 publications in a block. Original workload and cycle counts · June testnet report

Syscoin’s logarithmic chart of guest cycles for a nine-blob workload. KZG used 540 million cycles, Keccak used 154 million, and BLAKE2s used 300 thousand.

Figure 7. The logarithmic bars show guest cycles spent building the commitment. We used one H100 for the separate proving-throughput test in the June update. Open the full-size chart · April 13 cycle report · June testnet report, Figure 7

What the nine-blob benchmark records

We counted cycles for each algorithm on the same nine blobs and estimated their combined size at roughly 1.1 MiB. We have yet to publish the guest commit, encoded input fixture, proof and security settings, benchmark runner, or host for this cycle test.

DA commitment path testedGuest cyclesRelative to BLAKE2s
KZG path540,000,0001,800×
Keccak path154,000,000≈513×
BLAKE2s path300,0001×

Switching this workload from KZG to BLAKE2s cut commitment work from 540 million guest cycles to 300,000. Producing the full proof also takes application execution, delegated circuits, aggregation and wrapping. Ethereum’s KZG openings serve additional purposes such as verifying sampled blob cells. The choice trades those capabilities for a whole-blob digest that Airbender can prove efficiently and that ordinary readers can recompute. DA sampling comparison · Execution and proof stages

What the hash commits to​

Core accepts a legacy Keccak-256 digest or a BLAKE2s-256 digest. The typed BLAKE2s form is the byte 0x01 followed by the 32-byte digest where a versioned identifier is called for. Core decodes the algorithm and digest separately, recomputes the selected hash on supplied bytes, and rejects a mismatch. For Core blob lookups and the NEVM membership interface, use the 32-byte digest. Hash the exact payload bytes, including their order, and retain the algorithm alongside the identifier. SHA3-256 and Ethereum Keccak-256 are distinct algorithms. Core encoding · Core blob checks · Core lookup

This commitment is to a whole blob. A recipient downloads the bytes and recomputes the digest. There is no structured reference string or pairing operation in that check. Its cost is the full download. Core’s publication and relay rules make fresh data available, and an archive can serve it after the live window closes. BLAKE2 specification, RFC 7693 · Core data processing

One Syscoin Core block can include 32 DA publications of up to 2 MiB each, or 64 MiB of blob payload across all publishers. The data is carried as transaction sidecars. A zkSYS Edge batch also has a 32-blob encoding limit. Its 31-byte length prefix leaves 67,108,833 application bytes at that limit. Block occupancy depends on publishers, fees and relay. zkSYS derives ordered identifiers from the canonical publication bytes and checks those identifiers against the batch's operator DA input before publishing. Core limits · Core count check · Edge batch limit · zkSYS batcher

How PoW and compact relay protect the data path​

Any peer can forward a mined block. On the headers-first path, the receiving node checks continuity and the mining work before it requests the body and blob payloads. For a merge-mined block, it verifies the parent’s work against the Syscoin target and the commitment linking that work to the child header. Producing a fresh eligible header therefore requires mining work, and every receiver can check it for itself. Near the tip, Core considers direct block download only for a valid header tree with at least the active tip’s cumulative work. When a compact block arrives as an announcement, Core checks its header before trying to reconstruct missing transactions. AuxPoW checks · Headers and direct fetch · Compact announcement checks

There are two identifiers on this path. The 6-byte short ID helps a peer locate an already-known transaction. The 32-byte PoDA digest in that transaction lets the peer authenticate its full blob. The header’s Merkle root binds the transaction list. Each receiver checks the reconstructed block and, for a recent publication, the complete blob. When Core accepts a ChainLock covering the block, the publication and its digest are part of finalized history. A reader can then fetch the blob from a peer or archive and check those bytes against the finalized commitment. Compact transaction IDs · Reconstructed block checks · Blob validation · Publication and finality

What the receiving peer already holdsWhat crosses the connection
A matching transaction and its blob bytesThe compact announcement normally includes the header, coinbase, and one short ID per other transaction. Syscoin also carries any attached NEVM block data. The peer reuses the transaction from its mempool or extra transaction cache.
Some transaction positions still unresolvedThe peer can request the missing positions with getblocktxn. The sender returns those transactions in blocktxn. For a recent blob publication, the receiver still needs the full sidecar, the payload supplied alongside the transaction.
Compact reconstruction failsCore can request the full block with getdata or await another in-flight download. It applies the same block and sidecar rules to the result.

For example, take a block with 32 publications of 2 MiB each. On a connection where the receiving peer already holds all 32 transactions with their blobs, the compact announcement spends 192 bytes on their short IDs. If it lacks four of those transactions and obtains them by index, their attached payloads add 8 MiB to that exchange, plus transaction and message framing. Initial transaction propagation can deliver blob bytes before any miner includes them, under separate mempool admission rules. This is where the network still pays for whole-data publication. The bandwidth saved at block time depends on how much data peers already share. Local transaction matching · Missing positions and full-block fallback · Sidecar network serialization · Mempool admission

Availability, inclusion, and finality​

CheckEvidence to inspectWhat it establishes
Byte integrityRecomputed digest of retrieved bytesThe bytes match the identifier under the selected hash assumptions.
Availability lookupLocal Core blob metadata, or the configured PoDA archive responseA source reports the blob. Retrieve and hash the bytes when the application needs independent integrity verification.
Publication and finalityCanonical Core block containing the publication, with the required confirmations or ChainLockThe publication satisfies a specified settlement policy.
NEVM membershipThe 0x63 precompile returns the exact 32-byte digestA reference is present in sysgeth’s current canonical membership window.
Execution validityA settlement proof accepted by the active verifier for the expected batchThe verifier accepted a particular state transition under its configured proof system.

The v0.24.4 DA client checks availability with bounded JSON-RPC batches of getnevmblobdata calls using getdata=false. For entries the client treats as missing locally, it queries the configured PoDA archive in a separate batch. The Gateway admission and batch verification paths check these references. The commit path checks canonical publication and its configured finality separately. In the Tanenbaum one-confirmation configuration, a narrow NEVM registration path can satisfy the gate for previously registered hashes. The same fallback does not apply to mainnet or ChainLock policies. DA client availability · Gateway batch checks · Finality gate · Tanenbaum fallback policy

Retention and replay​

A node following the live tip checks blob bytes. A node syncing old history can validate the publication commitment after those bytes have expired. Core #609 makes this distinction using the block’s median-time-past (MTP) and the node’s adjusted current time. A sidecar is the blob data supplied alongside the transaction that commits to its digest. Block validation · Time limits

Age of the block by that clockSidecar rule
Up to and including 2 hoursThe node requires a nonempty sidecar and checks its digest.
More than 2 hoursThe node can accept the publication without a sidecar. If supplied, the node checks the bytes unless the old-block rule below applies.
More than 8 hours, with a recent ChainLockThe node requires the sidecar to be absent or empty. This rule requires a positive best ChainLock MTP no older than 2 hours against the same adjusted clock.

The mempool applies the sidecar checks using the active tip’s MTP. A person inspecting an old batch’s contents still needs matching bytes even when a Core node can sync its historical block from the commitment alone. Sidecar checks · Mempool clock

Suppose every block carries the full 64 MiB of blob payload and blocks arrive at the 150-second mainnet target. A node receiving one copy of each new payload averages 0.427 MiB/s, or 3.58 Mbit/s (67,108,864 bytes × 8 bits/byte ÷ 150 seconds ÷ 1,000,000 bits/Mbit). At that pace six hours gives 144 blocks and 9 GiB of payload before database overhead. Short bursts, duplicate transfers and serving peers can require substantially more link capacity. Finality delays can increase retained bytes. Archive operators can keep longer histories for replay and disputes. Mainnet target · Blob limits

Why a ChainLock changes when Core can delete bytes​

Suppose a blob is published once and no later publication renews its timestamp. Under Core #609, getnevmblobdata stops serving it when the active tip’s MTP is more than six hours past the blob’s recorded MTP. If ChainLocks stall, the unlocked suffix can still reorganize. A branch with an earlier tip MTP can bring the same publication back inside the lookup window. Keeping its bytes during that interval lets the node serve it again. Expiry predicate · Core query semantics

Under the activated PQ mainnet rules, accepting and enforcing a new ChainLock triggers pruning against the best accepted ChainLock block’s MTP. Once that clock passes the six-hour threshold, a normal reorganization respecting the lock cannot take the surviving publication back inside the window. Core can erase its stored payload and metadata. This gives independent validators a shared boundary for reclaiming storage, and it explains why a finality outage can increase disk use even while lookups expire on schedule. A node running with -testnet can also prune during a database flush using active-tip MTP. PQ ChainLock acceptance and pruning · Payload and metadata deletion · Testnet flush · Flush clock

Paired sysgeth #42 uses a third boundary. The 0x63 precompile returns the digest while one or more registrations remain in its 50,001-block current canonical window. A historical Ethereum eth_call selects past EVM state, but this precompile still consults the current membership index. A positive result can outlast Core’s live byte service or reflect a later registration of the same digest. To establish when that particular publication happened, verify its transaction in the original canonical Core block and apply the required finality policy. Membership window · Historical-call semantics · Reference count read

What can someone verify a week later?​

An archive operator retrieves a drive and seats it in a dock to read a saved copy.

Illustrative recovery. After Core’s lookup window closes, an archive that retained the blob can supply a copy. A reader can hash the returned bytes and compare the result with the digest in the original publication.

Consider a cooperative that gives members seven days to appeal a compute reservation. It can keep that promise without asking every Core node to store a week of data. What the cooperative needs to preserve depends on the question a member can ask. The reservation and appeal

Member’s questionEvidence that answers it
Which batch settled?Verify the recorded settlement against the expected chain, batch commitment, and verifier. The accepted proof attests to execution under that program. Settlement stages
What did the batch publish?Keep the original Core block hash and transaction ID, the batch’s ordered digests, and a reachable copy of the encoded blobs. Hash each blob, reassemble them in order, and check the batch commitment. The zkSYS recovery path similarly authenticates bytes fetched for republication before sending them to the wallet. Batch encoding · Ordered commitment · Recovery authentication
Can a replacement operator independently run the same blocks?zkSYS’s block replay archive stores transaction inputs, block context, protocol version, and forced preimages. Restore those records against a known canonical block hash and replay from the correct prior state. This is a separate service from the PoDA archive that serves content-addressed blob bytes. Replay inputs · Recovery and execution checks · Operator restore procedure

Use the zkSYS and DA command reference to query a blob, verify its bytes, and check the public Genesis network.