Search

Search for projects by name or address

ADI Chain logo
ADI Chain

Badges

About

ADI Chain is a zk rollup built for scale and policy alignment.



Badges

About

ADI Chain is a zk rollup built for scale and policy alignment.


Total
Canonically BridgedCanonically Bridged ValueCanonical
Natively MintedNatively Minted TokensNative
Externally BridgedExternally Bridged ValueExternal

ETH & derivatives
Stablecoins
BTC & derivatives
Other
Compare with other projects
Past Day UOPS
Past Day Ops count
Max. UOPS
Past day UOPS/TPS Ratio
Compare with other projects

The section shows the operating costs that L2s pay to Ethereum.



Total cost
Avg cost per L2 UOP
Avg cost per day

Compare with other projects

This section shows how much data the project publishes to its data-availability (DA) layer over time. The project currently posts data toEthereumEthereum.



Data posted
Avg size per day
Avg size per L2 UOP

Compare with other projects

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.

No ongoing anomalies detected

Avg. proof subs. interval
Avg. state updates interval
Past 30 days anomalies
98% normal uptime

Last 30 day anomalies

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..

Learn more
Sequencer failureState validationData availabilityExit windowProposer failure
Sequencer failure
Enqueue via L1

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.

State validation
Validity proofs (ST, SN)

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..

Data availability
Onchain (SD)

All of the data (SD = state diffs) needed for proof construction is published onchain.

Exit window
None (emergency upgrade path)
3d (regular upgrade path)

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.

Proposer failure
Cannot withdraw

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.

ADI Chain
ADI Chain is a
Stage 0
ZK Rollup.
The requirement for available nodeA software client that participates in the network. software is under review

Learn more about Stages
Please keep in mind that these stages do not reflect project security, this is an opinionated assessment of project maturity based on subjective criteria, created with a goal of incentivizing projects to push toward better decentralization. Each team may have taken different paths to achieve this goal.

All data required for proofs is published on chain

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.

Learn more about the DA layer here: Ethereum logoEthereum

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.


Prover Architecture

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.

PROVER

Trusted Setups

Onchain verifier

Used in

ADI Chain logo

Onchain verifier

Used in

ADI Chain logo

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.

Past upgrades

The metrics include upgrades on the currently used proxy contracts. Historical proxy contracts and changes of such are not included.

Count of upgrades
7
Last upgrade
19d 18h ago
Avg upgrade interval
3mo 2d
2026 September 10, 12:09 UTC
High severity
19changes

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.
2026 September 03, 10:44 UTC
High severity
5changes

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.

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
2026 June 04, 15:16 UTC
4changes

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
2026 April 10, 08:25 UTC
5changes

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
}
2026 March 20, 15:54 UTC
4changes

Plonk verifier is verified on etherscan.

New and verified contracts

contract ADI PlonkVerifier (eth:0x08513A4646d1Bc8c348C67A3680bb19626E7F13F) {
+++ description: None
unverified:
- true
values.verificationKeyHash:
+ "0x124ebcd537a1e1c152774dd18f67660e35625bba0b669bf3b4836d636b105337"
implementationNames.eth:0x08513A4646d1Bc8c348C67A3680bb19626E7F13F:
- ""
+ "ZKsyncOSVerifierPlonk"
sourceHashes:
+ ["0x99ad2513d609d837d3fb8bd7fa2df0a4f37aea1065e9036c5796772f248f8d30"]
}

The system has a centralized operator

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.

Users can force any transaction via L1

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.

  1. L1 - L2 interoperability - Developer's documentation

Regular messaging

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.

  1. Withdrawing funds - ZKsync documentation

Forced messaging

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.

A dashboard to explore contracts and permissions
Go to Disco
Disco UI Banner

Ethereum

Actors:

Governance0x8253…da95

Allows scheduling transparent and shadow proposals, ‘securityCouncil’ role can execute without delay.

  • Can upgrade with no delay
    • ZKsyncOSChainTypeManager
    • L1NativeTokenVault
    • L1Nullifier
    • L1MessageRoot
    • BridgeHub
    • L1ChainAssetHandler
    • CTMDeploymentTracker
    • ValidatorTimelock
    • L1AssetRouter
  • Can interact with ZKsyncOSChainTypeManager
    • manage the shared ValidatorTimelock contract address and the admin role, register and execute upgrades (and set their deadlines), freeze, revert batches and set permissioned 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 fee params for all connected chains
  • Can interact with RollupDAManager
    • manage allowed rollupA blockchain that inherits consensus and data availability from another blockchain called L1. Rollups enable trust minimized bridges with the base layer via proof systems, either optimistic or zero-knowledge. A rollup without a bridge, or without considering the bridge, is called a sovereign rollup. DA pairs (allowed to be used by rollups in permanent rollup mode)
  • Can interact with BridgeHub
    • set critical contract addresses for the shared cluster, register 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, pause and unpause migrations and the 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. and manage zk chain registration
ADI Multisig 20xB272…3754

A Multisig with 2/3 threshold.

  • Can upgrade with no delay
    • ServerNotifier
  • Can interact with ZKsyncOSChainTypeManager
    • set the pending admin of this contract and the ServerNotifier contract address (ZK cluster Admin role)
  • Can interact with BridgeHub
    • create new zk chains (based on the current version), register tokens (ZK cluster Admin role)
ADI Multisig 10xF502…0Cf9

A Multisig with 2/3 threshold.

  • Can interact with Diamond
    • administrate 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. roles for this chain in the ValidatorTimelock, manage fees, apply predefined upgrades, manage censorship through a TransactionFilterer, set DA mode, migrate the chain to whitelisted 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 (Chain Admin role)

A Multisig with 3/5 threshold.

  • Can interact with L1NativeTokenVault
    • pause / unpause the 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.
  • Can interact with L1Nullifier
    • pause, unpause and set critical escrow address references

A Multisig with 2/3 threshold.

  • Can interact with ValidatorTimelock
    • call the functions to commit, prove, execute and revert 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. batches through the ValidatorTimelock in the ADI Diamond contract
  • Can interact with ChainAdminOwnable
    • set the conversion factor for gasA virtual fuel used to execute smart contracts on a rollup. The EVM (or other VM within the rollup) uses an accounting mechanism to correspond the consumption of gas to the consumption of computing resources, and to limit the consumption of computing resources. token deposits
A dashboard to explore contracts and permissions
Go to Disco
Disco UI Banner

Ethereum

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.

  • Roles:
    • getAdmin: ChainAdminOwnable; ultimately ADI Multisig 1

[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.

  • Roles:
    • admin: ChainAdminOwnable, ProxyAdmin; ultimately ADI Multisig 2, Governance
    • owner: Governance
Can be upgraded by:
RollupDAManager0x57B0…EdEA

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.

  • Roles:
    • owner: Governance

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.

  • Roles:
    • admin: ProxyAdmin; ultimately Governance
    • owner: Safe
Can be upgraded by:

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.

  • Roles:
    • admin: ProxyAdmin; ultimately Governance
Can be upgraded by:

[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.

  • Roles:
    • admin: ChainAdminOwnable, ProxyAdmin; ultimately ADI Multisig 2, Governance
    • owner: Governance
Can be upgraded by:

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.

  • Roles:
    • admin: ProxyAdmin; ultimately Governance
Can be upgraded by:

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.

  • Roles:
    • admin: ProxyAdmin; ultimately Governance
    • validatorVTL: EOA 1, EOA 2, EOA 3, EOA 4
Can be upgraded by:

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.

  • Roles:
    • admin: ProxyAdmin; ultimately Governance
Can be upgraded by:
ChainAdminOwnable0x0a8a…B5B8

A governance proxy that lets ADI Multisig 1 act through it.

  • Roles:
    • owner: ADI Multisig 1
    • tokenMultiplierSetter: EOA 5
ChainAdminOwnable0x2d6E…2Ca7

A governance proxy that lets ADI Multisig 2 act through it.

  • Roles:
    • owner: ADI Multisig 2
L1ERC20Bridge0xfA8B…C3B8

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.

  • Roles:
    • admin: ProxyAdmin; ultimately Governance
    • owner: Safe

All supported tokens in this escrow are included in the value secured calculation.

Can be upgraded by:
ProxyAdmin0x34f5…C90C
  • Roles:
    • owner: ChainAdminOwnable
ProxyAdmin0x8140…3217
  • Roles:
    • owner: Governance

Specialized contract for managing chain assets, i.e. chain migrations.

  • Roles:
    • admin: ProxyAdmin; ultimately Governance
Can be upgraded by:
ZKsyncOSVerifierPlonk0xC128…2aa9
ZKsyncOSDualVerifier0xccbd…7a39

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.

  • Roles:
    • admin: ProxyAdmin; ultimately ADI Multisig 2
Can be upgraded by:
ZKsyncOSVerifierFflonk0xF6b3…0E6A

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..

BlobsL1DAValidatorZKsyncOS0xFB63…a211

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).