Search for projects by name or address
Kroma shut down on June 30, 2025. After this date, funds retrieval is not guaranteed. See announcement for details.
Kroma aims to develop a universal ZK Rollup based on the Optimism Bedrock architecture. Currently, Kroma operates as an Optimistic Rollup with ZK fault proofs, utilizing a zkEVM based on Scroll and a zkVM based proven with SP1.
Tokens breakdown
Kroma aims to develop a universal ZK Rollup based on the Optimism Bedrock architecture. Currently, Kroma operates as an Optimistic Rollup with ZK fault proofs, utilizing a zkEVM based on Scroll and a zkVM based proven with SP1.
Consequence: projects without a proper proof system fully rely on single entities to safely update the state. A malicious proposer can finalize an invalid state, which can cause loss of funds.
Learn more about the recategorisation here.
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.
Kroma shutdown announcement
2025 Jun 20th
Kroma announces its shutdown on June 30, 2025. Users must withdraw their funds before that date.
Plonky3 vulnerability patch
2025 Jun 4th
SP1 verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. is patched to fix critical vulnerability in Plonky3 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. (SP1 dependency).
In the event of a 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. failure, users can force transactions to be included in the project’s chain by sending them to 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.. There can be up to a 12h delay on this operation.
Fraud proofs allow actors watching the chain to prove that the state is incorrect. Interactive proofs (INT) require multiple transactions over time to resolve. ZK proofs are used to adjudicate the correctness of the last step. The challenge protocol can fail under certain conditions. The current system doesn’t use posted 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. txs batches 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. as inputs to prove a fault (for the zkEVM 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. path), meaning that DA is not always enforced.
All of the data needed for proof construction is published on Ethereum 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..
There is no window for users to exit in case of an unwanted upgrade since contracts are instantly upgradable.
Anyone can be a ProposerIn the context of L2s, the actor that proposes a claimed state root on L1. The term is also used in the context of Ethereum to refer to the actor that proposes a new block. and propose new roots to the 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. 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..
All executed transactions are submitted to an on chain smart contract. The execution of the 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. is based entirely on the submitted transactions, so anyone monitoring the contract can know the correct state of the rollup chain.
Kroma nodes source code, including full nodeA software client that participates in the network., proposerIn the context of L2s, the actor that proposes a claimed state root on L1. The term is also used in the context of Ethereum to refer to the actor that proposes a new block. and validatorIn 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, can be found here. Also, the geth server, source maintained here, is a fork of go-ethereum. For more details on how they are different from the Optimism implementation, see here. The instructions to run the proposer (called validator) and the ZK 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., are documented here.
Data batches are compressed using the zlib algorithm with best compression level.
The genesis file can be found here.
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. 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. derivation from 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. data plus the format and architecture of batch submission is documented here.
Kroma uses an interactive fraud 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. to find a single 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. of disagreement, which is then ZK proven. Once the single block of disagreement is found, the challenger is required to present a ZK proof of the fraud. This can be either a proof verified in a zkEVM verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. base on Scroll, or in a zkVMA special type of zk proving system that proves the correctness of state transitions of a virtual machine. Computation is represented by a program in a specific instruction language, it can have private and public inputs and public outputs. Most of zkVMs are STARKs. verifier built by Succinct SP1. If the proof is validated, the incorrect state output is deleted. The Security CouncilA Security Council is a sufficiently decentralized set of members that is able to upgrade a system. A properly set up Security Council consists of at least 8 members with a threshold greater than 75%. What 'sufficiently decentralized' means is fundamentally subjective and L2BEAT evaluates each case individually. A Security Council is allowed to instantly upgrade Stage 1 rollups. can always override the result of the challenge, it can also delete any 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. state rootA cryptographic hash succinctly representing a state using a Merkle tree. at any time. The protocol can fail under certain conditions.
Funds can be lost if the cryptography is broken or implemented incorrectly.
The metrics include upgrades on the currently used proxy contracts. Historical proxy contracts and changes of such are not included.
Discovery rerun on the same block number with only config-related changes.
Discovery rerun on the same block number with only config-related changes.
| + | Status: CREATED |
| contract ZKProofVerifier (0x005DDC466C804c79adB079c120347dDE48132105) | |
| +++ description: None | |
| + | Status: CREATED |
| contract L2OutputOracle (0x180c77aE51a9c505a43A2C7D81f8CE70cacb93A6) | |
| +++ description: The L2OutputOracle contract contains a list of proposed state roots which Proposers assert to be a result of block execution. Anyone can participate as a Proposer by depositing in the ValidatorPool. A root can be proposed every 1800 blocks (2s block time). | |
| + | Status: CREATED |
| contract L1Timelock (0x22605A12cB77Fe420B0cC1263cEb58a77352FDc1) | |
| +++ description: A standard timelock with access control. The current minimum delay is 0s. | |
| + | Status: CREATED |
| contract ValidatorManager (0x232277d9672eEdd53c4B26C0F386C2Eb88DC7363) | |
| +++ description: Manages the set of Proposers (Validators in Kroma) and selects the next proposer with the window to submit the output root within 30m, after which anyone can propose for them. It is also the entry point for other contracts, such as the L2OutputOracle and the Colosseum, which distribute output rewards and slash challenge losers. It makes successive calls to the AssetManager to apply changes to the proposers' assets. | |
| + | Status: CREATED |
| contract KromaPortal (0x31F648572b67e60Ec6eb8E197E1848CC5F5558de) | |
| +++ description: This is a fork of the standard OP stack OptimismPortal contract, the main entry point to deposit funds from L1 to L2. It also allows to prove and finalize withdrawals. | |
| + | Status: CREATED |
| contract ZKMerkleTrie (0x339208824010425cBE73201ceD4372308ACD610B) | |
| +++ description: Merkle Trie contract used to prove withdrawals that were initiated in the legacy system, deprecated for new withdrawals and succeeded by a merkle tree library in the KromaPortal. | |
| + | Status: CREATED |
| contract SystemConfig (0x3971EB866AA9b2b8aFEa8a7C816F3b7e8b195a35) | |
| +++ description: Contains configuration parameters such as the Sequencer address, gas limit on this chain and the unsafe block signer address. | |
| + | Status: CREATED |
| contract KromaSecurityCouncil (0x3de211088dF516da72efe68D386b561BEE256Ec4) | |
| +++ description: Custom Multisig contract in which each signer is identified by a token. The threshold is 8 and the token contract is called SecurityCouncilToken. | |
| + | Status: CREATED |
| contract L1CrossDomainMessenger (0x46B8bB4C5dd27bB42807Db477af4d1a7C8A5B746) | |
| +++ description: Sends messages from host chain to this chain, and relays messages back onto host chain. In the event that a message sent from host chain to this chain is rejected for exceeding this chain's epoch gas limit, it can be resubmitted via this contract's replay function. | |
| + | Status: CREATED |
| contract L1ERC721Bridge (0x46d07221dfC313afe1BF104F4bB1f185301D65B9) | |
| +++ description: Used to bridge ERC-721 tokens from host chain to this chain. | |
| + | Status: CREATED |
| contract ProxyAdmin (0x665c23A5722B6A237fa6Be2B49c0A94504db1edd) | |
| +++ description: None | |
| + | Status: CREATED |
| contract ZkVerifier (0x6deb6a630D7b486c1C08d4016AEe3835a2F52Fa7) | |
| +++ description: ZK verifier used to verify the last step of a legacy zkEVM proof, which corresponds to a block. | |
| + | Status: CREATED |
| contract Colosseum (0x713C2BEd44eB45D490afB8D4d1aA6F12290B829a) | |
| +++ description: Contract used to challenge state roots and prove fraud. If successful, the wrong state root in the eth:0x180c77aE51a9c505a43A2C7D81f8CE70cacb93A6 is replaced. | |
| + | Status: CREATED |
| contract USDCBridge (0x7e1Bdb9ee75B6ef1BCAAE3B1De1c616C7B11ef6e) | |
| +++ description: None | |
| + | Status: CREATED |
| contract L1StandardBridge (0x827962404D7104202C5aaa6b929115C8211d9596) | |
| +++ description: The main entry point to deposit ERC20 tokens from host chain to this chain. | |
| + | Status: CREATED |
| contract AssetManager (0xa295310DE52b86F236A815AFb2f518F3C0F5A6D3) | |
| +++ description: Manages the delegation and undelegation of KRO tokens and Kroma Guardian House (KGH) NFTs for Proposers (Kroma Validators) and distributes rewards. | |
| + | Status: CREATED |
| contract UpgradeGovernor (0xb3c415c2Aad428D5570208e1772cb68e7D06a537) | |
| +++ description: A governance proxy contract using token voting with eth:0xe4D08346609055c091D3DEECdAAd3Bf83119B08c as identification of actors allowed to vote/sign a proposal which is passed to the eth:0x22605A12cB77Fe420B0cC1263cEb58a77352FDc1 afterwards. | |
| + | Status: CREATED |
| contract SecurityCouncilTokenOwners (0xe4D08346609055c091D3DEECdAAd3Bf83119B08c) | |
| +++ description: A soulbound token implementation to identify participants of the KromaSecurityCouncil. Owners of the token are members of the council. There are currently 10 members. | |
| + | Status: CREATED |
| contract Kroma Multisig (0xe57E217d8ed498992452791622711B866403E950) | |
| +++ description: Escrows a pool of KRO used as validator rewards by the AssetManager. | |
| + | Status: CREATED |
| contract ValidatorPool (0xFdFF462845953D90719A78Fd12a2d103541d2103) | |
| +++ description: Contract used to manage the Proposers. Anyone can submit a deposit and bond to a state root, or create a challenge. It also manages the Proposer rotation for each submittable block using a random selection. If the selected proposer fails to publish a root within 30m then the submission becomes open to everyone. | |
selector 0x1b34fe11 and respective verifier frozen.
selector 0x1b34fe11 and respective verifier frozen.
| contract SP1VerifierGateway (0x3B6041173B80E77f038f3F2C0f9744f04837185e) { | |
| +++ description: This contract is the router for zk proof verification. It stores the mapping between identifiers and the address of onchain verifier contracts, routing each identifier to the corresponding verifier contract. | |
| +++ description: Verifiers that are routed to by their selector and not frozen. | |
| values.activeVerifiers.1: | |
| - | {"selector":"0x1b34fe11","verifier":"0xE00a3cBFC45241b33c0A44C78e26168CBc55EC63"} |
| } | |
| - | Status: DELETED |
| contract SP1Verifier (0xE00a3cBFC45241b33c0A44C78e26168CBc55EC63) | |
| +++ description: Verifier contract for SP1 proofs (v4.0.0-rc.3). | |
config: make sp1 gateway template more dynamic.
config: make sp1 gateway template more dynamic.
| + | Status: CREATED |
| contract SP1Verifier (0xE00a3cBFC45241b33c0A44C78e26168CBc55EC63) | |
| +++ description: Verifier contract for SP1 proofs (v4.0.0-rc.3). | |
SP1 verifier upgrade to v5 (plonky3 vuln related).
SP1 verifier upgrade to v5 (plonky3 vuln related).
| contract SP1VerifierGateway (0x3B6041173B80E77f038f3F2C0f9744f04837185e) { | |
| +++ description: This contract is the router for zk proof verification. It stores the mapping between identifiers and the address of onchain verifier contracts, routing each identifier to the corresponding verifier contract. | |
| values.verifier.prover: | |
| - | "0x0000000000000000000000000000000000000000" |
| + | "0x0459d576A6223fEeA177Fb3DF53C9c77BF84C459" |
| } | |
| + | Status: CREATED |
| contract SP1Verifier (0x0459d576A6223fEeA177Fb3DF53C9c77BF84C459) | |
| +++ description: Verifier contract for SP1 proofs. | |
Changed argument in a handler to discover SP1Verifier contract.
Changed argument in a handler to discover SP1Verifier contract.
| + | Status: CREATED |
| contract SP1Verifier (0xE00a3cBFC45241b33c0A44C78e26168CBc55EC63) | |
| +++ description: SP1Verifier is a contract used to verify proofs given public values and verification key. | |
While forcing transaction is open to anyone the system employs a privileged 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. that has priority for submitting transaction batches and ordering transactions.
MEV can be extracted if the operator exploits their centralized position and frontruns user transactions.
Because the state of the system is based on transactions submitted on the underlying host chain and anyone can submit their transactions there it allows the users to circumvent censorship by interacting with the smart contract on the host chain directly.
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. The process of block finalization takes a challenge periodIn optimistic rollups, the window of time wherein network participants can assert that some fraud was included in a prior block. Most optimistic rollups currently specify a challenge window of 7 days. By extending the period, there is more time for participants to guard against fraud (invalid state transitions), but also more time until withdrawals gets enabled. of 7d to complete.
Users can (eventually) exit the system by pushing the transaction 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. and providing the corresponding state rootA cryptographic hash succinctly representing a state using a Merkle tree.. The only way to prevent such withdrawal is via an upgrade.
OP stack chains are pursuing the EVM EquivalenceA perfect degree of compatibility; where one system or concept is indistinguishable from another in the domain being compared. In the context of rollups, it generally refers to the proximity to the EVM and to Ethereum architecture. model. No changes to smart contracts are required regardless of the language they are written in, i.e. anything deployed 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. can be deployed on 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..

A soulbound token implementation to identify participants of the KromaSecurityCouncil. Owners of the token are members of the council. There are currently 10 members.
Custom Multisig contract in which each signer is identified by a token. The threshold is 8 and the token contract is called SecurityCouncilToken.
forceDeleteOutput())A Multisig with 2/3 threshold.
A Multisig with 3/5 threshold. Escrows a pool of KRO used as validatorIn 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 rewards by the AssetManager.


Contains configuration parameters such as the 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. address, gas limitThe maximum amount of gas a transaction or block may consume. on this chain and the unsafe 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. signer address.
Sends messages from host chain to this chain, and relays messages back onto host chain. In the event that a message sent from host chain to this chain is rejected for exceeding this chain’s epoch gas limitThe maximum amount of gas a transaction or block may consume., it can be resubmitted via this contract’s replay function.
Used to 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. ERC-721 tokens from host chain to this chain.
The main entry point to deposit ERC20 tokens from host chain to this chain.
All supported tokens in this escrow are included in the value secured calculation.
The L2OutputOracle contract contains a list of proposed state rootsA cryptographic hash succinctly representing a state using a Merkle tree. which Proposers assert to be a result of 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. Anyone can participate as a ProposerIn the context of L2s, the actor that proposes a claimed state root on L1. The term is also used in the context of Ethereum to refer to the actor that proposes a new block. by depositing in the ValidatorPool. A root can be proposed every 1800 blocks (2s block time).
A standard timelock with access control. The current minimum delay is 0s.
Manages the set of Proposers (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 in Kroma) and selects the next proposerIn the context of L2s, the actor that proposes a claimed state root on L1. The term is also used in the context of Ethereum to refer to the actor that proposes a new block. with the window to submit the output root within 30m, after which anyone can propose for them. It is also the entry point for other contracts, such as the L2OutputOracle and the Colosseum, which distribute output rewards and slash challenge losers. It makes successive calls to the AssetManager to apply changes to the proposers’ assets.
This is a fork of the standard OP stack OptimismPortal contract, the main entry point to deposit funds from 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. to 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.. It also allows to prove and finalize withdrawals.

Merkle Trie contract used to prove withdrawals that were initiated in the legacy system, deprecated for new withdrawals and succeeded by a merkle treeA hash-based data structure in which each leaf node is a hash of a block of data, and each non-leaf node is a hash of its children. The root of the tree is a cryptographic fingerprint of the entire data structure. Merkle trees (Merkle Patricia Tries) are used in Ethereum to efficiently store key-value pairs. library in the KromaPortal.
ZK verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. used to verify the last step of a legacy zkEVM proof, which corresponds to a 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..
Contract used to challenge state rootsA cryptographic hash succinctly representing a state using a Merkle tree. and prove fraud. If successful, the wrong state root in the L2OutputOracle is replaced.

Manages the delegation and undelegation of KRO tokens and Kroma Guardian House (KGH) NFTs for Proposers (Kroma 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 distributes rewards.
A governance proxy contract using token voting with SecurityCouncilTokenOwners as identification of actors allowed to vote/sign a proposal which is passed to the Timelock afterwards.
Contract used to manage the Proposers. Anyone can submit a deposit and bond to a state rootA cryptographic hash succinctly representing a state using a Merkle tree., or create a challenge. It also manages the ProposerIn the context of L2s, the actor that proposes a claimed state root on L1. The term is also used in the context of Ethereum to refer to the actor that proposes a new block. rotation for each submittable 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. using a random selection. If the selected proposer fails to publish a root within 30m then the submission becomes open to everyone.
VerifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. contract for SP1 proofs (v5.0.0).
This contract is the router for zk proof verification. It stores the mapping between identifiers and the address of onchain verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. contracts, routing each identifier to the corresponding verifier contract.
VerifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. contract for SP1 proofs (v6.0.0).
VerifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. contract for SP1 proofs (v6.1.0).
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).