Search for projects by name or address
Facet is a based rollup built on OP-Succinct. It uses FCT as its native gas token, which is mintable by burning ETH on L1.
Facet is a based rollup built on OP-Succinct. It uses FCT as its native gas token, which is mintable by burning ETH on L1.
The section shows the operating costs that L2s pay 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 Tx data submissions were performed for 1d 6h (from 2026 Sep 10, 08:34 UTC until 2026 Sep 11, 15:11 UTC). These typically occur every 15m 23s on average.
No State updates were performed for 1d 9h (from 2026 Sep 10, 05:14 UTC until 2026 Sep 11, 15:11 UTC). These typically occur every 7h 35m on average.
Rollup redeployed
2026 May 18th
New 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. contract takes over state-root proposals with a new SP1VerifierGateway.
SP1 proof system deployed
2025 Jul 2nd
Facet launches its optimistic rollupA rollup that optimistically updates state with the possibility of fraud proofs being generated to revert faulty state roots. contract with SP1 zk fault proofs.
Users can self sequence transactions by sending them 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.. There is no privileged 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..
Actors watching the chain can challenge state proposals, and challenged proposals must provide ZK proofs. SNARKs are zero knowledge proofs that ensure state correctness, but require 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 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..
Users can exit funds at any time because contracts are not upgradeable.
Anyone 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. if accompanied by a validity proofThe output of a cryptographic proving system attesting to correct computation. ZK-Rollups use succinct validity proofs (also called zero-knowledge proofs) to prove a batch of rollup transactions and blocks were properly executed. Validity proofs are submitted to a verifier, such as an Ethereum smart contract, which accepts them if properly constructed.. Only the whitelisted proposers can propose state rootsA cryptographic hash succinctly representing a state using a Merkle tree. for recent blocks optimistically. Anyone can propose optimistically for 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. blocks that are older than 14d.

Facet implements a dual-track proving system that combines optimistic proposals with bonds with ZK validity proofs. The system allows bypassing the 7-day fraud proofAlso referred to as a fault proof, it is the construction of an assertion that fraud was perpetrated on an optimistic rollup. More concretely, that an invalid state transition took place according to the protocol rules. The submitter of a fraud proof would expect a reward from the optimistic rollup protocol for helping maintain the integrity of the system. window by providing a ZK proof.
The system operates on two parallel tracks: an optimistic track where whitelisted proposers submit state rootsA cryptographic hash succinctly representing a state using a Merkle tree. with ETH bonds that can be challenged within a time window, and a validity-proof track where anyone can submit direct ZK proofs for immediate resolution. Validity proofs bypass the optimistic flow and can invalidate multiple incorrect optimistic proposals simultaneously targeting the same state root. When optimistic proposals are challenged, proposers must defend their claims by providing ZK proofs within the proving window.
The system uses Succinct’s SP1 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. and 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. NetworkA constellation of nodes (peers) that communicate via a peer-to-peer protocol, for example, in propagating transactions and blocks to other nodes. to generate zero-knowledgeA cryptographic technology and sub-discipline of cryptography that allows an individual to prove that a statement or computation is true without revealing any additional information. proofs that verify 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 transitions. Anyone can submit a validity proofThe output of a cryptographic proving system attesting to correct computation. ZK-Rollups use succinct validity proofs (also called zero-knowledge proofs) to prove a batch of rollup transactions and blocks were properly executed. Validity proofs are submitted to a verifier, such as an Ethereum smart contract, which accepts them if properly constructed. through the proveBlock() function 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. contract to bypass the optimistic flow and settle an anchor 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.. Submitting a validity proof during a challenge settles the dispute in a single transaction.
Onchain verifier
Onchain verifier
Onchain verifier | ||
Onchain verifier |
This Rollup redeploy resolves the red trusted-setup risk: the new SP1VerifierGateway routes only to the Aztec-Ignition Plonk verifier (green), with ownership renounced so no other route can be added. Add the new Rollup contract (eth:0x026902ef…, deployed 2026-05-18) that took over state-root proposals on 2026-05-19, and rename the previous Rollup (eth:0x686E7d01…) to RollupDeprecated . Pulls in the new SP1VerifierGateway (eth:0xa236E6E3…) referenced by the new Rollup. The pre-existing L1Bridge is immutable and remains bound to RollupDeprecated ; it is dropped from escrows since it can no longer track live L2 state and no canonical bridge has been redeployed against the new Rollup.
This Rollup redeploy resolves the red trusted-setup risk: the new SP1VerifierGateway routes only to the Aztec-Ignition Plonk verifier (green), with ownership renounced so no other route can be added. Add the new Rollup contract (eth:0x026902ef…, deployed 2026-05-18) that took over state-root proposals on 2026-05-19, and rename the previous Rollup (eth:0x686E7d01…) to RollupDeprecated. Pulls in the new SP1VerifierGateway (eth:0xa236E6E3…) referenced by the new Rollup. The pre-existing L1Bridge is immutable and remains bound to RollupDeprecated; it is dropped from escrows since it can no longer track live L2 state and no canonical bridge has been redeployed against the new Rollup.
| contract Rollup (eth:0x026902EF5a0931F25cbB78b5dd7a72EE998569AE) [facet/Rollup] { | |
| +++ description: Core rollup contract that manages the state of the rollup and its ZK fault proof system. | |
| type: | |
| - | "EOA" |
| + | "Contract" |
| proxyType: | |
| - | "EOA" |
| + | "immutable" |
| template: | |
| + | "facet/Rollup" |
| sourceHashes: | |
| + | ["0x18a889e730255386b3ecf5a44ea1cdcc2a4ecbd02908aa838976646eb02a9681"] |
| description: | |
| + | "Core rollup contract that manages the state of the rollup and its ZK fault proof system." |
| deployerAddress: | |
| + | "eth:0x23B0caA3782b5CE6Be7A54655A5DD2791335EAFC" |
| sinceTimestamp: | |
| + | 1779135407 |
| sinceBlock: | |
| + | 25124426 |
| values: | |
| + | {"$immutable":true,"AGG_VKEY":"0x0083a8b50160475a7a5911c03dfdee30f6c8a83112a71c5c1125cfb96148b8c2","anchorL2BlockNumber":3829060,"anchorProposalId":59,"anchorRoot":"0x24652ac280fdf6eab6f0ba68a8da7163bae727773da815a3864e724de5d21c7e","canonicalProposalFor":[],"canonicalProposalIdFor":[],"CHALLENGER_BOND":"10000000000000000000","computeL2Timestamp":[],"FALLBACK_TIMEOUT_SECS":1209600,"getProposalsLength":88,"isInFallbackWindow":[],"L2_BLOCK_TIME":12,"L2_START_TIMESTAMP":1778518859,"l2BlockAge":[],"MAX_CHALLENGE_SECS":604800,"MAX_PROVE_SECS":604800,"owner":"eth:0xb2B01DeCb6cd36E7396b78D3744482627F22C525","PROPOSAL_INTERVAL":1800,"PROPOSER_BOND":5000000000000000,"RANGE_VKEY_COMMITMENT":"0x43f01f7522e77ddc0bea30de6cb8075608a0d0c906660e4f5f430a1e5e170829","renouncedOwner":"eth:0xdeaddeaddeaddeaddeaddeaddeaddeaddead0001","ROLLUP_CONFIG_HASH":"0x9554c3fe04d8bd05d2dff01471781e1d9fbbdcfa58bda686ad883fe5451fd97c","sequencerInbox":"eth:0x00000000000000000000000000000000000face7","VERIFIER":"eth:0xa236E6E31d94b613923d18313f534CE5b6b98eE1","version":"1.0.0","whitelistedProposers":["eth:0x615452db5467849689E98a8C5C242A96cF768a94"]} |
| implementationNames: | |
| + | {"eth:0x026902EF5a0931F25cbB78b5dd7a72EE998569AE":"Rollup"} |
| category: | |
| + | {"name":"Local Infrastructure","priority":5} |
| } | |
| EOA (eth:0x615452db5467849689E98a8C5C242A96cF768a94) { | |
| +++ description: None | |
| receivedPermissions.0: | |
| + | {"permission":"propose","from":"eth:0x026902EF5a0931F25cbB78b5dd7a72EE998569AE","description":"Can propose state roots optimistically without a ZK proof. Note that anyone can propose with a ZK proof, and anyone can propose optimistically after the fallback timeout.","role":".whitelistedProposers"} |
| } | |
| contract Facet Multisig (eth:0xb2B01DeCb6cd36E7396b78D3744482627F22C525) [GnosisSafe] { | |
| +++ description: None | |
| receivedPermissions.0: | |
| + | {"permission":"interact","from":"eth:0x026902EF5a0931F25cbB78b5dd7a72EE998569AE","description":"can set the whitelisted proposers.","role":".owner"} |
| } | |
| + | Status: CREATED |
| contract SP1VerifierGateway (eth:0xa236E6E31d94b613923d18313f534CE5b6b98eE1) [succinct/SP1VerifierGateway] | |
| +++ 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. | |
Silenced discovery.
Silenced discovery.
| contract L2Bridge (0x016bE6d77b783aBdDccaF3fea49ffa9c1CA660D4) { | |
| +++ description: L2Bridge is an ERC20 minter counterpart to an L1 bridge. This contract is used to mint new ERC20 tokens on the L2 once a token deposit is made on the L1. Note that the token received on L2 could have a different ticker/symbol than the token sent on L1. | |
| values.totalSupply: | |
| - | 1000000000000000 |
| + | "52000000000000000" |
| } | |
| contract L2ToL1MessagePasser (0x4200000000000000000000000000000000000016) { | |
| +++ description: L2ToL1MessagePasser is a contract that allows messages to be sent from the L2 to the L1, used to send withdrawal requests from the L2 to the L1. | |
| values.messageNonce: | |
| - | "1766847064778384329583297500742918515827483896875618958121606201292619931" |
| + | "1766847064778384329583297500742918515827483896875618958121606201292619932" |
| } | |
Whitelisted Proposer changed. Config changes only (our side) for the bridge.
Whitelisted Proposer changed. Config changes only (our side) for the bridge.
| contract Rollup (0x686E7d01C7BFCB563721333A007699F154C04eb4) { | |
| +++ description: Rollup contract for Facet. This is the core contract that manages the state of the rollup and its proof system. | |
| values.whitelistedProposers.0: | |
| - | "eth:0x23B0caA3782b5CE6Be7A54655A5DD2791335EAFC" |
| + | "eth:0x615452db5467849689E98a8C5C242A96cF768a94" |
| } | |
Initial discovery.
Initial discovery.
| + | Status: CREATED |
| contract L2Bridge (0x016bE6d77b783aBdDccaF3fea49ffa9c1CA660D4) | |
| +++ description: L2Bridge is an ERC20 minter counterpart to an L1 bridge. This contract is used to mint new ERC20 tokens on the L2 once a token deposit is made on the L1. Note that the token received on L2 could have a different ticker/symbol than the token sent on L1. | |
| + | Status: CREATED |
| contract L2ToL1MessagePasser (0x4200000000000000000000000000000000000016) | |
| +++ description: L2ToL1MessagePasser is a contract that allows messages to be sent from the L2 to the L1, used to send withdrawal requests from the L2 to the L1. | |
Discovery rerun on the same block number with only config-related changes.
Discovery rerun on the same block number with only config-related changes.
| contract L1Bridge (0x4E2eBa30a786c0643699b92234d74a71e958C08E) { | |
| +++ description: L1Bridge is an ETH bridge built on top of Rollup contract. It is the selected canonical bridge for this risk analysis. It used to bridge ETH from L1 to L2. Note that the token received on L2 has a different ticker/symbol than the token sent on L1. | |
| type: | |
| - | "EOA" |
| + | "Contract" |
| proxyType: | |
| - | "EOA" |
| + | "immutable" |
| template: | |
| + | "facet/L1ETHBridge" |
| sourceHashes: | |
| + | ["0x2428a7345462c1359eba9d5cf1d2749c05cb9419787b7e2914c411bb0c244867"] |
| description: | |
| + | "L1Bridge is an ETH bridge built on top of Rollup contract. It is the selected canonical bridge for this risk analysis. It used to bridge ETH from L1 to L2. Note that the token received on L2 has a different ticker/symbol than the token sent on L1." |
| sinceTimestamp: | |
| + | 1754512679 |
| sinceBlock: | |
| + | 23084460 |
| values: | |
| + | {"$immutable":true,"depositNonce":1,"l2Bridge":"eth:0x016bE6d77b783aBdDccaF3fea49ffa9c1CA660D4","owner":"eth:0x0000000000000000000000000000000000000000","paused":false,"rollup":"eth:0x686E7d01C7BFCB563721333A007699F154C04eb4","withdrawalDelay":0} |
| implementationNames: | |
| + | {"eth:0x4E2eBa30a786c0643699b92234d74a71e958C08E":"L1Bridge"} |
| category: | |
| + | {"name":"Canonical Bridges","priority":2} |
| } | |
| contract Rollup (0x686E7d01C7BFCB563721333A007699F154C04eb4) { | |
| +++ description: Rollup contract for Facet. This is the core contract that manages the state of the rollup and its proof system. | |
| type: | |
| - | "EOA" |
| + | "Contract" |
| proxyType: | |
| - | "EOA" |
| + | "immutable" |
| template: | |
| + | "facet/Rollup" |
| sourceHashes: | |
| + | ["0xd5ecfadcad80a6370fcf20fd9285959bf3452352c79ba06748998ea55cad3732"] |
| description: | |
| + | "Rollup contract for Facet. This is the core contract that manages the state of the rollup and its proof system." |
| sinceTimestamp: | |
| + | 1754512643 |
| sinceBlock: | |
| + | 23084457 |
| values: | |
| + | {"$immutable":true,"AGG_VKEY":"0x0083a8b50160475a7a5911c03dfdee30f6c8a83112a71c5c1125cfb96148b8c2","anchorL2BlockNumber":1721260,"anchorProposalId":0,"anchorRoot":"0x88b54f3a73b2cbb7f29caae53a780a8b4974c5e0bd157ad3c7bb122b72939bcc","canonicalProposalFor":[],"canonicalProposalIdFor":[],"CHALLENGER_BOND":"10000000000000000000","computeL2Timestamp":[],"FALLBACK_TIMEOUT_SECS":1209600,"getAnchorRoot":["0x88b54f3a73b2cbb7f29caae53a780a8b4974c5e0bd157ad3c7bb122b72939bcc",1721260],"getProposalsLength":1,"isInFallbackWindow":[],"L2_BLOCK_TIME":12,"L2_START_TIMESTAMP":1754499659,"l2BlockAge":[],"MAX_CHALLENGE_SECS":604800,"MAX_PROVE_SECS":604800,"owner":"eth:0xb2B01DeCb6cd36E7396b78D3744482627F22C525","PROPOSAL_INTERVAL":1800,"PROPOSER_BOND":5000000000000000,"RANGE_VKEY_COMMITMENT":"0x43f01f7522e77ddc0bea30de6cb8075608a0d0c906660e4f5f430a1e5e170829","renouncedOwner":"eth:0xdeaddeaddeaddeaddeaddeaddeaddeaddead0001","ROLLUP_CONFIG_HASH":"0x9554c3fe04d8bd05d2dff01471781e1d9fbbdcfa58bda686ad883fe5451fd97c","sequencerInbox":"eth:0x00000000000000000000000000000000000face7","VERIFIER":"eth:0x70C7FdB9e543bD15cd392df04e6d4BD05AfD8A66","version":"1.0.0","whitelistedProposers":["eth:0x23B0caA3782b5CE6Be7A54655A5DD2791335EAFC"]} |
| implementationNames: | |
| + | {"eth:0x686E7d01C7BFCB563721333A007699F154C04eb4":"Rollup"} |
| category: | |
| + | {"name":"Local Infrastructure","priority":5} |
| } | |
| + | Status: CREATED |
| contract SP1Verifier (0x0459d576A6223fEeA177Fb3DF53C9c77BF84C459) | |
| +++ description: Verifier contract for SP1 proofs (v5.0.0). | |
| + | Status: CREATED |
| contract FacetSafeModule (0x3235AdE33cF7013f5b5A51089390396e931e6BCF) | |
| +++ description: Module that allows the Safe to send Facet transactions. | |
| + | Status: CREATED |
| contract SP1Verifier (0x50ACFBEdecf4cbe350E1a86fC6f03a821772f1e5) | |
| +++ description: Verifier contract for SP1 proofs (v5.0.0). | |
| + | Status: CREATED |
| contract SP1VerifierGateway (0x70C7FdB9e543bD15cd392df04e6d4BD05AfD8A66) | |
| +++ 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. | |
| + | Status: CREATED |
| contract Facet Multisig (0xb2B01DeCb6cd36E7396b78D3744482627F22C525) | |
| +++ description: None | |
| + | Status: CREATED |
| contract FacetSafeProxy (0xC9F2d55C56Ef9fE4262c4d5b48d8032241AF4d25) | |
| +++ description: Helper of the Safe Module that allows to send Facet transactions. | |
There is no privileged entity that sequences transactions or produces 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.. This activity is permissionlessAnyone willing should be able to join and leave the network at any time, without causing significant disturbance to the network or being detrimental to the party in question. No single entity should have the power to allowlist or blocklist participants. and open to anyone.
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 EOA inbox on the host chain directly.
Facet uses a based sequencingA sequencing strategy for L2s based on Ethereum's own block building pipeline, which gets reused to also build L2 blocks. This strategy is in contrast to centralized sequencing or decentralized sequencing mechanisms that use networks external to Ethereum. model where transaction ordering is determined entirely by 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.. Users submit transactions to an immutable address on Ethereum with transaction information encoded as RLP calldata. Facet 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. preserve the exact order in which Ethereum includes these transactions. Additionally, L1 smart contracts can create Facet transactions by emitting events with the Facet event signature, where the event data payload contains the same RLP-encoded transaction data.
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. The challenge period can be shortened if the block is proven by providing a ZK proof.
Facet’s Rollup contract publishes 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 rootsA cryptographic hash succinctly representing a state using a Merkle tree. but is not paired with a canonical 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. escrow. Anyone can deploy a bridge that reads the Rollup’s anchor state root to bridge arbitrary tokens; each bridge has its own L2 counterpart, so the same 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. token bridged through different bridges results in different L2 representations. Trust assumptions (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. role, upgradeabilityThe ability for rollup smart contracts and parameters used in a rollup to be updated by holders of an admin key. Upgradeability represents a vector of risk for users, and should be decentralized and combined with time delays for greater security guarantees., withdrawal logic) are bridge-specific and do not propagate from the Rollup. The risk analysis on this page covers the Rollup and its 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. only; any bridge built on top must be assessed separately. Known bridges today include the FacetEtherBridgeV6 fast ETH bridge, whose withdrawals are processed by a permissioned EOA operator and do not depend on the Rollup state, and a legacy L1Bridge immutably bound to RollupDeprecated, which no longer receives state-root proposals.
Facet uses FCT as its native 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, which is minted through 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. gas consumption rather than being pre-minted. FCT issuance is directly tied to the amount of L1 ETH burned to pay calldata gas in Ethereum transactions, calculated as:
FCT minted = ETH burned for calldata × mint rate
ETH burned for calldata = L1 base fee × (total L1 gas cost - 21,000)
The system targets issuing ~78,300 FCT every 500 Facet 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.. If less than the target is minted in 500 blocks, the mint rate increases proportionally (up to a maximum 4x increase). If the target is reached in fewer than 500 blocks, the mint rate decreases proportionally (up to a maximum 75% decrease).
The maximum supply of FCT is ~1.65B. Once 50% of the supply is minted, the per-period target (now ~78,300) will be halved. It will be halved again at 75%, then at 87.5%, and so forth. The period target and period length are selected so that halvings will occur approximately every 5,256,000 blocks.
This mechanism is similar to standard OP Stack guaranteed gas markets, where L1 gas is burned to purchase 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. gas for deposits through an EIP-1559-style fee market. However, on Facet, gas purchased in this way accrues to the purchaser’s native balance on the L2, whereas in the OP Stack it can only be used for a single transaction.
.

A Multisig with 2/3 threshold. It uses the following modules: FacetSafeModule (Module that allows the Safe to send Facet transactions).


Core 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. contract that manages the state of the rollup and its ZK fault 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..
Core 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. contract that manages the state of the rollup and its ZK fault 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..
An immutable ETH 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. built on top of a 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. contract. Facet does not designate any single canonical bridge — multiple bridges of this kind can exist in parallel against a given Rollup, and each must be assessed independently. Note that the token received 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. has a different ticker/symbol than the token sent 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..

Deprecated entry point to deposit ERC20 tokens from host chain to this chain. Currently just holds ETH that the Facet multisig can withdraw.


A Facet implementation of the ETH 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.. This bridge is also called “fast bridge” as it uses a permissioned EOA as 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. for faster withdrawal processing.

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).
Module that allows the Safe to send Facet transactions.
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.
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.
Helper of the Safe Module that allows to send Facet transactions.
ERC20 minter counterpart 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. 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.. Mints new ERC20 tokens 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. once a token deposit is made on L1. Facet does not designate any single canonical bridge — multiple bridges of this kind can exist in parallel against a given 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., and each must be assessed independently. Note that the token received on L2 could have a different ticker/symbol than the token sent on L1.
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. message passer at the OP Stack predeploy address, used by L1Bridge-style canonical bridges to relay withdrawal requests from L2 to L1.