Search

Search for projects by name or address

Sorare logo
Sorare

Sorare froze its StarkEx rollup on June 1st, 2026. The core rollup contract is currently frozen.

Critical contracts can be upgraded by an EOA which could result in the loss of all funds.

Badges

About

Sorare is a global fantasy football game where you can play with officially licensed digital cards.


  • Total Value SecuredTVS
    $3.36 M6.78%
  • Past day UOPSDaily UOPS
    No data
  • Stage
  • Type
    Validium

  • Purposes
    NFT, Exchange

  • Tokens breakdown

    Sequencer failureState validationData availabilityExit windowProposer failure

    Badges

    About

    Sorare is a global fantasy football game where you can play with officially licensed digital cards.


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

    ETH & derivatives
    Stablecoins
    BTC & derivatives
    Other
    Data source: StarkEx Aggregations API

    2021 Jul 15 — 2026 Jul 16

    Past Day UOPS
    0.000.00%
    Past Day Ops count
    0
    Max. UOPS
    2.74
    2025 Aug 21
    Past day UOPS/TPS Ratio
    No data

    Sorare StarkEx deprecation

    2026 Jun 1st

    Sorare finalizes its migration to Solana by sunsetting its StarkEx L2 contract.

    Learn more

    Mainnet Launch

    2021 Jul 26th

    Layer 2 scaling solution powered by Starkware, is live on Ethereum.

    Learn more
    Critical contracts can be upgraded by an EOA which could result in the loss of all funds.
    Sequencer failureState validationData availabilityExit windowProposer failure
    Sequencer failure
    Force via L1

    Users can force the sequencer to include a transaction by submitting a request through L1. If the sequencer censors or is down for for more than 7d, users can use the exit hatch to withdraw their funds.

    State validation
    Validity proofs (ST)

    STARKs are zero knowledge proofs that ensure state correctness.

    Data availability
    External (DAC)

    Proof construction relies fully on data that is NOT published onchain. There exists a Data Availability Committee (DAC) with a threshold of 2/4 that is tasked with protecting and supplying the data.

    Exit window
    None

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

    Proposer failure
    Use escape hatch

    Users are able to trustlessly exit by submitting a Merkle proof of funds. NFTs will be minted on L1 to exit.

    Sorare
    Sorare is a
    Stage 0
    Appchain
    Validium.

    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.

    Set of parties responsible for signing and attesting to the availability of data.

    Economic security
    None

    There are no onchain assets at risk of being slashed in case of a data withholding attack, and the committee members are not publicly known.

    Fraud detection
    None

    There is no fraud detection mechanism in place. A data withholding attack can only be detected by nodes downloading the full data from the DA layer.

    Committee security
    2/4

    The committee does not meet basic security standards, either due to insufficient size, lack of member diversity, or poorly defined threshold parameters. The system lacks an effective DA bridge and it is reliant on the assumption of an honest sequencer, creating significant risks to data integrity and availability.

    Upgradeability
    Immutable

    The bridge smart contract is immutable and cannot be updated. The bridge committee security is low and cannot be improved.

    Relayer failure
    Self propose

    Anyone can relay data availability commitments to the DA bridge. In case of current relayer failure, users can collect attestations from committee members and propose new data availability commitments to the DA bridge.

    Architecture

    starkex architecture

    The Starkware application utilizes a data availability solution that relies on a Committee Service to ensure data persistence. This architecture comprises the following components:

    • Availability Gateway: The primary interface provided by the operator for committee members to access new batch information and submit signed availability claims.
    • Data Availability Committee (DAC): A group of nodes responsible for storing state data associated with each Merkle root and attesting to data availability by signing claims.
    • Data Batches: Collections of transactions processed in batches that update the state of accounts, resulting in a new Merkle root representing the updated state.

    Committee members run services that interact with the Availability Gateway to obtain information about new batches and submit their signed availability claims. Each batch includes a unique batch_id, a reference to a previous batch, and a list of account updates. Committee members combine this information with data from the reference batch to compute the new state and verify the Merkle root.

    When the operator produces a new batch, it must be signed by a minimum number of committee members—as defined by the application’s configuration—for it to be accepted onchain. This includes all members designated as mandatory signers. If the operator attempts to submit a batch without the required signatures, it will be rejected, thereby ensuring that data remains available and consistent.

    Committee members are expected to maintain a database that stores the data associated with each batch, making use of storage solutions with a replication factor of at least 2.

    DA Bridge Architecture

    starkex bridge architecture

    The DA commitments are posted to the destination chain, using the Committee Verifier contract as a DA bridge. The DA commitment consists of a data hash of the transaction batch the Committee has signed off on and a concatenation of ec-signatures by signatories.

    The Committee Verifier contract verifies the signatures and the data hash and if the required threshold of Committee members has signed off on the data, the hash is stored as a registeredFact in the StarkEx contract. In a separate transaction, the operator calls the updateState() function on the StarkEx contract to update the state. Before the state update is accepted, the StarkEx contract verifies the transaction public inputs by calling the isValid() function, which verifies the hash derived from state update inputs matches the hash stored by the Committee Verifier contract.

    • Funds can be lost if a malicious committee signs a data availability attestation for an unavailable transaction batch.

    1. StarkEx Committee Service - Source Code
    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
    PROVER

    Trusted Setups

    Onchain verifier

    Used in

    EdgeX logoSorare logotanX logoMyria logo

    Onchain verifier

    Used in

    EdgeX logoSorare logotanX logoMyria logo

    Program Hashes

    Name
    Hash
    Repository
    Verification
    Used in
    317490...6957
    Code unknown
    None
    Sorare logo
    342795...2024
    Starknet logoEdgeX logoParadex logoSorare logotanX logo

    Projects used in

    Search for projects used in

    344285...1079
    Starknet logoEdgeX logoParadex logoSorare logotanX logo

    Projects used in

    Search for projects used in

    235884...3330
    Starknet logoEdgeX logoParadex logoSorare logotanX logo

    Projects used in

    Search for projects used in

    254986...4351
    Code unknown
    None
    Starknet logoEdgeX logoParadex logoSorare logotanX logo

    Projects used in

    Search for projects used in

    234451...4732
    Code unknown
    None
    Starknet logoEdgeX logoParadex logoSorare 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
    25
    Last upgrade
    4d 8h ago
    Avg upgrade interval
    4mo 11d
    2026 June 05, 07:57 UTC
    23changes

    Froze Sorare rollup contract. Upgraded Sorare diamond facets. Verifiers facet: https://disco.l2beat.com/diff/eth:0xfbea22FeB369DB10C0d3a2aAa8F4939E76815f12/eth:0xA67821bC089B4374e8D62475526E7e84f09Da086: - Refactored governance - Reduced UNFREEZE DELAY (the time after which the rollup may be unfrozen after it froze) from 1 year to 1 day - Added adminFreeze 9994 function that allows governor to freeze the rollup TokensAndRamping facet: https://disco.l2beat.com/diff/eth:0x2Dbc18A3ac126abE1fF90A83Bbc3947ff7912Afb/eth:0xb97394B55b4807a835619EDbCC6aF6b1d3C71e98: - Added support for mintable ERC 1155 - Added withdrawWithFee 10 function that allows withdrawing ETH even when rollup is frozen. User authorizes a withdrawal with a signature passed in calldata, and pays a withdrawal fee. - Added withdrawWithFeeToBaseBank function that allows withdrawing ETH directly to Base L2, otherwise works similarly to the previous function.

    - Status: DELETED
    contract OrderRegistry (eth:0x518c4A79a1102eEDc987005CA8cE6B87Ca14dDf8) [starkex/OrderRegistry]
    +++ description: Helper contract for registering limit orders from L1.
    contract StarkExchange (eth:0xF5C9F957705bea56a7e806943f98F7777B995826) [starkex/StarkExchange_Frozen] {
    +++ description: Central Validium contract. Receives (verified) state roots from the Operator, 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.
    template:
    - "starkex/StarkExchange"
    + "starkex/StarkExchange_Frozen"
    sourceHashes.1:
    - "0x9b28596a715350d61f719241f35d6ee159c111c93c05da1d4804157142ee790c"
    + "0x0843c70dcca99b2fde3a18013b0af9af358e90066af9d8a2d3754785eb0ff2a0"
    values.$implementation.1:
    - "eth:0xfbea22FeB369DB10C0d3a2aAa8F4939E76815f12"
    + "eth:0xA67821bC089B4374e8D62475526E7e84f09Da086"
    values.$implementation.2:
    - "eth:0x2Dbc18A3ac126abE1fF90A83Bbc3947ff7912Afb"
    + "eth:0xb97394B55b4807a835619EDbCC6aF6b1d3C71e98"
    values.$pastUpgrades.12:
    + ["2026-05-31T10:22:59.000Z","0xfd3455fd60677c360679dc601a13283ad26f7f618c9c67db9a52b9d7d42d5014",["eth:0xdF2f24751F7e84ccDCD39e7b49904FAB0Fb0f583","eth:0xA67821bC089B4374e8D62475526E7e84f09Da086","eth:0xb97394B55b4807a835619EDbCC6aF6b1d3C71e98","eth:0x67e198743BC19fa4757720eDd0e769f8291e1F1D","eth:0x613ee54C54D5548627064B4D648942bF3648f376","eth:0xb2ED005D0278179001a49a9969BB22BA8e98f31F","eth:0xB5353268d8d4D711a92cb838F8fEDFC2A66E50Db"]]
    values.$upgradeCount:
    - 12
    + 13
    values.defaultVaultWithdrawalLock:
    - 0
    values.isFrozen:
    - false
    + true
    values.orderRegistryAddress:
    - "eth:0x518c4A79a1102eEDc987005CA8cE6B87Ca14dDf8"
    values.tokenAdmins:
    - ["eth:0xA5dAd8339d9279c2F16d02F2e903AB4B79a72815","eth:0x7F6d06eCd94bD899872cd2768e41B7d33EC13e19"]
    values.UNFREEZE_DELAY:
    - 31536000
    + 3600
    implementationNames.eth:0xfbea22FeB369DB10C0d3a2aAa8F4939E76815f12:
    - "AllVerifiers"
    implementationNames.eth:0x2Dbc18A3ac126abE1fF90A83Bbc3947ff7912Afb:
    - "TokensAndRamping"
    implementationNames.eth:0xA67821bC089B4374e8D62475526E7e84f09Da086:
    + "AllVerifiers"
    implementationNames.eth:0xb97394B55b4807a835619EDbCC6aF6b1d3C71e98:
    + "TokensAndRamping"
    }
    2026 May 04, 10:45 UTC
    2changes

    Verifier upgrade finalized, it is now actively used.

    contract GpsFactRegistryAdapter (eth:0xbcc17446B99465fF01E6816d9bcb2d8b1D7cEdB1) {
    +++ description: Adapter between the core contract and the eth:0x47312450B3Ac8b5b8e247a6bB6d523e7605bDb60. Stores the Cairo programHash (`3174901404014912024702042974619036870715605532092680335571201877913899936957`).
    values.hasRegisteredFact:
    - false
    + true
    }
    2026 April 30, 10:53 UTC
    11changes

    Reduced upgrade delay to zero. Verifier automatically changed hasRegisteredFact flag, indicating that verifier upgrade is not finalized yet.

    EOA (eth:0x5918481F777dBe437De249492B90AffB4e655de4) {
    +++ description: None
    receivedPermissions.2.delay:
    - 1209600
    }
    contract GpsFactRegistryAdapter (eth:0xbcc17446B99465fF01E6816d9bcb2d8b1D7cEdB1) {
    +++ description: Adapter between the core contract and the eth:0x47312450B3Ac8b5b8e247a6bB6d523e7605bDb60. Stores the Cairo programHash (`3174901404014912024702042974619036870715605532092680335571201877913899936957`).
    values.hasRegisteredFact:
    - true
    + false
    }
    contract SorareAdminMultisig (eth:0xCc928977e4a75d25099e7DA7B6Fd79Dac2f9fD2B) {
    +++ description: None
    receivedPermissions.2.delay:
    - 1209600
    }
    contract StarkExchange (eth:0xF5C9F957705bea56a7e806943f98F7777B995826) {
    +++ description: Central Validium contract. Receives (verified) state roots from the Operator, 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.
    values.$pastUpgrades.11:
    + ["2026-04-28T11:42:11.000Z","0x8133c660c29139f3afcfa0d694829a8e16d5473e74704be6b0aa06869cf329d8",["eth:0xdF2f24751F7e84ccDCD39e7b49904FAB0Fb0f583","eth:0xfbea22FeB369DB10C0d3a2aAa8F4939E76815f12","eth:0x2Dbc18A3ac126abE1fF90A83Bbc3947ff7912Afb","eth:0x67e198743BC19fa4757720eDd0e769f8291e1F1D","eth:0x613ee54C54D5548627064B4D648942bF3648f376","eth:0xb2ED005D0278179001a49a9969BB22BA8e98f31F","eth:0xB5353268d8d4D711a92cb838F8fEDFC2A66E50Db"]]
    values.$upgradeCount:
    - 11
    + 12
    values.getUpgradeActivationDelay:
    - 1209600
    + 0
    values.StarkWareDiamond_upgradeDelay:
    - 1209600
    + 0
    }
    2025 September 02, 12:41 UTC
    2changes

    Changed admin multisig. Added mapping from Starknet.

    contract SorareAdminMultisig (eth:0xCc928977e4a75d25099e7DA7B6Fd79Dac2f9fD2B) {
    +++ description: None
    values.$members.1:
    - "eth:0xd38831Bcb40bdEE0577Ee064112Fa77a38cAd3F8"
    + "eth:0xaDB26E60FA6e326B9Ee444D886B4B62EC7FA38fc"
    }

    The system has a centralized operator

    The operator is the only entity that can propose blocks. 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

    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 a defined time period. If this does not happen, the system will halt regular operation and permit trustless withdrawal of funds.

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

    1. Censorship Prevention - StarkEx documentation

    Regular exit

    The user initiates the withdrawal by submitting a regular transaction on this chain. When the block containing that transaction is settled the funds become available for withdrawal on L1. ZK proofs are required to settle blocks. Finally the user submits an L1 transaction to claim the funds. When withdrawing NFTs they are minted on L1.

    1. Withdrawal - StarkEx documentation

    Forced exit

    If the user experiences censorship from the operator with regular exit they can submit their withdrawal requests directly on L1. 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. Full Withdrawal - 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 L1 transaction.

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

    Ethereum

    Actors:

    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 verifier’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:
    SorareAdminMultisig0xCc92…fD2B

    A Multisig with 2/3 threshold.

    • Can upgrade with no delay
      • StarkExchange
    • Can interact with StarkExchange
      • manage the token admin role
      • Permissioned to appoint and remove the Operator, register additional verifier and availability verifier contracts (removals are delayed), set the default vault withdrawal lock, unfreeze the exchange and manage the governor set
    • Can upgrade with no delay
      • StarkExchange
    • Can interact with StarkExchange
      • manage the token admin role
      • Permissioned to appoint and remove the Operator, register additional verifier and availability verifier contracts (removals are delayed), set the default vault withdrawal lock, unfreeze the exchange and manage the governor set
    • Can interact with StarkExchange
      • Permissioned to regularly update the state roots of the L2 on L1. Each state update must have been proven via the SHARP verifier and contains commitments to the data that is itself kept offchain
    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

    DACommittee0x879c…be32

    Data Availability Committee (DAC) contract verifying and storing data availability claims from DAC Members (via a multisignature check). The threshold of valid signatures is 2.

    Central Validium contract. Receives (verified) state roots from the Operator, 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.

    • Roles:
      • admin: EOA 1, SorareAdminMultisig
      • operators: EOA 2, EOA 3
    The following tokens are included in the value secured calculation:
    ETH token logo
    CpuVerifierAllSolidity_2026_130x0153…2CD6

    Immutable Solidity verifier for one Cairo CPU layout. It checks the STARK proof using layout-specific constraint, OODS, Merkle, FRI, and periodic-column helper contracts. The SHARP verifier can select any configured layout by cairoVerifierId.

    Implementation used in:
    CpuVerifierDex_2026_130x0cD0…5CdC

    Immutable Solidity verifier for one Cairo CPU layout. It checks the STARK proof using layout-specific constraint, OODS, Merkle, FRI, 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 verifier 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 verifier for one Cairo CPU layout. It checks the STARK proof using layout-specific constraint, OODS, Merkle, FRI, and periodic-column helper contracts. The SHARP verifier can select any configured layout by cairoVerifierId.

    Implementation used in:
    CpuVerifierSmall_2026_130x30F3…419b

    Immutable Solidity verifier for one Cairo CPU layout. It checks the STARK proof using layout-specific constraint, OODS, Merkle, FRI, and periodic-column helper contracts. The SHARP verifier can select any configured layout by cairoVerifierId.

    Implementation used in:
    MemoryPageFactRegistry_2023_90x4086…70fA

    Permissionless commitment calculator and registry used by the Solidity STARK verifiers. Anyone may submit a public-memory page and interaction elements; the contract computes its hash and cumulative product and registers the fact key committing to them, which the CPU verifier 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 liveness 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 verifier 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 verifier shared by Starknet and other StarkWare systems. It verifies a STARK 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 verifier shared by Starknet and other StarkWare systems. It verifies a STARK 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 verifier for one Cairo CPU layout. It checks the STARK proof using layout-specific constraint, OODS, Merkle, FRI, and periodic-column helper contracts. The SHARP verifier can select any configured layout by cairoVerifierId.

    Implementation used in:
    CpuVerifierStarknet_2026_130x7157…A26D

    Immutable Solidity verifier for one Cairo CPU layout. It checks the STARK proof using layout-specific constraint, OODS, Merkle, FRI, 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 verifier shared by Starknet and other StarkWare systems. It verifies a STARK 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 verifier for one Cairo CPU layout. It checks the STARK proof using layout-specific constraint, OODS, Merkle, FRI, and periodic-column helper contracts. The SHARP verifier can select any configured layout by cairoVerifierId.

    Implementation used in:
    MemoryPageFactRegistry0xe583…C460

    Permissionless commitment calculator and registry used by the Solidity STARK verifiers. Anyone may submit a public-memory page and interaction elements; the contract computes its hash and cumulative product and registers the fact key committing to them, which the CPU verifier 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 liveness failure instead.

    Implementation used in:
    SHARPVerifier_2026_13_30xE675…b406

    Immutable GPS statement verifier shared by Starknet and other StarkWare systems. It verifies a STARK 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 verifier for one Cairo CPU layout. It checks the STARK proof using layout-specific constraint, OODS, Merkle, FRI, and periodic-column helper contracts. The SHARP verifier can select any configured layout by cairoVerifierId.

    Implementation used in:
    GpsFactRegistryAdapter0xbcc1…EdB1

    Adapter between the core contract and the SHARPVerifierCallProxy. Stores the Cairo programHash (3174901404014912024702042974619036870715605532092680335571201877913899936957).

    CpuFrilessVerifier0x03Fa…12e8
    Implementation used in:
    CpuFrilessVerifier0x2177…C214
    Implementation used in:
    CairoBootloaderProgram_2022_70x5d07…9dDf
    Implementation used in:
    CpuFrilessVerifier0x630A…f239
    Implementation used in:
    CpuFrilessVerifier0x78Af…c590
    Implementation used in:
    CpuFrilessVerifier0x8488…E57B
    Implementation used in:
    CpuFrilessVerifier0x9E61…Bd21
    Implementation used in:
    CpuFrilessVerifier0xC879…31e3
    Implementation used in:
    CpuFrilessVerifier0xe966…0E24
    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
    317490...6957
    Code unknown
    None
    Sorare logo
    342795...2024
    Starknet logoEdgeX logoParadex logoSorare logotanX logo

    Projects used in

    Search for projects used in

    344285...1079
    Starknet logoEdgeX logoParadex logoSorare logotanX logo

    Projects used in

    Search for projects used in

    235884...3330
    Starknet logoEdgeX logoParadex logoSorare logotanX logo

    Projects used in

    Search for projects used in

    254986...4351
    Code unknown
    None
    Starknet logoEdgeX logoParadex logoSorare logotanX logo

    Projects used in

    Search for projects used in

    234451...4732
    Code unknown
    None
    Starknet logoEdgeX logoParadex logoSorare logotanX logo

    Projects used in

    Search for projects used in