Source Code
Overview
ETH Balance
0 ETH
More Info
ContractCreator
Multichain Info
N/A
Latest 25 from a total of 73,091 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Verify Blobs | 3105471 | 30 days ago | IN | 0 ETH | 0.00000009 | ||||
Verify Blobs | 3105470 | 30 days ago | IN | 0 ETH | 0.00000009 | ||||
Verify Blobs | 3105451 | 30 days ago | IN | 0 ETH | 0.00000009 | ||||
Verify Blobs | 3105450 | 30 days ago | IN | 0 ETH | 0.00000009 | ||||
Verify Blobs | 3105449 | 30 days ago | IN | 0 ETH | 0.00000009 | ||||
Verify Blobs | 3105448 | 30 days ago | IN | 0 ETH | 0.00000009 | ||||
Verify Blobs | 3105445 | 30 days ago | IN | 0 ETH | 0.00000009 | ||||
Verify Blobs | 3105444 | 30 days ago | IN | 0 ETH | 0.00000009 | ||||
Verify Blobs | 3105419 | 30 days ago | IN | 0 ETH | 0.00000017 | ||||
Verify Blobs | 3105417 | 30 days ago | IN | 0 ETH | 0.00000009 | ||||
Verify Blobs | 3105416 | 30 days ago | IN | 0 ETH | 0.00000009 | ||||
Verify Blobs | 3105415 | 30 days ago | IN | 0 ETH | 0.00000009 | ||||
Verify Blobs | 3105414 | 30 days ago | IN | 0 ETH | 0.00000009 | ||||
Verify Blobs | 3105391 | 30 days ago | IN | 0 ETH | 0.00000009 | ||||
Verify Blobs | 3105390 | 30 days ago | IN | 0 ETH | 0.00000009 | ||||
Verify Blobs | 3105388 | 30 days ago | IN | 0 ETH | 0.00000009 | ||||
Verify Blobs | 3105387 | 30 days ago | IN | 0 ETH | 0.00000009 | ||||
Verify Blobs | 3105386 | 30 days ago | IN | 0 ETH | 0.00000009 | ||||
Verify Blobs | 3105385 | 30 days ago | IN | 0 ETH | 0.00000009 | ||||
Verify Blobs | 3105362 | 30 days ago | IN | 0 ETH | 0.00000009 | ||||
Verify Blobs | 3105361 | 30 days ago | IN | 0 ETH | 0.00000009 | ||||
Verify Blobs | 3105360 | 30 days ago | IN | 0 ETH | 0.00000009 | ||||
Verify Blobs | 3105359 | 30 days ago | IN | 0 ETH | 0.00000009 | ||||
Verify Blobs | 3105357 | 30 days ago | IN | 0 ETH | 0.00000009 | ||||
Verify Blobs | 3105356 | 30 days ago | IN | 0 ETH | 0.00000009 |
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
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); } }
[{"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"}]
Contract Creation Code
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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
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.