Holesky Testnet

Contract

0xc01f3F43a449BdB6C1e00b9d9200A4C82C211aFF

Overview

ETH Balance

0 ETH

Multichain Info

N/A
Transaction Hash
Method
Block
From
To
Verify Blobs31054712025-01-08 20:59:1230 days ago1736369952IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.00100025
Verify Blobs31054702025-01-08 20:59:0030 days ago1736369940IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.00100028
Verify Blobs31054512025-01-08 20:54:3630 days ago1736369676IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.00100027
Verify Blobs31054502025-01-08 20:54:2430 days ago1736369664IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.00100031
Verify Blobs31054492025-01-08 20:54:1230 days ago1736369652IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.00100028
Verify Blobs31054482025-01-08 20:54:0030 days ago1736369640IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.00100026
Verify Blobs31054452025-01-08 20:53:2430 days ago1736369604IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.0010003
Verify Blobs31054442025-01-08 20:53:1230 days ago1736369592IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.00100034
Verify Blobs31054192025-01-08 20:48:1230 days ago1736369292IN
0xc01f3F43...82C211aFF
0 ETH0.000000170.00100044
Verify Blobs31054172025-01-08 20:47:3630 days ago1736369256IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.00100052
Verify Blobs31054162025-01-08 20:47:2430 days ago1736369244IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.00100048
Verify Blobs31054152025-01-08 20:47:1230 days ago1736369232IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.00100053
Verify Blobs31054142025-01-08 20:47:0030 days ago1736369220IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.00100049
Verify Blobs31053912025-01-08 20:42:1230 days ago1736368932IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.00100049
Verify Blobs31053902025-01-08 20:42:0030 days ago1736368920IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.00100044
Verify Blobs31053882025-01-08 20:41:3630 days ago1736368896IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.00100046
Verify Blobs31053872025-01-08 20:41:2430 days ago1736368884IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.00100049
Verify Blobs31053862025-01-08 20:41:1230 days ago1736368872IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.00100045
Verify Blobs31053852025-01-08 20:41:0030 days ago1736368860IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.00100041
Verify Blobs31053622025-01-08 20:36:1230 days ago1736368572IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.00100058
Verify Blobs31053612025-01-08 20:36:0030 days ago1736368560IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.00100053
Verify Blobs31053602025-01-08 20:35:4830 days ago1736368548IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.0010006
Verify Blobs31053592025-01-08 20:35:3630 days ago1736368536IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.00100054
Verify Blobs31053572025-01-08 20:35:1230 days ago1736368512IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.00100056
Verify Blobs31053562025-01-08 20:35:0030 days ago1736368500IN
0xc01f3F43...82C211aFF
0 ETH0.000000090.00100063
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:
EigenDAFactRegistry

Compiler Version
v0.8.26+commit.8a97fa7a

Optimization Enabled:
Yes with 200 runs

Other Settings:
paris EvmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2024-10-14
*/

// SPDX-License-Identifier: UNLICENSED
pragma solidity =0.8.26 ^0.8.0 ^0.8.12 ^0.8.20 ^0.8.9;

// lib/openzeppelin-contracts/contracts/utils/structs/EnumerableSet.sol

// OpenZeppelin Contracts (last updated v5.0.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position is the index of the value in the `values` array plus 1.
        // Position 0 is used to mean a value is not in the set.
        mapping(bytes32 value => uint256) _positions;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._positions[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We cache the value's position to prevent multiple reads from the same storage slot
        uint256 position = set._positions[value];

        if (position != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 valueIndex = position - 1;
            uint256 lastIndex = set._values.length - 1;

            if (valueIndex != lastIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the lastValue to the index where the value to delete is
                set._values[valueIndex] = lastValue;
                // Update the tracked position of the lastValue (that was just moved)
                set._positions[lastValue] = position;
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the tracked position for the deleted slot
            delete set._positions[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._positions[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

// src/dep/eigenda/BN254.sol

// several functions are taken or adapted from https://github.com/HarryR/solcrypto/blob/master/contracts/altbn128.sol (MIT license):
// Copyright 2017 Christian Reitwiessner
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.

// The remainder of the code is written by LayrLabs Inc. and is under the BUSL-1.1 license

/**
 * @title Library for operations on the BN254 elliptic curve.
 * @author Layr Labs, Inc.
 * @notice Terms of Service: https://docs.eigenlayer.xyz/overview/terms-of-service
 * @notice Contains BN254 parameters, common operations (addition, scalar mul, pairing), and BLS signature functionality.
 */
library BN254 {
    // modulus for the underlying field F_p of the elliptic curve
    uint256 internal constant FP_MODULUS = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
    // modulus for the underlying field F_r of the elliptic curve
    uint256 internal constant FR_MODULUS = 21888242871839275222246405745257275088548364400416034343698204186575808495617;

    struct G1Point {
        uint256 X;
        uint256 Y;
    }

    // Encoding of field elements is: X[1] * i + X[0]
    struct G2Point {
        uint256[2] X;
        uint256[2] Y;
    }

    function generatorG1() internal pure returns (G1Point memory) {
        return G1Point(1, 2);
    }

    // generator of group G2
    /// @dev Generator point in F_q2 is of the form: (x0 + ix1, y0 + iy1).
    uint256 internal constant G2x1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634;
    uint256 internal constant G2x0 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
    uint256 internal constant G2y1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;
    uint256 internal constant G2y0 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;

    /// @notice returns the G2 generator
    /// @dev mind the ordering of the 1s and 0s!
    ///      this is because of the (unknown to us) convention used in the bn254 pairing precompile contract
    ///      "Elements a * i + b of F_p^2 are encoded as two elements of F_p, (a, b)."
    ///      https://github.com/ethereum/EIPs/blob/master/EIPS/eip-197.md#encoding
    function generatorG2() internal pure returns (G2Point memory) {
        return G2Point([G2x1, G2x0], [G2y1, G2y0]);
    }

    // negation of the generator of group G2
    /// @dev Generator point in F_q2 is of the form: (x0 + ix1, y0 + iy1).
    uint256 internal constant nG2x1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634;
    uint256 internal constant nG2x0 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
    uint256 internal constant nG2y1 = 17805874995975841540914202342111839520379459829704422454583296818431106115052;
    uint256 internal constant nG2y0 = 13392588948715843804641432497768002650278120570034223513918757245338268106653;

    function negGeneratorG2() internal pure returns (G2Point memory) {
        return G2Point([nG2x1, nG2x0], [nG2y1, nG2y0]);
    }

    bytes32 internal constant powersOfTauMerkleRoot = 0x22c998e49752bbb1918ba87d6d59dd0e83620a311ba91dd4b2cc84990b31b56f;

    /**
     * @param p Some point in G1.
     * @return The negation of `p`, i.e. p.plus(p.negate()) should be zero.
     */
    function negate(G1Point memory p) internal pure returns (G1Point memory) {
        // The prime q in the base field F_q for G1
        if (p.X == 0 && p.Y == 0) {
            return G1Point(0, 0);
        } else {
            return G1Point(p.X, FP_MODULUS - (p.Y % FP_MODULUS));
        }
    }

    /**
     * @return r the sum of two points of G1
     */
    function plus(G1Point memory p1, G1Point memory p2) internal view returns (G1Point memory r) {
        uint256[4] memory input;
        input[0] = p1.X;
        input[1] = p1.Y;
        input[2] = p2.X;
        input[3] = p2.Y;
        bool success;

        // solium-disable-next-line security/no-inline-assembly
        assembly {
            success := staticcall(sub(gas(), 2000), 6, input, 0x80, r, 0x40)
            // Use "invalid" to make gas estimation work
            switch success
            case 0 { invalid() }
        }

        require(success, "ec-add-failed");
    }

    /**
     * @notice an optimized ecMul implementation that takes O(log_2(s)) ecAdds
     * @param p the point to multiply
     * @param s the scalar to multiply by
     * @dev this function is only safe to use if the scalar is 9 bits or less
     */
    function scalar_mul_tiny(BN254.G1Point memory p, uint16 s) internal view returns (BN254.G1Point memory) {
        require(s < 2 ** 9, "scalar-too-large");

        // if s is 1 return p
        if (s == 1) {
            return p;
        }

        // the accumulated product to return
        BN254.G1Point memory acc = BN254.G1Point(0, 0);
        // the 2^n*p to add to the accumulated product in each iteration
        BN254.G1Point memory p2n = p;
        // value of most significant bit
        uint16 m = 1;
        // index of most significant bit
        uint8 i = 0;

        //loop until we reach the most significant bit
        while (s >= m) {
            unchecked {
                // if the  current bit is 1, add the 2^n*p to the accumulated product
                if ((s >> i) & 1 == 1) {
                    acc = plus(acc, p2n);
                }
                // double the 2^n*p for the next iteration
                p2n = plus(p2n, p2n);

                // increment the index and double the value of the most significant bit
                m <<= 1;
                ++i;
            }
        }

        // return the accumulated product
        return acc;
    }

    /**
     * @return r the product of a point on G1 and a scalar, i.e.
     *         p == p.scalar_mul(1) and p.plus(p) == p.scalar_mul(2) for all
     *         points p.
     */
    function scalar_mul(G1Point memory p, uint256 s) internal view returns (G1Point memory r) {
        uint256[3] memory input;
        input[0] = p.X;
        input[1] = p.Y;
        input[2] = s;
        bool success;
        // solium-disable-next-line security/no-inline-assembly
        assembly {
            success := staticcall(sub(gas(), 2000), 7, input, 0x60, r, 0x40)
            // Use "invalid" to make gas estimation work
            switch success
            case 0 { invalid() }
        }
        require(success, "ec-mul-failed");
    }

    /**
     *  @return The result of computing the pairing check
     *         e(p1[0], p2[0]) *  .... * e(p1[n], p2[n]) == 1
     *         For example,
     *         pairing([P1(), P1().negate()], [P2(), P2()]) should return true.
     */
    function pairing(G1Point memory a1, G2Point memory a2, G1Point memory b1, G2Point memory b2)
        internal
        view
        returns (bool)
    {
        G1Point[2] memory p1 = [a1, b1];
        G2Point[2] memory p2 = [a2, b2];

        uint256[12] memory input;

        for (uint256 i = 0; i < 2; i++) {
            uint256 j = i * 6;
            input[j + 0] = p1[i].X;
            input[j + 1] = p1[i].Y;
            input[j + 2] = p2[i].X[0];
            input[j + 3] = p2[i].X[1];
            input[j + 4] = p2[i].Y[0];
            input[j + 5] = p2[i].Y[1];
        }

        uint256[1] memory out;
        bool success;

        // solium-disable-next-line security/no-inline-assembly
        assembly {
            success := staticcall(sub(gas(), 2000), 8, input, mul(12, 0x20), out, 0x20)
            // Use "invalid" to make gas estimation work
            switch success
            case 0 { invalid() }
        }

        require(success, "pairing-opcode-failed");

        return out[0] != 0;
    }

    /**
     * @notice This function is functionally the same as pairing(), however it specifies a gas limit
     *         the user can set, as a precompile may use the entire gas budget if it reverts.
     */
    function safePairing(G1Point memory a1, G2Point memory a2, G1Point memory b1, G2Point memory b2, uint256 pairingGas)
        internal
        view
        returns (bool, bool)
    {
        G1Point[2] memory p1 = [a1, b1];
        G2Point[2] memory p2 = [a2, b2];

        uint256[12] memory input;

        for (uint256 i = 0; i < 2; i++) {
            uint256 j = i * 6;
            input[j + 0] = p1[i].X;
            input[j + 1] = p1[i].Y;
            input[j + 2] = p2[i].X[0];
            input[j + 3] = p2[i].X[1];
            input[j + 4] = p2[i].Y[0];
            input[j + 5] = p2[i].Y[1];
        }

        uint256[1] memory out;
        bool success;

        // solium-disable-next-line security/no-inline-assembly
        assembly {
            success := staticcall(pairingGas, 8, input, mul(12, 0x20), out, 0x20)
        }

        //Out is the output of the pairing precompile, either 0 or 1 based on whether the two pairings are equal.
        //Success is true if the precompile actually goes through (aka all inputs are valid)

        return (success, out[0] != 0);
    }

    /// @return hashedG1 the keccak256 hash of the G1 Point
    /// @dev used for BLS signatures
    function hashG1Point(BN254.G1Point memory pk) internal pure returns (bytes32 hashedG1) {
        assembly {
            mstore(0, mload(pk))
            mstore(0x20, mload(add(0x20, pk)))
            hashedG1 := keccak256(0, 0x40)
        }
    }

    /// @return the keccak256 hash of the G2 Point
    /// @dev used for BLS signatures
    function hashG2Point(BN254.G2Point memory pk) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked(pk.X[0], pk.X[1], pk.Y[0], pk.Y[1]));
    }

    /**
     * @notice adapted from https://github.com/HarryR/solcrypto/blob/master/contracts/altbn128.sol
     */
    function hashToG1(bytes32 _x) internal view returns (G1Point memory) {
        uint256 beta = 0;
        uint256 y = 0;

        uint256 x = uint256(_x) % FP_MODULUS;

        while (true) {
            (beta, y) = findYFromX(x);

            // y^2 == beta
            if (beta == mulmod(y, y, FP_MODULUS)) {
                return G1Point(x, y);
            }

            x = addmod(x, 1, FP_MODULUS);
        }
        return G1Point(0, 0);
    }

    /**
     * Given X, find Y
     *
     *   where y = sqrt(x^3 + b)
     *
     * Returns: (x^3 + b), y
     */
    function findYFromX(uint256 x) internal view returns (uint256, uint256) {
        // beta = (x^3 + b) % p
        uint256 beta = addmod(mulmod(mulmod(x, x, FP_MODULUS), x, FP_MODULUS), 3, FP_MODULUS);

        // y^2 = x^3 + b
        // this acts like: y = sqrt(beta) = beta^((p+1) / 4)
        uint256 y = expMod(beta, 0xc19139cb84c680a6e14116da060561765e05aa45a1c72a34f082305b61f3f52, FP_MODULUS);

        return (beta, y);
    }

    function expMod(uint256 _base, uint256 _exponent, uint256 _modulus) internal view returns (uint256 retval) {
        bool success;
        uint256[1] memory output;
        uint256[6] memory input;
        input[0] = 0x20; // baseLen = new(big.Int).SetBytes(getData(input, 0, 32))
        input[1] = 0x20; // expLen  = new(big.Int).SetBytes(getData(input, 32, 32))
        input[2] = 0x20; // modLen  = new(big.Int).SetBytes(getData(input, 64, 32))
        input[3] = _base;
        input[4] = _exponent;
        input[5] = _modulus;
        assembly {
            success := staticcall(sub(gas(), 2000), 5, input, 0xc0, output, 0x20)
            // Use "invalid" to make gas estimation work
            switch success
            case 0 { invalid() }
        }
        require(success, "BN254.expMod: call failure");
        return output[0];
    }
}

// src/dep/eigenda/BitmapUtils.sol

/**
 * @title Library for Bitmap utilities such as converting between an array of bytes and a bitmap and finding the number of 1s in a bitmap.
 * @author Layr Labs, Inc.
 */
library BitmapUtils {
    /**
     * @notice Byte arrays are meant to contain unique bytes.
     * If the array length exceeds 256, then it's impossible for all entries to be unique.
     * This constant captures the max allowed array length (inclusive, i.e. 256 is allowed).
     */
    uint256 internal constant MAX_BYTE_ARRAY_LENGTH = 256;

    /**
     * @notice Converts an ordered array of bytes into a bitmap.
     * @param orderedBytesArray The array of bytes to convert/compress into a bitmap. Must be in strictly ascending order.
     * @return The resulting bitmap.
     * @dev Each byte in the input is processed as indicating a single bit to flip in the bitmap.
     * @dev This function will eventually revert in the event that the `orderedBytesArray` is not properly ordered (in ascending order).
     * @dev This function will also revert if the `orderedBytesArray` input contains any duplicate entries (i.e. duplicate bytes).
     */
    function orderedBytesArrayToBitmap(bytes memory orderedBytesArray) internal pure returns (uint256) {
        // sanity-check on input. a too-long input would fail later on due to having duplicate entry(s)
        require(
            orderedBytesArray.length <= MAX_BYTE_ARRAY_LENGTH,
            "BitmapUtils.orderedBytesArrayToBitmap: orderedBytesArray is too long"
        );

        // return empty bitmap early if length of array is 0
        if (orderedBytesArray.length == 0) {
            return uint256(0);
        }

        // initialize the empty bitmap, to be built inside the loop
        uint256 bitmap;
        // initialize an empty uint256 to be used as a bitmask inside the loop
        uint256 bitMask;

        // perform the 0-th loop iteration with the ordering check *omitted* (since it is unnecessary / will always pass)
        // construct a single-bit mask from the numerical value of the 0th byte of the array, and immediately add it to the bitmap
        bitmap = uint256(1 << uint8(orderedBytesArray[0]));

        // loop through each byte in the array to construct the bitmap
        for (uint256 i = 1; i < orderedBytesArray.length; ++i) {
            // construct a single-bit mask from the numerical value of the next byte of the array
            bitMask = uint256(1 << uint8(orderedBytesArray[i]));
            // check strictly ascending array ordering by comparing the mask to the bitmap so far (revert if mask isn't greater than bitmap)
            require(bitMask > bitmap, "BitmapUtils.orderedBytesArrayToBitmap: orderedBytesArray is not ordered");
            // add the entry to the bitmap
            bitmap = (bitmap | bitMask);
        }
        return bitmap;
    }

    /**
     * @notice Converts an ordered byte array to a bitmap, validating that all bits are less than `bitUpperBound`
     * @param orderedBytesArray The array to convert to a bitmap; must be in strictly ascending order
     * @param bitUpperBound The exclusive largest bit. Each bit must be strictly less than this value.
     * @dev Reverts if bitmap contains a bit greater than or equal to `bitUpperBound`
     */
    function orderedBytesArrayToBitmap(bytes memory orderedBytesArray, uint8 bitUpperBound)
        internal
        pure
        returns (uint256)
    {
        uint256 bitmap = orderedBytesArrayToBitmap(orderedBytesArray);

        require((1 << bitUpperBound) > bitmap, "BitmapUtils.orderedBytesArrayToBitmap: bitmap exceeds max value");

        return bitmap;
    }

    /**
     * @notice Utility function for checking if a bytes array is strictly ordered, in ascending order.
     * @param bytesArray the bytes array of interest
     * @return Returns 'true' if the array is ordered in strictly ascending order, and 'false' otherwise.
     * @dev This function returns 'true' for the edge case of the `bytesArray` having zero length.
     * It also returns 'false' early for arrays with length in excess of MAX_BYTE_ARRAY_LENGTH (i.e. so long that they cannot be strictly ordered)
     */
    function isArrayStrictlyAscendingOrdered(bytes calldata bytesArray) internal pure returns (bool) {
        // Return early if the array is too long, or has a length of 0
        if (bytesArray.length > MAX_BYTE_ARRAY_LENGTH) {
            return false;
        }

        if (bytesArray.length == 0) {
            return true;
        }

        // Perform the 0-th loop iteration by pulling the 0th byte out of the array
        bytes1 singleByte = bytesArray[0];

        // For each byte, validate that each entry is *strictly greater than* the previous
        // If it isn't, return false as the array is not ordered
        for (uint256 i = 1; i < bytesArray.length; ++i) {
            if (uint256(uint8(bytesArray[i])) <= uint256(uint8(singleByte))) {
                return false;
            }

            // Pull the next byte out of the array
            singleByte = bytesArray[i];
        }

        return true;
    }

    /**
     * @notice Converts a bitmap into an array of bytes.
     * @param bitmap The bitmap to decompress/convert to an array of bytes.
     * @return bytesArray The resulting bitmap array of bytes.
     * @dev Each byte in the input is processed as indicating a single bit to flip in the bitmap
     */
    function bitmapToBytesArray(uint256 bitmap) internal pure returns (bytes memory /*bytesArray*/ ) {
        // initialize an empty uint256 to be used as a bitmask inside the loop
        uint256 bitMask;
        // allocate only the needed amount of memory
        bytes memory bytesArray = new bytes(countNumOnes(bitmap));
        // track the array index to assign to
        uint256 arrayIndex = 0;
        /**
         * loop through each index in the bitmap to construct the array,
         * but short-circuit the loop if we reach the number of ones and thus are done
         * assigning to memory
         */
        for (uint256 i = 0; (arrayIndex < bytesArray.length) && (i < 256); ++i) {
            // construct a single-bit mask for the i-th bit
            bitMask = uint256(1 << i);
            // check if the i-th bit is flipped in the bitmap
            if (bitmap & bitMask != 0) {
                // if the i-th bit is flipped, then add a byte encoding the value 'i' to the `bytesArray`
                bytesArray[arrayIndex] = bytes1(uint8(i));
                // increment the bytesArray slot since we've assigned one more byte of memory
                unchecked {
                    ++arrayIndex;
                }
            }
        }
        return bytesArray;
    }

    /// @return count number of ones in binary representation of `n`
    function countNumOnes(uint256 n) internal pure returns (uint16) {
        uint16 count = 0;
        while (n > 0) {
            n &= (n - 1); // Clear the least significant bit (turn off the rightmost set bit).
            count++; // Increment the count for each cleared bit (each one encountered).
        }
        return count; // Return the total count of ones in the binary representation of n.
    }

    /// @notice Returns `true` if `bit` is in `bitmap`. Returns `false` otherwise.
    function isSet(uint256 bitmap, uint8 bit) internal pure returns (bool) {
        return 1 == ((bitmap >> bit) & 1);
    }

    /**
     * @notice Returns a copy of `bitmap` with `bit` set.
     * @dev IMPORTANT: we're dealing with stack values here, so this doesn't modify
     * the original bitmap. Using this correctly requires an assignment statement:
     * `bitmap = bitmap.setBit(bit);`
     */
    function setBit(uint256 bitmap, uint8 bit) internal pure returns (uint256) {
        return bitmap | (1 << bit);
    }

    /**
     * @notice Returns true if `bitmap` has no set bits
     */
    function isEmpty(uint256 bitmap) internal pure returns (bool) {
        return bitmap == 0;
    }

    /**
     * @notice Returns true if `a` and `b` have no common set bits
     */
    function noBitsInCommon(uint256 a, uint256 b) internal pure returns (bool) {
        return a & b == 0;
    }

    /**
     * @notice Returns true if `a` is a subset of `b`: ALL of the bits in `a` are also in `b`
     */
    function isSubsetOf(uint256 a, uint256 b) internal pure returns (bool) {
        return a & b == a;
    }

    /**
     * @notice Returns a new bitmap that contains all bits set in either `a` or `b`
     * @dev Result is the union of `a` and `b`
     */
    function plus(uint256 a, uint256 b) internal pure returns (uint256) {
        return a | b;
    }

    /**
     * @notice Returns a new bitmap that clears all set bits of `b` from `a`
     * @dev Negates `b` and returns the intersection of the result with `a`
     */
    function minus(uint256 a, uint256 b) internal pure returns (uint256) {
        return a & ~b;
    }
}

// src/dep/eigenda/Merkle.sol

// Adapted from OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/MerkleProof.sol)

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 * OpenZeppelin's JavaScript library generates merkle trees that are safe
 * against this attack out of the box.
 */
library Merkle {
    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. The tree is built assuming `leaf` is
     * the 0 indexed `index`'th leaf from the bottom left of the tree.
     *
     * Note this is for a Merkle tree using the keccak/sha3 hash function
     */
    function verifyInclusionKeccak(bytes memory proof, bytes32 root, bytes32 leaf, uint256 index)
        internal
        pure
        returns (bool)
    {
        return processInclusionProofKeccak(proof, leaf, index) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. The tree is built assuming `leaf` is
     * the 0 indexed `index`'th leaf from the bottom left of the tree.
     *
     * _Available since v4.4._
     *
     * Note this is for a Merkle tree using the keccak/sha3 hash function
     */
    function processInclusionProofKeccak(bytes memory proof, bytes32 leaf, uint256 index)
        internal
        pure
        returns (bytes32)
    {
        require(
            proof.length != 0 && proof.length % 32 == 0,
            "Merkle.processInclusionProofKeccak: proof length should be a non-zero multiple of 32"
        );
        bytes32 computedHash = leaf;
        for (uint256 i = 32; i <= proof.length; i += 32) {
            if (index % 2 == 0) {
                // if ith bit of index is 0, then computedHash is a left sibling
                assembly {
                    mstore(0x00, computedHash)
                    mstore(0x20, mload(add(proof, i)))
                    computedHash := keccak256(0x00, 0x40)
                    index := div(index, 2)
                }
            } else {
                // if ith bit of index is 1, then computedHash is a right sibling
                assembly {
                    mstore(0x00, mload(add(proof, i)))
                    mstore(0x20, computedHash)
                    computedHash := keccak256(0x00, 0x40)
                    index := div(index, 2)
                }
            }
        }
        return computedHash;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. The tree is built assuming `leaf` is
     * the 0 indexed `index`'th leaf from the bottom left of the tree.
     *
     * Note this is for a Merkle tree using the sha256 hash function
     */
    function verifyInclusionSha256(bytes memory proof, bytes32 root, bytes32 leaf, uint256 index)
        internal
        view
        returns (bool)
    {
        return processInclusionProofSha256(proof, leaf, index) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. The tree is built assuming `leaf` is
     * the 0 indexed `index`'th leaf from the bottom left of the tree.
     *
     * _Available since v4.4._
     *
     * Note this is for a Merkle tree using the sha256 hash function
     */
    function processInclusionProofSha256(bytes memory proof, bytes32 leaf, uint256 index)
        internal
        view
        returns (bytes32)
    {
        require(
            proof.length != 0 && proof.length % 32 == 0,
            "Merkle.processInclusionProofSha256: proof length should be a non-zero multiple of 32"
        );
        bytes32[1] memory computedHash = [leaf];
        for (uint256 i = 32; i <= proof.length; i += 32) {
            if (index % 2 == 0) {
                // if ith bit of index is 0, then computedHash is a left sibling
                assembly {
                    mstore(0x00, mload(computedHash))
                    mstore(0x20, mload(add(proof, i)))
                    if iszero(staticcall(sub(gas(), 2000), 2, 0x00, 0x40, computedHash, 0x20)) { revert(0, 0) }
                    index := div(index, 2)
                }
            } else {
                // if ith bit of index is 1, then computedHash is a right sibling
                assembly {
                    mstore(0x00, mload(add(proof, i)))
                    mstore(0x20, mload(computedHash))
                    if iszero(staticcall(sub(gas(), 2000), 2, 0x00, 0x40, computedHash, 0x20)) { revert(0, 0) }
                    index := div(index, 2)
                }
            }
        }
        return computedHash[0];
    }
}

// src/dep/eigenda/IEigenDAServiceManager.sol

interface IEigenDAServiceManager {
    /// @notice mapping between the batchId to the hash of the metadata of the corresponding Batch
    function batchIdToBatchMetadataHash(uint32 batchId) external view returns (bytes32);

    /// @notice Returns the bytes array of quorumAdversaryThresholdPercentages
    function quorumAdversaryThresholdPercentages() external view returns (bytes memory);

    /// @notice Returns the bytes array of quorumsNumbersRequired
    function quorumNumbersRequired() external view returns (bytes memory);
}

// src/facts/FactTypes.sol

library FactTypes {
    /// @notice Denotes the state of a fact in a fact registry.
    enum FactState {
        NOT_INITIATED,
        OPTIMISTIC,
        CHALLENGED,
        REVERTED,
        FINALIZED_TIMEOUT,
        FINALIZED_PROVED
    }

    /// @param prevStateHash The summary of the previous state to update from.
    /// @param pendingStateHash The summary of the pending state to update to.
    /// @param daFact The data availability fact that proves the pending state.
    /// @param onchainUpdatesHash The hash of the onchain updates that are applied to the pending state.
    struct StateUpdateFacts {
        bytes32 prevStateHash;
        bytes32 pendingStateHash;
        bytes32 daFact;
        bytes32 onchainUpdatesHash;
        uint64 startingActionId;
        uint64 endingActionId;
    }
}

// src/facts/IFactRegistry.sol

interface IFactRegistry {
    function getFactState(bytes32 fact) external view returns (FactTypes.FactState);

    event FactStateUpdated(bytes32 indexed fact, FactTypes.FactState oldState, FactTypes.FactState newState);
}

// src/dep/eigenda/EigenDAHasher.sol

/**
 * @title Library of functions for hashing various EigenDA structs.
 * @author Layr Labs, Inc.
 */
library EigenDAHasher {
    /**
     * @notice hashes the given metdata into the commitment that will be stored in the contract
     * @param batchHeaderHash the hash of the batchHeader
     * @param signatoryRecordHash the hash of the signatory record
     * @param blockNumber the block number at which the batch was confirmed
     */
    function hashBatchHashedMetadata(bytes32 batchHeaderHash, bytes32 signatoryRecordHash, uint32 blockNumber)
        internal
        pure
        returns (bytes32)
    {
        return keccak256(abi.encodePacked(batchHeaderHash, signatoryRecordHash, blockNumber));
    }

    /**
     * @notice given the a batchHeader in the provided metdata, calculates the hash of the batchMetadata
     * @param batchMetadata the metadata of the batch
     * @return the hash of the batchMetadata
     */
    function hashBatchMetadata(EigenDARollupUtils.BatchMetadata memory batchMetadata) internal pure returns (bytes32) {
        return hashBatchHashedMetadata(
            keccak256(abi.encode(batchMetadata.batchHeader)),
            batchMetadata.signatoryRecordHash,
            batchMetadata.confirmationBlockNumber
        );
    }

    /**
     * @notice hashes the given batch header
     * @param batchHeader the batch header to hash
     */
    function hashBatchHeader(EigenDARollupUtils.BatchHeader calldata batchHeader) internal pure returns (bytes32) {
        return keccak256(abi.encode(batchHeader));
    }

    /**
     * @notice hashes the given blob header
     * @param blobHeader the blob header to hash
     */
    function hashBlobHeader(EigenDARollupUtils.BlobHeader memory blobHeader) internal pure returns (bytes32) {
        return keccak256(abi.encode(blobHeader));
    }
}

// src/dep/eigenda/EigenDARollupUtils.sol

/**
 * @title Library of functions to be used by smart contracts wanting to prove blobs on EigenDA and open KZG commitments.
 * @author Layr Labs, Inc.
 */
library EigenDARollupUtils {
    using BN254 for BN254.G1Point;

    // STRUCTS

    struct QuorumBlobParam {
        uint8 quorumNumber;
        uint8 adversaryThresholdPercentage;
        uint8 confirmationThresholdPercentage;
        uint32 chunkLength; // the length of the chunks in the quorum
    }

    struct BlobHeader {
        BN254.G1Point commitment; // the kzg commitment to the blob
        uint32 dataLength; // the length of the blob in coefficients of the polynomial
        QuorumBlobParam[] quorumBlobParams; // the quorumBlobParams for each quorum
    }

    struct BatchHeader {
        bytes32 blobHeadersRoot;
        bytes quorumNumbers; // each byte is a different quorum number
        bytes signedStakeForQuorums; // every bytes is an amount less than 100 specifying the percentage of stake
            // that must have signed in the corresponding quorum in `quorumNumbers`
        uint32 referenceBlockNumber;
    }

    // Relevant metadata for a given datastore
    struct BatchMetadata {
        BatchHeader batchHeader; // the header of the data store
        bytes32 signatoryRecordHash; // the hash of the signatory record
        uint32 confirmationBlockNumber; // the block number at which the batch was confirmed
    }

    struct BlobVerificationProof {
        uint32 batchId;
        uint32 blobIndex;
        BatchMetadata batchMetadata;
        bytes inclusionProof;
        bytes quorumIndices;
    }

    /**
     * @notice Verifies the inclusion of a blob within a batch confirmed in `eigenDAServiceManager` and its trust assumptions
     * @param blobHeader the header of the blob containing relevant attributes of the blob
     * @param eigenDAServiceManager the contract in which the batch was confirmed
     * @param blobVerificationProof the relevant data needed to prove inclusion of the blob and that the trust assumptions were as expected
     */
    function verifyBlob(
        BlobHeader memory blobHeader,
        IEigenDAServiceManager eigenDAServiceManager,
        BlobVerificationProof memory blobVerificationProof
    ) internal view {
        require(
            EigenDAHasher.hashBatchMetadata(blobVerificationProof.batchMetadata)
                == eigenDAServiceManager.batchIdToBatchMetadataHash(blobVerificationProof.batchId),
            "EigenDARollupUtils.verifyBlob: batchMetadata does not match stored metadata"
        );

        require(
            Merkle.verifyInclusionKeccak(
                blobVerificationProof.inclusionProof,
                blobVerificationProof.batchMetadata.batchHeader.blobHeadersRoot,
                keccak256(abi.encodePacked(EigenDAHasher.hashBlobHeader(blobHeader))),
                blobVerificationProof.blobIndex
            ),
            "EigenDARollupUtils.verifyBlob: inclusion proof is invalid"
        );

        // bitmap of quorum numbers in all quorumBlobParams
        uint256 confirmedQuorumsBitmap;

        // require that the security param in each blob is met
        for (uint256 i = 0; i < blobHeader.quorumBlobParams.length; i++) {
            // make sure that the quorumIndex matches the given quorumNumber
            require(
                uint8(
                    blobVerificationProof.batchMetadata.batchHeader.quorumNumbers[uint8(
                        blobVerificationProof.quorumIndices[i]
                    )]
                ) == blobHeader.quorumBlobParams[i].quorumNumber,
                "EigenDARollupUtils.verifyBlob: quorumNumber does not match"
            );

            // make sure that the adversaryThresholdPercentage is less than the given confirmationThresholdPercentage
            require(
                blobHeader.quorumBlobParams[i].adversaryThresholdPercentage
                    < blobHeader.quorumBlobParams[i].confirmationThresholdPercentage,
                "EigenDARollupUtils.verifyBlob: adversaryThresholdPercentage is not valid"
            );

            // make sure that the adversaryThresholdPercentage is at least the given quorumAdversaryThresholdPercentage
            uint8 _adversaryThresholdPercentage =
                getQuorumAdversaryThreshold(eigenDAServiceManager, blobHeader.quorumBlobParams[i].quorumNumber);
            if (_adversaryThresholdPercentage > 0) {
                require(
                    blobHeader.quorumBlobParams[i].adversaryThresholdPercentage >= _adversaryThresholdPercentage,
                    "EigenDARollupUtils.verifyBlob: adversaryThresholdPercentage is not met"
                );
            }

            // make sure that the stake signed for is greater than the given confirmationThresholdPercentage
            require(
                uint8(
                    blobVerificationProof.batchMetadata.batchHeader.signedStakeForQuorums[uint8(
                        blobVerificationProof.quorumIndices[i]
                    )]
                ) >= blobHeader.quorumBlobParams[i].confirmationThresholdPercentage,
                "EigenDARollupUtils.verifyBlob: confirmationThresholdPercentage is not met"
            );

            // mark confirmed quorum in the bitmap
            confirmedQuorumsBitmap =
                BitmapUtils.setBit(confirmedQuorumsBitmap, blobHeader.quorumBlobParams[i].quorumNumber);
        }

        // check that required quorums are a subset of the confirmed quorums
        require(
            BitmapUtils.isSubsetOf(
                BitmapUtils.orderedBytesArrayToBitmap(eigenDAServiceManager.quorumNumbersRequired()),
                confirmedQuorumsBitmap
            ),
            "EigenDARollupUtils.verifyBlob: required quorums are not a subset of the confirmed quorums"
        );
    }

    /**
     * @notice gets the adversary threshold percentage for a given quorum
     * @param eigenDAServiceManager the contract in which the batch was confirmed
     * @param quorumNumber the quorum number to get the adversary threshold percentage for
     * @dev returns 0 if the quorumNumber is not found
     */
    function getQuorumAdversaryThreshold(IEigenDAServiceManager eigenDAServiceManager, uint256 quorumNumber)
        internal
        view
        returns (uint8 adversaryThresholdPercentage)
    {
        if (eigenDAServiceManager.quorumAdversaryThresholdPercentages().length > quorumNumber) {
            adversaryThresholdPercentage =
                uint8(eigenDAServiceManager.quorumAdversaryThresholdPercentages()[quorumNumber]);
        }
    }

    /**
     * @notice opens the KZG commitment at a point
     * @param point the point to evaluate the polynomial at
     * @param evaluation the evaluation of the polynomial at the point
     * @param tau the power of tau
     * @param commitment the commitment to the polynomial
     * @param proof the proof of the commitment
     */
    function openCommitment(
        uint256 point,
        uint256 evaluation,
        BN254.G1Point memory tau,
        BN254.G1Point memory commitment,
        BN254.G2Point memory proof
    ) internal view returns (bool) {
        BN254.G1Point memory negGeneratorG1 = BN254.generatorG1().negate();

        //e([s]_1 - w[1]_1, [pi(x)]_2) = e([p(x)]_1 - p(w)[1]_1, [1]_2)
        return BN254.pairing(
            tau.plus(negGeneratorG1.scalar_mul(point)),
            proof,
            commitment.plus(negGeneratorG1.scalar_mul(evaluation)),
            BN254.negGeneratorG2()
        );
    }
}

// src/facts/da/IEigenDAFactRegistry.sol

interface IEigenDAFactRegistry is IFactRegistry {
    error InvalidLength(uint256 length);
    error MismatchedLength(uint256 length1, uint256 length2);

    function verifyBlobs(
        EigenDARollupUtils.BlobHeader[] memory blobHeaders,
        EigenDARollupUtils.BlobVerificationProof[] memory blobVerificationProofs
    ) external;
}

// src/facts/da/EigenDAFactRegistry.sol

contract EigenDAFactRegistry is IEigenDAFactRegistry {
    address public immutable EIGENDA_SERVICE_MANAGER;

    mapping(bytes32 => FactTypes.FactState) internal _registeredFact;

    constructor(address eigenDAServiceManager) {
        EIGENDA_SERVICE_MANAGER = eigenDAServiceManager;
    }

    function getFactState(bytes32 fact) external view override returns (FactTypes.FactState) {
        return _registeredFact[fact];
    }

    function verifyBlobs(
        EigenDARollupUtils.BlobHeader[] memory blobHeaders,
        EigenDARollupUtils.BlobVerificationProof[] memory blobVerificationProofs
    ) external {
        if (blobHeaders.length == 0) {
            revert InvalidLength(blobHeaders.length);
        }
        if (blobHeaders.length != blobVerificationProofs.length) {
            revert MismatchedLength(blobHeaders.length, blobVerificationProofs.length);
        }
        bytes memory commitmentData;
        for (uint256 i; i < blobHeaders.length; i++) {
            EigenDARollupUtils.verifyBlob(
                blobHeaders[i], IEigenDAServiceManager(EIGENDA_SERVICE_MANAGER), blobVerificationProofs[i]
            );
            commitmentData = bytes.concat(commitmentData, _getDACommitmentBytes(blobHeaders[i]));
        }

        bytes32 fact = sha256(commitmentData);

        emit FactStateUpdated(fact, _registeredFact[fact], FactTypes.FactState.FINALIZED_PROVED);
        _registeredFact[fact] = FactTypes.FactState.FINALIZED_PROVED;
    }

    function _getDACommitmentBytes(EigenDARollupUtils.BlobHeader memory blobHeader)
        internal
        pure
        returns (bytes memory)
    {
        // Packed encoding is okay because the lengths are fixed
        return abi.encodePacked(blobHeader.commitment.X, blobHeader.commitment.Y, blobHeader.dataLength);
    }
}

Contract ABI

[{"inputs":[{"internalType":"address","name":"eigenDAServiceManager","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"length","type":"uint256"}],"name":"InvalidLength","type":"error"},{"inputs":[{"internalType":"uint256","name":"length1","type":"uint256"},{"internalType":"uint256","name":"length2","type":"uint256"}],"name":"MismatchedLength","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"fact","type":"bytes32"},{"indexed":false,"internalType":"enum FactTypes.FactState","name":"oldState","type":"uint8"},{"indexed":false,"internalType":"enum FactTypes.FactState","name":"newState","type":"uint8"}],"name":"FactStateUpdated","type":"event"},{"inputs":[],"name":"EIGENDA_SERVICE_MANAGER","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"fact","type":"bytes32"}],"name":"getFactState","outputs":[{"internalType":"enum FactTypes.FactState","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"components":[{"internalType":"uint256","name":"X","type":"uint256"},{"internalType":"uint256","name":"Y","type":"uint256"}],"internalType":"struct BN254.G1Point","name":"commitment","type":"tuple"},{"internalType":"uint32","name":"dataLength","type":"uint32"},{"components":[{"internalType":"uint8","name":"quorumNumber","type":"uint8"},{"internalType":"uint8","name":"adversaryThresholdPercentage","type":"uint8"},{"internalType":"uint8","name":"confirmationThresholdPercentage","type":"uint8"},{"internalType":"uint32","name":"chunkLength","type":"uint32"}],"internalType":"struct EigenDARollupUtils.QuorumBlobParam[]","name":"quorumBlobParams","type":"tuple[]"}],"internalType":"struct EigenDARollupUtils.BlobHeader[]","name":"blobHeaders","type":"tuple[]"},{"components":[{"internalType":"uint32","name":"batchId","type":"uint32"},{"internalType":"uint32","name":"blobIndex","type":"uint32"},{"components":[{"components":[{"internalType":"bytes32","name":"blobHeadersRoot","type":"bytes32"},{"internalType":"bytes","name":"quorumNumbers","type":"bytes"},{"internalType":"bytes","name":"signedStakeForQuorums","type":"bytes"},{"internalType":"uint32","name":"referenceBlockNumber","type":"uint32"}],"internalType":"struct EigenDARollupUtils.BatchHeader","name":"batchHeader","type":"tuple"},{"internalType":"bytes32","name":"signatoryRecordHash","type":"bytes32"},{"internalType":"uint32","name":"confirmationBlockNumber","type":"uint32"}],"internalType":"struct EigenDARollupUtils.BatchMetadata","name":"batchMetadata","type":"tuple"},{"internalType":"bytes","name":"inclusionProof","type":"bytes"},{"internalType":"bytes","name":"quorumIndices","type":"bytes"}],"internalType":"struct EigenDARollupUtils.BlobVerificationProof[]","name":"blobVerificationProofs","type":"tuple[]"}],"name":"verifyBlobs","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)

000000000000000000000000d4a7e1bd8015057293f0d0a557088c286942e84b

-----Decoded View---------------
Arg [0] : eigenDAServiceManager (address): 0xD4A7E1Bd8015057293f0D0A557088c286942e84b

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000d4a7e1bd8015057293f0d0a557088c286942e84b


Deployed Bytecode Sourcemap

53176:1849:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53627:1057;;;;;;:::i;:::-;;:::i;:::-;;53483:136;;;;;;:::i;:::-;53551:19;53590:21;;;;;;;;;;;;;;53483:136;;;;;;;;:::i;:::-;;;;;;;;53236:48;;;;;;;;-1:-1:-1;;;;;9837:32:1;;;9819:51;;9807:2;9792:18;53236:48:0;9673:203:1;53627:1057:0;53823:11;:18;53845:1;53823:23;53819:96;;53884:11;:18;53870:33;;-1:-1:-1;;;53870:33:0;;;;;;10027:25:1;;10015:2;10000:18;;9881:177;53870:33:0;;;;;;;;53819:96;53951:22;:29;53929:11;:18;:51;53925:158;;54021:18;;54041:29;;54004:67;;-1:-1:-1;;;54004:67:0;;;;;10237:25:1;;;;10278:18;;;10271:34;10210:18;;54004:67:0;10063:248:1;53925:158:0;54093:27;54136:9;54131:324;54151:11;:18;54147:1;:22;54131:324;;;54191:153;54239:11;54251:1;54239:14;;;;;;;;:::i;:::-;;;;;;;54278:23;54304:22;54327:1;54304:25;;;;;;;;:::i;:::-;;;;;;;54191:29;:153::i;:::-;54389:14;54405:37;54427:11;54439:1;54427:14;;;;;;;;:::i;:::-;;;;;;;54405:21;:37::i;:::-;54376:67;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;54376:67:0;;;;;;;;;;-1:-1:-1;54171:3:0;;54131:324;;;;54467:12;54482:22;54489:14;54482:22;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54545:15;:21;;;;;;;;;;;;;54522:83;;54467:37;;-1:-1:-1;54467:37:0;;54522:83;;;;54545:21;;;;;54568:36;;54522:83;:::i;:::-;;;;;;;;54616:15;:21;;;;;;;;;;:60;;-1:-1:-1;;54616:60:0;54640:36;54616:60;;;-1:-1:-1;;;53627:1057:0:o;47136:3841::-;47503:29;;47454:79;;-1:-1:-1;;;47454:79:0;;12170:10:1;12158:23;;;47454:79:0;;;12140:42:1;-1:-1:-1;;;;;47454:48:0;;;;;12113:18:1;;47454:79:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;47365:68;47397:21;:35;;;47365:31;:68::i;:::-;:168;47343:293;;;;-1:-1:-1;;;47343:293:0;;12395:2:1;47343:293:0;;;12377:21:1;12434:2;12414:18;;;12407:30;12473:34;12453:18;;;12446:62;12544:34;12524:18;;;12517:62;-1:-1:-1;;;12595:19:1;;;12588:42;12647:19;;47343:293:0;12193:479:1;47343:293:0;47718:36;;;;47773:35;;;;:47;:63;47671:318;;47718:36;47882:40;47911:10;47882:28;:40::i;:::-;47865:58;;;;;;12806:19:1;;12850:2;12841:12;;12677:182;47865:58:0;;;;;;;;;;;;;47855:69;;;;;;47943:21;:31;;;47671:318;;:28;:318::i;:::-;47649:425;;;;-1:-1:-1;;;47649:425:0;;13066:2:1;47649:425:0;;;13048:21:1;13105:2;13085:18;;;13078:30;13144:34;13124:18;;;13117:62;13215:27;13195:18;;;13188:55;13260:19;;47649:425:0;12864:421:1;47649:425:0;48148:30;;48255:2304;48279:10;:27;;;:34;48275:1;:38;48255:2304;;;48646:10;:27;;;48674:1;48646:30;;;;;;;;:::i;:::-;;;;;;;:43;;;48439:250;;48467:21;:35;;;:47;;;:61;;;48561:21;:35;;;48597:1;48561:38;;;;;;;;:::i;:::-;;;;;48467:156;;48561:38;;;;;;48467:156;;;;;;:::i;:::-;;;;;;;48439:250;48413:370;;;;-1:-1:-1;;;48413:370:0;;13492:2:1;48413:370:0;;;13474:21:1;13531:2;13511:18;;;13504:30;13570:34;13550:18;;;13543:62;13641:28;13621:18;;;13614:56;13687:19;;48413:370:0;13290:422:1;48413:370:0;49028:10;:27;;;49056:1;49028:30;;;;;;;;:::i;:::-;;;;;;;:62;;;48945:145;;:10;:27;;;48973:1;48945:30;;;;;;;;:::i;:::-;;;;;;;:59;;;:145;;;48919:279;;;;-1:-1:-1;;;48919:279:0;;13919:2:1;48919:279:0;;;13901:21:1;13958:2;13938:18;;;13931:30;13997:34;13977:18;;;13970:62;14068:34;14048:18;;;14041:62;-1:-1:-1;;;14119:19:1;;;14112:39;14168:19;;48919:279:0;13717:476:1;48919:279:0;49336:35;49391:95;49419:21;49442:10;:27;;;49470:1;49442:30;;;;;;;;:::i;:::-;;;;;;;:43;;;49391:95;;:27;:95::i;:::-;49336:150;-1:-1:-1;49505:33:0;;;;49501:310;;49652:29;49589:92;;:10;:27;;;49617:1;49589:30;;;;;;;;:::i;:::-;;;;;;;:59;;;:92;;;;49559:236;;;;-1:-1:-1;;;49559:236:0;;14400:2:1;49559:236:0;;;14382:21:1;14439:2;14419:18;;;14412:30;14478:34;14458:18;;;14451:62;14549:34;14529:18;;;14522:62;-1:-1:-1;;;14600:19:1;;;14593:37;14647:19;;49559:236:0;14198:474:1;49559:236:0;50178:10;:27;;;50206:1;50178:30;;;;;;;;:::i;:::-;;;;;;;:62;;;49963:277;;49991:21;:35;;;:47;;;:69;;;50093:21;:35;;;50129:1;50093:38;;;;;;;;:::i;:::-;;;;;49991:164;;50093:38;;;;;;49991:164;;;;;;:::i;:::-;;;;;;;49963:277;;49937:412;;;;-1:-1:-1;;;49937:412:0;;14879:2:1;49937:412:0;;;14861:21:1;14918:2;14898:18;;;14891:30;14957:34;14937:18;;;14930:62;15028:34;15008:18;;;15001:62;-1:-1:-1;;;15079:19:1;;;15072:40;15129:19;;49937:412:0;14677:477:1;49937:412:0;50460:87;50479:22;50503:10;:27;;;50531:1;50503:30;;;;;;;;:::i;:::-;;;;;;;:43;;;34493:1;:8;;;;;;34483:19;;34390:120;50460:87;50418:129;-1:-1:-1;;48315:3:0;;48255:2304;;;;50671:181;50712:84;50750:21;-1:-1:-1;;;;;50750:43:0;;:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;50750:45:0;;;;;;;;;;;;:::i;:::-;50712:37;:84::i;:::-;50815:22;35107:5;;:10;;35018:107;50671:181;50649:320;;;;-1:-1:-1;;;50649:320:0;;16033:2:1;50649:320:0;;;16015:21:1;16072:2;16052:18;;;16045:30;16111:34;16091:18;;;16084:62;16182:34;16162:18;;;16155:62;16254:27;16233:19;;;16226:56;16299:19;;50649:320:0;15831:493:1;50649:320:0;47332:3645;47136:3841;;;:::o;54692:330::-;54942:21;;:23;;54967;;;;;54992:21;;;;54925:89;;54822:12;;54925:89;;54942:23;54967;54992:21;54925:89;16512:19:1;;;16556:2;16547:12;;16540:28;;;;16624:3;16602:16;-1:-1:-1;;;;;;16598:43:1;16593:2;16584:12;;16577:65;16667:2;16658:12;;16329:347;54925:89:0;;;;;;;;;;;;;54918:96;;54692:330;;;:::o;44055:337::-;44160:7;44187:197;44246:13;:25;;;44235:37;;;;;;;;:::i;:::-;;;;;;;;;;;;;44225:48;;;;;;44288:13;:33;;;44336:13;:37;;;44187:23;:197::i;:::-;44180:204;44055:337;-1:-1:-1;;44055:337:0:o;44807:164::-;44903:7;44951:10;44940:22;;;;;;;;:::i;:::-;;;;;;;;;;;;;44930:33;;;;;;44923:40;;44807:164;;;:::o;36913:236::-;37057:4;37137;37086:47;37114:5;37121:4;37127:5;37086:27;:47::i;:::-;:55;;36913:236;-1:-1:-1;;;;;36913:236:0:o;51309:456::-;51464:34;51589:12;51520:21;-1:-1:-1;;;;;51520:57:0;;:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;51520:59:0;;;;;;;;;;;;:::i;:::-;:66;:81;51516:242;;;51672:21;-1:-1:-1;;;;;51672:57:0;;:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;51672:59:0;;;;;;;;;;;;:::i;:::-;51732:12;51672:73;;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1;51309:456:0;;;;:::o;27694:1746::-;27784:7;27067:3;27931:17;:24;:49;;27909:167;;;;-1:-1:-1;;;27909:167:0;;19047:2:1;27909:167:0;;;19029:21:1;19086:2;19066:18;;;19059:30;;;19125:34;19105:18;;;19098:62;19196:34;19176:18;;;19169:62;-1:-1:-1;;;19247:19:1;;;19240:35;19292:19;;27909:167:0;18845:472:1;27909:167:0;28155:17;:24;28183:1;28155:29;28151:79;;-1:-1:-1;28216:1:0;;27694:1746;-1:-1:-1;27694:1746:0:o;28151:79::-;28311:14;28416:15;28727:17;28745:1;28727:20;;;;;;;;:::i;:::-;;;;;28716:1;28727:20;;;;;28716:32;;;;-1:-1:-1;28834:575:0;28858:17;:24;28854:1;:28;28834:575;;;29032:17;29050:1;29032:20;;;;;;;;:::i;:::-;;;;;29021:1;29032:20;;;;;29021:32;;-1:-1:-1;29219:16:0;;;29211:100;;;;-1:-1:-1;;;29211:100:0;;19524:2:1;29211:100:0;;;19506:21:1;19563:2;19543:18;;;19536:30;19602:34;19582:18;;;19575:62;19673:34;19653:18;;;19646:62;-1:-1:-1;;;19724:19:1;;;19717:38;19772:19;;29211:100:0;19322:475:1;29211:100:0;29380:16;;;;28884:3;;28834:575;;;-1:-1:-1;29426:6:0;;27694:1746;-1:-1:-1;;;27694:1746:0:o;43547:275::-;43746:67;;;;;;;16512:19:1;;;16547:12;;;16540:28;;;16624:3;16602:16;;;-1:-1:-1;;;;;;16598:43:1;16584:12;;;16577:65;43746:67:0;;;;;;;;;16658:12:1;;;;43746:67:0;;;43736:78;;;;;43547:275;;;;;;:::o;37609:1230::-;37745:7;37792:5;:12;37808:1;37792:17;;:43;;;;;37828:2;37813:5;:12;:17;;;;:::i;:::-;:22;37792:43;37770:177;;;;-1:-1:-1;;;37770:177:0;;20570:2:1;37770:177:0;;;20552:21:1;20609:2;20589:18;;;20582:30;20648:34;20628:18;;;20621:62;20719:34;20699:18;;;20692:62;-1:-1:-1;;;20770:19:1;;;20763:51;20831:19;;37770:177:0;20368:488:1;37770:177:0;37981:4;38013:2;37996:806;38022:5;:12;38017:1;:17;37996:806;;38064:9;38072:1;38064:5;:9;:::i;:::-;38077:1;38064:14;38060:731;;38226:12;38220:4;38213:26;38291:1;38284:5;38280:13;38274:20;38268:4;38261:34;38349:4;38343;38333:21;38317:37;;38396:1;38389:5;38385:13;38376:22;;38060:731;;;38602:1;38595:5;38591:13;38585:20;38579:4;38572:34;38641:12;38635:4;38628:26;38708:4;38702;38692:21;38676:37;;38755:1;38748:5;38744:13;38735:22;;38060:731;38036:7;38041:2;38036:7;;:::i;:::-;;;37996:806;;;-1:-1:-1;38819:12:0;37609:1230;-1:-1:-1;;;;37609:1230:0:o;14:127:1:-;75:10;70:3;66:20;63:1;56:31;106:4;103:1;96:15;130:4;127:1;120:15;146:253;218:2;212:9;260:4;248:17;;-1:-1:-1;;;;;280:34:1;;316:22;;;277:62;274:88;;;342:18;;:::i;:::-;378:2;371:22;146:253;:::o;404:::-;476:2;470:9;518:4;506:17;;-1:-1:-1;;;;;538:34:1;;574:22;;;535:62;532:88;;;600:18;;:::i;662:253::-;734:2;728:9;776:4;764:17;;-1:-1:-1;;;;;796:34:1;;832:22;;;793:62;790:88;;;858:18;;:::i;920:251::-;992:2;986:9;;;1022:15;;-1:-1:-1;;;;;1052:34:1;;1088:22;;;1049:62;1046:88;;;1114:18;;:::i;1176:275::-;1247:2;1241:9;1312:2;1293:13;;-1:-1:-1;;1289:27:1;1277:40;;-1:-1:-1;;;;;1332:34:1;;1368:22;;;1329:62;1326:88;;;1394:18;;:::i;:::-;1430:2;1423:22;1176:275;;-1:-1:-1;1176:275:1:o;1456:193::-;1526:4;-1:-1:-1;;;;;1551:6:1;1548:30;1545:56;;;1581:18;;:::i;:::-;-1:-1:-1;1626:1:1;1622:14;1638:4;1618:25;;1456:193::o;1654:163::-;1721:20;;1781:10;1770:22;;1760:33;;1750:61;;1807:1;1804;1797:12;1750:61;1654:163;;;:::o;1822:156::-;1888:20;;1948:4;1937:16;;1927:27;;1917:55;;1968:1;1965;1958:12;1983:186;2031:4;-1:-1:-1;;;;;2056:6:1;2053:30;2050:56;;;2086:18;;:::i;:::-;-1:-1:-1;2152:2:1;2131:15;-1:-1:-1;;2127:29:1;2158:4;2123:40;;1983:186::o;2174:486::-;2216:5;2269:3;2262:4;2254:6;2250:17;2246:27;2236:55;;2287:1;2284;2277:12;2236:55;2327:6;2314:20;2358:52;2374:35;2402:6;2374:35;:::i;:::-;2358:52;:::i;:::-;2435:6;2426:7;2419:23;2489:3;2482:4;2473:6;2465;2461:19;2457:30;2454:39;2451:59;;;2506:1;2503;2496:12;2451:59;2571:6;2564:4;2556:6;2552:17;2545:4;2536:7;2532:18;2519:59;2627:1;2598:20;;;2620:4;2594:31;2587:42;;;;2602:7;2174:486;-1:-1:-1;;;2174:486:1:o;2665:1173::-;2725:5;2773:4;2761:9;2756:3;2752:19;2748:30;2745:50;;;2791:1;2788;2781:12;2745:50;2813:22;;:::i;:::-;2804:31;;2871:9;2858:23;-1:-1:-1;;;;;2896:6:1;2893:30;2890:50;;;2936:1;2933;2926:12;2890:50;2959:22;;3011:4;2997:12;;;2993:23;2990:43;;;3029:1;3026;3019:12;2990:43;3057:22;;:::i;:::-;3124:16;;3149:24;;3219:2;3211:11;;3198:25;-1:-1:-1;;;;;3235:32:1;;3232:52;;;3280:1;3277;3270:12;3232:52;3318:40;3354:3;3343:8;3339:2;3335:17;3318:40;:::i;:::-;3313:2;3304:7;3300:16;3293:66;;3405:2;3401;3397:11;3384:25;-1:-1:-1;;;;;3424:8:1;3421:32;3418:52;;;3466:1;3463;3456:12;3418:52;3504:40;3540:3;3529:8;3525:2;3521:17;3504:40;:::i;:::-;3499:2;3490:7;3486:16;3479:66;;3581:32;3607:4;3603:2;3599:13;3581:32;:::i;:::-;3574:4;3561:18;;3554:60;3623:22;;-1:-1:-1;3718:2:1;3703:18;;;3690:32;3738:14;;;3731:31;3794:37;3827:2;3812:18;;3794:37;:::i;:::-;3789:2;3782:5;3778:14;3771:61;2665:1173;;;;:::o;3843:1739::-;3918:5;3971:3;3964:4;3956:6;3952:17;3948:27;3938:55;;3989:1;3986;3979:12;3938:55;4029:6;4016:20;4056:74;4072:57;4122:6;4072:57;:::i;4056:74::-;4154:3;4178:6;4173:3;4166:19;4210:4;4205:3;4201:14;4194:21;;4271:4;4261:6;4258:1;4254:14;4246:6;4242:27;4238:38;4224:52;;4299:3;4291:6;4288:15;4285:35;;;4316:1;4313;4306:12;4285:35;4352:4;4344:6;4340:17;4366:1185;4382:6;4377:3;4374:15;4366:1185;;;4470:3;4457:17;-1:-1:-1;;;;;4493:11:1;4490:35;4487:55;;;4538:1;4535;4528:12;4487:55;4565:24;;4637:4;4613:12;;;-1:-1:-1;;4609:26:1;4605:37;4602:57;;;4655:1;4652;4645:12;4602:57;4685:22;;:::i;:::-;4734:32;4760:4;4756:2;4752:13;4734:32;:::i;:::-;4727:5;4720:47;4805:30;4831:2;4827;4823:11;4805:30;:::i;:::-;4798:4;4791:5;4787:16;4780:56;4886:2;4882;4878:11;4865:25;-1:-1:-1;;;;;4909:8:1;4906:32;4903:52;;;4951:1;4948;4941:12;4903:52;4991:66;5053:3;5046:4;5035:8;5031:2;5027:17;5023:28;4991:66;:::i;:::-;4986:2;4979:5;4975:14;4968:90;;5108:3;5104:2;5100:12;5087:26;-1:-1:-1;;;;;5132:8:1;5129:32;5126:52;;;5174:1;5171;5164:12;5126:52;5214:51;5261:3;5254:4;5243:8;5239:2;5235:17;5231:28;5214:51;:::i;:::-;5209:2;5202:5;5198:14;5191:75;;5316:4;5312:2;5308:13;5295:27;-1:-1:-1;;;;;5341:8:1;5338:32;5335:52;;;5383:1;5380;5373:12;5335:52;5424:51;5471:3;5464:4;5453:8;5449:2;5445:17;5441:28;5424:51;:::i;:::-;5418:3;5407:15;;5400:76;-1:-1:-1;5489:18:1;;-1:-1:-1;5536:4:1;5527:14;;;;4399;4366:1185;;;-1:-1:-1;5569:7:1;3843:1739;-1:-1:-1;;;;;3843:1739:1:o;5587:3263::-;5772:6;5780;5833:2;5821:9;5812:7;5808:23;5804:32;5801:52;;;5849:1;5846;5839:12;5801:52;5889:9;5876:23;-1:-1:-1;;;;;5914:6:1;5911:30;5908:50;;;5954:1;5951;5944:12;5908:50;5977:22;;6030:4;6022:13;;6018:27;-1:-1:-1;6008:55:1;;6059:1;6056;6049:12;6008:55;6099:2;6086:16;6122:74;6138:57;6188:6;6138:57;:::i;6122:74::-;6218:3;6242:6;6237:3;6230:19;6274:4;6269:3;6265:14;6258:21;;6331:4;6321:6;6318:1;6314:14;6310:2;6306:23;6302:34;6288:48;;6359:7;6351:6;6348:19;6345:39;;;6380:1;6377;6370:12;6345:39;6412:4;6408:2;6404:13;6426:2171;6442:6;6437:3;6434:15;6426:2171;;;6530:3;6517:17;-1:-1:-1;;;;;6553:11:1;6550:35;6547:55;;;6598:1;6595;6588:12;6547:55;6625:20;;6672:16;;;-1:-1:-1;;6668:30:1;6722:4;6714:13;;6711:33;;;6740:1;6737;6730:12;6711:33;6770:22;;:::i;:::-;6816:2;6812;6808:11;6805:31;;;6832:1;6829;6822:12;6805:31;6864:22;;:::i;:::-;6960:4;6952:13;;;6939:27;6979:24;;7077:2;7069:11;;7056:25;7101:18;;;7094:35;7142:22;;;6849:37;-1:-1:-1;7202:32:1;7228:4;7220:13;;7202:32;:::i;:::-;7195:4;7188:5;7184:16;7177:58;7285:4;7281:2;7277:13;7264:27;7248:43;;-1:-1:-1;;;;;7310:8:1;7307:32;7304:52;;;7352:1;7349;7342:12;7304:52;7402:4;7391:8;7387:2;7383:17;7379:28;7369:38;;7449:7;7442:4;7438:2;7434:13;7430:27;7420:55;;7471:1;7468;7461:12;7420:55;7517:2;7504:16;7488:32;;7546:76;7562:59;7612:8;7562:59;:::i;7546:76::-;7650:5;7682:8;7675:5;7668:23;7724:4;7717:5;7713:16;7704:25;;7789:4;7777:8;7774:1;7770:16;7766:2;7762:25;7758:36;7742:52;;7823:7;7813:8;7810:21;7807:41;;;7844:1;7841;7834:12;7807:41;7882:4;7878:2;7874:13;7861:26;;7900:578;7918:8;7911:5;7908:19;7900:578;;;8016:4;8008:5;7999:7;7995:19;7991:30;7988:50;;;8034:1;8031;8024:12;7988:50;8070:22;;:::i;:::-;8125:23;8142:5;8125:23;:::i;:::-;8116:7;8109:40;8193:34;8221:4;8214:5;8210:16;8193:34;:::i;:::-;8186:4;8177:7;8173:18;8166:62;8270:32;8298:2;8291:5;8287:14;8270:32;:::i;:::-;8265:2;8256:7;8252:16;8245:58;8347:35;8376:4;8369:5;8365:16;8347:35;:::i;:::-;8340:4;8327:18;;8320:63;8400:22;;7950:4;7939:16;;;;;8459:4;8448:16;;;;7900:578;;;8509:2;8498:14;;8491:31;-1:-1:-1;8535:18:1;;-1:-1:-1;;8582:4:1;8573:14;;;;6459;6426:2171;;;-1:-1:-1;8616:5:1;-1:-1:-1;;;;8674:4:1;8659:20;;8646:34;-1:-1:-1;;;;;8692:32:1;;8689:52;;;8737:1;8734;8727:12;8689:52;8760:84;8836:7;8825:8;8814:9;8810:24;8760:84;:::i;:::-;8750:94;;;5587:3263;;;;;:::o;8855:226::-;8914:6;8967:2;8955:9;8946:7;8942:23;8938:32;8935:52;;;8983:1;8980;8973:12;8935:52;-1:-1:-1;9028:23:1;;8855:226;-1:-1:-1;8855:226:1:o;9218:237::-;9299:1;9292:5;9289:12;9279:143;;9344:10;9339:3;9335:20;9332:1;9325:31;9379:4;9376:1;9369:15;9407:4;9404:1;9397:15;9279:143;9431:18;;9218:237::o;9460:208::-;9606:2;9591:18;;9618:44;9595:9;9644:6;9618:44;:::i;10316:127::-;10377:10;10372:3;10368:20;10365:1;10358:31;10408:4;10405:1;10398:15;10432:4;10429:1;10422:15;10448:250;10533:1;10543:113;10557:6;10554:1;10551:13;10543:113;;;10633:11;;;10627:18;10614:11;;;10607:39;10579:2;10572:10;10543:113;;;-1:-1:-1;;10690:1:1;10672:16;;10665:27;10448:250::o;10703:492::-;10878:3;10916:6;10910:13;10932:66;10991:6;10986:3;10979:4;10971:6;10967:17;10932:66;:::i;:::-;11061:13;;11020:16;;;;11083:70;11061:13;11020:16;11130:4;11118:17;;11083:70;:::i;:::-;11169:20;;10703:492;-1:-1:-1;;;;10703:492:1:o;11200:287::-;11329:3;11367:6;11361:13;11383:66;11442:6;11437:3;11430:4;11422:6;11418:17;11383:66;:::i;:::-;11465:16;;;;;11200:287;-1:-1:-1;;11200:287:1:o;11492:184::-;11562:6;11615:2;11603:9;11594:7;11590:23;11586:32;11583:52;;;11631:1;11628;11621:12;11583:52;-1:-1:-1;11654:16:1;;11492:184;-1:-1:-1;11492:184:1:o;11681:310::-;11867:2;11852:18;;11879:44;11856:9;11905:6;11879:44;:::i;:::-;11932:53;11981:2;11970:9;11966:18;11958:6;11932:53;:::i;15159:667::-;15238:6;15291:2;15279:9;15270:7;15266:23;15262:32;15259:52;;;15307:1;15304;15297:12;15259:52;15340:9;15334:16;-1:-1:-1;;;;;15365:6:1;15362:30;15359:50;;;15405:1;15402;15395:12;15359:50;15428:22;;15481:4;15473:13;;15469:27;-1:-1:-1;15459:55:1;;15510:1;15507;15500:12;15459:55;15543:2;15537:9;15568:52;15584:35;15612:6;15584:35;:::i;15568:52::-;15643:6;15636:5;15629:21;15691:7;15686:2;15677:6;15673:2;15669:15;15665:24;15662:37;15659:57;;;15712:1;15709;15702:12;15659:57;15725:71;15789:6;15784:2;15777:5;15773:14;15768:2;15764;15760:11;15725:71;:::i;:::-;15815:5;15159:667;-1:-1:-1;;;;;15159:667:1:o;16681:270::-;16722:3;16760:5;16754:12;16787:6;16782:3;16775:19;16803:76;16872:6;16865:4;16860:3;16856:14;16849:4;16842:5;16838:16;16803:76;:::i;:::-;16933:2;16912:15;-1:-1:-1;;16908:29:1;16899:39;;;;16940:4;16895:50;;16681:270;-1:-1:-1;;16681:270:1:o;16956:702::-;17143:2;17132:9;17125:21;17188:6;17182:13;17177:2;17166:9;17162:18;17155:41;17106:4;17243:2;17235:6;17231:15;17225:22;17283:4;17278:2;17267:9;17263:18;17256:32;17311:51;17357:3;17346:9;17342:19;17328:12;17311:51;:::i;:::-;17297:65;;17411:2;17403:6;17399:15;17393:22;17483:2;17479:7;17467:9;17459:6;17455:22;17451:36;17446:2;17435:9;17431:18;17424:64;17511:40;17544:6;17528:14;17511:40;:::i;:::-;17497:54;;;17617:10;17611:2;17603:6;17599:15;17593:22;17589:39;17582:4;17571:9;17567:20;17560:69;17646:6;17638:14;;;16956:702;;;;:::o;17663:1177::-;17848:2;17837:9;17830:21;17811:4;17889:3;17878:9;17874:19;17918:6;17912:13;17967:2;17961:9;17956:2;17945:9;17941:18;17934:37;18021:2;18017;18013:11;18007:18;18002:2;17991:9;17987:18;17980:46;;18090:10;18084:2;18076:6;18072:15;18066:22;18062:39;18057:2;18046:9;18042:18;18035:67;18149:2;18141:6;18137:15;18131:22;18191:4;18184;18173:9;18169:20;18162:34;18216:6;18251:12;18245:19;18288:6;18280;18273:22;18326:3;18315:9;18311:19;18304:26;;18371:2;18357:12;18353:21;18339:35;;18392:1;18383:10;;18402:412;18416:6;18413:1;18410:13;18402:412;;;18481:6;18475:13;18528:4;18523:2;18517:9;18513:20;18508:3;18501:33;18592:4;18586:2;18582;18578:11;18572:18;18568:29;18563:2;18558:3;18554:12;18547:51;18656:4;18650:2;18646;18642:11;18636:18;18632:29;18627:2;18622:3;18618:12;18611:51;18720:10;18714:2;18710;18706:11;18700:18;18696:35;18691:2;18686:3;18682:12;18675:57;;18761:4;18756:3;18752:14;18745:21;;18801:2;18793:6;18789:15;18779:25;;18438:1;18435;18431:9;18426:14;;18402:412;;20154:209;20186:1;20212;20202:132;;20256:10;20251:3;20247:20;20244:1;20237:31;20291:4;20288:1;20281:15;20319:4;20316:1;20309:15;20202:132;-1:-1:-1;20348:9:1;;20154:209::o;20861:222::-;20926:9;;;20947:10;;;20944:133;;;20999:10;20994:3;20990:20;20987:1;20980:31;21034:4;21031:1;21024:15;21062:4;21059:1;21052:15

Swarm Source

ipfs://e0149759192bca2023464a493949e27828fc89c5de0fdff3d6c9a0f2d1b91263

Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

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

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
[ 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.