Search for projects by name or address
ADI Chain is a zk rollup built for scale and policy alignment.
ADI Chain is a zk rollup built for scale and policy alignment.
The section shows the operating costs that L2s pay to Ethereum.
This section shows how much data the project publishes to its data-availability (DA) layer over time. The project currently posts data to
Ethereum.
This section shows how "live" the project's operators are by displaying how frequently they submit transactions of the selected type. It also highlights anomalies - significant deviations from their typical schedule.
All liveness anomalies detected for this project in the last 30 days, helping you review recent downtime and availability issues.
No State updates were performed for 7h 41m (from 2026 Sep 03, 04:46 UTC until 2026 Sep 03, 12:28 UTC). These typically occur every 31m 58s on average.
No Proof submissions were performed for 7h 41m (from 2026 Sep 03, 04:46 UTC until 2026 Sep 03, 12:27 UTC). These typically occur every 33m 38s on average.
No State updates were performed for 4d 1h (from 2026 Apr 04, 11:42 UTC until 2026 Apr 08, 12:50 UTC). These typically occur every 31m 58s on average.
No Proof submissions were performed for 4d 1h (from 2026 Apr 04, 11:41 UTC until 2026 Apr 08, 12:49 UTC). These typically occur every 33m 38s on average.
No State updates were performed for 3d 3h (from 2026 Mar 28, 17:46 UTC until 2026 Mar 31, 21:27 UTC). These typically occur every 31m 58s on average.
ADI chain mainnet launch
2025 Dec 9th
ADI mainnet is live as a ZK stack L2Layer 2 (L2) is a category of technical solutions aimed to scale the base layer in a trust minimized way. This category includes solutions like rollups as well as state channels and plasma. Other solutions are able to scale further, but with the introduction of additional trust assumptions, which are therefore not trust minimized. Sometimes the term Layer 2 is used to refer to include these solutions too, like validiums and optimiums, but to distinguish between trust minimized and non trust minimized solutions they are often referred to as "light" L2s, opposed to "strong" L2s like rollups. secured by the Airbender proverAn entity that generates the cryptographic proof to convince the verifier that the statement is true. In a ZK-Rollup, the prover generates the ZK (validity) proof to submit to the verifier contract..
Users can submit transactions to an L1Layer 1 (L1) is a blockchain that is self-reliant on its validator set for its security and consensus properties. Ethereum is an example of a layer 1. Blockchains started receiving the moniker of layer 1 once layer 2 became a meaningful area of development. queue, but can’t force them. The sequencers cannot selectively skip transactions but can stop processing the queue entirely. In other words, if the sequencers censor or are down, they are so for everyone.
STARKs and SNARKs are zero knowledge proofs that ensure state correctness. STARKs proofs are wrapped in SNARKs proofs for efficiency. SNARKs require a trusted setupGeneration of a piece of data that must then be used for some cryptographic protocol to run. Generating this data requires some secret information. The "trust" comes from the fact the secret must be destroyed after the ceremony, otherwise cryptographic properties of the protocol could be broken. Once the data is generated, and the secrets are forgotten, no further participation from the creators of the ceremony is required. There are two types of trusted setups for SNARKs: (i) trusted setup per circuit where it is generated from scratch for each circuit, (ii) trusted universal setup per proving system where it can be used for several circuits..
All of the data (SD = state diffs) needed for proof construction is published onchain.
Non-emergency upgrades go through a 3d delay, but the central operatorAn operator is the entity charged with managing a rollup and progressing its state. A rollup operator can be a centralized sequencer, proposer, prover, challenger, pauser of admin that is able to perform upgrades. can still censor withdrawal transactions by implementing a TransactionFilterer with no delay.
There is no window for users to exit in case of an unwanted upgrade since contracts are instantly upgradable.
Only the whitelisted proposers can publish state rootsA cryptographic hash succinctly representing a state using a Merkle tree. on L1Layer 1 (L1) is a blockchain that is self-reliant on its validator set for its security and consensus properties. Ethereum is an example of a layer 1. Blockchains started receiving the moniker of layer 1 once layer 2 became a meaningful area of development., so in the event of failure the withdrawals are frozen.
All the data that is used to construct the system state is published on chain in the form of cheap blobsThe data that a rollup publishes to its L1/data availability (DA) layer. They consist of the L2 transactions that are rolled up, along with some metadata. Blobs are introduced as a new transaction type within Ethereum with EIP-4844, and has rollup scaling specifically in mind. Blobs persist on Ethereum’s Beacon Chain ephemerally. or calldata. This ensures that it will be available for enough time.
Each update to the system state must be accompanied by a ZK proof that ensures that the new state was derived by correctly applying a series of valid user transactions to the previous state. These proofs are then verified on Ethereum by a smart contract.
MatterLabs proof systemThe infrastructure that allows projects to verify their state transitions. It is composed by onchain verifiers and offchain provers. The main two flavors are optimistic and ZK proof systems, but they can be combined in a hybrid model. In general though, if a system is able to accept state roots optimistically, even if it has a ZK component, it is considered an optimistic proof system. Airbender can be found here and contains essential tools like the ProverAn entity that generates the cryptographic proof to convince the verifier that the statement is true. In a ZK-Rollup, the prover generates the ZK (validity) proof to submit to the verifier contract., the VerifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover., and other backend components. The docs about the system can be found here.
Funds can be lost if the proof system is implemented incorrectly.
Onchain verifier
Onchain verifier |
Upgrades are managed by a Governance smart contract on L1Layer 1 (L1) is a blockchain that is self-reliant on its validator set for its security and consensus properties. Ethereum is an example of a layer 1. Blockchains started receiving the moniker of layer 1 once layer 2 became a meaningful area of development.. The owner of smart contract (ADI Multisig 2) can schedule either transparent or shadow proposals. Transparent proposals have full upgrade data onchain when scheduled. Shadow proposals post only the hashA fixed-length fingerprint of variable-size input, produced by a hash function. of the upgrade data onchain when proposed, and the full upgrade data during execution.
Scheduled proposals must wait a minimal delay before being executed (currently 3d). Governance supports a ‘securityCouncil’ role (Safe) that can execute proposals without any delay.
Currently, the governance process does not involve ADI token holders. See this link for more info: https://docs.adi.foundation/appendix/appendix-b-governance.
The metrics include upgrades on the currently used proxy contracts. Historical proxy contracts and changes of such are not included.
Used governance proposals to upgrade to v0.30.2, which modified only the verifier. New verifiers are not yet reproduced.
Used governance proposals to upgrade to v0.30.2, which modified only the verifier. New verifiers are not yet reproduced.
| contract Diamond (eth:0x0583Ef2B6416cb7B287406438B940E4d99680C5B) [shared-zk-stack/Diamond] { | |
| +++ description: The main contract defining the Layer 2. Operator actions like commiting blocks, providing ZK proofs and executing batches ultimately target this contract which then processes transactions. During batch execution it processes L1 --> L2 and L2 --> L1 transactions. | |
| values.$pastUpgrades.7: | |
| + | ["2026-09-09T08:38:23.000Z","0xb8aa1631290b261ab7bbc2d789cfcaec178946b0ec7c9231b139ad9ce23ea8c7",["eth:0xf9DD56364E3878056654C756cEBA692e577f8466","eth:0xB0D33d94aD4048070f510eF0086F12d20595dd07","eth:0xFA565846c217Bc0bA0f75027D4eECccdD68a9708","eth:0x56767eB2E3197A1dfa030faaD4A65cF38E807c81"]] |
| values.$upgradeCount: | |
| - | 7 |
| + | 8 |
| +++ description: Protocol version, increments with each protocol upgrade. | |
| +++ severity: HIGH | |
| values.getProtocolVersion: | |
| - | 128849018881 |
| + | 128849018882 |
| values.getSemverProtocolVersion.2: | |
| - | 1 |
| + | 2 |
| values.getVerifier: | |
| - | "eth:0x5E7cF1C310F9E0BF8DbFe70D5cC8021a2109D0AE" |
| + | "eth:0xccbdfd7f9A8e60d0C1e79fa620205d14121e7a39" |
| } | |
| - | Status: DELETED |
| contract ZKsyncOSVerifierPlonk (eth:0x08513A4646d1Bc8c348C67A3680bb19626E7F13F) [N/A] | |
| +++ description: None | |
| contract ZKsyncOSChainTypeManager (eth:0x08A1D2962fC29AA46e869A1E7561112cc1026EfA) [adi/ChainTypeManager] { | |
| +++ description: [FORK] This contract is not the standard hub contract from the Elastic network but a local fork for ADI chain. Defines L2 diamond contract versions, creation and upgrade data and the proof system for all ZK stack chains connected to it. ZK chains are children of this central contract and can only upgrade to versions that were previously registered here. The current protocol version is 0,30,2. | |
| description: | |
| - | "[FORK] This contract is not the standard hub contract from the Elastic network but a local fork for ADI chain. Defines L2 diamond contract versions, creation and upgrade data and the proof system for all ZK stack chains connected to it. ZK chains are children of this central contract and can only upgrade to versions that were previously registered here. The current protocol version is 0,30,1." |
| + | "[FORK] This contract is not the standard hub contract from the Elastic network but a local fork for ADI chain. Defines L2 diamond contract versions, creation and upgrade data and the proof system for all ZK stack chains connected to it. ZK chains are children of this central contract and can only upgrade to versions that were previously registered here. The current protocol version is 0,30,2." |
| values.getSemverProtocolVersion.2: | |
| - | 1 |
| + | 2 |
| values.initialCutHash: | |
| - | "0xedf457bf18d9feac26a2fb4a43686971a5eb0f0e21d80393cc8118ecaff31e29" |
| + | "0x8c06a7a3d4ce7eb8b62ffded867bcd4db8cbd092b1c1517d3ecaa6d02e6d1f55" |
| values.protocolVersion: | |
| - | 128849018881 |
| + | 128849018882 |
| } | |
| EOA (eth:0x3740B047227a94AcB5eCeCc5b7D6148857C81ecE) { | |
| +++ description: None | |
| proxyType: | |
| - | "EOA" |
| + | "EIP7702 EOA" |
| sourceHashes: | |
| + | ["0x1f44812af62d28f019e30e8eb2af596fb36c7db9d34576972c0405e110a6ef45"] |
| values: | |
| + | {"$implementation":"eth:0x63c0c19a282a1B52b07dD5a65b58948A07DAE32B","delegationManager":"eth:0xdb9B1e94B5b69Df7e401DDbedE43491141047dB3","DOMAIN_VERSION":"1","eip712Domain":{"fields":"0x0f","name":"EIP7702StatelessDeleGator","version":"1","chainId":1,"verifyingContract":"eth:0x3740B047227a94AcB5eCeCc5b7D6148857C81ecE","salt":"0x0000000000000000000000000000000000000000000000000000000000000000","extensions":[]},"entryPoint":"eth:0x0000000071727De22E5E9d8BAf0edAc6f37da032","getDeposit":0,"getDomainHash":"0xff0ef90d99405cd840d320a84642ddf007aa9a3fb9beee8bffd76cd39679a196","getNonce":0,"NAME":"EIP7702StatelessDeleGator","PACKED_USER_OP_TYPEHASH":"0xbc37962d8bd1d319c95199bdfda6d3f92baa8903a61b32d5f4ec1f4b36a3bc18","VERSION":"1.3.0"} |
| } | |
| - | Status: DELETED |
| contract ZKsyncOSDualVerifier (eth:0x5E7cF1C310F9E0BF8DbFe70D5cC8021a2109D0AE) [adi/ZKsyncOSDualVerifier_post_v30] | |
| +++ description: A router contract for verifiers. Routes verification requests to THE PLONK VERIFIER ONLY depending on the supplied proof version. | |
| contract Governance (eth:0x8253F33026c49A430963FE3991441c02175bda95) [adi/Governance] { | |
| +++ description: Allows scheduling transparent and shadow proposals, 'securityCouncil' role can execute without delay. | |
| +++ description: Number of executed proposals | |
| values.executedCount: | |
| - | 12 |
| + | 15 |
| +++ description: Number of scheduled transparent proposals | |
| values.scheduledTransparentCount: | |
| - | 12 |
| + | 15 |
| } | |
| contract ServerNotifier (eth:0xd477bd7f14F9A26ebd51827EFB1d40a41f71b70C) [adi/ServerNotifier] { | |
| +++ description: A simple contract that can be called by the ChainAdmin to emit notifications about chain migrations. | |
| +++ description: Scheduled upgrade timestamps for specific protocol versions. | |
| +++ severity: HIGH | |
| values.upgradeTimestamps.0: | |
| + | {"chainId":36900,"protocolVersion":128849018881,"upgradeTimestamp":1} |
| } | |
| + | Status: CREATED |
| contract ZKsyncOSVerifierPlonk (eth:0xC1288A84C5b2c93Ed4bF712fF4Bb96D862b32aa9) [N/A] | |
| +++ description: None | |
| + | Status: CREATED |
| contract ZKsyncOSDualVerifier (eth:0xccbdfd7f9A8e60d0C1e79fa620205d14121e7a39) [adi/ZKsyncOSDualVerifier_post_v30] | |
| +++ description: A router contract for verifiers. Routes verification requests to THE PLONK VERIFIER ONLY depending on the supplied proof version. | |
Executed two Governance proposals: - https://tools.l2beat.com/decoder-new/?hash=0x72cd8876128636f521ee95d874b59f0ce2c6e7f621bca48e342262f4285e40f0&data=AwA changed security council from an EOA to a 2/3 Safe. - https://tools.l2beat.com/decoder-new/?hash=0xbbec72e508d41c1bae51c7c5a0624bb5d7bd7b72778e1701f96b09bab032c1ed&data=AwA changed governance execution delay from 0 to 3 days.
Executed two Governance proposals:
| contract Governance (eth:0x8253F33026c49A430963FE3991441c02175bda95) [adi/Governance] { | |
| +++ description: Allows scheduling transparent and shadow proposals, 'securityCouncil' role can execute without delay. | |
| +++ description: Number of executed proposals | |
| values.executedCount: | |
| - | 10 |
| + | 12 |
| +++ severity: HIGH | |
| values.minDelay: | |
| - | 0 |
| + | 259200 |
| +++ description: Number of scheduled transparent proposals | |
| values.scheduledTransparentCount: | |
| - | 10 |
| + | 12 |
| +++ severity: HIGH | |
| values.securityCouncil: | |
| - | "eth:0x59Be28DE6eFb1f78802E96188d2b7907059Be59f" |
| + | "eth:0x95f0c748f60624ddAd536d979993fA23FD86021a" |
| } | |
| + | Status: CREATED |
| contract Safe (eth:0x95f0c748f60624ddAd536d979993fA23FD86021a) [GnosisSafe] | |
| +++ description: None | |
Owner of L1NativeTokenVault and L1Nullifier changed from an EOA to a multisig.
Owner of L1NativeTokenVault and L1Nullifier changed from an EOA to a multisig.
| contract L1NativeTokenVault (eth:0x0A0F8912162Ff83A036883dbaDA42efF647a3065) [shared-zk-stack/L1NativeTokenVault] { | |
| +++ description: Canonical central asset escrow for all ZK stack chains. | |
| values.owner: | |
| - | "eth:0x59Be28DE6eFb1f78802E96188d2b7907059Be59f" |
| + | "eth:0xdE4781a08Cc75D4E1b07fb3909840AE685960711" |
| } | |
| EOA (eth:0x59Be28DE6eFb1f78802E96188d2b7907059Be59f) { | |
| +++ description: None | |
| receivedPermissions: | |
| - | [{"permission":"interact","from":"eth:0x0A0F8912162Ff83A036883dbaDA42efF647a3065","description":"pause / unpause the bridge.","role":".owner"}] |
| } | |
| contract L1Nullifier (eth:0x5E5a72077dFB354Dfe61200b8f31fa491F9B9Cea) [shared-zk-stack/L1Nullifier] { | |
| +++ description: Contract responsible for bookkeeping L1 bridging transactions. Used to finalize withdrawals and reclaim failed deposits. Does not escrow funds. | |
| values.owner: | |
| - | "eth:0xb63320480218fbC7Cc31c3f92C254D4732528985" |
| + | "eth:0xdE4781a08Cc75D4E1b07fb3909840AE685960711" |
| } | |
| + | Status: CREATED |
| contract Safe (eth:0xdE4781a08Cc75D4E1b07fb3909840AE685960711) [GnosisSafe] | |
| +++ description: None | |
Upgraded executor facet on ADI Diamond to a new version, then upgraded back. Upgrade params stay the same, the only diff in the contracts is MAINNET COMMIT TIMESTAMP NOT OLDER change from 3 days to 10 days: https://disco.l2beat.com/diff/eth:0x56767eB2E3197A1dfa030faaD4A65cF38E807c81/eth:0x8991bF7Ed45ad2B8352efbaB83aD6e00c056a61c. Probably they did that to post old batches ( 3 days) from when the chain was down.
Upgraded executor facet on ADI Diamond to a new version, then upgraded back. Upgrade params stay the same, the only diff in the contracts is MAINNET_COMMIT_TIMESTAMP_NOT_OLDER change from 3 days to 10 days:
https://disco.l2beat.com/diff/eth:0x56767eB2E3197A1dfa030faaD4A65cF38E807c81/eth:0x8991bF7Ed45ad2B8352efbaB83aD6e00c056a61c.
Probably they did that to post old batches (>3 days) from when the chain was down.
| contract Diamond (eth:0x0583Ef2B6416cb7B287406438B940E4d99680C5B) { | |
| +++ description: The main contract defining the Layer 2. Operator actions like commiting blocks, providing ZK proofs and executing batches ultimately target this contract which then processes transactions. During batch execution it processes L1 --> L2 and L2 --> L1 transactions. | |
| values.$pastUpgrades.5: | |
| + | ["2026-04-08T18:36:47.000Z","0x4428eb3c0a1be76b850c3a1cd744087320aa49dfa2304311ed0579c10ec1e568",["eth:0xf9DD56364E3878056654C756cEBA692e577f8466","eth:0xB0D33d94aD4048070f510eF0086F12d20595dd07","eth:0xFA565846c217Bc0bA0f75027D4eECccdD68a9708","eth:0x8991bF7Ed45ad2B8352efbaB83aD6e00c056a61c"]] |
| values.$pastUpgrades.6: | |
| + | ["2026-04-09T13:05:35.000Z","0x08471063fd03e8dacd215a9c030f4c54a0f002c778a9a8283bc5161efae20e39",["eth:0xf9DD56364E3878056654C756cEBA692e577f8466","eth:0xB0D33d94aD4048070f510eF0086F12d20595dd07","eth:0xFA565846c217Bc0bA0f75027D4eECccdD68a9708","eth:0x56767eB2E3197A1dfa030faaD4A65cF38E807c81"]] |
| values.$upgradeCount: | |
| - | 5 |
| + | 7 |
| } | |
| contract Governance (eth:0x8253F33026c49A430963FE3991441c02175bda95) { | |
| +++ description: Allows scheduling transparent and shadow proposals, 'securityCouncil' role can execute without delay. | |
| +++ description: Number of executed proposals | |
| values.executedCount: | |
| - | 8 |
| + | 10 |
| +++ description: Number of scheduled transparent proposals | |
| values.scheduledTransparentCount: | |
| - | 8 |
| + | 10 |
| } | |
Plonk verifier is verified on etherscan.
Plonk verifier is verified on etherscan.
| contract ADI PlonkVerifier (eth:0x08513A4646d1Bc8c348C67A3680bb19626E7F13F) { | |
| +++ description: None | |
| unverified: | |
| - | true |
| values.verificationKeyHash: | |
| + | "0x124ebcd537a1e1c152774dd18f67660e35625bba0b669bf3b4836d636b105337" |
| implementationNames.eth:0x08513A4646d1Bc8c348C67A3680bb19626E7F13F: | |
| - | "" |
| + | "ZKsyncOSVerifierPlonk" |
| sourceHashes: | |
| + | ["0x99ad2513d609d837d3fb8bd7fa2df0a4f37aea1065e9036c5796772f248f8d30"] |
| } | |
The operatorAn operator is the entity charged with managing a rollup and progressing its state. A rollup operator can be a centralized sequencer, proposer, prover, challenger, pauser of admin that is able to perform upgrades. is the only entity that can propose blocksAn ordered list of transactions and chain-related metadata that gets bundled together and published to the L1/DA layer. Nodes execute the transactions contained within blocks to change the rollup chain’s state. Protocol rules dictate what constitutes a valid block, and invalid blocks are skipped over.. A live and trustworthy operator is vital to the health of the system.
MEV can be extracted if the operator exploits their centralized position and frontruns user transactions.
If a user is censored by the L2Layer 2 (L2) is a category of technical solutions aimed to scale the base layer in a trust minimized way. This category includes solutions like rollups as well as state channels and plasma. Other solutions are able to scale further, but with the introduction of additional trust assumptions, which are therefore not trust minimized. Sometimes the term Layer 2 is used to refer to include these solutions too, like validiums and optimiums, but to distinguish between trust minimized and non trust minimized solutions they are often referred to as "light" L2s, opposed to "strong" L2s like rollups. SequencerA party responsible for ordering and executing transactions on the rollup. The sequencer verifies transactions, compresses the data into a block, and submits the data related to it to enable state reconstruction to Ethereum L1 as a single transaction. The data can be either transaction data or state diffs., they can try to force their transaction via an L1Layer 1 (L1) is a blockchain that is self-reliant on its validator set for its security and consensus properties. Ethereum is an example of a layer 1. Blockchains started receiving the moniker of layer 1 once layer 2 became a meaningful area of development. queue. Right now there is no mechanism that forces L2 Sequencer to include transactions from the queue in an L2 blockAn ordered list of transactions and chain-related metadata that gets bundled together and published to the L1/DA layer. Nodes execute the transactions contained within blocks to change the rollup chain’s state. Protocol rules dictate what constitutes a valid block, and invalid blocks are skipped over.. The operatorAn operator is the entity charged with managing a rollup and progressing its state. A rollup operator can be a centralized sequencer, proposer, prover, challenger, pauser of admin that is able to perform upgrades. can implement a TransactionFilterer that censors forced transactions.
Users can be censored if the operator refuses to include their transactions.
Users can be censored if the operator implements a TransactionFilterer, which is possible without delay.
The user initiates L2Layer 2 (L2) is a category of technical solutions aimed to scale the base layer in a trust minimized way. This category includes solutions like rollups as well as state channels and plasma. Other solutions are able to scale further, but with the introduction of additional trust assumptions, which are therefore not trust minimized. Sometimes the term Layer 2 is used to refer to include these solutions too, like validiums and optimiums, but to distinguish between trust minimized and non trust minimized solutions they are often referred to as "light" L2s, opposed to "strong" L2s like rollups.->L1Layer 1 (L1) is a blockchain that is self-reliant on its validator set for its security and consensus properties. Ethereum is an example of a layer 1. Blockchains started receiving the moniker of layer 1 once layer 2 became a meaningful area of development. messages by submitting a regular transaction on this chain. When the blockAn ordered list of transactions and chain-related metadata that gets bundled together and published to the L1/DA layer. Nodes execute the transactions contained within blocks to change the rollup chain’s state. Protocol rules dictate what constitutes a valid block, and invalid blocks are skipped over. containing that transaction is settled, the message becomes available for processing on L1. ZK proofs are required to settle blocks.
If the user experiences censorship from the operatorAn operator is the entity charged with managing a rollup and progressing its state. A rollup operator can be a centralized sequencer, proposer, prover, challenger, pauser of admin that is able to perform upgrades. with regular L2Layer 2 (L2) is a category of technical solutions aimed to scale the base layer in a trust minimized way. This category includes solutions like rollups as well as state channels and plasma. Other solutions are able to scale further, but with the introduction of additional trust assumptions, which are therefore not trust minimized. Sometimes the term Layer 2 is used to refer to include these solutions too, like validiums and optimiums, but to distinguish between trust minimized and non trust minimized solutions they are often referred to as "light" L2s, opposed to "strong" L2s like rollups.->L1Layer 1 (L1) is a blockchain that is self-reliant on its validator set for its security and consensus properties. Ethereum is an example of a layer 1. Blockchains started receiving the moniker of layer 1 once layer 2 became a meaningful area of development. messaging they can submit their messages directly on L1. The system is then obliged to service this request or halt all messages from L1, including all forced withdrawals and deposits. Once the force operation is submitted and if the request is serviced, the operation follows the flow of a regular message.

Allows scheduling transparent and shadow proposals, ‘securityCouncil’ role can execute without delay.
A Multisig with 2/3 threshold.
A Multisig with 2/3 threshold.
A Multisig with 3/5 threshold.

The main contract defining the Layer 2Layer 2 (L2) is a category of technical solutions aimed to scale the base layer in a trust minimized way. This category includes solutions like rollups as well as state channels and plasma. Other solutions are able to scale further, but with the introduction of additional trust assumptions, which are therefore not trust minimized. Sometimes the term Layer 2 is used to refer to include these solutions too, like validiums and optimiums, but to distinguish between trust minimized and non trust minimized solutions they are often referred to as "light" L2s, opposed to "strong" L2s like rollups.. OperatorAn operator is the entity charged with managing a rollup and progressing its state. A rollup operator can be a centralized sequencer, proposer, prover, challenger, pauser of admin that is able to perform upgrades. actions like commiting blocksAn ordered list of transactions and chain-related metadata that gets bundled together and published to the L1/DA layer. Nodes execute the transactions contained within blocks to change the rollup chain’s state. Protocol rules dictate what constitutes a valid block, and invalid blocks are skipped over., providing ZK proofs and executing batches ultimately target this contract which then processes transactions. During batch execution it processes L1Layer 1 (L1) is a blockchain that is self-reliant on its validator set for its security and consensus properties. Ethereum is an example of a layer 1. Blockchains started receiving the moniker of layer 1 once layer 2 became a meaningful area of development. --> L2 and L2 --> L1 transactions.
[FORK] This contract is not the standard hub contract from the Elastic networkA constellation of nodes (peers) that communicate via a peer-to-peer protocol, for example, in propagating transactions and blocks to other nodes. but a local fork for ADI chain. Defines L2Layer 2 (L2) is a category of technical solutions aimed to scale the base layer in a trust minimized way. This category includes solutions like rollups as well as state channels and plasma. Other solutions are able to scale further, but with the introduction of additional trust assumptions, which are therefore not trust minimized. Sometimes the term Layer 2 is used to refer to include these solutions too, like validiums and optimiums, but to distinguish between trust minimized and non trust minimized solutions they are often referred to as "light" L2s, opposed to "strong" L2s like rollups. diamond contract versions, creation and upgrade data and the proof systemThe infrastructure that allows projects to verify their state transitions. It is composed by onchain verifiers and offchain provers. The main two flavors are optimistic and ZK proof systems, but they can be combined in a hybrid model. In general though, if a system is able to accept state roots optimistically, even if it has a ZK component, it is considered an optimistic proof system. for all ZK stack chains connected to it. ZK chains are children of this central contract and can only upgrade to versions that were previously registered here. The current protocol version is 0,30,2.
Simple registry for allowed DA validatorsIn the context of L2s, a Validator is an actor that validates the correctness of state transitions. For optimistic rollups this corresponds to challengers, and for ZK rollups this corresponds to the onchain verifier for different data availabilityThe property of a rollup's data being reachable by any node retrieving the data that were rolled up and executed to reach the proposed state. Data availability (DA), specifically decoupling it from the rollup nodes themselves, is one of the preeminent factors which allows a rollup to scale securely. A rollup is faced with a decision of what to use as a DA layer to guarantee that any node can retrieve this data--permissionlessly under any circumstance. For this reason, using Ethereum for DA currently provides the strongest security guarantees. If data is stored somewhere other than a permissionless L1, then the project is not a rollup, but rather a validium or an optimium. modes. Scheme 3 is used by default RollupL1DAValidator, the commitment includes EIP-4844 blobsThe data that a rollup publishes to its L1/data availability (DA) layer. They consist of the L2 transactions that are rolled up, along with some metadata. Blobs are introduced as a new transaction type within Ethereum with EIP-4844, and has rollup scaling specifically in mind. Blobs persist on Ethereum’s Beacon Chain ephemerally. data. Scheme 4 is used only for ZKsyncOS, it is keccakCryptographic hash function used in Ethereum. of blob versioned hashes filled with pubdata.
Contract responsible for bookkeeping L1Layer 1 (L1) is a blockchain that is self-reliant on its validator set for its security and consensus properties. Ethereum is an example of a layer 1. Blockchains started receiving the moniker of layer 1 once layer 2 became a meaningful area of development. bridging transactions. Used to finalize withdrawals and reclaim failed deposits. Does not escrow funds.
Aggregates remote bridgeA message-passing protocol between two blockchains. At its most basic, a token bridge consists of a smart contract which can escrow funds on one side of the bridge, and instruct the release or minting of corresponding assets on the other side, but bridges could also support arbitrary messages. How these instructions are validated is a critical factor in assessing the trust assumptions of a bridge. message roots from all ZK stack chains. To be used with the Gateway when deployed.
[FORK] This contract is not the standard hub contract from the Elastic networkA constellation of nodes (peers) that communicate via a peer-to-peer protocol, for example, in propagating transactions and blocks to other nodes. but a local fork for ADI chain. The main registry (hub) for chain contracts (supports more than ADI chain) and central entrypoint for bridgeA message-passing protocol between two blockchains. At its most basic, a token bridge consists of a smart contract which can escrow funds on one side of the bridge, and instruct the release or minting of corresponding assets on the other side, but bridges could also support arbitrary messages. How these instructions are validated is a critical factor in assessing the trust assumptions of a bridge. transactions. Stores important mappings like from chainId to diamond address, from chainId to parent CTM, from chainId to base token etc. A clone of Bridgehub is also deployed on each L2Layer 2 (L2) is a category of technical solutions aimed to scale the base layer in a trust minimized way. This category includes solutions like rollups as well as state channels and plasma. Other solutions are able to scale further, but with the introduction of additional trust assumptions, which are therefore not trust minimized. Sometimes the term Layer 2 is used to refer to include these solutions too, like validiums and optimiums, but to distinguish between trust minimized and non trust minimized solutions they are often referred to as "light" L2s, opposed to "strong" L2s like rollups. chain, but this clone is only used on settlementThe mechanism with which the execution of rollup blocks and the resultant state is verified and possible disputes are resolved. In the context of rollups or other modular blockchains, it often refers to the proof system used--validity (ZK) or fraud proofs, or a combination thereof. Sometimes it will refer to this mechanism along with where the mechanism's outputs are ultimately published and verified, as in Ethereum being a settlement layer by verifying the proofs and allowing for withdrawals. layers.
Asset deployment tracker where the ‘asset’ is a ChainTypeManager. The registering of asset IDs for ChainTypeManagers is necessary to be able to migrate them to a given settlementThe mechanism with which the execution of rollup blocks and the resultant state is verified and possible disputes are resolved. In the context of rollups or other modular blockchains, it often refers to the proof system used--validity (ZK) or fraud proofs, or a combination thereof. Sometimes it will refer to this mechanism along with where the mechanism's outputs are ultimately published and verified, as in Ethereum being a settlement layer by verifying the proofs and allowing for withdrawals. layer, for example the Gateway.
Intermediary contract between the ValidatorsIn the context of L2s, a Validator is an actor that validates the correctness of state transitions. For optimistic rollups this corresponds to challengers, and for ZK rollups this corresponds to the onchain verifier and the central diamond contract that delays blockAn ordered list of transactions and chain-related metadata that gets bundled together and published to the L1/DA layer. Nodes execute the transactions contained within blocks to change the rollup chain’s state. Protocol rules dictate what constitutes a valid block, and invalid blocks are skipped over. execution (ie withdrawals and other L2Layer 2 (L2) is a category of technical solutions aimed to scale the base layer in a trust minimized way. This category includes solutions like rollups as well as state channels and plasma. Other solutions are able to scale further, but with the introduction of additional trust assumptions, which are therefore not trust minimized. Sometimes the term Layer 2 is used to refer to include these solutions too, like validiums and optimiums, but to distinguish between trust minimized and non trust minimized solutions they are often referred to as "light" L2s, opposed to "strong" L2s like rollups. --> L1Layer 1 (L1) is a blockchain that is self-reliant on its validator set for its security and consensus properties. Ethereum is an example of a layer 1. Blockchains started receiving the moniker of layer 1 once layer 2 became a meaningful area of development. messages) by 0s.
Canonical central asset router for all ZK stack chains. Routes deposits and withdrawals to the respective asset handlers (like the L1NativeTokenVault); does not escrow funds itself.
A governance proxy that lets ADI Multisig 1 act through it.
A governance proxy that lets ADI Multisig 2 act through it.
Legacy bridgeA message-passing protocol between two blockchains. At its most basic, a token bridge consists of a smart contract which can escrow funds on one side of the bridge, and instruct the release or minting of corresponding assets on the other side, but bridges could also support arbitrary messages. How these instructions are validated is a critical factor in assessing the trust assumptions of a bridge. for depositing ERC20 tokens to ADI Chain.
Canonical central asset escrow for all ZK stack chains.
All supported tokens in this escrow are included in the value secured calculation.
Specialized contract for managing chain assets, i.e. chain migrations.
A router contract for verifiers. Routes verification requests to THE PLONKA zk-SNARK proving system introduced by Gabizon, Williamson and Ciobotaru in 2019 that allows proving custom circuits. Plonk is based on KZG polynomial commitments and thus requires a universal trusted setup. VERIFIERAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. ONLY depending on the supplied proof version.
A simple contract that can be called by the ChainAdmin to emit notifications about chain migrations.
Verifies a zk-SNARKShort for "succinct non-interactive argument of knowledge", a SNARK is a widely used type of zero-knowledge proof that is short and fast to verify. Different kinds of SNARKs are usually systematized by proof size, verification time, and type of setup. The most famous SNARKs are Groth16, PLONK/Marlin, Bulletproofs, and STARKs. proof using an implementation of the fflonk proof systemThe infrastructure that allows projects to verify their state transitions. It is composed by onchain verifiers and offchain provers. The main two flavors are optimistic and ZK proof systems, but they can be combined in a hybrid model. In general though, if a system is able to accept state roots optimistically, even if it has a ZK component, it is considered an optimistic proof system..
DA verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. specifically for zksync OS chains. It keeps track of blobThe data that a rollup publishes to its L1/data availability (DA) layer. They consist of the L2 transactions that are rolled up, along with some metadata. Blobs are introduced as a new transaction type within Ethereum with EIP-4844, and has rollup scaling specifically in mind. Blobs persist on Ethereum’s Beacon Chain ephemerally. versioned hashes and checks if blob with particular hashA fixed-length fingerprint of variable-size input, produced by a hash function. was published.
The current deployment carries some associated risks:
Funds can be stolen if a contract receives a malicious code upgrade. There is no delay on code upgrades (CRITICAL).