ETH Price: $2,715.91 (+1.64%)

Contract

0x626211C1e9BC633f4D342Af99f4E8bc93f11F3DD
 

Overview

ETH Balance

0 ETH

Eth Value

$0.00

Multichain Info

No addresses found
Transaction Hash
Method
Block
From
To
0x18ee3ac550ec286ee17608cb55a1e1421e66f11a426657e5a86cdedef4ed38e8 Verify Escape(pending)2025-02-16 22:12:5129 hrs ago1739743971IN
0x626211C1...93f11F3DD
0 ETH(Pending)(Pending)
0xb70d2168c270243dd5cf7bfa24a7259b3b1c1e0763cb5f350d3405a39f285222 Verify Escape(pending)2025-02-16 20:03:3131 hrs ago1739736211IN
0x626211C1...93f11F3DD
0 ETH(Pending)(Pending)
0x7facb747e178ff35c464b57a5d5dc2863baf2ed744812b304b9850d3f7c102e5 Verify Escape(pending)2025-02-16 7:01:2344 hrs ago1739689283IN
0x626211C1...93f11F3DD
0 ETH(Pending)(Pending)
Verify Escape218702322025-02-18 2:19:471 hr ago1739845187IN
0x626211C1...93f11F3DD
0 ETH0.002473340.96333651
Verify Escape218702212025-02-18 2:17:351 hr ago1739845055IN
0x626211C1...93f11F3DD
0 ETH0.002209580.86061319
Verify Escape218701982025-02-18 2:12:591 hr ago1739844779IN
0x626211C1...93f11F3DD
0 ETH0.002091580.81464424
Verify Escape218701772025-02-18 2:08:471 hr ago1739844527IN
0x626211C1...93f11F3DD
0 ETH0.001946080.75798055
Verify Escape218700742025-02-18 1:47:591 hr ago1739843279IN
0x626211C1...93f11F3DD
0 ETH0.002119190.82541379
Verify Escape218699222025-02-18 1:17:232 hrs ago1739841443IN
0x626211C1...93f11F3DD
0 ETH0.00256751
Verify Escape218699202025-02-18 1:16:592 hrs ago1739841419IN
0x626211C1...93f11F3DD
0 ETH0.002053920.8
Verify Escape218699042025-02-18 1:13:472 hrs ago1739841227IN
0x626211C1...93f11F3DD
0 ETH0.001843470.71801373
Verify Escape218698882025-02-18 1:10:352 hrs ago1739841035IN
0x626211C1...93f11F3DD
0 ETH0.001978540.77061216
Verify Escape218698032025-02-18 0:53:352 hrs ago1739840015IN
0x626211C1...93f11F3DD
0 ETH0.002033040.79185139
Verify Escape218697882025-02-18 0:50:352 hrs ago1739839835IN
0x626211C1...93f11F3DD
0 ETH0.002070670.79453792
Verify Escape218693262025-02-17 23:17:354 hrs ago1739834255IN
0x626211C1...93f11F3DD
0 ETH0.002012510.78384351
Verify Escape218688012025-02-17 21:31:596 hrs ago1739827919IN
0x626211C1...93f11F3DD
0 ETH0.003865231.48308443
Verify Escape218618072025-02-16 22:01:5929 hrs ago1739743319IN
0x626211C1...93f11F3DD
0 ETH0.00230510.88377683
Verify Escape218618012025-02-16 22:00:4729 hrs ago1739743247IN
0x626211C1...93f11F3DD
0 ETH0.003434621.31684382
Verify Escape218611692025-02-16 19:53:4731 hrs ago1739735627IN
0x626211C1...93f11F3DD
0 ETH0.003624341.41162646
Verify Escape218581732025-02-16 9:49:4741 hrs ago1739699387IN
0x626211C1...93f11F3DD
0 ETH0.003136751.2217483
Verify Escape218446992025-02-14 12:27:593 days ago1739536079IN
0x626211C1...93f11F3DD
0 ETH0.00371681.44762642
Verify Escape218437312025-02-14 9:12:473 days ago1739524367IN
0x626211C1...93f11F3DD
0 ETH0.004305091.6767469
Verify Escape218410742025-02-14 0:16:594 days ago1739492219IN
0x626211C1...93f11F3DD
0 ETH0.003289071.26105199
Verify Escape218371352025-02-13 11:02:234 days ago1739444543IN
0x626211C1...93f11F3DD
0 ETH0.002203450.85822638
Verify Escape218369432025-02-13 10:23:474 days ago1739442227IN
0x626211C1...93f11F3DD
0 ETH0.002146530.83604308
View all transactions

View more zero value Internal Transactions in Advanced View mode

Advanced mode:
Loading...
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
PerpetualEscapeVerifier

Compiler Version
v0.6.11+commit.5ef660b1

Optimization Enabled:
Yes with 100 runs

Other Settings:
default evmVersion, Apache-2.0 license

Contract Source Code (Solidity Multiple files format)

File 1 of 7: PerpetualEscapeVerifier.sol
/*
  Copyright 2019,2020 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.0 (the "License").
  You may not use this file except in compliance with the License.
  You may obtain a copy of the License at

  https://www.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions
  and limitations under the License.
*/
// SPDX-License-Identifier: Apache-2.0.
pragma solidity ^0.6.11;

import "FactRegistry.sol";
import "PedersenMerkleVerifier.sol";
import "Identity.sol";
import "ProgramOutputOffsets.sol";

/*
  A PerpetualEscapeVerifier is a fact registry contract for claims of the form:
    The owner of 'publicKey' may withdraw 'withdrawalAmount' qunatized collateral units
    from 'positionId' assuming the hash of the shared state is 'sharedStateHash'

  The fact is encoded as:
    keccak256(abi.encodePacked(
        publicKey, withdrawalAmount, sharedStateHash, positionId).
*/
contract PerpetualEscapeVerifier is
    PedersenMerkleVerifier, FactRegistry,
    Identity, ProgramOutputOffsets {
    event LogEscapeVerified(
        uint256 publicKey,
        int256 withdrawalAmount,
        bytes32 sharedStateHash,
        uint256 positionId
    );

    uint256 internal constant N_ASSETS_BITS = 16;
    uint256 internal constant BALANCE_BITS = 64;
    uint256 internal constant FUNDING_BITS = 64;
    uint256 internal constant BALANCE_BIAS = 2**63;
    uint256 internal constant FXP_BITS = 32;

    uint256 internal constant FUNDING_ENTRY_SIZE = 2;
    uint256 internal constant PRICE_ENTRY_SIZE = 2;

    constructor(address[N_TABLES] memory tables)
        PedersenMerkleVerifier(tables)
        public
    {
    }

    function identify()
        external pure override virtual
        returns(string memory)
    {
        return "StarkWare_PerpetualEscapeVerifier_2021_2";
    }

    /*
      Finds an entry corresponding to assetId in the slice array[startIdx:endIdx].
      Assumes that size of each entry is 2 and that the key is in offset 0 of an entry.
    */
    function findAssetId(
        uint256 assetId, uint256[] memory array, uint256 startIdx, uint256 endIdx)
        internal pure returns (uint256 idx) {
        idx = startIdx;
        while(array[idx] != assetId) {
            idx += /*entry_size*/2;
            require(idx < endIdx, "assetId not found.");
        }
    }


    /*
      Computes the balance of the position according to the sharedState.

      Assumes the position is given as
      [
       positionAsset_0, positionAsset_1, ..., positionAsset_{n_assets},
       publicKey, biasedBalance << N_ASSETS_BITS | nAssets,
      ]
      where positionAsset_{i} is encoded as
         assedId << 128 | cachedFunding << BALANCE_BITS | biased_asset_balance.

    */
    function computeFxpBalance(
        uint256[] memory position, uint256[] memory sharedState)
        internal pure returns (int256) {

        uint256 nAssets;
        uint256 fxpBalance;

        {
            // Decode collateral_balance and nAssets.
            uint256 lastWord = position[position.length - 1];
            nAssets = lastWord & ((1 << N_ASSETS_BITS) - 1);
            uint256 biasedBalance = lastWord >> N_ASSETS_BITS;

            require(position.length == nAssets + 2, "Bad number of assets.");
            require(biasedBalance < 2**BALANCE_BITS, "Bad balance.");

            fxpBalance = (biasedBalance - BALANCE_BIAS) << FXP_BITS;
        }

        uint256 fundingIndicesOffset = STATE_OFFSET_FUNDING;
        uint256 nFundingIndices = sharedState[fundingIndicesOffset - 1];

        uint256 fundingEnd = fundingIndicesOffset + FUNDING_ENTRY_SIZE * nFundingIndices;

        // Skip global_funding_indices.timestamp and nPrices.
        uint256 pricesOffset = fundingEnd + 2;
        uint256 nPrices = sharedState[pricesOffset - 1];
        uint256 pricesEnd = pricesOffset + PRICE_ENTRY_SIZE * nPrices;
        // Copy sharedState ptr to workaround stack too deep.
        uint256[] memory sharedStateCopy = sharedState;

        uint256 fundingTotal = 0;
        for (uint256 i = 0; i < nAssets; i++) {
            // Decodes a positionAsset (See encoding in the function description).
            uint256 positionAsset = position[i];
            uint256 assedId = positionAsset >> 128;

            // Note that the funding_indices in both the position and the shared state
            // are biased by the same amount.
            uint256 cachedFunding = (positionAsset >> BALANCE_BITS) & (2**FUNDING_BITS - 1);
            uint256 assetBalance = (positionAsset & (2**BALANCE_BITS - 1)) - BALANCE_BIAS;

            fundingIndicesOffset = findAssetId(
                assedId, sharedStateCopy, fundingIndicesOffset, fundingEnd);
            fundingTotal -= assetBalance *
                (sharedStateCopy[fundingIndicesOffset + 1] - cachedFunding);

            pricesOffset = findAssetId(assedId, sharedStateCopy, pricesOffset, pricesEnd);
            fxpBalance += assetBalance * sharedStateCopy[pricesOffset + 1];
        }

        uint256 truncatedFunding = fundingTotal & ~(2**FXP_BITS - 1);
        return int256(fxpBalance + truncatedFunding);
    }


    /*
      Extracts the position from the escapeProof.

      Assumes the position is encoded in the first (nAssets + 2) right nodes in the merkleProof.
      and that each pair of nodes is encoded in 2 256bits words as follows:
      +-------------------------------+---------------------------+-----------+
      | left_node_i (252)             | right_node_i (252)        | zeros (8) |
      +-------------------------------+---------------------------+-----------+

      See PedersenMerkleVerifier.sol for more details.
    */
    function extractPosition(uint256[] memory merkleProof, uint256 nAssets)
        internal pure
        returns (uint256 positionId, uint256[] memory position) {

        require((merkleProof[0] >> 8) == 0, 'Position hash-chain must start with 0.');

        uint256 positionLength = nAssets + 2;
        position = new uint256[](positionLength);
        uint256 nodeIdx = merkleProof[merkleProof.length - 1] >> 8;

        // Check that the merkleProof starts with a hash_chain of 'positionLength' elements.
        require(
            (nodeIdx & ((1 << positionLength) - 1)) == 0,
            "merkleProof is inconsistent with nAssets.");
        positionId = nodeIdx >> positionLength;

        assembly {
            let positionPtr := add(position, 0x20)
            let positionEnd := add(positionPtr, mul(mload(position), 0x20))
            let proofPtr := add(merkleProof, 0x3f)

            for { } lt(positionPtr, positionEnd)  { positionPtr := add(positionPtr, 0x20) } {
                mstore(positionPtr, and(mload(proofPtr),
                       0x0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))
                proofPtr := add(proofPtr, 0x40)
            }
        }
    }


    /*
      Verifies an escape and registers the corresponding fact as
        keccak256(abi.encodePacked(
            publicKey, withdrawalAmount, sharedStateHash, positionId)).

      The escape verification has two parts:
        a. verifying that a certain position belongs to the position tree in the shared state.
        b. computing the amount that may be withdrawan from that position.

      Part a is delegated to the PedersenMerkleVerifier.
      To this end the position is encoded in the prefix of the merkleProof and the node_selector at
      the end of the merkleProof is adjusted accordingly.
    */
    function verifyEscape(
        uint256[] calldata merkleProof, uint256 nAssets, uint256[] calldata sharedState) external {
        (uint256 positionId, uint256[] memory position) = extractPosition(merkleProof, nAssets);

        int256 withdrawalAmount = computeFxpBalance(position, sharedState) >> FXP_BITS;

        // Each hash takes 2 256bit words and the last two words are the root and nodeIdx.
        uint256 nHashes = (merkleProof.length - 2) / 2; // NOLINT: divide-before-multiply.
        uint256 positionTreeHeight = nHashes - position.length;

        require(
            sharedState[STATE_OFFSET_VAULTS_ROOT] == (merkleProof[merkleProof.length - 2] >> 4),
            "merkleProof is inconsistent with the root in the sharedState.");

        require(
            sharedState[STATE_OFFSET_VAULTS_HEIGHT] == positionTreeHeight,
            "merkleProof is inconsistent with the height in the sharedState.");

        require(withdrawalAmount > 0, "Withdrawal amount must be positive.");
        bytes32 sharedStateHash = keccak256(abi.encodePacked(sharedState));

        uint256 publicKey = position[nAssets];
        emit LogEscapeVerified(publicKey, withdrawalAmount, sharedStateHash, positionId);
        bytes32 fact = keccak256(
            abi.encodePacked(
            publicKey, withdrawalAmount, sharedStateHash, positionId));

        verifyMerkle(merkleProof);

        registerFact(fact);
    }
}

File 2 of 7: FactRegistry.sol
/*
  Copyright 2019,2020 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.0 (the "License").
  You may not use this file except in compliance with the License.
  You may obtain a copy of the License at

  https://www.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions
  and limitations under the License.
*/
// SPDX-License-Identifier: Apache-2.0.
pragma solidity ^0.6.11;

import "IQueryableFactRegistry.sol";

contract FactRegistry is IQueryableFactRegistry {
    // Mapping: fact hash -> true.
    mapping (bytes32 => bool) private verifiedFact;

    // Indicates whether the Fact Registry has at least one fact registered.
    bool anyFactRegistered;

    /*
      Checks if a fact has been verified.
    */
    function isValid(bytes32 fact)
        external view override
        returns(bool)
    {
        return _factCheck(fact);
    }


    /*
      This is an internal method to check if the fact is already registered.
      In current implementation of FactRegistry it's identical to isValid().
      But the check is against the local fact registry,
      So for a derived referral fact registry, it's not the same.
    */
    function _factCheck(bytes32 fact)
        internal view
        returns(bool)
    {
        return verifiedFact[fact];
    }

    function registerFact(
        bytes32 factHash
        )
        internal
    {
        // This function stores the fact hash in the mapping.
        verifiedFact[factHash] = true;

        // Mark first time off.
        if (!anyFactRegistered) {
            anyFactRegistered = true;
        }
    }

    /*
      Indicates whether at least one fact was registered.
    */
    function hasRegisteredFact()
        external view override
        returns(bool)
    {
        return anyFactRegistered;
    }

}

File 3 of 7: Identity.sol
/*
  Copyright 2019,2020 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.0 (the "License").
  You may not use this file except in compliance with the License.
  You may obtain a copy of the License at

  https://www.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions
  and limitations under the License.
*/
// SPDX-License-Identifier: Apache-2.0.
pragma solidity ^0.6.11;

interface Identity {

    /*
      Allows a caller, typically another contract,
      to ensure that the provided address is of the expected type and version.
    */
    function identify()
        external pure
        returns(string memory);
}

File 4 of 7: IFactRegistry.sol
/*
  Copyright 2019,2020 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.0 (the "License").
  You may not use this file except in compliance with the License.
  You may obtain a copy of the License at

  https://www.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions
  and limitations under the License.
*/
// SPDX-License-Identifier: Apache-2.0.
pragma solidity ^0.6.11;

/*
  The Fact Registry design pattern is a way to separate cryptographic verification from the
  business logic of the contract flow.

  A fact registry holds a hash table of verified "facts" which are represented by a hash of claims
  that the registry hash check and found valid. This table may be queried by accessing the
  isValid() function of the registry with a given hash.

  In addition, each fact registry exposes a registry specific function for submitting new claims
  together with their proofs. The information submitted varies from one registry to the other
  depending of the type of fact requiring verification.

  For further reading on the Fact Registry design pattern see this
  `StarkWare blog post <https://medium.com/starkware/the-fact-registry-a64aafb598b6>`_.
*/
interface IFactRegistry {
    /*
      Returns true if the given fact was previously registered in the contract.
    */
    function isValid(bytes32 fact)
        external view
        returns(bool);
}

File 5 of 7: IQueryableFactRegistry.sol
/*
  Copyright 2019,2020 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.0 (the "License").
  You may not use this file except in compliance with the License.
  You may obtain a copy of the License at

  https://www.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions
  and limitations under the License.
*/
// SPDX-License-Identifier: Apache-2.0.
pragma solidity ^0.6.11;

import "IFactRegistry.sol";

/*
  Extends the IFactRegistry interface with a query method that indicates
  whether the fact registry has successfully registered any fact or is still empty of such facts.
*/
interface IQueryableFactRegistry is IFactRegistry {

    /*
      Returns true if at least one fact has been registered.
    */
    function hasRegisteredFact()
        external view
        returns(bool);

}

File 6 of 7: PedersenMerkleVerifier.sol
/*
  Copyright 2019,2020 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.0 (the "License").
  You may not use this file except in compliance with the License.
  You may obtain a copy of the License at

  https://www.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions
  and limitations under the License.
*/
// SPDX-License-Identifier: Apache-2.0.
pragma solidity ^0.6.11;

contract PedersenMerkleVerifier {

    // Note that those values are hardcoded in the assembly.
    uint256 constant internal N_TABLES = 63;

    address[N_TABLES] lookupTables;
    constructor(address[N_TABLES] memory tables) public {
        lookupTables = tables;

        assembly {
            if gt(lookupTables_slot, 0) {
                // The address of the lookupTables must be 0.
                // This is guaranteed by the ABI, as long as it is the first storage variable.
                // This is an assumption in the implementation, and can be removed if
                // the lookup table address is taken into account.
                revert(0, 0)
            }

        }
    }

    /**
      Verifies a merkle proof for a Merkle commitment.

      The Merkle commitment uses the Pedersen hash variation described next:

      - **Hash constants:** A sequence :math:`p_i` of 504 points on an elliptic curve and an additional :math:`ec_{shift}` point
      - **Input:** A vector of 504 bits :math:`b_i`
      - **Output:** The 252 bits x coordinate of :math:`(ec_{shift} + \sum_i b_i*p_i)`

      The following table describes the expected `merkleProof` format. Note that unlike a standard
      Merkle proof, the `merkleProof` contains both the nodes along the Merkle path and their
      siblings. The proof ends with the expected root and the ID of the vault for which the proof is
      submitted (which implies the location of the nodes within the Merkle tree).

          +-------------------------------+---------------------------+-----------+
          | left_node_0 (252)             | right_node_0 (252)        | zeros (8) |
          +-------------------------------+---------------------------+-----------+
          | ...                                                                   |
          +-------------------------------+---------------------------+-----------+
          | left_node_n (252)             | right_node_n (252)        | zeros (8) |
          +-------------------------------+-----------+---------------+-----------+
          | root (252)                    | zeros (4) | nodeIdx (248) | zeros (8) |
          +-------------------------------+-----------+---------------+-----------+


      Note that if the merkle leafs are computed using a hashchain as follows:
        hashchain_state = init_state
        for value in leaf_values:
            hashchain_state = pedersen_hash(hashchain_state, value)
        leaf_value = hashchain_state

      Then we may use this function to verify the leaf value by setting:
      nodeIdx = merkle_idx << hashchain_lengh and for every 0 <= i < hashchain_lengh.
      left_node_0 = hashchain_state_i
      right_node_i = leaf_values_i.

    */
    /*
      Implementation details:
      The EC sum required for the hash computation is computed using lookup tables and EC additions.
      There are 63 lookup tables and each table contains all the possible subset sums of the
      corresponding 8 EC points in the hash definition.

      Both the full subset sum and the tables are shifted to avoid a special case for the 0 point.
      lookupTables[0] uses the offset 2^62*ec_shift and lookupTables[k] for k > 0 uses
      the offset 2^(62-k)*(-ec_shift).
      Note that the sum of the shifts of all the tables is exactly the shift required for the
      hash. Moreover, the partial sums of those shifts are never 0.

      The calls to the lookup table contracts are batched to save on gas cost.
      We allocate a table of N_HASHES by N_TABLES EC elements.
      Fill the i'th row by calling the i'th lookup contract to lookup the i'th byte in each hash and
      then compute the j'th hash by summing the j'th column.

                  N_HASHES
              --------------
              |            |
              |            |
              |            |
              |            | N_TABLES
              |            |
              |            |
              |            |
              |            |
              --------------

      The batched lookup is facilitated by the fact that the merkleProof includes nodes along the
      Merkle path.
      However having this redundant information requires us to do consistency checks
      to ensure we indeed verify a coherent authentication path:

          hash((left_node_{i-1}, right_node_{i-1})) ==
            (nodeIdx & (1<<i)) == 0 ? left_node_i : right_node_i.
    */
    function verifyMerkle(uint256[] memory merkleProof) internal view {
        uint256 proofLength = merkleProof.length;

        // The minimal supported proof length is for a tree height of 1 in a 4 word representation as follows:
        // 1 word pairs representing the authentication path.
        // 1 word pair representing the root and the nodeIdx.
        require(proofLength >= 4, "Proof too short.");

        // The contract supports verification paths of lengths up to 200 in a 402 word representation as described above.
        // This limitation is imposed in order to avoid potential attacks.
        require(proofLength <= 402, "Proof too long.");

        // Ensure proofs are always a series of word pairs.
        require((proofLength & 1) == 0, "Proof length must be even.");

        // Each hash takes 2 256bit words and the last two words are the root and nodeIdx.
        uint256 height = (proofLength - 2) / 2; // NOLINT: divide-before-multiply.

        // Note that it is important to limit the range of vault id, to make sure
        // we use the left node (== merkle_root) in the last iteration of the loop below.

        uint256 nodeIdx = merkleProof[proofLength - 1] >> 8;
        require(nodeIdx < 2**height, "nodeIdx not in tree.");
        require((nodeIdx & 1) == 0, "nodeIdx must be even.");

        uint256 rowSize = (2 * height) * 0x20;
        uint256[] memory proof = merkleProof;
        assembly {
            // Skip the length of the proof array.
            proof := add(proof, 0x20)

            function raise_error(message, msg_len) {
                // Solidity generates reverts with reason that look as follows:
                // 1. 4 bytes with the constant 0x08c379a0 (== Keccak256(b'Error(string)')[:4]).
                // 2. 32 bytes offset bytes (typically 0x20).
                // 3. 32 bytes with the length of the revert reason.
                // 4. Revert reason string.

                mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
                mstore(0x4, 0x20)
                mstore(0x24, msg_len)
                mstore(0x44, message)
                revert(0, add(0x44, msg_len))
            }

            let left_node := shr(4, mload(proof))
            let right_node := and(mload(add(proof, 0x1f)),
                               0x0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)

            let primeMinusOne := 0x800000000000011000000000000000000000000000000000000000000000000
            if or(gt(left_node, primeMinusOne), gt(right_node, primeMinusOne)) {
                raise_error("Bad starkKey or assetId.", 24)
            }

            let nodeSelectors := nodeIdx

            // Allocate EC points table with dimensions N_TABLES by N_HASHES.
            let table := mload(0x40)
            let tableEnd := add(table, mul(rowSize, /*N_TABLES*/63))

            // for i = 0..N_TABLES-1, fill the i'th row in the table.
            for { let i := 0 } lt(i, 63) { i := add(i, 1)} {
                if iszero(staticcall(gas(), sload(i), add(proof, i), rowSize,
                                     add(table, mul(i, rowSize)), rowSize)) {
                   returndatacopy(0, 0, returndatasize())
                   revert(0, returndatasize())
                }
            }

            // The following variables are allocated above PRIME to avoid the stack too deep error.
            // Byte offset used to access the table and proof.
            let offset := 0
            let ptr
            let aZ

            let PRIME := 0x800000000000011000000000000000000000000000000000000000000000001

            // For k = 0..HASHES-1, Compute the k'th hash by summing the k'th column in table.
            // Instead of k we use offset := k * sizeof(EC point).
            // Additonally we use ptr := offset + j * rowSize to ge over the EC points we want
            // to sum.
            for { } lt(offset, rowSize) { } {
                // Init (aX, aY, aZ) to the first value in the current column and sum over the
                // column.
                ptr := add(table, offset)
                aZ := 1
                let aX := mload(ptr)
                let aY := mload(add(ptr, 0x20))

                for { ptr := add(ptr, rowSize) } lt(ptr, tableEnd)
                    { ptr:= add(ptr, rowSize) } {

                    let bX := mload(ptr)
                    let bY := mload(add(ptr, 0x20))

                    // Set (aX, aY, aZ) to be the sum of the EC points (aX, aY, aZ) and (bX, bY, 1).
                    let minusAZ := sub(PRIME, aZ)
                    // Slope = sN/sD =  {(aY/aZ) - (bY/1)} / {(aX/aZ) - (bX/1)}.
                    // sN = aY - bY * aZ.
                    let sN := addmod(aY, mulmod(minusAZ, bY, PRIME), PRIME)

                    let minusAZBX := mulmod(minusAZ, bX, PRIME)
                    // sD = aX - bX * aZ.
                    let sD := addmod(aX, minusAZBX, PRIME)

                    let sSqrD := mulmod(sD, sD, PRIME)

                    // Compute the (affine) x coordinate of the result as xN/xD.

                    // (xN/xD) = ((sN)^2/(sD)^2) - (aX/aZ) - (bX/1).
                    // xN = (sN)^2 * aZ - aX * (sD)^2 - bX * (sD)^2 * aZ.
                    // = (sN)^2 * aZ + (sD^2) (bX * (-aZ) - aX).
                    let xN := addmod(mulmod(mulmod(sN, sN, PRIME), aZ, PRIME),
                                    mulmod(sSqrD,
                                            add(minusAZBX, sub(PRIME, aX)),
                                            PRIME),
                                    PRIME)

                    // xD = (sD)^2 * aZ.
                    let xD := mulmod(sSqrD, aZ, PRIME)

                    // Compute (aX', aY', aZ') for the next iteration and assigning them to (aX, aY, aZ).
                    // (y/z) = (sN/sD) * {(bX/1) - (xN/xD)} - (bY/1).
                    // aZ' = sD*xD.
                    aZ := mulmod(sD, xD, PRIME)
                    // aY' = sN*(bX * xD - xN) - bY*z = -bY * z + sN * (-xN + xD*bX).
                    aY := addmod(sub(PRIME, mulmod(bY, aZ, PRIME)),
                                    mulmod(sN,
                                    add(sub(PRIME, xN),
                                        mulmod(xD, bX, PRIME)),
                                    PRIME),
                                PRIME)

                    // As the value of the affine x coordinate is xN/xD and z=sD*xD,
                    // the projective x coordinate is xN*sD.
                    aX := mulmod(xN, sD, PRIME)
                }

                // At this point proof[offset + 0x40] holds the next input to be hashed.
                // This input is typically in the form left_node||right_node||0 and
                // we need to extract the relevant node for the consistent check below.
                // Note that the same logic is reused for the leaf computation and
                // for the consistent check with the final root.
                offset := add(offset, 0x40)

                // Init expected_hash to left_node.
                // It will be replaced by right_node if necessary.
                let expected_hash := shr(4, mload(add(proof, offset)))

                let other_node := and(  // right_node
                    mload(add(proof, add(offset, 0x1f))),
                    0x0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)

                // Make sure both nodes are in the range [0, PRIME - 1].
                if or(gt(expected_hash, primeMinusOne), gt(other_node, primeMinusOne)) {
                    raise_error("Value out of range.", 19)
                }

                nodeSelectors := shr(1, nodeSelectors)
                if and(nodeSelectors, 1) {
                    expected_hash := other_node
                }

                // Make sure the result is consistent with the Merkle path.
                // I.e (aX/aZ) == expected_hash,
                // where expected_hash = (nodeSelectors & 1) == 0 ? left_node : right_node.
                // We also make sure aZ is not 0. I.e. during the summation we never tried
                // to add two points with the same x coordinate.
                // This is not strictly necessary because knowing how to trigger this condition
                // implies knowing a non-trivial linear equation on the random points defining the
                // hash function.
                if iszero(aZ) {
                   raise_error("aZ is zero.", 11)
                }

                if sub(aX, mulmod(expected_hash, aZ, PRIME))/*!=0*/ {
                   raise_error("Bad Merkle path.", 16)
                }
            }
        }
    }
}

File 7 of 7: ProgramOutputOffsets.sol
/*
  Copyright 2019,2020 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.0 (the "License").
  You may not use this file except in compliance with the License.
  You may obtain a copy of the License at

  https://www.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions
  and limitations under the License.
*/
// SPDX-License-Identifier: Apache-2.0.
pragma solidity ^0.6.11;

contract ProgramOutputOffsets {
    // The following constants are offsets of data expected in the program output.
    // The offsets here are of the fixed fields.
    uint256 internal constant PROG_OUT_GENERAL_CONFIG_HASH = 0;
    uint256 internal constant PROG_OUT_N_ASSET_CONFIGS = 1;
    uint256 internal constant PROG_OUT_ASSET_CONFIG_HASHES = 2;

    /*
      Additional mandatory fields of a single word:
      - Previous state size         2
      - New state size              3
      - Vault tree height           4
      - Order tree height           5
      - Expiration timestamp        6
      - No. of Modifications        7.
    */
    uint256 internal constant PROG_OUT_N_WORDS_MIN_SIZE = 8;

    uint256 internal constant PROG_OUT_N_WORDS_PER_ASSET_CONFIG = 2;
    uint256 internal constant PROG_OUT_N_WORDS_PER_MODIFICATION = 3;

    uint256 internal constant ASSET_CONFIG_OFFSET_ASSET_ID = 0;
    uint256 internal constant ASSET_CONFIG_OFFSET_CONFIG_HASH = 1;

    uint256 internal constant MODIFICATIONS_OFFSET_STARKKEY = 0;
    uint256 internal constant MODIFICATIONS_OFFSET_POS_ID = 1;
    uint256 internal constant MODIFICATIONS_OFFSET_BIASED_DIFF = 2;

    uint256 internal constant STATE_OFFSET_VAULTS_ROOT = 0;
    uint256 internal constant STATE_OFFSET_VAULTS_HEIGHT = 1;
    uint256 internal constant STATE_OFFSET_ORDERS_ROOT = 2;
    uint256 internal constant STATE_OFFSET_ORDERS_HEIGHT = 3;
    uint256 internal constant STATE_OFFSET_N_FUNDING = 4;
    uint256 internal constant STATE_OFFSET_FUNDING = 5;

    // The following constants are offsets of data expected in the application data.
    uint256 internal constant APP_DATA_BATCH_ID_OFFSET = 0;
    uint256 internal constant APP_DATA_PREVIOUS_BATCH_ID_OFFSET = 1;
    uint256 internal constant APP_DATA_N_CONDITIONAL_TRANSFER = 2;
    uint256 internal constant APP_DATA_CONDITIONAL_TRANSFER_DATA_OFFSET = 3;
    uint256 internal constant APP_DATA_N_WORDS_PER_CONDITIONAL_TRANSFER = 2;
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address[63]","name":"tables","type":"address[63]"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"publicKey","type":"uint256"},{"indexed":false,"internalType":"int256","name":"withdrawalAmount","type":"int256"},{"indexed":false,"internalType":"bytes32","name":"sharedStateHash","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"positionId","type":"uint256"}],"name":"LogEscapeVerified","type":"event"},{"inputs":[],"name":"hasRegisteredFact","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"identify","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes32","name":"fact","type":"bytes32"}],"name":"isValid","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"merkleProof","type":"uint256[]"},{"internalType":"uint256","name":"nAssets","type":"uint256"},{"internalType":"uint256[]","name":"sharedState","type":"uint256[]"}],"name":"verifyEscape","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

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

-----Decoded View---------------
Arg [0] : tables (address[63]): 0x3325e8C5d390AeC436Ff225779Dcdd4D12314f27,0x5429509172710E58bb5BCACC550F3f980c992233,0x7F7cB4B506ed8f17de6d35d3a33D8976D67eCDD2,0x1F396a7F8695247cf59fa20a8712776723831a4E,0xd2724CFf92E4Fb9d268ACE4b935316f863d254a1,0xd5dcdADDED0967Dfd142C6fED9F7042703a088d4,0x8F91a4214b618B01c9594BD24BDEE2EF31723289,0x9e6D164fA1aaC396F9E43E2Be487aAe7C30bE280,0x022b47E37a3010688343E55D603fa6283B896690,0xad91E3112F771423a2541492E7c448640022319d,0xF37de395d4542b2569D7ee29D9cC95d3052C3D3B,0x5A7fa37F1579d0C01008A5f58d5620D3a63A55c4,0x3f4794a3965f074139157C58BAe2a430335E99DB,0x541f7350CD28596De8952b5b589bC787D15dcC98,0x3511627D93a82D674ee31D13b66797362Ef02B86,0x84ab3eEADE82519965F9025fF3Eb7c8A766188af,0x21F9214709B8c27F97AFf3579B50f958F9aCFC61,0xb63b81a06EeE9A8A26f1D06Ce1405FCE83CDEd6A,0x5CFFD98CAb9044E2793B103f5a0624178862c261,0x1A14602619d1d2A74cb585D51DD4B21d85224B71,0x91dBD50021d130FE238564Aa5fb12738b37Ad4BC,0xC5F6cCD88F63830e081EC4bD731d6831C9B3B116,0x6b930261955B33389a77dFe32150E2CbA337A3ca,0xe63ADECC2e13844A7BA7538682bEAd0dC8462fBD,0xA5c893E8625010BC1540c6531A870E62F78c0EB7,0x9d3fD9B24A206C680B52F154727a5DDD56Aa39a0,0x18e80Fa7802Af0A3F3E95616Be44dD4d0Fcc7939,0xA01c0c4eB0ED14f58d69BE4f91BA72ebc8348e1f,0xF82E395916A96e6A8030EEd1553dc138D955bb4b,0x12048d9D1F7B349517c139F513eC7a935fdC63C4,0x8344Be5293E810659460D39DEe509cf9d269FA42,0x38870Cd26e79D1F254d8af368286e0ae32866364,0x07E3FE674bb6Fccd7C1f3eE4789DF50BE0C6f0d6,0xD6a561e177a3052cdC16D872522B70eEfcfA27BE,0x40066A2BdaAE99474e675ED77Ba5A720B20C4A30,0xFC7e6df14D65B7D4a3fFb9bd6064332733Cb0479,0x069FE848b2648a66BF058f7118E7e6BeE447770f,0xCb1fF41B7bECE607c2cA2619381342F01510864E,0x84253EC1578afFd76453479Be335BE6537562540,0x2c8fF23E595849e3A4B303E80EfE8A5eC9779cAB,0x974eAe262De47bEf42670c8E854aab4caBbB35d9,0x3770f554F9604C7F1730762501A38bc4fE82a2DB,0x287df1a8c699Cc3B14D31d9351fd34ECb349938b,0xf90860cEAeE3dBbcd48b3368308644a9D868FC6A,0x86c7a6a07b6e9152AD68b0906Da997aa868dB9C7,0x701b4b446a297382078167d63911734c2B021E2D,0xd3B06ab11b1Fa5786d1DC1C9dB5BAb5febbbA55E,0x610787b7b8be9077F2F67Cd2467C3b6942eD1a2a,0x50e37C5497a56eb99d32e77206157663ae14E2C3,0xd6828b1436a83FDd783400975f631f46beAa14a8,0x7A3F5179721C7c15719A39B82eC86Bd57aFd57c2,0x8D089b74b48aFE95e2265dd8088B851Ef186E5D4,0x0d04eb7393ED549Bc910faa9e9033dE7a3aAD3Ba,0x62ef96151942Fcc6dA68E1d56161e3dc607A314b,0x9a53B25FeaC3a46eA3cAF7FBa7F6Bc9543678e9C,0x81C14cC73ED4A51370c2b2648b28D71D595F3819,0x6cBb47ab221F20949B17b17524B31D20f2822452,0x069D1FC7D0B8104f2804626C6d568a17eBC28b55,0xAdA2274eFB1AFc76634db2DE873e10aB5E5B9988,0xd94Ff8B17E8C03ba24B1D36A09eB0df72DcF07ec,0x40C47F7013630ae10ae6548dE678bD701dfbf6ff,0xE778E3cEa2b42A0286667e6882947ec9ac928dC2,0x9e65312260907D5A66c6d0f407aA29e761D9BD5e

-----Encoded View---------------
63 Constructor Arguments found :
Arg [0] : 0000000000000000000000003325e8c5d390aec436ff225779dcdd4d12314f27
Arg [1] : 0000000000000000000000005429509172710e58bb5bcacc550f3f980c992233
Arg [2] : 0000000000000000000000007f7cb4b506ed8f17de6d35d3a33d8976d67ecdd2
Arg [3] : 0000000000000000000000001f396a7f8695247cf59fa20a8712776723831a4e
Arg [4] : 000000000000000000000000d2724cff92e4fb9d268ace4b935316f863d254a1
Arg [5] : 000000000000000000000000d5dcdadded0967dfd142c6fed9f7042703a088d4
Arg [6] : 0000000000000000000000008f91a4214b618b01c9594bd24bdee2ef31723289
Arg [7] : 0000000000000000000000009e6d164fa1aac396f9e43e2be487aae7c30be280
Arg [8] : 000000000000000000000000022b47e37a3010688343e55d603fa6283b896690
Arg [9] : 000000000000000000000000ad91e3112f771423a2541492e7c448640022319d
Arg [10] : 000000000000000000000000f37de395d4542b2569d7ee29d9cc95d3052c3d3b
Arg [11] : 0000000000000000000000005a7fa37f1579d0c01008a5f58d5620d3a63a55c4
Arg [12] : 0000000000000000000000003f4794a3965f074139157c58bae2a430335e99db
Arg [13] : 000000000000000000000000541f7350cd28596de8952b5b589bc787d15dcc98
Arg [14] : 0000000000000000000000003511627d93a82d674ee31d13b66797362ef02b86
Arg [15] : 00000000000000000000000084ab3eeade82519965f9025ff3eb7c8a766188af
Arg [16] : 00000000000000000000000021f9214709b8c27f97aff3579b50f958f9acfc61
Arg [17] : 000000000000000000000000b63b81a06eee9a8a26f1d06ce1405fce83cded6a
Arg [18] : 0000000000000000000000005cffd98cab9044e2793b103f5a0624178862c261
Arg [19] : 0000000000000000000000001a14602619d1d2a74cb585d51dd4b21d85224b71
Arg [20] : 00000000000000000000000091dbd50021d130fe238564aa5fb12738b37ad4bc
Arg [21] : 000000000000000000000000c5f6ccd88f63830e081ec4bd731d6831c9b3b116
Arg [22] : 0000000000000000000000006b930261955b33389a77dfe32150e2cba337a3ca
Arg [23] : 000000000000000000000000e63adecc2e13844a7ba7538682bead0dc8462fbd
Arg [24] : 000000000000000000000000a5c893e8625010bc1540c6531a870e62f78c0eb7
Arg [25] : 0000000000000000000000009d3fd9b24a206c680b52f154727a5ddd56aa39a0
Arg [26] : 00000000000000000000000018e80fa7802af0a3f3e95616be44dd4d0fcc7939
Arg [27] : 000000000000000000000000a01c0c4eb0ed14f58d69be4f91ba72ebc8348e1f
Arg [28] : 000000000000000000000000f82e395916a96e6a8030eed1553dc138d955bb4b
Arg [29] : 00000000000000000000000012048d9d1f7b349517c139f513ec7a935fdc63c4
Arg [30] : 0000000000000000000000008344be5293e810659460d39dee509cf9d269fa42
Arg [31] : 00000000000000000000000038870cd26e79d1f254d8af368286e0ae32866364
Arg [32] : 00000000000000000000000007e3fe674bb6fccd7c1f3ee4789df50be0c6f0d6
Arg [33] : 000000000000000000000000d6a561e177a3052cdc16d872522b70eefcfa27be
Arg [34] : 00000000000000000000000040066a2bdaae99474e675ed77ba5a720b20c4a30
Arg [35] : 000000000000000000000000fc7e6df14d65b7d4a3ffb9bd6064332733cb0479
Arg [36] : 000000000000000000000000069fe848b2648a66bf058f7118e7e6bee447770f
Arg [37] : 000000000000000000000000cb1ff41b7bece607c2ca2619381342f01510864e
Arg [38] : 00000000000000000000000084253ec1578affd76453479be335be6537562540
Arg [39] : 0000000000000000000000002c8ff23e595849e3a4b303e80efe8a5ec9779cab
Arg [40] : 000000000000000000000000974eae262de47bef42670c8e854aab4cabbb35d9
Arg [41] : 0000000000000000000000003770f554f9604c7f1730762501a38bc4fe82a2db
Arg [42] : 000000000000000000000000287df1a8c699cc3b14d31d9351fd34ecb349938b
Arg [43] : 000000000000000000000000f90860ceaee3dbbcd48b3368308644a9d868fc6a
Arg [44] : 00000000000000000000000086c7a6a07b6e9152ad68b0906da997aa868db9c7
Arg [45] : 000000000000000000000000701b4b446a297382078167d63911734c2b021e2d
Arg [46] : 000000000000000000000000d3b06ab11b1fa5786d1dc1c9db5bab5febbba55e
Arg [47] : 000000000000000000000000610787b7b8be9077f2f67cd2467c3b6942ed1a2a
Arg [48] : 00000000000000000000000050e37c5497a56eb99d32e77206157663ae14e2c3
Arg [49] : 000000000000000000000000d6828b1436a83fdd783400975f631f46beaa14a8
Arg [50] : 0000000000000000000000007a3f5179721c7c15719a39b82ec86bd57afd57c2
Arg [51] : 0000000000000000000000008d089b74b48afe95e2265dd8088b851ef186e5d4
Arg [52] : 0000000000000000000000000d04eb7393ed549bc910faa9e9033de7a3aad3ba
Arg [53] : 00000000000000000000000062ef96151942fcc6da68e1d56161e3dc607a314b
Arg [54] : 0000000000000000000000009a53b25feac3a46ea3caf7fba7f6bc9543678e9c
Arg [55] : 00000000000000000000000081c14cc73ed4a51370c2b2648b28d71d595f3819
Arg [56] : 0000000000000000000000006cbb47ab221f20949b17b17524b31d20f2822452
Arg [57] : 000000000000000000000000069d1fc7d0b8104f2804626c6d568a17ebc28b55
Arg [58] : 000000000000000000000000ada2274efb1afc76634db2de873e10ab5e5b9988
Arg [59] : 000000000000000000000000d94ff8b17e8c03ba24b1d36a09eb0df72dcf07ec
Arg [60] : 00000000000000000000000040c47f7013630ae10ae6548de678bd701dfbf6ff
Arg [61] : 000000000000000000000000e778e3cea2b42a0286667e6882947ec9ac928dc2
Arg [62] : 0000000000000000000000009e65312260907d5a66c6d0f407aa29e761d9bd5e


Deployed Bytecode Sourcemap

1166:8011:5:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1004:128:0;;;;;;;;;;;;;;;;-1:-1:-1;1004:128:0;;:::i;:::-;;;;;;;;;;;;;;;;;;7754:1421:5;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;7754:1421:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;7754:1421:5;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;7754:1421:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;7754:1421:5;;;;;;;;;;-1:-1:-1;7754:1421:5;;-1:-1:-1;7754:1421:5;-1:-1:-1;7754:1421:5;:::i;:::-;;1939:127:0;;;:::i;1911:160:5:-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1004:128:0;1082:4;1109:16;1120:4;1109:10;:16::i;:::-;1102:23;1004:128;-1:-1:-1;;1004:128:0:o;7754:1421:5:-;7886:18;7906:25;7935:37;7951:11;;7935:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7964:7:5;;-1:-1:-1;7935:15:5;;-1:-1:-1;;7935:37:5:i;:::-;7885:87;;;;7983:23;1679:2;8009:40;8027:8;8037:11;;8009:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8009:17:5;;-1:-1:-1;;;8009:40:5:i;:::-;8293:15;;8009:52;;;-1:-1:-1;8208:1:5;-1:-1:-1;;8182:22:5;;8181:28;;;;8283:25;;;8421:1;;8382:11;;8182:22;;8382:35;;;;;;;;;;;;;:40;;8340:11;;1897:1:6;8340:37:5;;;;;;;;;;;;;:83;8319:182;;;;-1:-1:-1;;;8319:182:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8576:18;8533:11;;1959:1:6;8533:39:5;;;;;;;;;;;;;:61;8512:162;;;;-1:-1:-1;;;8512:162:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8712:1;8693:16;:20;8685:68;;;;-1:-1:-1;;;8685:68:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8763:23;8816:11;;8799:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8789:40;;;;;;8763:66;;8840:17;8860:8;8869:7;8860:17;;;;;;;;;;;;;;;;;;;8892:75;;;;;;;;;;;;;;;;;;;;;;;;;8860:17;;-1:-1:-1;8892:75:5;;;;;;;;;8977:12;9045:9;9056:16;9074:15;9091:10;9015:87;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8992:111;;;;;;8977:126;;9114:25;9127:11;;9114:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9114:12:5;;-1:-1:-1;;;9114:25:5:i;:::-;9150:18;9163:4;9150:12;:18::i;:::-;7754:1421;;;;;;;;;;;;;:::o;1939:127:0:-;2042:17;;;;1939:127;:::o;1911:160:5:-;1986:13;2015:49;;;;;;;;;;;;;;;;;;;1911:160;:::o;1429:124:0:-;1501:4;1528:18;;;:12;:18;;;;;;;;;1429:124::o;5921:1207:5:-;6032:18;6052:25;6117:1;6099:11;6111:1;6099:14;;;;;;;;;;;;;;:19;;6123:1;6098:26;6090:77;;;;-1:-1:-1;;;6090:77:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6213:1;6203:11;;;6235:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;6235:29:5;;6224:40;;6274:15;6331:1;6292:11;6325:1;6304:11;:18;:22;6292:35;;;;;;;;;;;;;;:40;;6274:58;;6493:1;6475:14;6470:1;:19;;6469:25;6458:7;:37;6500:1;6457:44;6436:123;;;;-1:-1:-1;;;6436:123:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6593:14;6582:7;:25;;6569:38;;6674:4;6664:8;6660:19;6749:4;6738:8;6732:15;6728:26;6715:11;6711:44;6801:4;6788:11;6784:22;6820:292;6844:11;6831;6828:28;6820:292;;;6942:15;;-1:-1:-1;;;;;6938:111:5;6918:132;;6892:4;6875:22;;;;7093:4;7079:19;6820:292;;;6824:3;;;6627:495;;;;;;;:::o;2991:2389::-;3115:6;3134:15;3159:18;3256:16;3275:8;3302:1;3284:8;:15;:19;3275:29;;;;;;;;;;;;;;;;;;3451:15;;3340:24;3328:37;;;-1:-1:-1;3275:29:5;;-1:-1:-1;1484:2:5;3403:25;;;;3480:1;3470:11;;3451:30;3443:64;;;;;-1:-1:-1;;;3443:64:5;;;;;;;;;;;;-1:-1:-1;;;3443:64:5;;;;;;;;;;;;;;;-1:-1:-1;;;3529:31:5;;3521:56;;;;;-1:-1:-1;;;3521:56:5;;;;;;;;;;;;-1:-1:-1;;;3521:56:5;;;;;;;;;;;;;;;3755:37;;-1:-1:-1;;3606:28:5;;;1679:2;3605:42;;-1:-1:-1;2195:1:6;;-1:-1:-1;3668:28:5;;3755:11;;3767:24;;3755:37;;;;;;;;;;;;3729:63;;3803:18;3868:15;1735:1;3847:36;3824:20;:59;3803:80;;3956:20;3979:10;3992:1;3979:14;3956:37;;4003:15;4021:11;4048:1;4033:12;:16;4021:29;;;;;;;;;;;;;;;;;;;-1:-1:-1;1787:1:5;4095:26;;4080:41;;4228:11;4060:17;;4284:965;4308:7;4304:1;:11;4284:965;;;4419:21;4443:8;4452:1;4443:11;;;;;;;;;;;;;;;;;;;-1:-1:-1;4503:3:5;4486:20;;;4713:19;1582:2;4679:29;;;4678:55;;;4771:37;;-1:-1:-1;;4770:54:5;4862:88;4486:20;4900:15;4917:20;4939:10;4862:11;:88::i;:::-;4839:111;;5056:13;5012:15;5028:20;5051:1;5028:24;5012:41;;;;;;;;;;;;;;:57;4980:12;:90;4964:106;;;;5100:62;5112:7;5121:15;5138:12;5152:9;5100:11;:62::i;:::-;5085:77;;5205:15;5221:12;5236:1;5221:16;5205:33;;;;;;;;;;;;;;5190:12;:48;5176:62;;;;4284:965;;;;4317:3;;;;;;;4284:965;;;-1:-1:-1;;;5286:33:5;5343:29;;;;;2991:2389;-1:-1:-1;;;;;;;;;;;2991:2389:5:o;5113:8719:4:-;5211:18;;5498:1;5483:16;;;5475:45;;;;;-1:-1:-1;;;5475:45:4;;;;;;;;;;;;-1:-1:-1;;;5475:45:4;;;;;;;;;;;;;;;5751:3;5736:11;:18;;5728:46;;;;;-1:-1:-1;;;5728:46:4;;;;;;;;;;;;-1:-1:-1;;;5728:46:4;;;;;;;;;;;;;;;5868:1;5854:15;;5853:22;5845:61;;;;;-1:-1:-1;;;5845:61:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;6008:14;6045:1;-1:-1:-1;;6026:15:4;;6025:21;6008:38;;6265:15;6315:1;6283:11;6309:1;6295:11;:15;6283:28;;;;;;;;;;;;;;:33;;6265:51;;6347:6;6344:1;:9;6334:7;:19;6326:52;;;;;-1:-1:-1;;;6326:52:4;;;;;;;;;;;;-1:-1:-1;;;6326:52:4;;;;;;;;;;;;;;;6407:1;6397:11;;6396:18;6388:52;;;;;-1:-1:-1;;;6388:52:4;;;;;;;;;;;;-1:-1:-1;;;6388:52:4;;;;;;;;;;;;;;;6469:19;;;6484:4;6627:16;;6657:657;;;-1:-1:-1;;;7074:1:4;7067:77;7173:4;7168:3;7161:17;7208:7;7202:4;7195:21;7246:7;7240:4;7233:21;7291:7;7285:4;7281:18;7278:1;7271:29;6696:618;7358:5;7352:12;7349:1;7345:20;-1:-1:-1;;;;;7417:4:4;7410:5;7406:16;7400:23;7396:127;-1:-1:-1;;;7687:13:4;7675:10;7672:29;7656:13;7645:9;7642:28;7639:63;7636:2;;;7721:43;7761:2;-1:-1:-1;;;7721:43:4;:::i;:::-;7813:7;7792:28;;7931:4;7925:11;7912:24;;8001:2;7980:7;7976:28;7969:5;7965:40;8104:1;8089:341;8114:2;8111:1;8108:9;8089:341;;;8282:7;8271;8268:1;8264:15;8257:5;8253:27;8207:7;8203:1;8196:5;8192:13;8188:1;8182:8;8175:5;8164:126;8154:2;;8334:16;8331:1;8328;8313:38;8381:16;8378:1;8371:27;8154:2;8132:1;8125:9;8089:341;;;8093:14;8621:1;8635:7;8655:6;-1:-1:-1;;;;;9047:4769:4;9066:7;9058:6;9055:19;9047:4769;;;9226:18;;;9295:10;;9347:4;9338:14;;9332:21;9384:17;;;;-1:-1:-1;9267:1:4;;-1:-1:-1;9295:10:4;9371:2333;9412:8;9407:3;9404:17;9371:2333;;;9509:3;9503:10;9559:4;9554:3;9550:14;9544:21;9714:2;9707:5;9703:14;9910:5;9902;9898:2;9889:7;9882:26;9878:2;9871:45;9975:5;9971:2;9962:7;9955:26;10076:5;10065:9;10061:2;10054:28;10044:38;;10132:5;10128:2;10124;10117:21;10723:5;10679;10629:2;10622:5;10618:14;10607:9;10603:30;10552:5;10545:140;10501:5;10497:2;10489:5;10485:2;10481;10474:21;10467:40;10460:269;10820:5;10816:2;10809:5;10802:24;10792:34;;11081:5;11077:2;11073;11066:21;11060:27;;11485:5;11445;11400;11396:2;11392;11385:21;11340:2;11333:5;11329:14;11325:82;11285:2;11278:173;11233:5;11229:2;11225;11218:21;11211:5;11207:33;11200:291;11194:297;;11680:5;11676:2;11672;11665:21;11659:27;;;;;;;;;9459:7;9454:3;9450:17;9444:23;;9371:2333;;;9375:28;12153:4;12145:6;12141:17;12131:27;;12340:6;12333:5;12329:18;12323:25;12320:1;12316:33;-1:-1:-1;;;;;12454:4:4;12446:6;12442:17;12435:5;12431:29;12425:36;12385:165;12696:13;12684:10;12681:29;12665:13;12650;12647:32;12644:67;12641:2;;;12734:38;12769:2;-1:-1:-1;;;12734:38:4;:::i;:::-;12829:1;12825:21;;;;12866;;12863:2;;;12927:10;12910:27;;12863:2;;13585;13575;;13610:30;13637:2;-1:-1:-1;;;13610:30:4;:::i;:::-;13713:5;13709:2;13694:13;13687:32;13683:2;13679:41;13676:2;;;13749:35;13781:2;-1:-1:-1;;;13749:35:4;:::i;:::-;13676:2;;9047:4769;;;9051:3;;;;;;;;6553:7273;;;;;;:::o;1559:302:0:-;1710:22;;;;:12;:22;;;;;;;:29;;-1:-1:-1;;1710:29:0;1735:4;1710:29;;;1787:17;1710:29;1787:17;1782:73;;1820:17;:24;;-1:-1:-1;;1820:24:0;1840:4;1820:24;;;1782:73;1559:302;:::o;2262:322:5:-;2427:8;2445:133;2465:7;2451:5;2457:3;2451:10;;;;;;;;;;;;;;:21;2445:133;;2509:1;2488:22;2532:12;;;2524:43;;;;;-1:-1:-1;;;2524:43:5;;;;;;;;;;;;-1:-1:-1;;;2524:43:5;;;;;;;;;;;;;;;2445:133;;;2262:322;;;;;;:::o

Swarm Source

ipfs://0d27f0ecbdf3e63706a044a2ad77f8962f091319b17ed36ac2febc36bc488d9f

Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading
Loading...
Loading

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
Loading...
Loading
[ Download: CSV Export  ]

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.