Search

Search for projects by name or address

dYdX v3 logo
dYdX v3

dYdX v3 shut down on October 28th and is currently processing withdrawals in escape-hatch mode. Read more or use the escape-hatch.

Badges

About

dYdX v3 aims to build a powerful and professional exchange for trading crypto assets where users can truly own their trades and, eventually, the exchange itself.


Sequencer failureState validationData availabilityExit windowProposer failure

Badges

About

dYdX v3 aims to build a powerful and professional exchange for trading crypto assets where users can truly own their trades and, eventually, the exchange itself.


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

ETH & derivatives
Stablecoins
BTC & derivatives
Other
Data source: StarkEx Aggregations API
Past Day UOPS
Past Day Ops count
Max. UOPS
Past day UOPS/TPS Ratio

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



Total cost
Avg cost per L2 UOP
Avg cost per day

dYdX v4 announcement

2022 Jun 22nd

dYdX V4 will be developed as a standalone blockchain based on the Cosmos SDK.

Learn more

dYdX Foundation

2021 Aug 3rd

Independent foundation was created to participate in the Protocol governance.

Learn more
This page describes dYdX v3, which is an 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. built on Ethereum. Recently deployed dYdX v4 is a separate blockchain based on Cosmos SDK, unrelated to Ethereum and is using different technology. No information on this page applies to dYdX v4.
This page describes dYdX v3, which is an 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. built on Ethereum. Recently deployed dYdX v4 is a separate blockchain based on Cosmos SDK, unrelated to Ethereum and is using different technology. No information on this page applies to dYdX v4.
Sequencer failureState validationData availabilityExit windowProposer failure
Sequencer failure
Force via L1

Users can force the sequencerA party responsible for ordering and executing transactions on the rollup. The sequencer verifies transactions, compresses the data into a block, and submits the data related to it to enable state reconstruction to Ethereum L1 as a single transaction. The data can be either transaction data or state diffs. to include a trade or a withdrawal transaction by submitting a request 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.. If the sequencer censors or is down for 14d, users can use the exit hatch to withdraw their funds. Users are required to find a counterparty for the trade by out of system means.

State validation
Validity proofs (ST)

STARKs are zero knowledge proofs that ensure state correctness.

Data availability
Onchain

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

Exit window
9d

There is a 9d exit windowThe amount of time that users have to exit a system before an unwanted upgrade. It takes into account upgrade delays, forced transaction delays and other time factors. To be considered Stage 1, a rollup needs to have an exit window of at least 7d if upgrades are initiated by a permissioned actor less decentralized than a Security Council. For Stage 2, a rollup needs at least 30d in all cases outside of onchain provable bugs. (or 2d if shortened by the Priority Controller).

Proposer failure
Use escape hatch

Users are able to trustlessly exit by submitting a Merkle proof of funds. Positions will be closed using the average price from the last batch state updateA mechanism that allows to update the claimed state of a project. It usually involves verifying a state transition proof, but it can also be done in a trusted manner by a permissioned actor..

dYdX v3
dYdX v3 is a
Stage 1
ZK Rollup.

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

All data required for proofs is published on chain

All the relevant data that is used to recover the balances Merkle TreeA hash-based data structure in which each leaf node is a hash of a block of data, and each non-leaf node is a hash of its children. The root of the tree is a cryptographic fingerprint of the entire data structure. Merkle trees (Merkle Patricia Tries) are used in Ethereum to efficiently store key-value pairs. is published onchain as calldata. This includes, in addition to the proven new state, the complete list of differences of the users’ balances from the previous state.

  1. Data Availability Modes - StarkEx documentation
  2. ZK Rollup - StarkEx documentation
  3. UpdatePerpetualState.sol#L82 - Etherscan source code, updateState function
Learn more about the DA layer here: Ethereum logoEthereum
Node software

State can be independently derived from data (state updates) published on Ethereum by running an open-source StarkEx Explorer. The explorer, once fully synced, provides UI interface to perform forced actions, trigger 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. freeze and withdraw funds using escape hatchThe facility for any user of a rollup to exit the system with their assets under any circumstance. Most relevant in rollups with a centralized proposer, wherein users do not have the ability to propose blocks, but can nonetheless exit the rollup by interacting with a smart contract on L1..

Compression scheme

No compression is used, state updates and other metadata are simply serialized 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.

Genesis state

There is no genesis file for dYdX. By default, all accounts were empty at the beginning.

Data format

dYdX doesn’t publish transactions. Balances of user positions are stored in a Merkle TreeA hash-based data structure in which each leaf node is a hash of a block of data, and each non-leaf node is a hash of its children. The root of the tree is a cryptographic fingerprint of the entire data structure. Merkle trees (Merkle Patricia Tries) are used in Ethereum to efficiently store key-value pairs. and updates to that tree are published on Ethereum, together with Merkle Root and a ZK proof. Deserialization of that data is implemented here. Generating Merkle Proof is implemented here.

Validity proofs

Each update to the system state must be accompanied by a ZK proof that ensures that the new state was derived by correctly applying a series of valid user transactions to the previous state. These proofs are then verified on Ethereum by a smart contract. The system state is represented using Merkle roots.

  1. Enforcing Consistency on the On-Chain State - StarkEx documentation
  2. UpdatePerpetualState.sol#L125 - Etherscan source code, verifyFact function call

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
5
Last upgrade
3y 5mo ago
Avg upgrade interval
1y 6mo
2025 July 14, 12:44 UTC
38changes

Discovery rerun on the same block number with only config-related changes.

New and verified contracts

+ Status: CREATED
contract MerkleDistributor (0x01d3348601968aB85b4bb028979006eac235a588)
+++ description: None
+ Status: CREATED
contract CpuFrilessVerifier (0x04D4E67F8B6c67D63219Cd088bC45E8e89fE6D73)
+++ description: None
+ Status: CREATED
contract CpuOods (0x0c6dEc0B366b1bb4C14597cf1Da8b4af2E7799b5)
+++ description: None
+ Status: CREATED
contract MerkleStatementContract (0x0d62bac5c346c78DC1b27107CAbC5F4DE057a830)
+++ description: None
+ Status: CREATED
contract ClaimsProxy (0x0fd829C3365A225FB9226e75c97c3A114bD3199e)
+++ description: None
+ Status: CREATED
contract PedersenHashPointsYColumn (0x0fED12bD8B1B11c629001c436b90bcd99F4Fec92)
+++ description: None
+ Status: CREATED
contract CairoBootloaderProgram (0x1dd8945200f5a09D6Fe0ed68494c2ac41cd02E2D)
+++ description: None
+ Status: CREATED
contract CpuConstraintPoly (0x1F5459AA7857291112A8172ae1328248948d9d13)
+++ description: None
+ Status: CREATED
contract TreasuryProxyAdmin (0x40D6992cbd03E0DC1c2DE9606D29Cb245E737a5d)
+++ description: None
+ Status: CREATED
contract WrappedEthereumDydxToken (0x46b2DeAe6eFf3011008EA27EA36b7c27255ddFA9)
+++ description: None
+ Status: CREATED
contract CpuFrilessVerifier (0x4922f8750DFd040954b44F23980160342e308863)
+++ description: None
+ Status: CREATED
contract EcdsaPointsXColumn (0x52c4bb16FbA75f6EBD672568267BC334255Fb3c5)
+++ description: None
+ Status: CREATED
contract LiquidityStaking (0x5Aa653A076c1dbB47cec8C1B4d152444CAD91941)
+++ description: None
+ Status: CREATED
contract PerpetualEscapeVerifier (0x626211C1e9BC633f4D342Af99f4E8bc93f11F3DD)
+++ description: None
+ Status: CREATED
contract TreasuryBridge (0x639192D54431F8c816368D3FB4107Bc168d0E871)
+++ description: None
+ Status: CREATED
contract ShortTimelockExecutor (0x64c7d40c07EFAbec2AafdC243bF59eaF2195c6dc)
+++ description: None
+ Status: CREATED
contract SafetyModule (0x65f7BA4Ec257AF7c55fd5854E5f6356bBd0fb8EC)
+++ description: None
+ Status: CREATED
contract SafetyModuleProxyAdmin (0x6aaD0BCfbD91963Cf2c8FB042091fd411FB05b3C)
+++ description: None
+ Status: CREATED
contract MerkleDistributorProxyAdmin (0x6C5cd3aD7A16Ae207D221908E6b997d9B0DcD7b0)
+++ description: None
+ Status: CREATED
contract DydxGovernor (0x7E9B1672616FF6D6629Ef2879419aaE79A9018D2)
+++ description: None
+ Status: CREATED
contract GpsStatementVerifier (0x894c4a12548FB18EaA48cF34f9Cd874Fc08b7FC3)
+++ description: None
+ Status: CREATED
contract Committee (0x8A8E80e0762243f0df39f2847808B7F6D62e2bb1)
+++ description: None
+ Status: CREATED
contract DydxToken (0x92D6C1e31e14520e676a687F0a93788B716BEff5)
+++ description: None
+ Status: CREATED
contract ChainlinkAdapter (0x99B0599952a4FD2d1A1561Fa4C010827EaD30354)
+++ description: None
+ Status: CREATED
contract PedersenHashPointsXColumn (0x9Bcf13C6b68450B427bfa86698D61901A8a3456D)
+++ description: None
+ Status: CREATED
contract PriorityExecutor (0xa306989BA6BcacdECCf3C0614FfF2B8C668e3CaE)
+++ description: None
+ Status: CREATED
contract LiquidityStakingProxyAdmin (0xAc5D8bCD13da463bea96c75f9085c4e40037F790)
+++ description: None
+ Status: CREATED
contract TreasuryVester (0xb9431E19B29B952d9358025f680077C3Fd37292f)
+++ description: None
+ Status: CREATED
contract GovernanceStrategyV2 (0xc2f5F3505910Da80F0592a3Cc023881C50b16505)
+++ description: None
+ Status: CREATED
contract EcdsaPointsYColumn (0xD14fd39630Ec941C3bA6C791E3af9E0027013A15)
+++ description: None
+ Status: CREATED
contract StarkPerpetual (0xD54f502e184B6B739d7D27a6410a67dc462D69c8)
+++ description: None
+ Status: CREATED
contract MerklePauserExecutor (0xd98e7A71BacB6F11438A8271dDB2EFd7f9361F52)
+++ description: None
+ Status: CREATED
contract CpuFrilessVerifier (0xeCa5Da0287D407a23f7c0a13a9AAD87c7fBC10A3)
+++ description: None
+ Status: CREATED
contract LongTimelockExecutor (0xEcaE9BF44A21d00E2350a42127A377Bf5856d84B)
+++ description: None
+ Status: CREATED
contract MemoryPageFactRegistry (0xEfbCcE4659db72eC6897F46783303708cf9ACef8)
+++ description: None
+ Status: CREATED
contract FinalizableGpsFactAdapter (0xF23754231BC4cE8C8E92C3bADfB37d922d46053C)
+++ description: Adapter between the core contract and the eth:0x894c4a12548FB18EaA48cF34f9Cd874Fc08b7FC3. Stores the Cairo programHash (`3022993219738828102988654230098311570191704199468817569337520096526584973032`).
+ Status: CREATED
contract FriStatementContract (0xf6b83CcaDeee478FC372AF6ca7069b14FBc5E1B1)
+++ description: None
+ Status: CREATED
contract StarkExRemoverGovernorV2 (0xFCAac0F14deA11eDe11Afcb875f29130e1ad5ec0)
+++ description: None
2024 October 31, 10:41 UTC
2changes

The escape hatch is open and the according verifier operational. Link to escape hatch added to header warn.

contract PerpetualEscapeVerifier (0x626211C1e9BC633f4D342Af99f4E8bc93f11F3DD) {
+++ description: None
values.hasRegisteredFact:
- false
+ true
}
contract StarkPerpetual (0xD54f502e184B6B739d7D27a6410a67dc462D69c8) {
+++ description: None
values.isFrozen:
- false
+ true
}
2024 January 09, 11:54 UTC
High severity
7changes

Implementation of Proposal DIP-29 intended to bridge ethDYDX tokens from Treasury on Ethereum to dYdX Chain.

contract Treasury (0x639192D54431F8c816368D3FB4107Bc168d0E871) {
name:
- "Treasury"
+ "TreasuryBridge"
upgradeability.implementation:
- "0x0AdA60E07717Ab19E4A466f5f0ac68A66e3995Ce"
+ "0x8d0051943D4c72aF12D638c6b7253C71929A910A"
implementations.0:
- "0x0AdA60E07717Ab19E4A466f5f0ac68A66e3995Ce"
+ "0x8d0051943D4c72aF12D638c6b7253C71929A910A"
values.BRIDGE:
+ "0x46b2DeAe6eFf3011008EA27EA36b7c27255ddFA9"
values.BURN_ADDRESS:
+ "0x0000000000000000000000000000000000000001"
values.TREASURY_VESTER:
+ "0xb9431E19B29B952d9358025f680077C3Fd37292f"
}
contract TreasuryVester (0xb9431E19B29B952d9358025f680077C3Fd37292f) {
values.recipient:
- "0x639192D54431F8c816368D3FB4107Bc168d0E871"
+ "0x0000000000000000000000000000000000000001"
}
2023 October 05, 07:17 UTC
4changes

Proposal: <https://dydx.community/dashboard/proposal/15 TLDR: added wethDYDX in the calculation of governance power. wethDYDX is a token minted by locking Ethereum DYDX tokens (called ethDYDX) permanently which will be later bridged to the dYdX Chain. wethDYDX is a transferable ERC20. Does this mean that tokens will get duplicated? We don't have a specific section on the website to specify this information, but we will soon with the Governance section, so I'll wait before adding anything to the project page.

contract DydxGovernor (0x7E9B1672616FF6D6629Ef2879419aaE79A9018D2) {
values.getGovernanceStrategy:
- "0x90Dfd35F4a0BB2d30CDf66508085e33C353475D9"
+ "0xc2f5F3505910Da80F0592a3Cc023881C50b16505"
}
- Status: DELETED
contract GovernanceStrategy (0x90Dfd35F4a0BB2d30CDf66508085e33C353475D9) {
}
+ Status: CREATED
contract WrappedEthereumDydxToken (0x46b2DeAe6eFf3011008EA27EA36b7c27255ddFA9) {
}
+ Status: CREATED
contract GovernanceStrategyV2 (0xc2f5F3505910Da80F0592a3Cc023881C50b16505) {
}
2023 September 26, 11:49 UTC
1change
contract SafetyModule (0x65f7BA4Ec257AF7c55fd5854E5f6356bBd0fb8EC) {
values.slashings:
+ []
}

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. Typically, the Operator is the hot wallet of the StarkEx service submitting state updates for which proofs have been already submitted and verified.

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

  1. Operator - StarkEx documentation
  2. Operator.sol#L42 - Etherscan source code, onlyOperator modifier

Users can force exit the system

Force exit allows the users to escape censorship by withdrawing their funds. The system allows users to force the withdrawal of funds by submitting a request directly to the contract onchain. The request must be served within 14d. If this does not happen, the system will halt regular operation and permit trustless withdrawal of funds. Perpetual positions can also be force closed before withdrawing, however this requires the user to find the counterparty for the trade themselves.

  • Users can be censored if the operator refuses to include their transactions. However, there exists a mechanism to independently exit the system.

  • Funds can be lost if the user is unable to find the counterparty for the force trade.

  1. Censorship Prevention - StarkEx documentation
  2. Forced Trade - StarkEx documentation
  3. ForcedTrades.sol#L46 - Etherscan source code, forcedTradeRequest function
  4. ForcedWithdrawals.sol#L32 - Etherscan source code, forcedWithdrawalRequest function

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.

  1. Withdrawal - StarkEx documentation

Forced exit

If the user experiences censorship from the operatorAn operator is the entity charged with managing a rollup and progressing its state. A rollup operator can be a centralized sequencer, proposer, prover, challenger, pauser of admin that is able to perform upgrades. with regular exit they can submit their withdrawal requests directly on L1Layer 1 (L1) is a blockchain that is self-reliant on its validator set for its security and consensus properties. Ethereum is an example of a layer 1. Blockchains started receiving the moniker of layer 1 once layer 2 became a meaningful area of development.. The system is then obliged to service this request. Once the force operation is submitted and if the request is serviced, the operation follows the flow of a regular exit.

  1. Forced Operations - StarkEx documentation
  2. Forced Withdrawal - StarkEx documentation
  3. Forced Trade - StarkEx documentation

Emergency exit

If the enough time deadline passes and the forced exit is still ignored the user can put the system into a frozen state, disallowing further state updates. In that case everybody can withdraw by submitting a merkle proof of their funds with their 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. transaction.

  1. Forced Operations - StarkEx documentation
  2. Forced Withdrawal - StarkEx documentation
  3. Forced Trade - StarkEx documentation
A dashboard to explore contracts and permissions
Go to Disco
Disco UI Banner

Ethereum

Actors:

Operators0x8129…390a

Allowed to update state 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.. When 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 down the state cannot be updated.

Rollup Admin0x7E9B…18D2

Controlled by dYdX Governance. Defines rules of governance via the dYdX token. Can upgrade implementation 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., potentially gaining access to all funds stored in 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.. Currently there is 9d delay before the upgrade.

  1. Rollup Admin documentation
Rollup Priority Controller0xDC7e…B2c0

Can decrease the delay required for 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. upgrade to 2d.

  1. dYdX governance documentation
  2. Priority Controller documentation
Treasury Admin0x7E9B…18D2

Controlled by dYdX Governance. Owner of dYdX token. Can upgrade Treasury, Liquidity Module and Merkle Distributor. Currently there is 2d delay before the upgrade.

  1. Treasury Admin documentation
Safety Module Admin0x7E9B…18D2

Controlled by dYdX Governance. Has the ability to update Governance Strategy resulting in different logic of votes counting. Can upgrade Safety Module. Currently there is 7d delay before the upgrade.

  1. Safety Module Admin
Merkle Pauser0x7E9B…18D2

Controlled by dYdX Governance. The Merkle-pauser executor can freeze the Merkle root, which is updated periodically with each user cumulative reward balance, in case the proposed root is incorrect or malicious. It can also veto forced trade requests by any of the starkShort for "scalable transparent argument of knowledge", a STARK is a type of zero-knowledge proof that resolves one of the primary weaknesses of ZK-SNARKs, its reliance on a "trusted setup”. STARKs also come with much simpler cryptographic assumptions, avoiding the need for elliptic curves, pairings, and the knowledge-of-exponent assumption and instead relying purely on hashes and information theory. This means that they are secure even against attackers with quantum computers. proxy contracts.Currently there is 0s delay before the upgrade.

  1. Merkle Pauser documentation
A dashboard to explore contracts and permissions
Go to Disco
Disco UI Banner
A diagram of the smart contract architecture
A diagram of the smart contract architecture

Ethereum

Main contract of dYdX exchange. Updates dYdX state and verifies its integrity using STARKShort for "scalable transparent argument of knowledge", a STARK is a type of zero-knowledge proof that resolves one of the primary weaknesses of ZK-SNARKs, its reliance on a "trusted setup”. STARKs also come with much simpler cryptographic assumptions, avoiding the need for elliptic curves, pairings, and the knowledge-of-exponent assumption and instead relying purely on hashes and information theory. This means that they are secure even against attackers with quantum computers. VerifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover.. Allows users to deposit and withdraw tokens via normal and emergency modes.

The following tokens are included in the value secured calculation:
USDC token logo
FinalizableGpsFactAdapter0xF237…053C

Contract serving as an adapter for STARKShort for "scalable transparent argument of knowledge", a STARK is a type of zero-knowledge proof that resolves one of the primary weaknesses of ZK-SNARKs, its reliance on a "trusted setup”. STARKs also come with much simpler cryptographic assumptions, avoiding the need for elliptic curves, pairings, and the knowledge-of-exponent assumption and instead relying purely on hashes and information theory. This means that they are secure even against attackers with quantum computers. VerifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover.. It holds the address of the STARK Verifier and CAIRO program hashA fixed-length fingerprint of variable-size input, produced by a hash function. needed for verification.

GpsStatementVerifier0x894c…7FC3

STARKShort for "scalable transparent argument of knowledge", a STARK is a type of zero-knowledge proof that resolves one of the primary weaknesses of ZK-SNARKs, its reliance on a "trusted setup”. STARKs also come with much simpler cryptographic assumptions, avoiding the need for elliptic curves, pairings, and the knowledge-of-exponent assumption and instead relying purely on hashes and information theory. This means that they are secure even against attackers with quantum computers. VerifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover.. In contrast to other StarkWare systems which use common SHARP 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., dYdX uses separate Prover/Verifier.

MemoryPageFactRegistry0xEfbC…Cef8

Contract storing CAIRO Program Output, in case of dYdX, it stores state diffs of dYdX Exchange.

FriStatementContract0xf6b8…E1B1

Part of STARKShort for "scalable transparent argument of knowledge", a STARK is a type of zero-knowledge proof that resolves one of the primary weaknesses of ZK-SNARKs, its reliance on a "trusted setup”. STARKs also come with much simpler cryptographic assumptions, avoiding the need for elliptic curves, pairings, and the knowledge-of-exponent assumption and instead relying purely on hashes and information theory. This means that they are secure even against attackers with quantum computers. VerifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover..

MerkleStatementContract0x0d62…a830

Part of STARKShort for "scalable transparent argument of knowledge", a STARK is a type of zero-knowledge proof that resolves one of the primary weaknesses of ZK-SNARKs, its reliance on a "trusted setup”. STARKs also come with much simpler cryptographic assumptions, avoiding the need for elliptic curves, pairings, and the knowledge-of-exponent assumption and instead relying purely on hashes and information theory. This means that they are secure even against attackers with quantum computers. VerifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover..

CairoBootloaderProgram0x1dd8…2E2D

Part of STARKShort for "scalable transparent argument of knowledge", a STARK is a type of zero-knowledge proof that resolves one of the primary weaknesses of ZK-SNARKs, its reliance on a "trusted setup”. STARKs also come with much simpler cryptographic assumptions, avoiding the need for elliptic curves, pairings, and the knowledge-of-exponent assumption and instead relying purely on hashes and information theory. This means that they are secure even against attackers with quantum computers. VerifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover..

PerpetualEscapeVerifier0x6262…F3DD

Contract responsible for validating force withdrawal requests.

The Merkle Distributor smart contract distributes DYDX token rewards according to a Merkle treeA hash-based data structure in which each leaf node is a hash of a block of data, and each non-leaf node is a hash of its children. The root of the tree is a cryptographic fingerprint of the entire data structure. Merkle trees (Merkle Patricia Tries) are used in Ethereum to efficiently store key-value pairs. of balances.

Can be upgraded by:

The Liquidity Module is a collection of smart contracts for staking and borrowing, which incentivize the allocation of USDC funds for market making purposes on the dYdX layer 2Layer 2 (L2) is a category of technical solutions aimed to scale the base layer in a trust minimized way. This category includes solutions like rollups as well as state channels and plasma. Other solutions are able to scale further, but with the introduction of additional trust assumptions, which are therefore not trust minimized. Sometimes the term Layer 2 is used to refer to include these solutions too, like validiums and optimiums, but to distinguish between trust minimized and non trust minimized solutions they are often referred to as "light" L2s, opposed to "strong" L2s like rollups. exchange.

Can be upgraded by:

The Safety Module is a staking pool that offers DYDX rewards to users who stake DYDX towards the security of the Protocol.

DydxGovernor0x7E9B…18D2

Contract storing dYdX Governance logic.

GovernanceStrategyV20xc2f5…6505

Contract storing logic for votes counting in dYdX Governance.

DydxToken0x92D6…Eff5

Token used by the dYdX Governance for voting.

The current deployment carries some associated risks:

  • Funds can be stolen if a contract receives a malicious code upgrade. There is a 9d delay on code upgrades.The delay can be decreased by the Priority Controller to 2d.