Compare modular blockchain designs
Consider two people checking the same rollup batch. A recovery operator needs every input byte to rebuild state. A reader on a limited connection may only need confidence that someone could recover those bytes. On Syscoin, the recovery operator can fetch the blob and hash it. Ethereum PeerDAS nodes sample columns, while Celestia and Avail light clients sample encoded shares or cells. Whole-payload and sampling checks
Syscoin’s other design choices affect what a node operator, an application, or a bridge verifier can check.
- A base node can check hash-based finality directly under Core #609. This candidate lets a node verify a bounded set of signatures locally. The price is a larger certificate on the network. Ethereum's proposed recursive aggregation would trade prover work for less material per verifying node. Direct verification and recursive aggregation
- An Edgechain can share settlement without sending its full batch through Gateway. Core takes the byte traffic, while Gateway processes compact references and proofs. A recovery operator still needs the payload. Two-Edgechain example
- An execution layer can tie its issuance to the base asset. In zkSYS, SYS stake and eligible Sentry collateral determine reward weight, and the resulting zkSYS token can pay eligible fees. Arbitrum One and OP Mainnet charge ETH for gas and distribute their separate governance tokens under their own allocation rules. Rollup economics and collateral
- A BTC withdrawal verifier could pause on visible disagreement. Participating miners already publish Syscoin ancestor tags in Bitcoin. The proposed bridge uses a qualifying conflicting tag to veto a release without first electing a winning Syscoin fork. Bitcoin-anchored fork detection
The Syscoin entries use the PQ candidate and the zkSYS design with real-proof settlement. Network and release status
What one MiB costs in data references
Take 1 MiB of identical application bytes and compare the two DA encoders in the ZKsync OS lineage. Each adds a 31-byte length prefix. The Syscoin encoder groups the result into chunks of up to 2 MiB. The upstream Ethereum encoder puts 31 application bytes in each of 4,096 field elements per blob. Other Ethereum applications can use different packing. Syscoin v0.24.4 encoder · Upstream ZKsync OS v0.4.0 encoder
| Measure for 1,048,576 input bytes | zkSYS compact references | Ethereum EIP-4844 with the upstream encoder |
|---|---|---|
| Encoded input to divide among blobs | 1,048,607 bytes | 1,048,607 bytes |
| Capacity used for the division | 2,097,152 bytes per chunk | 126,976 bytes per blob |
| Blob count | 1 blob | 9 blobs |
| Combined 32-byte IDs | 32 bytes in the Edge commit ID field | 288 bytes of versioned hashes across blob transactions |
| Serialized blob data before transport and erasure coding | 1,048,607 bytes, variable length | 1,179,648 bytes, nine fixed 128 KiB blobs |
The upstream encoder needs ceil(1,048,607 ÷ 126,976) = 9 blobs. Syscoin fits the same input in one, so the ordered list of 32-byte identifiers is one ninth the size. Ethereum’s 48-byte KZG commitment lets a reader authenticate a piece independently. Syscoin’s digest check takes the whole blob. EIP-4844 sizes and versioned hash · PeerDAS authentication · Gateway commit envelope
What a verifier can check with those bytes
| Publication path | Unit at the verification boundary | What the verifier does |
|---|---|---|
| Syscoin whole-blob DA | A 32-byte digest identifies up to 2 MiB of encoded bytes. The typed Core form carries one additional algorithm byte. | A reader hashes the full payload. The zkSYS proving guest computes the same BLAKE2s-256 IDs and takes Keccak-256 over their ordered list. Gateway can carry the list while independent readers fetch the bytes from Core. Core limits and types · Guest commitment |
| Ethereum PeerDAS | A 128 KiB blob extends to 128 cells of 2 KiB each. One column contains a cell from each blob at that index. A KZG proof is 48 bytes. | Nodes custody and sample columns. The separate EVM point-evaluation precompile accepts 192 input bytes, including the commitment and proof, to verify one claimed polynomial value. Mainnet cell parameters · PeerDAS columns · Point evaluation |
| Celestia regular DA | Shares are 512 bytes each, including their framing. Two-dimensional coding expands a square of k × k shares to 2k × 2k, four times as many shares. | A light node requests selected shares and verifies Merkle inclusion. This is another hash-based authentication route, with erasure coding and sampling at the availability layer. Share layout · Celestia sampling and reconstruction |
Why call BLAKE2s proof-friendly here? Airbender has a dedicated implementation for proving BLAKE2s rounds. The zkSYS guest derives each blob ID from the bytes and an ordinary Core node can reproduce it with a standard hash implementation. In Syscoin’s published nine-blob workload, the BLAKE2s commitment path used 300,000 guest cycles against 540 million for KZG. This saving applies to constructing the commitment. The full proof also includes execution, delegated circuits and wrapping. Original benchmark chart and cycle table · Airbender proving implementation · Syscoin guest and upstream KZG path
How networks publish rollup data
| Publication path | Commitment and availability check | History and settlement |
|---|---|---|
| Syscoin PoDA | For a block whose median time is at most two hours behind the node’s adjusted time, Core requires the whole blob and checks its hash. Historical Core sync can accept an older block carrying the commitment alone. A reader with the bytes can recompute the BLAKE2s-256 or legacy Keccak-256 digest. | Core serves blobs within a bounded window. Archive operators can retain them for replay. AuxPoW and the active ChainLock policy establish Core ordering and finality. The rollup's configured verifier checks its execution proof. Core byte-presence rule · PoDA retention |
| Bitcoin blocks | The header commits to the transaction Merkle root. SegWit adds a witness commitment through the coinbase. Full nodes download and validate the block data. | Pruned nodes may discard old block files after validation. Historical sync needs peers that serve the required blocks. Fork choice follows accumulated proof of work, giving confirmations probabilistic security. Bitcoin paper · BIP 141 · Bitcoin Core pruning |
| Ethereum blobs after Fusaka | The blob identifier is a versioned hash of a KZG commitment. PeerDAS extends blobs with erasure coding and distributes columns. Nodes custody assigned columns and sample peers to check availability. | Blob serving is time-bounded. Archival retrieval requires a data source that keeps the bytes. Ethereum proof-of-stake consensus orders the publication, and the rollup's contracts define its settlement rules. EIP-4844 · EIP-7594 · Storage strategies |
| Celestia regular blobs | A data square is extended in two dimensions with Reed–Solomon coding. Namespaced Merkle trees allow applications to authenticate their own shares. Light nodes sample shares to gain availability confidence. | Celestia consensus orders data publication. Its DA service leaves rollup execution and settlement to the rollup stack. Light-node sampling has a defined window and historical readers need providers that retain the required shares. Celestia data availability · Celestia retrievability |
| Celestia Fibre | Publishers split encoded blobs across validator-operated Fibre servers. Signed storage attestations from a voting-power quorum support settlement of the publication. Readers request shards by blob ID and reconstruct the payload. | Active on Mainnet Beta. Consensus records the commitment and finalizes payment. Server storage is time-bounded and availability depends on the provider quorum and reachable shards. When to use Fibre · Fibre network status |
| Avail DA | Data is arranged in a matrix with rows extended by Reed–Solomon coding. KZG commitments authenticate individual cells. Light clients sample cells through the peer network or RPC. | Avail's nominated proof-of-stake validators finalize headers. Rollup execution and settlement follow the rollup stack. Historical retrieval depends on who retains its data. How Avail DA works |
Other Bitcoin-oriented designs
Rootstock reuses Bitcoin mining work. Stacks anchors its ordering in Bitcoin. Nervos CKB gives independently operated nodes a UTXO-like state model.
| Network | What it shares with Syscoin | Main architectural difference |
|---|---|---|
| Rootstock | Reuses SHA-256 mining work from participating Bitcoin pools and supplies an EVM-compatible chain. | Rootstock couples merge mining with PowPeg and rBTC. Released Syscoin pairs its UTXO base with NEVM and supports blob publication. Direct hash-based ChainLocks are a Core #609 candidate. The released v5.1.3 line uses BLS. Rootstock foundations · Rootstock merge mining · Syscoin release evidence |
| Stacks | Combines Bitcoin-linked ordering with a distinct signing and execution system. | Proof of Transfer uses Bitcoin transactions for tenure selection and anchors Stacks history at tenure boundaries. Syscoin accepts AuxPoW under its own target and obtains durable finality from Sentry certificates. Proof of Transfer · Bitcoin finality in Stacks |
| Nervos CKB | Uses proof of work and a generalized UTXO model to let independent nodes verify state while computation can happen off-chain. | CKB validates state stored in Cells through RISC-V scripts. Syscoin's design uses Bitcoin merge-mining, a dedicated whole-blob DA path, and NEVM contracts to settle validity proofs from zkSYS. CKB Cell Model · CKB verification |
Syscoin puts mining and data publication on the same base. In the PQ and zkSYS design, Core checks the finality signatures directly, Gateway carries the compact commitments, and SYS stake or eligible Sentry collateral earns a share of Edgechain issuance. Syscoin design trade-offs · Network and release status
Rootstock also monitors Bitcoin coinbase commitments for visible sidechain forks. See Bitcoin-anchored fork detection for how Syscoin’s proposal uses related evidence in a withdrawal veto and what the Bitcoin light-client window must establish.
Whole-payload verification and data availability sampling
Before fetching a blob, a reader needs a reason to follow the history advertising it. A Syscoin full node can screen a candidate header chain using AuxPoW and cumulative work before downloading block bodies. Block validation and accepted ChainLocks constrain the history it ultimately accepts. Ethereum nodes returning after a long absence use a recent trusted checkpoint to anchor their proof-of-stake history. PeerDAS can then check availability against commitments on that history. Syscoin header sync · Ethereum weak subjectivity · PeerDAS specification
Syscoin’s PQ migration has its own bootstrap assumption. In the Core #609 candidate, an existing legacy-validated datadir authenticates the predecessor at activation height minus one (A−1). A future bootstrap release for fresh nodes may explicitly trust the independently verified hash of that boundary. Replaying historical data in the new client does not reverify the removed BLS signatures. This handoff concerns a change of finality rules. Routine AuxPoW screening answers which candidate bodies merit download. Pinned migration and bootstrap rules
PoDA's whole-blob check gives the reader the exact bytes to feed into a decoder, state reconstruction, or a prover. It costs bandwidth proportional to the bytes that reader fetches. Compact zkSYS references remove that payload from the Edgechain-to-Gateway batch envelope. Publishers and validating readers still need a data path for the bytes. zkSYS publication and retrieval · PoDA validation and limits
Networks that use data availability sampling encode a payload as redundant shares. A light node can check a small, random set of authenticated shares to gain confidence that enough were distributed to reconstruct the data. How much confidence it gains depends on the encoding, the number of samples, and the peers it can reach. An application replaying the batch still needs the reconstructed payload. Original data availability sampling paper
A valid commitment identifies data under the commitment scheme's assumptions. A successful fetch establishes access for that reader at that time. Canonical inclusion and finality establish which publication belongs to the accepted chain. A settlement proof covers the statement and inputs its verifier checks. Historical replay also uses the retained payloads and their order, authenticated prior state and block inputs. PoDA evidence and retention
Ethereum's blob interface associates availability with an Ethereum blob transaction and its consensus-layer publication. An application can build additional indexing and retrieval services around those commitments. Syscoin's Core interface lets an Edgechain publish independently and lets Gateway look up the content by digest through the same live DA service. zkSYS uses that interface to admit a small commit transaction while the full payload travels on the separate DA path. The cost moves toward Core propagation and retrieval, where block limits and fees constrain demand. Ethereum blob transactions · Gateway admission and settlement
Where cryptographic assumptions enter
Syscoin's design uses hashes for different jobs. AuxPoW validates SHA-256 mining work. PoDA uses a whole-blob hash to bind the payload. The PQ ChainLock protocol uses SHAKE-based signatures for operator identity and scheduled voting. Each choice protects a different object and has its own parameter, implementation, and operational assumptions. Post-quantum ChainLocks · Network and release status
Ethereum blobs and Avail use KZG, which has a structured setup and pairing-based group assumptions. Celestia's regular Merkle commitment uses hash assumptions, while validator authorization is a separate layer. Bitcoin's hashes protect mining work and block commitments. Spending rules also use classical signatures such as ECDSA or Taproot Schnorr. The cryptography of a data commitment gives only one part of each system's post-quantum profile. Ethereum KZG specification · Avail commitments · Celestia validator keys · BIP 340
The same rule applies above the base chain. A hash-based recursive proof path can have different assumptions from a deployment that wraps its proofs with a pairing-based proof for cheap contract verification. A payment through such a wrapper inherits its setup and soundness assumptions. Spending authority still comes from the account, and an operator with upgrade or custody keys retains the powers those keys grant. zkSYS proof and settlement path · Cryptographic standards and research
Direct verification and recursive aggregation
In the activated Syscoin design, Core nodes verify SLH-DSA authorization and each scheduled WOTS+ signature in the ChainLock certificate. The pinned certificate carries 801 roster-slot signatures and is about 1 MB. Core's slower time budget and bounded quorum make that an explicit bandwidth and verification trade. Moving rollup execution proofs to zkSYS lets Core take that trade on finality while applications benefit from succinct batch proofs. Syscoin certificate checks · System architecture
Ethereum's draft EIP-8292 defines an aggregator role for its proposed PQ consensus. A specialized leanVM prover proves that hash-based validator signatures are valid, and recursive aggregation can combine leaf proofs into larger claims. This design reduces the signature material other validators need to receive and check. The consensus path would also depend on the soundness of the proof system and the speed at which aggregators can produce proofs. The signatures are hash-based and the proof uses algebraic constraints and commitments. The leanVM project reports that the formal statements and the implementation's correspondence to the specification are still under review. Draft EIP-8292 · leanVM development and verification status
Protocol recovery and social recovery
Ethereum's deployed proof-of-stake protocol uses in-protocol penalties for defined forms of misbehavior and an inactivity leak to help restore finality after some outages. Its documentation treats coordinated social recovery as an exceptional fallback for conflicting finality or a dishonest finalized history. That judgment is distinct from applying evidence that a protocol can verify. Ethereum rewards and penalties · Ethereum attack and defense documentation
Syscoin keeps proof-of-work block production separate from Sentry finality. A certificate outage can leave the active tip moving while finality stalls. That property gives miners a way to contribute valid work through normal consensus during a finality outage. It applies above the last durable ChainLock, which the protocol enforces. Recovering progress when new certificates are missing and selecting between histories after a finality safety failure are different problems. Core finality outage behavior · Quorum safety assumptions
Rollup economics and collateral
Gas pays for execution. A security bond puts collateral at risk. A reward or governance token has its own issuance rules. zkSYS’s entry reflects its reference contracts. Network status
| Design | How users pay for execution | How the separate token is issued or earned |
|---|---|---|
| Arbitrum One | ETH pays gas. The protocol can also require a WETH bond for assertions. | ARB governs the DAO and had its own initial supply and distribution. ARB issuance is separate from the WETH assertion bond. Arbitrum gas FAQ · Nitro assertion bonds · ARB token |
| OP Mainnet | ETH pays gas. Users pay for execution and the rollup’s share of L1 data costs. | OP participates in Optimism Collective governance and has its own initial allocation and distribution schedule. OP Mainnet fees · Optimism governance · OP supply |
| zkSYS design | Native SYS is the ordinary fee path. An enabled Gas Tank lets an eligible transaction pay with prepaid zkSYS credit. The Gas Tank backs each outstanding unit of credit with a unit of deposited zkSYS. | The design links scheduled reward weight to SYS locked in the native staking vault and to eligible, SYS-collateralized Sentry Nodes. zkSYS rewards accrue according to the issuer's accounting. This link is a rule for earning issuance. The design creates no fixed-rate zkSYS claim on a pool of SYS. Native staking vault · Reward weights · Issuer · Gas Tank |
Arbitrum One and OP Mainnet can use Ethereum settlement and charge users in ETH while issuing their governance tokens under independent allocation rules. The zkSYS design connects part of its reward issuance to SYS at stake and gives the reward token a use in paying for execution. Gas Tank credit can coexist with a native SYS balance requirement in transaction admission. Pinned zkSYS fee accounting · zkSYS fee and issuance design thread
Tying rewards to SYS makes eligibility inspectable. Sequencing authority follows a separate rule. In the opt-in prover design, senior Sentries can perform and earn for proof work while a shared sequencer still orders the transactions. zkSYS prover service design