Search

Search projects, tokens and protocols by name or address

Badges

About

Derive V3 is an options, perpetuals and spot exchange with offchain matching, whose margin and settlement logic runs in an SP1 zkVM program. Batches are proven to Ethereum and their data is posted to Celestia.


  • Value secured
    $90.13 M−7.54%
  • Past day UOPS
    No data
  • Type
    Other

  • Purpose
    Exchange

  • Tokens breakdown

    Sequencer failureState validationData availabilityExit windowProposer failure

    Badges

    About

    Derive V3 is an options, perpetuals and spot exchange with offchain matching, whose margin and settlement logic runs in an SP1 zkVM program. Batches are proven to Ethereum and their data is posted to Celestia.

    Why is the project listed in others?

    There is no data availability bridge

    Consequence: projects without a data availability bridge fully rely on single entities (the sequencer) to honestly rely available data roots on Ethereum. A malicious sequencer can collude with the proposer to finalize an unavailable state, which can cause loss of funds.

    Learn more about the recategorisation here.


    Total
    Canonically bridgedCanonically bridged valueCanonical
    Natively mintedNatively minted tokensNative
    Externally bridgedExternally bridged valueExternal

    ETH & derivatives
    Stablecoins
    BTC & derivatives
    Other
    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 "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 submission interval
    Avg state update interval
    Anomalies in the past 30 days
    100% normal uptime

    Derive V3 launch

    6 Oct 2026

    Derive V2 balances and positions are migrated into Derive V3, which settles on Ethereum.

    Learn more
    The project relies on program hashes that could not be successfully reproduced from their published sources.
    (CRITICAL)
    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. If the oldest queued action stays unprocessed for 28d, anyone can remove the designated batch submitter, but independent proving is not possible from published artifacts and there is no exit hatch.

    State validation
    Validity proofs (SN)

    SNARKs are succinct 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..

    Data availability
    External

    Proof construction and state reconstruction rely on data posted to Celestia. Each proof commits to a Celestia header range chained from an anchor stored onchain and to a hashA fixed-length fingerprint of variable-size input, produced by a hash function.-chain of the batch’s Celestia 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.; the oldest referenced Celestia 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. must be at most 2d old. The 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. program that checks Celestia signatures and data inclusion is not public.

    Exit window
    None

    There is no window for users to exit in case of an unwanted upgrade since contracts are instantly upgradable.

    Proposer failure
    Cannot withdraw

    If 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. action stays unprocessed for 28d, anyone can remove the batch submitter and submit batches. However, the 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. program is not public, so independent proving is not possible from published artifacts.

    Derive V3
    Derive V3 is not even a
    Stage 0
    Appchain
    project.
    There is no available nodeA software client that participates in the network. software that can reconstruct 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 from available DA, so this system cannot be independently verified.

    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.

    Data is posted to Celestia

    Batch data is posted to Celestia as a chain of 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. in which every blob starts with the commitment of the previous one. The VerifiableApp stores the latest proven Celestia header and blob commitment, and each proof must chain from them to a newer Celestia 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. at most 2d old. The program is meant to prove the Celestia header transition and the inclusion of the batch’s blobs, but its source is not public. The owner can re-point the stored Celestia anchor at any time.

    • Funds can be lost if the sequencer posts an unavailable transaction root (CRITICAL).

    • Funds can be lost if the data is not available on the external provider (CRITICAL).

    1. VerifiableApp - submitBatch and Celestia anchor

    Each batch is proven with an SP1 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. that is verified onchain through the SP1VerifierGateway. The proof commits to the old and new state rootsA cryptographic hash succinctly representing a state using a Merkle tree., the consumed 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. action queue, the withdrawals to pay out, and the Celestia data used for the batch.


    Validity proofs

    Margin, 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., deposits and withdrawals are executed inside an 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. program identified onchain by its verification key (0x00bc954fe627a8c36173e608608795425e22b4134914c7da5bd233b4718c855b). The program source is not public, so the verification key cannot be independently regenerated and what the program enforces cannot be verified.

    • Funds can be stolen if the zkVM program does not enforce the protocol rules, as its source is not public.

    • Funds can be stolen if the owner replaces the state root, the program verification key or the verifier.

    • Funds can be stolen if the SP1VerifierGateway owner adds a malicious or faulty verifier route and the batch submitter routes proofs through it.

    • Funds can be frozen if the SP1VerifierGateway owner freezes the verifier route used for the proofs.

    1. DIP: Launch Derive V3

    Trusted setups

    Onchain verifier

    Used in

    Base Chain logoMantle logoCelo logoX Layer logo

    Onchain verifier

    Used in

    Base Chain logoMantle logoCelo logoX Layer logo

    Program hashes

    Hash
    Repository
    Verification
    Used in
    0x00bc...855b
    Code unknown
    Derive V3 logo

    The core contracts are upgradeable. Upgrades and other owner actions take effect either through a timelock with a 4h delay or immediately through a path that bypasses it. The owner can replace the state rootA cryptographic hash succinctly representing a state using a Merkle tree., the program verification key, the verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. and the trusted Celestia anchor, set the batch submitter and the stall timeout, register or re-point asset vaults, and move funds held in forwarded-withdrawal escrows. A guardian can refill the withdrawal rate limits and, like a set of individual pausers, pause withdrawals.

    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
    1mo 6d ago
    Avg upgrade interval
    17d 4h
    17changes

    Initial discovery of Derive V3: VerifiableApp, OnchainActionManager, WithdrawalOutbox, SpotVault, WithdrawFactory, their owner multisig with its timelock and bypass members, the guardian, pausers and keepers.

    Initial discovery

    + Status: CREATED
    contract DeriveTimelock (eth:0x12D612647e8bcacec9148e477CAdE67bD07abc78) [global/TimelockController]
    +++ description: A timelock with access control. The current minimum delay is 4h.
    + Status: CREATED
    contract Derive Multisig (eth:0x169a99B9958386a5D91E732Ed08B344946A92391) [GnosisSafe]
    +++ description: None
    + Status: CREATED
    contract ProxyAdmin (eth:0x2c53cbB96fb65e8711dAAe530c87473789a13781) [global/ProxyAdmin]
    +++ description: None
    + Status: CREATED
    contract SpotVault (eth:0x2e7dF4fAf35a1599979C7E764444e112d936ec42) [derivev3/SpotVault]
    +++ description: Escrow for the collateral deposited to Derive. It grants eth:0x7c743D79C9C595cE332314503d84cBBb4E85FA63 unlimited allowance for approved tokens.
    + Status: CREATED
    external contract SP1VerifierGateway (eth:0x3B6041173B80E77f038f3F2C0f9744f04837185e)
    +++ description: None
    + Status: CREATED
    contract ProxyAdmin (eth:0x4EcBfaBF336a757FE82898e0e1083a6Cbb042C3D) [global/ProxyAdmin]
    +++ description: None
    + Status: CREATED
    contract Derive Bypass Multisig (eth:0x5F8D40613d49179376a200cc808d322f4331453a) [GnosisSafe]
    +++ description: None
    + Status: CREATED
    contract Derive Owner Multisig (eth:0x62c004a89EDBd7bECBdf54E14779B7e7F5b390F7) [GnosisSafe]
    +++ description: None
    + Status: CREATED
    contract Derive Guardian Multisig (eth:0x682CD085aC63739a9F44E069E91BB6AA09a312E8) [GnosisSafe]
    +++ description: None
    + Status: CREATED
    contract WithdrawalOutbox (eth:0x7c743D79C9C595cE332314503d84cBBb4E85FA63) [derivev3/WithdrawalOutbox]
    +++ description: Pays out withdrawals committed to by batches proven in eth:0xd330145C17fB6EF2a21ACf1275Ce683A305F58BB from the registered asset vaults, subject to USD-denominated per-recipient and global rate limits.
    + Status: CREATED
    contract DepositEscrow (eth:0xA20f87a5443E3Be4925109cA189134c825932560) [N/A]
    +++ description: None
    + Status: CREATED
    contract VerifiableApp (eth:0xd330145C17fB6EF2a21ACf1275Ce683A305F58BB) [derivev3/VerifiableApp]
    +++ description: Holds the state root and verifies SP1 validity proofs for each batch through eth:0x3B6041173B80E77f038f3F2C0f9744f04837185e. Each proof also commits to a Celestia header range and blob hash-chain, which this contract chains from a stored Celestia anchor and checks for freshness.
    + Status: CREATED
    contract ProxyAdmin (eth:0xD773a38B81bBe7992209D6c4ef663c6A7F6cbfBd) [global/ProxyAdmin]
    +++ description: None
    + Status: CREATED
    contract OnchainActionManager (eth:0xE366CcA474968e33b777E13905829A3b800CFAD3) [derivev3/OnchainActionManager]
    +++ description: Entry point for L1 deposits and withdrawal requests. Every action is appended to an accumulator that batches consume in order.
    + Status: CREATED
    contract ProxyAdmin (eth:0xeB26aA88C73D3a03fE82be3C241B6ccd2D596811) [global/ProxyAdmin]
    +++ description: None
    + Status: CREATED
    contract WithdrawFactory (eth:0xFec48bBC648bd2284520d862Ec67fc68F709915e) [derivev3/WithdrawFactory]
    +++ description: Deploys a deterministic escrow per recipient and destination chain. Withdrawals paid to such an escrow are bridged onward by keepers via LayerZero OFT or CCIP.
    + Status: CREATED
    external contract (eth:0xCafEf00d348Adbd57c37d1B77e0619C6244C6878)
    +++ description: None

    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. Orders are matched offchain by a centralized engine, and only the designated batch submitter can submit batches unless it is removed through the stall timeout.

    • MEV can be extracted if the operator exploits their centralized position and frontruns user transactions.

    Users can queue withdrawals on L1

    Deposits and withdrawal requests submitted 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. are appended to an onchain queue. Batches consume it in order but are not required to consume any of it. If the oldest queued action stays unprocessed for 28d, anyone can remove the designated batch submitter and submit batches themselves. Since the 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. program is not public, independent proving is not possible from published artifacts, and there is no exit hatch.

    • Users can be censored if the operator refuses to process their L1 withdrawal request, as independent proving is not possible from published artifacts.

    Regular exit

    The user initiates the withdrawal 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 funds become available for withdrawal 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.. ZK proofs are required to settle blocks. Finally the user submits an L1 transaction to claim the funds.

    • Funds can be frozen if the owner, the guardian or a single pauser pauses the WithdrawalOutbox. Only the owner can unpause.

    • Funds can be frozen if the owner revokes the WithdrawalOutbox allowance on the SpotVault, or does not retry withdrawals whose payout failed, which only the owner can do.

    • Withdrawals can be delayed if they exceed the USD-denominated withdrawal rate limits, in which case they are queued until the limit refills.

    Forwarded withdrawals

    Users can withdraw to a deterministic escrow deployed by the WithdrawFactory, from which keepers 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. the funds to another chain via LayerZero OFT or CCIP. Funds waiting in these escrows are not protected by the validity proofs.

    • Funds can be stolen if the WithdrawFactory owner moves funds out of a withdraw escrow, or sets a malicious bridge route.

    1. Derive docs - Transfers & Withdrawals

    Prices are provided by an offchain oracle

    Margin, liquidation and option 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. use spot, forward, perpetual, volatility and rate feeds provided by 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. Scholes. These feeds are consumed inside the 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. program, whose source is not public.

    • Funds can be lost if the oracle reports incorrect prices.

    1. Derive docs - Oracles
    A dashboard to explore contracts and permissions
    Go to Disco
    Disco UI Banner

    Ethereum

    Actors

    Derive Multisig0x169a…2391

    A Multisig with 3/5 threshold.

    • Can upgrade with 4h delay
      • SpotVault
      • WithdrawalOutbox
      • VerifiableApp
      • OnchainActionManager
    • Can interact with DeriveTimelock
      • cancel queued transactions
      • manage all access control roles with 4h delay
      • propose transactions
    • Can interact with SpotVault
      • approve or revoke the withdrawal outbox’s allowance for any token with 4h delay
    • Can interact with WithdrawalOutbox
      • register assets and their vaults, set rate limits, static prices and the minimum time between guardian refills, appoint the guardian and pausers, pause and unpause, and pay out deferred withdrawals without rate limits with 4h delay
    • Can interact with VerifiableApp
      • replace the state rootA cryptographic hash succinctly representing a state using a Merkle tree., the program verification key, the verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. and the trusted Celestia anchor, and set the batch submitter and its stall timeout with 4h delay
    • Can interact with OnchainActionManager
      • withdraw the collected withdrawal fees with 4h delay
    • Can interact with WithdrawFactory
      • set 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. route per token and chain, appoint keepers, and move funds held in any withdraw escrow or in the factory to the owner with 4h delay

    Participants (5):

    EOA 7,EOA 8,EOA 2,EOA 3,EOA 9
    Derive Bypass Multisig0x5F8D…453a

    A Multisig with 6/8 threshold. Member of Derive Owner Multisig.

    • Can upgrade with no delay
      • SpotVault
      • WithdrawalOutbox
      • VerifiableApp
      • OnchainActionManager
    • Can interact with SpotVault
      • approve or revoke the withdrawal outbox’s allowance for any token
    • Can interact with WithdrawalOutbox
      • register assets and their vaults, set rate limits, static prices and the minimum time between guardian refills, appoint the guardian and pausers, pause and unpause, and pay out deferred withdrawals without rate limits
    • Can interact with VerifiableApp
      • replace the state rootA cryptographic hash succinctly representing a state using a Merkle tree., the program verification key, the verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. and the trusted Celestia anchor, and set the batch submitter and its stall timeout
    • Can interact with OnchainActionManager
      • withdraw the collected withdrawal fees
    • Can interact with WithdrawFactory
      • set 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. route per token and chain, appoint keepers, and move funds held in any withdraw escrow or in the factory to the owner
    Derive Guardian Multisig0x682C…12E8

    A Multisig with 2/7 threshold.

    • Can interact with WithdrawalOutbox
      • refill withdrawal rate limit buckets and pause withdrawals

    Participants (7):

    EOA 8,EOA 2,EOA 3,EOA 9,EOA 5,EOA 6,EOA 10
    SP1VerifierGatewayMultisig0xCafE…6878

    A Multisig with 2/3 threshold.

    • Can interact with SP1VerifierGateway
      • affect the livenessLiveness refers to the ability of a system to respond to requests and to process them in a timely manner. In the context of L2s, it refers to the ability of settling transactions, proofs and state roots to the base layer. and safety of the gateway - can transfer ownership, add and freeze verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. routes
    Used in:
    Celo logoFluent logoMantle logoRISE logo
    Derive Owner Multisig0x62c0…90F7

    A Multisig with 1/2 threshold.

    • Can interact with VerifiableApp
      • exclusively submit batches with validity proofs, until the oldest unprocessed 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. action is older than the submitter stall timeout

    Member of Derive Multisig, Derive Bypass Multisig, Derive Guardian Multisig.

    • Can interact with DeriveTimelock
      • cancel queued transactions
      • execute transactions that are ready
    • Can interact with WithdrawalOutbox
      • pause all withdrawal payouts. Only the owner can unpause
    • Can interact with WithdrawFactory
      • 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. the balance of a withdraw escrow to its recipient on the configured destination chain

    Member of Derive Bypass Multisig, Derive Guardian Multisig.

    • Can interact with WithdrawalOutbox
      • pause all withdrawal payouts. Only the owner can unpause

    Member of Derive Multisig, Derive Bypass Multisig.

    • Can interact with DeriveTimelock
      • cancel queued transactions
      • execute transactions that are ready

    Member of Derive Guardian Multisig.

    • Can interact with WithdrawalOutbox
      • pause all withdrawal payouts. Only the owner can unpause

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

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

    Ethereum

    DeriveTimelock0x12D6…bc78

    A timelock with access control. The current minimum delay is 4h. Member of Derive Owner Multisig.

    • Roles:
      • canceller: Derive Multisig, EOA 2, EOA 3, EOA 7, EOA 8, EOA 9
      • defaultAdmin: DeriveTimelock; ultimately Derive Multisig
      • executor: EOA 2, EOA 3, EOA 7, EOA 8, EOA 9
      • 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.: Derive Multisig
    • Roles:
      • owner: Derive Owner Multisig

    Escrow for the collateral deposited to Derive. It grants WithdrawalOutbox unlimited allowance for approved tokens.

    • Roles:
      • admin: ProxyAdmin; ultimately Derive Bypass Multisig, Derive Multisig
      • owner: Derive Owner Multisig; ultimately Derive Bypass Multisig, Derive Multisig

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

    Can be upgraded by: Derive Multisig with 4h delay, Derive Bypass Multisig with no delay

    Pays out withdrawals committed to by batches proven in VerifiableApp from the registered asset vaults, subject to USD-denominated per-recipient and global rate limits.

    • Roles:
      • admin: ProxyAdmin; ultimately Derive Bypass Multisig, Derive Multisig
      • guardian: Derive Guardian Multisig
      • owner: Derive Owner Multisig; ultimately Derive Bypass Multisig, Derive Multisig
      • pausers: EOA 10, EOA 2, EOA 3, EOA 5, EOA 6, EOA 8, EOA 9

    Can be upgraded by: Derive Multisig with 4h delay, Derive Bypass Multisig with no delay

    DepositEscrow0xA20f…2560

    Holds the state rootA cryptographic hash succinctly representing a state using a Merkle tree. and verifies SP1 validity proofs for each batch through SP1VerifierGateway. Each proof also commits to a Celestia header range and 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. hashA fixed-length fingerprint of variable-size input, produced by a hash function.-chain, which this contract chains from a stored Celestia anchor and checks for freshness.

    • Roles:
      • admin: ProxyAdmin; ultimately Derive Bypass Multisig, Derive Multisig
      • batchSubmitter: EOA 1
      • owner: Derive Owner Multisig; ultimately Derive Bypass Multisig, Derive Multisig

    Can be upgraded by: Derive Multisig with 4h delay, Derive Bypass Multisig with no delay

    Entry point for 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. deposits and withdrawal requests. Every action is appended to an accumulator that batches consume in order.

    • Roles:
      • admin: ProxyAdmin; ultimately Derive Bypass Multisig, Derive Multisig
      • owner: Derive Owner Multisig; ultimately Derive Bypass Multisig, Derive Multisig

    Can be upgraded by: Derive Multisig with 4h delay, Derive Bypass Multisig with no delay

    WithdrawFactory0xFec4…915e

    Deploys a deterministic escrow per recipient and destination chain. Withdrawals paid to such an escrow are bridged onward by keepers via LayerZero OFT or CCIP.

    • Roles:
      • keepers: EOA 11, EOA 4
      • owner: Derive Owner Multisig; ultimately Derive Bypass Multisig, Derive Multisig
    SP1VerifierGateway0x3B60…185e

    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.

    • Roles:
      • owner: SP1VerifierGatewayMultisig
    Implementation used in:
    Celo logoMantle logoRISE logoTaiko Alethia logo
    SP1Verifier0xc3c6…AF2A

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

    Implementation used in:
    Base Chain logoMantle logoCelo logoX Layer logo

    Program hashes

    Hash
    Repository
    Verification
    Used in
    0x00bc...855b
    Code unknown
    Derive V3 logo