Search for projects by name or address
dYdX v3 shut down on October 28th and is currently processing withdrawals in escape-hatch mode. Read more or use the escape-hatch.
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.
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.
The section shows the operating costs that L2s pay to Ethereum.
dYdX v4 announcement
2022 Jun 22nd
dYdX V4 will be developed as a standalone blockchain based on the Cosmos SDK.
dYdX Foundation
2021 Aug 3rd
Independent foundation was created to participate in the Protocol governance.
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.
STARKs are zero knowledge proofs that ensure state correctness.
All of the data needed for proof construction is published on Ethereum L1Layer 1 (L1) is a blockchain that is self-reliant on its validator set for its security and consensus properties. Ethereum is an example of a layer 1. Blockchains started receiving the moniker of layer 1 once layer 2 became a meaningful area of development..
There is 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).
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..
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.
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..
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.
There is no genesis file for dYdX. By default, all accounts were empty at the beginning.
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.
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.
The metrics include upgrades on the currently used proxy contracts. Historical proxy contracts and changes of such are not included.
Discovery rerun on the same block number with only config-related changes.
Discovery rerun on the same block number with only config-related changes.
| + | Status: CREATED |
| contract 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 | |
The escape hatch is open and the according verifier operational. Link to escape hatch added to header warn.
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 |
| } | |
Implementation of Proposal DIP-29 intended to bridge ethDYDX tokens from Treasury on Ethereum to dYdX Chain.
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" |
| } | |
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.
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) { | |
| } | |
| contract SafetyModule (0x65f7BA4Ec257AF7c55fd5854E5f6356bBd0fb8EC) { | |
| values.slashings: | |
| + | [] |
| } | |
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.
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.
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.
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.
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.

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.
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.
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.
Controlled by dYdX Governance. Owner of dYdX token. Can upgrade Treasury, Liquidity Module and Merkle Distributor. Currently there is 2d delay before the upgrade.
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.
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.


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.

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.
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.
Contract storing CAIRO Program Output, in case of dYdX, it stores state diffs of dYdX Exchange.
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..
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..
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..
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.
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.
The Safety Module is a staking pool that offers DYDX rewards to users who stake DYDX towards the security of the Protocol.
Contract storing dYdX Governance logic.
Contract storing logic for votes counting in dYdX Governance.
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.