Search projects, tokens and protocols by name or address
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.
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.
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.
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.
Derive V3 launch
6 Oct 2026
Derive V2 balances and positions are migrated into Derive V3, which settles on Ethereum.
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.
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..
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.
There is no window for users to exit in case of an unwanted upgrade since contracts are instantly upgradable.
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.
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).
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 SP1
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.
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.
The metrics include upgrades on the currently used proxy contracts. Historical proxy contracts and changes of such are not included.
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 of Derive V3: VerifiableApp, Onchain
| + | 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 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.
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.
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.
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.
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.

A Multisig with 3/5 threshold.
A Multisig with 6/8 threshold. Member of Derive Owner Multisig.
A Multisig with 2/3 threshold.
A Multisig with 1/2 threshold.
Member of Derive Multisig, Derive Bypass Multisig.
Member of Derive Guardian Multisig.
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 timelock with access control. The current minimum delay is 4h. Member of Derive Owner Multisig.
Escrow for the collateral deposited to Derive. It grants Withdrawal
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.
Can be upgraded by: Derive Multisig with 4h delay, Derive Bypass Multisig with no delay
Holds the state rootA cryptographic hash succinctly representing a state using a Merkle tree. and verifies SP1 validity proofs for each batch through SP1
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.
Can be upgraded by: Derive Multisig with 4h delay, Derive Bypass Multisig with no delay
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.
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.1.0).