Search

Search for projects by name or address

Paradex logo
Paradex

Badges

About

Paradex is a high-performance crypto-derivatives exchange offering zero fee and private perpetuals.


  • Total Value SecuredTVS
    $22.36 M8.97%
  • Past day UOPSDaily UOPS
    2.1127.4%
  • Gas token
    ETH
  • Type
    Other

  • Purposes
    Universal, Exchange

  • Tokens breakdown

    Sequencer failureState validationData availabilityExit windowProposer failure

    Badges

    About

    Paradex is a high-performance crypto-derivatives exchange offering zero fee and private perpetuals.

    Why is the project listed in others?

    There are less than 5 external actors that can attest data availability

    Consequence: projects without a sufficiently decentralized data availability committee rely on few entities to safely attest data availability on Ethereum. A small set of entities 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
    Past Day UOPS
    Past Day Ops count
    Max. UOPS
    Past day UOPS/TPS Ratio
    Compare with other projects

    This section shows how much data the project publishes to its data-availability (DA) layer over time. The project currently posts data toEthereumEthereum.



    Data posted
    Avg size per day
    Avg size per L2 UOP

    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. state updates interval
    Past 30 days anomalies
    100% normal uptime

    Paradex introduces privacy perps

    2025 Dec 15th

    Paradex introduces a privacy council to manage decryption keys for encrypted data availabilityThe property of a rollup's data being reachable by any node retrieving the data that were rolled up and executed to reach the proposed state. Data availability (DA), specifically decoupling it from the rollup nodes themselves, is one of the preeminent factors which allows a rollup to scale securely. A rollup is faced with a decision of what to use as a DA layer to guarantee that any node can retrieve this data--permissionlessly under any circumstance. For this reason, using Ethereum for DA currently provides the strongest security guarantees. If data is stored somewhere other than a permissionless L1, then the project is not a rollup, but rather a validium or an optimium..

    Learn more

    Paradex migrates to Stwo prover

    2025 Nov 25th

    Paradex switches from Stone zk 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. to Stwo to prove its 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..

    Learn more
    Sequencer failureState validationData availabilityExit windowProposer failure
    Sequencer failure
    No mechanism

    There is no mechanism to have transactions be included if 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. is down or censoring.

    State validation
    Validity proofs (ST)

    STARKs are zero knowledge proofs that ensure state correctness.

    Data availability
    External

    Encrypted data is posted on Ethereum as 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., and a privacy council of 3 members holds the decryption keys. Users are not able to independetly reconstruct the 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 without relying on the council members.

    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

    Only the whitelisted proposers can publish state rootsA cryptographic hash succinctly representing a state using a Merkle tree. 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., so in the event of failure the withdrawals are frozen.

    Encrypted blobs via privacy council

    Data is posted as encrypted 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. on Ethereum using a random symmetric key per 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.. Such symmetric key is also posted, but encrypted to the privacy council members public keys. Each member can recover the symmetric key and decrypt the data. The council has 3 members and at least one is required to disclose the decryption keys to reconstruct the 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. Users cannot independently reconstruct the L2 state without relying on the council members.

    • Funds can be frozen if no privacy council member discloses the decryption keys.

    1. Privacy Perps - Paradex docs
    Node software

    SN stack-compatible nodeA software client that participates in the network. software can be used, please find the Paradex-specific node setup guide in their docs.The Juno node software can be used to reconstruct the 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 entirely from 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 feature has not been released yet, but can be found in this PR.

    Compression scheme
    Genesis state

    There is no non-empty genesis state.

    Data format

    The data format has been updated with different versions, and the full specification can be found 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.

    PROVER

    Trusted Setups

    Onchain verifier

    Used in

    Starknet logoParadex logo

    Onchain verifier

    Used in

    Starknet logoParadex logo

    Program Hashes

    Name
    Hash
    Repository
    Verification
    Used in
    273300...7702
    Paradex logo
    257150...8294
    Paradex logo
    342795...2024
    Starknet logoParadex logoSorare logoedgeX v1 logotanX logo

    Projects used in

    Search for projects used in

    344285...1079
    Starknet logoParadex logoSorare logoedgeX v1 logotanX logo

    Projects used in

    Search for projects used in

    235884...3330
    Starknet logoParadex logoSorare logoedgeX v1 logotanX logo

    Projects used in

    Search for projects used in

    254986...4351
    Starknet logoParadex logoSorare logoedgeX v1 logotanX logo

    Projects used in

    Search for projects used in

    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
    21
    Last upgrade
    2mo 16d ago
    Avg upgrade interval
    5mo 20d
    2026 July 16, 09:25 UTC
    1change

    Added another Paradex operator.

    contract Paradex (eth:0xF338cad020D506e8e3d9B4854986E0EcE6C23640) [starknet/Starknet] {
    +++ description: Central Starknet rollup contract. For every state update it derives a SHARP fact from the state-transition output and either the Starknet OS or aggregator program hash, checks that fact through the configured SHARP call proxy, and requires the output's OS-config hash to match. It also processes L1 <-> L2 messages and stores the finalized L2 state.
    values.operators.1:
    + "eth:0x09d1ad25B369A0C48Bdf4CaAb85aFd08a3f07044"
    }
    2026 June 16, 09:47 UTC
    2changes

    Add permissioned address to bridge access control.

    contract USDC Bridge (eth:0xE3cbE3A636AB6A754e9e41B12b09d09Ce9E53Db3) [starknet/StarknetERC20Bridge] {
    +++ description: Standard Starkware bridge escrow (single token). Withdrawals can be throttled to 0% of the locked funds per 24 hours.
    values.accessControl.SECURITY_AGENT.members.2:
    + "eth:0x27aFEd9831209B58Cf24fa241E028dD1e80Fb17D"
    values.secAgentAC.2:
    + "eth:0x27aFEd9831209B58Cf24fa241E028dD1e80Fb17D"
    }
    2026 June 04, 15:26 UTC
    6changes

    signer added, threshold increased to 3. Also, rotated ms member.

    contract Paradex Multisig (eth:0x0a64d3D7747549aF6d65C225D56ac8f71e436B93) [GnosisSafe] {
    +++ description: None
    values.$members.0:
    + "eth:0x0405107a60391Eb51821be373ff978115Ee58488"
    values.$members.1:
    - "eth:0x2871B956bC19D25961E9a7519f32D7fDaA21B403"
    + "eth:0xCe958D997F4a5824D4d503A128216322C6C223a0"
    values.$threshold:
    - 2
    + 3
    values.multisigThreshold:
    - "2 of 5 (40%)"
    + "3 of 6 (50%)"
    }
    contract Paradex Multisig 2 (eth:0xFF57A3bB6465501c993acF8f3b29125a862661C0) [GnosisSafe] {
    +++ description: None
    values.$members.5:
    - "eth:0x661B48092a5af3F8d5B551D66f5B3F639deD3155"
    + "eth:0x6f52712Ae102e6B7970F1e24c83d22e5fF5E8950"
    }
    + Status: CREATED
    reference (eth:0x0405107a60391Eb51821be373ff978115Ee58488)
    +++ description: None
    2026 May 12, 09:54 UTC
    High severity
    13changes

    Upgraded Paradex rollup contract by adding small check on l1 to l2 msg hash: https://disco.l2beat.com/diff/eth:0x2793010E6711Acd5C46ed17f2183a9d58db71e04/eth:0x9961D34D3baE6914635c882e8FE382e14E0F172A. Also, updated program hashes to already verified versions. Config: use the new flattener implementation

    contract Paradex (eth:0xF338cad020D506e8e3d9B4854986E0EcE6C23640) [starknet/Starknet] {
    +++ description: Central rollup contract. Receives (verified) state roots from the Sequencer, allows users to consume L2 -> L1 messages and send L1 -> L2 messages. Critical configuration values for the L2's logic are defined here by various governance roles.
    sourceHashes.1:
    - "0xfee7303d7ae61327a9f6516d410a6efbe76c07d2ca3406be62e5bb3baa5532c9"
    + "0xef60960a959a9506c3f6eece9374f7fbcd095a488763801577ae88e427fd3d51"
    values.$implementation:
    - "eth:0x2793010E6711Acd5C46ed17f2183a9d58db71e04"
    + "eth:0x9961D34D3baE6914635c882e8FE382e14E0F172A"
    values.$pastUpgrades.4:
    + ["2026-05-10T13:30:11.000Z","0x1e964f795063d0e9b55f3f260bcbd3f11b3f3b43df658b9da2b78ce919bd4009",["eth:0x9961D34D3baE6914635c882e8FE382e14E0F172A"]]
    values.$upgradeCount:
    - 4
    + 5
    values.aggregatorHashMapped:
    - "1701025211190912681772481128523426351562426117847395998223683709327746845867"
    + "2571508110958925737463010241874806654058743535666147712534445437599630018294"
    values.aggregatorProgramHash:
    - "1701025211190912681772481128523426351562426117847395998223683709327746845867"
    + "2571508110958925737463010241874806654058743535666147712534445437599630018294"
    values.identify:
    - "StarkWare_Starknet_2025_10"
    + "StarkWare_Starknet_2026_11"
    values.implementation:
    - "eth:0x2793010E6711Acd5C46ed17f2183a9d58db71e04"
    + "eth:0x9961D34D3baE6914635c882e8FE382e14E0F172A"
    +++ description: The L2 programHash which is a hash of the L2 state machine logic. Liveness config MUST be changed in the .ts as soon as this is updated.
    +++ severity: HIGH
    values.programHash:
    - "918745833886511857768061986591752808672496300091957204265383861063635175685"
    + "2733003247060056328192560178934419513655729851806095615814023997114795707702"
    values.programHashHistory.8:
    + "918745833886511857768061986591752808672496300091957204265383861063635175685"
    values.programHashMapped:
    - "918745833886511857768061986591752808672496300091957204265383861063635175685"
    + "2733003247060056328192560178934419513655729851806095615814023997114795707702"
    implementationNames.eth:0x2793010E6711Acd5C46ed17f2183a9d58db71e04:
    - "Starknet"
    implementationNames.eth:0x9961D34D3baE6914635c882e8FE382e14E0F172A:
    + "Starknet"
    }
    2026 February 23, 12:02 UTC
    High severity
    13changes

    Removed LegacyBridge logic from the USDC bridge. Diff: https://disco.l2beat.com/diff/eth:0x8A4e51ff0F2a45899519e6049FB2D1F038Be1e77/eth:0xDcbD52FFaF81BF0aA5bD38B0c15F60345e8Eec86. Also added a StarkgateManager for this bridge.

    contract USDC Bridge (eth:0xE3cbE3A636AB6A754e9e41B12b09d09Ce9E53Db3) {
    +++ description: Standard Starkware bridge escrow (single token). Withdrawals can be throttled to 0% of the locked funds per 24 hours.
    sourceHashes.1:
    - "0xbe08cd77d92ae2b4d333c5d2850e16d06e16d98de2a8435e0a49dc35ad73b915"
    + "0xecdc47d2045525d1d373fdecc6478959fa5b2d2595713c2187c41ed98baa4738"
    values.$implementation:
    - "eth:0x8A4e51ff0F2a45899519e6049FB2D1F038Be1e77"
    + "eth:0xDcbD52FFaF81BF0aA5bD38B0c15F60345e8Eec86"
    values.$pastUpgrades.4:
    + ["2026-02-21T13:53:59.000Z","0xb0ea49fedd399a118b3f8a0c6a05b3e73a8235a184e1e5c61f57c601f94b59e7",["eth:0xDcbD52FFaF81BF0aA5bD38B0c15F60345e8Eec86"]]
    values.$upgradeCount:
    - 4
    + 5
    values.identify:
    - "StarkWare_StarknetERC20Bridge_2.0_4"
    + "StarkWare_StarknetTokenBridge_2.0_5"
    values.implementation:
    - "eth:0x8A4e51ff0F2a45899519e6049FB2D1F038Be1e77"
    + "eth:0xDcbD52FFaF81BF0aA5bD38B0c15F60345e8Eec86"
    values.manager:
    - "eth:0x0000000000000000000000000000000000000000"
    + "eth:0x279b87139f2e89D7ce44c3056D2876fDEAB29BAE"
    implementationNames.eth:0x8A4e51ff0F2a45899519e6049FB2D1F038Be1e77:
    - "StarknetERC20Bridge"
    implementationNames.eth:0xDcbD52FFaF81BF0aA5bD38B0c15F60345e8Eec86:
    + "StarknetTokenBridge"
    }
    contract Paradex Multisig 2 (eth:0xFF57A3bB6465501c993acF8f3b29125a862661C0) {
    +++ description: None
    receivedPermissions.4:
    + {"permission":"upgrade","from":"eth:0x279b87139f2e89D7ce44c3056D2876fDEAB29BAE","role":".$admin"}
    receivedPermissions.5:
    + {"permission":"upgrade","from":"eth:0xc50E4DF59aad8Ab494d10d2B66a90C9F0298f280","role":".$admin"}
    }
    + Status: CREATED
    contract StarkgateManager (eth:0x279b87139f2e89D7ce44c3056D2876fDEAB29BAE)
    +++ description: Acts as a central contract to manage StarkGate bridge escrows (add new ones, deactivate existing, change configs) when given the Manager role from the respective escrows.
    + Status: CREATED
    contract StarkgateRegistry (eth:0xc50E4DF59aad8Ab494d10d2B66a90C9F0298f280)
    +++ description: A simple registry that maps tokens to their StarkGate escrows. It also keeps a list of tokens that are blocked from being added to StarkGate.

    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.

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

    Users can't force any transaction

    There is no general mechanism to 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 the transaction.

    • Users can be censored if the operator refuses to include their transactions.

    1. Censorship resistance of Starknet - Forum Discussion

    Regular messaging

    The user initiates L2Layer 2 (L2) is a category of technical solutions aimed to scale the base layer in a trust minimized way. This category includes solutions like rollups as well as state channels and plasma. Other solutions are able to scale further, but with the introduction of additional trust assumptions, which are therefore not trust minimized. Sometimes the term Layer 2 is used to refer to include these solutions too, like validiums and optimiums, but to distinguish between trust minimized and non trust minimized solutions they are often referred to as "light" L2s, opposed to "strong" L2s like rollups.->L1Layer 1 (L1) is a blockchain that is self-reliant on its validator set for its security and consensus properties. Ethereum is an example of a layer 1. Blockchains started receiving the moniker of layer 1 once layer 2 became a meaningful area of development. messages by submitting a regular transaction on this chain. When the blockAn ordered list of transactions and chain-related metadata that gets bundled together and published to the L1/DA layer. Nodes execute the transactions contained within blocks to change the rollup chain’s state. Protocol rules dictate what constitutes a valid block, and invalid blocks are skipped over. containing that transaction is settled, the message becomes available for processing on L1. ZK proofs are required to settle blocks. Note that the message request can be censored by 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..

    • Funds can be frozen if the operator censors withdrawal transaction.

    1. Withdrawing is based on l2 to l1 messages - Starknet documentation

    Emergency exit

    There is no generic 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. mechanism as Starknet cannot be forced by users into a frozen state. Note that a freezing mechanism on L2Layer 2 (L2) is a category of technical solutions aimed to scale the base layer in a trust minimized way. This category includes solutions like rollups as well as state channels and plasma. Other solutions are able to scale further, but with the introduction of additional trust assumptions, which are therefore not trust minimized. Sometimes the term Layer 2 is used to refer to include these solutions too, like validiums and optimiums, but to distinguish between trust minimized and non trust minimized solutions they are often referred to as "light" L2s, opposed to "strong" L2s like rollups., to be secure, requires anti-censorship protection.

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

    Ethereum

    Actors:

    Paradex Multisig 20xFF57…61C0

    A Multisig with 3/6 threshold.

    • Can upgrade with no delay
      • StarkgateManager
      • StarkgateRegistry
      • USDC 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.
      • Paradex
    • Can interact with USDC Bridge
      • disable the withdrawal limit and manage the security agent role that can enable it
      • enable the withdrawal limit
      • manage critical access control roles related to upgrades and set the proxy governor that can upgrade the implementation
    • Can interact with Paradex
      • Permissioned to manage 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. role, finalize the application configuration, and change the OS program hashA fixed-length fingerprint of variable-size input, produced by a hash function., aggregator program hash, OS-config hash, fee collector, or message cancellation delay
    SHARP Multisig0x21F9…AEc4

    A Multisig with 2/4 threshold.

    • Can upgrade with 8d delay
      • SHARPVerifierCallProxy
    • Can interact with SHARPVerifierCallProxy
      • Administer the CallProxy’s GOVERNANCE_ADMIN and role-admin hierarchy. This AccessControl role is separate from the outer proxy governor that schedules implementation upgrades
      • Grant and revoke application roles, including the APP_GOVERNOR role that controls caller-specific fallback routes
      • Route fallback calls from specific callers to a still-active registry in the default verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover.’s reference chain. This principally determines which verifier and bootloader configuration processes their proof submissions; the proxy’s explicit isValid entry point always queries the default target
    Used in:
    Paradex Multisig0x0a64…6B93

    A Multisig with 3/6 threshold.

    • Can upgrade with no delay
      • Paradex
    • Can interact with Paradex
      • Permissioned to manage 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. role, finalize the application configuration, and change the OS program hashA fixed-length fingerprint of variable-size input, produced by a hash function., aggregator program hash, OS-config hash, fee collector, or message cancellation delay
    StarkgateManager0x279b…9BAE

    Acts as a central contract to manage StarkGate 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. escrows (add new ones, deactivate existing, change configs) when given the Manager role from the respective escrows.

    • Can interact with USDC Bridge
      • deactivate bridging for deposits into the escrow
    • Can interact with Paradex
      • Permissioned to regularly post 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 updates and choose an available data-availability entry point. Under the current implementation, every update still needs a fact accepted by SHARP and cannot bypass the pinned program and config hashes
    • Can interact with StarkgateManager
      • enroll new tokens, deactivate existing ones (for deposits) or 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. tokens from being added to the Multibridge
      • manage critical access control roles related to upgrades and set the proxy governor that can upgrade the implementation
    • Can interact with StarkgateRegistry
      • manage critical access control roles and the role that can upgrade the implementation
    • Can interact with USDC 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.
      • enable the withdrawal limit
    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

    Central Starknet rollupA blockchain that inherits consensus and data availability from another blockchain called L1. Rollups enable trust minimized bridges with the base layer via proof systems, either optimistic or zero-knowledge. A rollup without a bridge, or without considering the bridge, is called a sovereign rollup. contract. For every 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. it derives a SHARP fact from the state-transition output and either the Starknet OS or aggregator program hashA fixed-length fingerprint of variable-size input, produced by a hash function., checks that fact through the configured SHARP call proxy, and requires the output’s OS-config hash to match. It also processes 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. <-> 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. messages and stores the finalized L2 state.

    • Roles:
      • admin: Paradex Multisig, Paradex Multisig 2
      • operators: EOA 1, EOA 2
    Implementation used in:
    CpuVerifierAllSolidity_2026_130x0153…2CD6

    Immutable Solidity verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. for one Cairo CPU layout. It checks 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. proof using layout-specific constraint, OODS, Merkle, FRIA proximity test method that is used to determine whether a set of points is mostly on a polynomial with a degree less than a specified value. It resembles the FFT but the arithmetic complexity of its prover is strictly linear and that of the verifier is strictly logarithmic., and periodic-column helper contracts. The SHARP verifier can select any configured layout by cairoVerifierId.

    Implementation used in:
    CpuVerifierDex_2026_130x0cD0…5CdC

    Immutable Solidity verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. for one Cairo CPU layout. It checks 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. proof using layout-specific constraint, OODS, Merkle, FRIA proximity test method that is used to determine whether a set of points is mostly on a polynomial with a degree less than a specified value. It resembles the FFT but the arithmetic complexity of its prover is strictly linear and that of the verifier is strictly logarithmic., and periodic-column helper contracts. The SHARP verifier can select any configured layout by cairoVerifierId.

    Implementation used in:
    CairoBootloaderProgram0x2410…4A47

    Stores the complete compiled Cairo outer bootloader used as the top-level program of a SHARP proof. The SHARP verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. copies these words into public memory, pinning this exact executable onchain independently of the separately committed simple, applicative, and recursive-verifier programs.

    Implementation used in:
    CpuVerifierRecursive_2026_130x2867…9B6B

    Immutable Solidity verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. for one Cairo CPU layout. It checks 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. proof using layout-specific constraint, OODS, Merkle, FRIA proximity test method that is used to determine whether a set of points is mostly on a polynomial with a degree less than a specified value. It resembles the FFT but the arithmetic complexity of its prover is strictly linear and that of the verifier is strictly logarithmic., and periodic-column helper contracts. The SHARP verifier can select any configured layout by cairoVerifierId.

    Implementation used in:
    CpuVerifierSmall_2026_130x30F3…419b

    Immutable Solidity verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. for one Cairo CPU layout. It checks 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. proof using layout-specific constraint, OODS, Merkle, FRIA proximity test method that is used to determine whether a set of points is mostly on a polynomial with a degree less than a specified value. It resembles the FFT but the arithmetic complexity of its prover is strictly linear and that of the verifier is strictly logarithmic., and periodic-column helper contracts. The SHARP verifier can select any configured layout by cairoVerifierId.

    Implementation used in:
    MemoryPageFactRegistry_2023_90x4086…70fA

    PermissionlessAnyone willing should be able to join and leave the network at any time, without causing significant disturbance to the network or being detrimental to the party in question. No single entity should have the power to allowlist or blocklist participants. commitment calculator and registry used by the Solidity 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. verifiers. Anyone may submit a public-memory page and interaction elements; the contract computes its hashA fixed-length fingerprint of variable-size input, produced by a hash function. and cumulative product and registers the fact key committing to them, which the CPU verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. must bind to the proof. It is part of the proof verifier, not an application-level program registry. A malicious or nonconforming implementation can break public-memory soundness; binding to a different honest registry generally causes a 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. failure instead.

    Implementation used in:

    Upgradeable call router through which Starknet and other applications access SHARP fact registries. It uses call, not delegatecall, so facts and immutable verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. configuration remain at each target registry. The explicit isValid entry point always queries the default target. Other calls handled by the fallback, principally proof submissions, can be routed per caller to a still-active registry in the default target’s reference chain. The default target can be replaced by SHARP Multisig after 8d.

    • Roles:
      • admin: SHARP Multisig
      • appGovernor: SHARP Multisig
      • appRoleAdmin: SHARP Multisig
      • governanceAdmin: SHARP Multisig
    Can be upgraded by:
    Proxy used in:
    SHARPVerifier0x4956…72b6

    Immutable GPS statement verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. shared by Starknet and other StarkWare systems. It verifies a 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. proof of the exact Cairo bootloader stored onchain, forces the bootloader configuration into public memory, and registers a fact for every bootloader task. A fact is also considered valid when it exists in the time-limited reference fact registry.

    Implementation used in:
    SHARPVerifier_2026_13_10x5C1C…a9fe

    Immutable GPS statement verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. shared by Starknet and other StarkWare systems. It verifies a 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. proof of the exact Cairo bootloader stored onchain, forces the bootloader configuration into public memory, and registers a fact for every bootloader task. A fact is also considered valid when it exists in the time-limited reference fact registry.

    Implementation used in:
    CpuVerifierDexWithBitwise_2026_130x6a67…3F11

    Immutable Solidity verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. for one Cairo CPU layout. It checks 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. proof using layout-specific constraint, OODS, Merkle, FRIA proximity test method that is used to determine whether a set of points is mostly on a polynomial with a degree less than a specified value. It resembles the FFT but the arithmetic complexity of its prover is strictly linear and that of the verifier is strictly logarithmic., and periodic-column helper contracts. The SHARP verifier can select any configured layout by cairoVerifierId.

    Implementation used in:
    CpuVerifierStarknet_2026_130x7157…A26D

    Immutable Solidity verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. for one Cairo CPU layout. It checks 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. proof using layout-specific constraint, OODS, Merkle, FRIA proximity test method that is used to determine whether a set of points is mostly on a polynomial with a degree less than a specified value. It resembles the FFT but the arithmetic complexity of its prover is strictly linear and that of the verifier is strictly logarithmic., and periodic-column helper contracts. The SHARP verifier can select any configured layout by cairoVerifierId.

    Implementation used in:
    SHARPVerifier_2026_13_20x7Da1…3fF7

    Immutable GPS statement verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. shared by Starknet and other StarkWare systems. It verifies a 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. proof of the exact Cairo bootloader stored onchain, forces the bootloader configuration into public memory, and registers a fact for every bootloader task. A fact is also considered valid when it exists in the time-limited reference fact registry.

    Implementation used in:
    CpuVerifierRecursiveLargeOutput_2026_130xbe0F…AEF3

    Immutable Solidity verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. for one Cairo CPU layout. It checks 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. proof using layout-specific constraint, OODS, Merkle, FRIA proximity test method that is used to determine whether a set of points is mostly on a polynomial with a degree less than a specified value. It resembles the FFT but the arithmetic complexity of its prover is strictly linear and that of the verifier is strictly logarithmic., and periodic-column helper contracts. The SHARP verifier can select any configured layout by cairoVerifierId.

    Implementation used in:
    MemoryPageFactRegistry0xe583…C460

    PermissionlessAnyone willing should be able to join and leave the network at any time, without causing significant disturbance to the network or being detrimental to the party in question. No single entity should have the power to allowlist or blocklist participants. commitment calculator and registry used by the Solidity 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. verifiers. Anyone may submit a public-memory page and interaction elements; the contract computes its hashA fixed-length fingerprint of variable-size input, produced by a hash function. and cumulative product and registers the fact key committing to them, which the CPU verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. must bind to the proof. It is part of the proof verifier, not an application-level program registry. A malicious or nonconforming implementation can break public-memory soundness; binding to a different honest registry generally causes a 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. failure instead.

    Implementation used in:
    SHARPVerifier_2026_13_30xE675…b406

    Immutable GPS statement verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. shared by Starknet and other StarkWare systems. It verifies a 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. proof of the exact Cairo bootloader stored onchain, forces the bootloader configuration into public memory, and registers a fact for every bootloader task. A fact is also considered valid when it exists in the time-limited reference fact registry.

    Implementation used in:
    CpuVerifierPerpetual_2026_130xFFC7…6b44

    Immutable Solidity verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. for one Cairo CPU layout. It checks 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. proof using layout-specific constraint, OODS, Merkle, FRIA proximity test method that is used to determine whether a set of points is mostly on a polynomial with a degree less than a specified value. It resembles the FFT but the arithmetic complexity of its prover is strictly linear and that of the verifier is strictly logarithmic., and periodic-column helper contracts. The SHARP verifier can select any configured layout by cairoVerifierId.

    Implementation used in:

    A simple registry that maps tokens to their StarkGate escrows. It also keeps a list of tokens that are blocked from being added to StarkGate.

    • Roles:
      • admin: Paradex Multisig 2
      • govAdmin: EOA 3

    Standard Starkware bridgeA message-passing protocol between two blockchains. At its most basic, a token bridge consists of a smart contract which can escrow funds on one side of the bridge, and instruct the release or minting of corresponding assets on the other side, but bridges could also support arbitrary messages. How these instructions are validated is a critical factor in assessing the trust assumptions of a bridge. escrow (single token). Withdrawals can be throttled to 0% of the locked funds per 24 hours.

    • Roles:
      • admin: Paradex Multisig 2
      • govAdmin: Paradex Multisig 2
      • manager: StarkgateManager
      • secAdmin: Paradex Multisig 2
      • secAgent: EOA 4, EOA 5, Paradex Multisig 2
    The following tokens are included in the value secured calculation:
    USDC token logo
    CairoBootloaderProgram_2022_70x5d07…9dDf
    Implementation used in:
    MemoryPageFactRegistry_2022_70xFD14…D1b4
    Implementation used in:

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

    Program Hashes

    Name
    Hash
    Repository
    Verification
    Used in
    273300...7702
    Paradex logo
    257150...8294
    Paradex logo
    342795...2024
    Starknet logoParadex logoSorare logoedgeX v1 logotanX logo

    Projects used in

    Search for projects used in

    344285...1079
    Starknet logoParadex logoSorare logoedgeX v1 logotanX logo

    Projects used in

    Search for projects used in

    235884...3330
    Starknet logoParadex logoSorare logoedgeX v1 logotanX logo

    Projects used in

    Search for projects used in

    254986...4351
    Starknet logoParadex logoSorare logoedgeX v1 logotanX logo

    Projects used in

    Search for projects used in