zkSYS and Edgechains
zkSYS is Syscoin’s EVM-compatible execution chain. Send a payment and your wallet gets a receipt there. How can someone who never used your wallet check what happened? In the real-proof design, the Edgechain publishes batch data to Syscoin Core and a validity proof binds the execution result to the data commitment. Gateway is a shared settlement chain for Edgechains. Its contracts check the batch commitment and proof and record the accepted result in a Gateway block. The Gateway batch containing that block settles on Syscoin NEVM. Multiple Edgechains can share this path while setting their own execution and fee policies. Syscoin's Edgechain design · Syscoin's ZKsync OS server

The V32 design supports real proofs. On the Genesis public testnet, the Gateway batch traced below settled on Tanenbaum NEVM with its test verifier. Genesis public testnet · V32 testnet configuration · Real and mock verifier modes
What zkSYS uses from each layer
| Layer | What zkSYS uses it for |
|---|---|
| Core and PQ ChainLocks | Order and finalize publication so the settlement process can refer to a locked base-chain history. |
| PoDA | Publish the complete encoded batch data. A reader can fetch and hash the blobs. The Edge commit on Gateway carries their ordered identifiers. |
| NEVM and Gateway | Coordinate acceptance of Edgechain commitments and settle verified batches into a shared EVM state. |
| Airbender and the settlement verifier | Prove execution in batches and verify succinct claims about the state changes. |
| SYS-linked issuance and fees | Allocate a separate reward token using base-asset stake and eligible collateral. Use that token for eligible execution fees through the Gas Tank. |
| Upgrade and operator rules | Set who can change contracts, order transactions, produce or attest proofs, and receive compensation for measured work. |
Fast execution is an Edgechain property. Shared history, durable finality, and proof settlement have their own timing. The governance boundary matters because the users who rely on a proof also rely on rules about who can upgrade its verifier or change the operator and fee policies. Verify those authorities in each deployment. Base and Edgechain cadence · Operator participation · Enshrine or align?
Follow an application transaction
- Read the local receipt. The sequencer orders the payment in an Edgechain block. The receipt records its execution status and logs. A batch later groups that block with others.
- Identify the published data. The batcher derives a 32-byte BLAKE2s ID from each encoded blob and submits the full blobs to Core. For 5 MiB of application data, the Edge commit carries three IDs, 96 bytes in its blob-ID field. Anyone with a copy can hash each blob and match it against the ordered list. Batch publication · Encoding and exact wire sizes
- Check execution against that data. The proving program derives the blob IDs from the batch it executed. Keccak-256 commits to the IDs in order. The wrapped proof binds the state transition to the batch commitment. To accept it, the real verifier must check the proof against the agreed public input. A reader who wants to inspect a published payload fetches its bytes from Core or a retaining archive. Proving guest · Ordered commitment · Settlement public input
- Match the two settlements. Find the Edge batch’s execution event on Gateway. Its Gateway block belongs to a numbered Gateway batch. On NEVM, match that range to the Gateway batch’s commit, proof and execution records. Before submitting the Gateway commit, the node checks its own DA publications and the forwarded Edge blob references under its configured finality policy. Gateway commit checks
Try the two-settlement check on Genesis. Edge block 10,968 belongs to Edge batch 10,436. Gateway executed that batch in block 31,362. In turn, Gateway batch 9,448 covers blocks 31,360–31,362 and settled on Tanenbaum NEVM. The five public records span 22 minutes 37 seconds. The NEVM proof transaction for this Gateway batch used the V8 testnet mock format. Trace the transaction and decode the proof format
Why there are two proof stages
The V32 server code separates execution V7 from proving V8. In the V8 proof path a worker proves the RISC-V batch program with Airbender. FRI is a low-degree test used by the proof system to check polynomial encodings of execution constraints. Merkle commitments bind queries to previously committed data. The server verifies the submitted proof and binds its output to the expected batch public input and program. Proof shape, recursion, and batch input checks all matter to what the verifier has accepted. Execution and proving versions · V8 proof verifier · Airbender source
The separate SNARK stage aggregates and wraps proof work for an EVM-friendly verifier. The real proof producer checks that the deployed wrapper identifies itself as production mode and exposes the expected canonical verification key. An installed wrapper and valid public-input binding are part of the settlement security model. With a PLONK wrapper, the end-to-end system also has the wrapper's cryptographic and setup assumptions. The wrapper makes the proof cheap to verify in an EVM contract, at the cost of carrying those assumptions through settlement. Wrapper readiness · Wrapper implementation · Airbender prover implementation
What Gateway changes
Gateway can coordinate settlement for multiple Edgechains. If each chain sends its full payload through Gateway, each added byte uses the shared ingestion, batching, and proving path. One busy Edgechain can slow the others. In our testnet runs, the full-data path backed up under load. We moved the payloads to Core so Gateway could carry compact references. A proof that checks an Edgechain's execution binds the batch to its DA commitment. Gateway checks that the ordered array of 32-byte hashes matches the committed value. Its own execution data, proof aggregation, and settlement capacity still matter. Testnet update · Batch publication · Reference format and commitment
- Admit a commitment. In compact-reference mode, Gateway verifies the commitment format and checks availability through its configured Core DA node. The v0.24.4 admission path checks metadata in a bounded batch and can fall back to a configured archive for missing entries. A reader can obtain the full payload and verify its digest. Admission does not itself download and hash every blob or establish confirmation. Availability check · DA client and archive lookup
- Recover outstanding publications. If a publication stalls and the configured recovery policy allows another attempt, the finality gate can fetch the full blob, authenticate it against its digest, and republish it. Recovery depends on bytes still being available, a funded wallet, and the bounded recovery rules. Authenticated recovery path
- Check finality before settling. Gateway's commit path checks its own publications and forwarded Edge commitments against the configured policy. The NEVM
0x63precompile exposes registered digest membership as a separate on-chain interface. An application that needs to prove historical availability, replay, or ChainLock ancestry needs the corresponding evidence. Gateway commit gate · NEVM membership check
This makes Gateway closer to a light client for the shared execution history it accepts. It processes commitments and proof results while relying on a DA path capable of serving full data. Faster root import can make messages usable sooner after Gateway accepts the source root. It cannot fix an ingress backlog that delays source acceptance. PoDA capacity and retention · Cross-chain DA comparison
SYS collateral, issuance, and gas
SYS is the native balance on zkSYS. The zkSYS token is a separate 18-decimal ERC-20 issued on the Edgechain. In the reference design, native SYS staked on zkSYS and eligible Core Sentry collateral determine how accounts share scheduled zkSYS issuance. Wallets can use their issued or acquired zkSYS to prepay execution fees through the gas tank. Token contract · Reference deployment and roles
Collateral and issuance
- Stake native SYS. The staking vault holds native SYS on zkSYS and reports an account's balance to the reward registry. A withdrawal lowers the account's stake and returns native SYS from its vault balance. Native staking vault
- Recognize Core Sentry collateral. The NEVM registry bridge derives collateral height from the registered Sentry address via precompile
0x62and enqueues a membership observation for the Edgechain registry. Each relay samples the addresses supplied to it, so membership and reward weights depend on updates reaching zkSYS, including removals and replacements. The resulting weight can depend on collateral seniority and whether service accounting is active. Registry bridge · Membership update path - Claim scheduled rewards. The weight registry feeds periodic issuance accounting. Eligible accounts claim the rewards attributed to them and the issuer mints the ERC-20. The cumulative schedule applies 20%, 12%, and 8% of the remaining cap in the first three schedule years, then 5% per year, prorated over periods, subject to the 210 million zkSYS cap. SYS stake affects the share of this schedule. The token has its own supply and carries no contractual right to redeem it for SYS. Reward weight registry · Issuer schedule and claims
The reference configuration grants the issuer MINTER_ROLE and the Gas Tank BURNER_ROLE. Role administrators can change those assignments, and the proxy administrator can upgrade the token. Token role checks · Bootstrap authority wiring
Paying execution fees
- Fund gas credit. With an ERC-20 allowance,
funddeposits zkSYS for the caller.fundFordeposits for another account, and that recipient owns the resulting credit. The tank holds one atomic zkSYS unit for each atomic credit unit. A holder can withdraw unused credit as zkSYS. Gas tank funding, typed balances, and withdrawals - Precharge. The bootloader validates the sender's native SYS balance first. An ordinary transaction needs enough native balance for its value and maximum fee requirement even when it ultimately pays from the tank. Sufficient tank credit and execution resources allow the bootloader to precharge credit at the same numeric atomic-unit fee amount. Otherwise it can pay in native SYS. This native balance check is distinct from reward-eligible Sentry collateral and vault stake. Native balance validation · Bootloader fee selection
- Settle and burn. The bootloader returns unused fee credit to the refund recipient and credits the operator's priority tip. The base fee and any applicable blob gas fee reduce the tank's aggregate credit obligation. The corresponding zkSYS stays in the tank as surplus until someone calls
burnSurplus(). The charge and token burn are separate events. Bootloader refunds and fee settlement · Priority tip and consumed credit · Surplus burn
On an ETH-denominated rollup such as Arbitrum One, a user can bridge ETH to the rollup and pay fees with that native ETH balance. zkSYS joins two different mechanisms. Stake and collateral confer a share of independently scheduled issuance, and the gas tank lets users spend the resulting Edgechain asset on execution. The tank's 1:1 token-to-credit accounting sets a protocol fee rate in atomic units. It establishes no SYS-to-zkSYS market price or peg. Arbitrum native tokens and deposits
Sequencing, proving, and recovery
- Ordering and liveness. A proof constrains the state transition that a verifier accepts. Timely inclusion still depends on the deployment's sequencer, DA publication, proving, and settlement paths.
- Recovery. To inspect published batch data, retrieve the encoded blobs and check their digests. To re-execute the original blocks, a replacement operator also needs the prior state, transactions, block context, protocol version and forced preimages. zkSYS keeps those inputs in its block replay archive and checks the replay against an authenticated history. Replay inputs and recovery checks
- Cross-chain messages. Verify the message against the receiving contract's protocol and accepted settlement root. A source transaction receipt alone is insufficient evidence of destination delivery.
- Progressively decentralizing operators. Decentralized sequencing and proving are distinct objectives. Independently operated provers can share execution proof duties and endorse wrapping while a sequencer still determines transaction order. Our opt-in senior Sentry design shares proving work and pays bonuses by duty while using one shared sequencer. Decentralizing sequencing also requires a deployed ordering and handoff protocol. Prover service design and rollout boundaries
Use the public Genesis commands to check the network, inspect a deployment's issuance and gas contracts, or read the DA lifecycle for retention, retrieval, and membership checks.
Wallets and post-quantum account authorization
We’re adding post-quantum signing for zkSYS smart accounts in Pali v5. Pali manages the SLH-DSA keys locally. The validator module checks each user operation against the account’s authorized signer. With ERC-4337 modules, the account can set its own signing and recovery policies. SLH-DSA integration in Pali · ERC-4337
The native zkSYS verifier checks signatures under the experimental, limited-use SLH-DSA-SHA2-128-24 profile. This puts the SHA-2 work on a path Airbender can prove efficiently. The signing policy must enforce the profile’s per-key limit. Core uses a different signature profile for long-lived Sentry identity. Pali validation module · Native verifier implementation · Core identity and voting keys