Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity 0.8.18;

import {RLPReader} from "contracts/RLPReader.sol";
import {StateProofVerifier as Verifier} from "contracts/libs/StateProofVerifier.sol";

interface IBlockHashOracle {
    function get_block_hash(uint256 _number) external view returns (bytes32);
    function get_state_root(uint256 _number) external view returns (bytes32);
}

interface IGaugeTypeOracle {
    function set_gauge_type(address _gauge, uint256 _type) external;
}

/// @title Gauge Type Verifier
/// @author Curve Finance
contract GaugeTypeVerifier {
    using RLPReader for bytes;
    using RLPReader for RLPReader.RLPItem;

    address constant GAUGE_CONTROLLER =
        0x2F50D538606Fa9EDD2B11E2446BEb18C9D5846bB;
    bytes32 constant GAUGE_CONTROLLER_HASH =
        keccak256(abi.encodePacked(GAUGE_CONTROLLER));

    address public immutable BLOCK_HASH_ORACLE;
    address public immutable GAUGE_TYPE_ORACLE;

    constructor(address _block_hash_oracle, address _gauge_type_oracle) {
        BLOCK_HASH_ORACLE = _block_hash_oracle;
        GAUGE_TYPE_ORACLE = _gauge_type_oracle;
    }

    /// Verify the type of a gauge.
    /// @param _gauges List of gauges to verify the type of.
    /// @param _block_header_rlp The block header of any block in which the gauge has its type set.
    /// @param _proof_rlp The state proof of the gauge types.
    function verifyGaugeTypeByBlockHash(
        address[] memory _gauges,
        bytes memory _block_header_rlp,
        bytes memory _proof_rlp
    ) external {
        Verifier.BlockHeader memory block_header = Verifier.parseBlockHeader(
            _block_header_rlp
        );
        require(block_header.hash != bytes32(0)); // dev: invalid blockhash
        require(
            block_header.hash ==
                IBlockHashOracle(BLOCK_HASH_ORACLE).get_block_hash(
                    block_header.number
                )
        ); // dev: blockhash mismatch

        return _verifyGaugeType(_gauges, block_header.stateRootHash, _proof_rlp);
    }

    /// Verify the type of a gauge.
    /// @param _gauges List of gauges to verify the type of.
    /// @param _block_number Number of the block to use state root hash
    /// @param _proof_rlp The state proof of the gauge types.
    function verifyGaugeTypeByStateRoot(
        address[] memory _gauges,
        uint256 _block_number,
        bytes memory _proof_rlp
    ) external {
        bytes32 state_root = IBlockHashOracle(BLOCK_HASH_ORACLE).get_state_root(_block_number);

        return _verifyGaugeType(_gauges, state_root, _proof_rlp);
    }

    function _verifyGaugeType(
        address[] memory gauges,
        bytes32 state_root,
        bytes memory proof_rlp
    ) internal {
        // convert _proof_rlp into a list of `RLPItem`s
        RLPReader.RLPItem[] memory proofs = proof_rlp.toRlpItem().toList();
        require(proofs.length >= 2 && proofs.length - 1 == gauges.length); // dev: invalid number of proofs

        // 0th proof is the account proof for the Gauge Controller contract
        Verifier.Account memory account = Verifier.extractAccountFromProof(
            GAUGE_CONTROLLER_HASH, // position of the account is the hash of its address
            state_root,
            proofs[0].toList()
        );
        require(account.exists); // dev: Gauge Controller account does not exist

        // iterate through each proof and set the gauge type of each gauge
        Verifier.SlotValue memory slot;
        for (uint256 idx = 1; idx < proofs.length; idx++) {
            slot = Verifier.extractSlotValueFromProof(
                keccak256(
                    abi.encode(keccak256(abi.encode(8, gauges[idx - 1])))
                ),
                account.storageRoot,
                proofs[idx].toList()
            );
            require(slot.exists && slot.value != 0);

            IGaugeTypeOracle(GAUGE_TYPE_ORACLE).set_gauge_type(
                gauges[idx - 1],
                slot.value - 1 // the true gauge type is the slot value - 1
            );
        }
    }
}

// SPDX-License-Identifier: Apache-2.0

/*
 * @author Hamdi Allam [email protected]
 * Please reach out with any questions or concerns
 */
pragma solidity >=0.5.10 <=0.8.18;

library RLPReader {
    uint8 constant STRING_SHORT_START = 0x80;
    uint8 constant STRING_LONG_START = 0xb8;
    uint8 constant LIST_SHORT_START = 0xc0;
    uint8 constant LIST_LONG_START = 0xf8;
    uint8 constant WORD_SIZE = 32;

    struct RLPItem {
        uint256 len;
        uint256 memPtr;
    }

    struct Iterator {
        RLPItem item; // Item that's being iterated over.
        uint256 nextPtr; // Position of the next item in the list.
    }

    /*
     * @dev Returns the next element in the iteration. Reverts if it has not next element.
     * @param self The iterator.
     * @return The next element in the iteration.
     */
    function next(Iterator memory self) internal pure returns (RLPItem memory) {
        require(hasNext(self));

        uint256 ptr = self.nextPtr;
        uint256 itemLength = _itemLength(ptr);
        self.nextPtr = ptr + itemLength;

        return RLPItem(itemLength, ptr);
    }

    /*
     * @dev Returns true if the iteration has more elements.
     * @param self The iterator.
     * @return true if the iteration has more elements.
     */
    function hasNext(Iterator memory self) internal pure returns (bool) {
        RLPItem memory item = self.item;
        return self.nextPtr < item.memPtr + item.len;
    }

    /*
     * @param item RLP encoded bytes
     */
    function toRlpItem(bytes memory item) internal pure returns (RLPItem memory) {
        uint256 memPtr;
        assembly {
            memPtr := add(item, 0x20)
        }

        return RLPItem(item.length, memPtr);
    }

    /*
     * @dev Create an iterator. Reverts if item is not a list.
     * @param self The RLP item.
     * @return An 'Iterator' over the item.
     */
    function iterator(RLPItem memory self) internal pure returns (Iterator memory) {
        require(isList(self));

        uint256 ptr = self.memPtr + _payloadOffset(self.memPtr);
        return Iterator(self, ptr);
    }

    /*
     * @param the RLP item.
     */
    function rlpLen(RLPItem memory item) internal pure returns (uint256) {
        return item.len;
    }

    /*
     * @param the RLP item.
     * @return (memPtr, len) pair: location of the item's payload in memory.
     */
    function payloadLocation(RLPItem memory item) internal pure returns (uint256, uint256) {
        uint256 offset = _payloadOffset(item.memPtr);
        uint256 memPtr = item.memPtr + offset;
        uint256 len = item.len - offset; // data length
        return (memPtr, len);
    }

    /*
     * @param the RLP item.
     */
    function payloadLen(RLPItem memory item) internal pure returns (uint256) {
        (, uint256 len) = payloadLocation(item);
        return len;
    }

    /*
     * @param the RLP item containing the encoded list.
     */
    function toList(RLPItem memory item) internal pure returns (RLPItem[] memory) {
        require(isList(item));

        uint256 items = numItems(item);
        RLPItem[] memory result = new RLPItem[](items);

        uint256 memPtr = item.memPtr + _payloadOffset(item.memPtr);
        uint256 dataLen;
        for (uint256 i = 0; i < items; i++) {
            dataLen = _itemLength(memPtr);
            result[i] = RLPItem(dataLen, memPtr);
            memPtr = memPtr + dataLen;
        }

        return result;
    }

    // @return indicator whether encoded payload is a list. negate this function call for isData.
    function isList(RLPItem memory item) internal pure returns (bool) {
        if (item.len == 0) return false;

        uint8 byte0;
        uint256 memPtr = item.memPtr;
        assembly {
            byte0 := byte(0, mload(memPtr))
        }

        if (byte0 < LIST_SHORT_START) return false;
        return true;
    }

    /*
     * @dev A cheaper version of keccak256(toRlpBytes(item)) that avoids copying memory.
     * @return keccak256 hash of RLP encoded bytes.
     */
    function rlpBytesKeccak256(RLPItem memory item) internal pure returns (bytes32) {
        uint256 ptr = item.memPtr;
        uint256 len = item.len;
        bytes32 result;
        assembly {
            result := keccak256(ptr, len)
        }
        return result;
    }

    /*
     * @dev A cheaper version of keccak256(toBytes(item)) that avoids copying memory.
     * @return keccak256 hash of the item payload.
     */
    function payloadKeccak256(RLPItem memory item) internal pure returns (bytes32) {
        (uint256 memPtr, uint256 len) = payloadLocation(item);
        bytes32 result;
        assembly {
            result := keccak256(memPtr, len)
        }
        return result;
    }

    /** RLPItem conversions into data types **/

    // @returns raw rlp encoding in bytes
    function toRlpBytes(RLPItem memory item) internal pure returns (bytes memory) {
        bytes memory result = new bytes(item.len);
        if (result.length == 0) return result;

        uint256 ptr;
        assembly {
            ptr := add(0x20, result)
        }

        copy(item.memPtr, ptr, item.len);
        return result;
    }

    // any non-zero byte except "0x80" is considered true
    function toBoolean(RLPItem memory item) internal pure returns (bool) {
        require(item.len == 1);
        uint256 result;
        uint256 memPtr = item.memPtr;
        assembly {
            result := byte(0, mload(memPtr))
        }

        // SEE Github Issue #5.
        // Summary: Most commonly used RLP libraries (i.e Geth) will encode
        // "0" as "0x80" instead of as "0". We handle this edge case explicitly
        // here.
        if (result == 0 || result == STRING_SHORT_START) {
            return false;
        } else {
            return true;
        }
    }

    function toAddress(RLPItem memory item) internal pure returns (address) {
        // 1 byte for the length prefix
        require(item.len == 21);

        return address(uint160(toUint(item)));
    }

    function toUint(RLPItem memory item) internal pure returns (uint256) {
        require(item.len > 0 && item.len <= 33);

        (uint256 memPtr, uint256 len) = payloadLocation(item);

        uint256 result;
        assembly {
            result := mload(memPtr)

            // shift to the correct location if neccesary
            if lt(len, 32) {
                result := div(result, exp(256, sub(32, len)))
            }
        }

        return result;
    }

    // enforces 32 byte length
    function toUintStrict(RLPItem memory item) internal pure returns (uint256) {
        // one byte prefix
        require(item.len == 33);

        uint256 result;
        uint256 memPtr = item.memPtr + 1;
        assembly {
            result := mload(memPtr)
        }

        return result;
    }

    function toBytes(RLPItem memory item) internal pure returns (bytes memory) {
        require(item.len > 0);

        (uint256 memPtr, uint256 len) = payloadLocation(item);
        bytes memory result = new bytes(len);

        uint256 destPtr;
        assembly {
            destPtr := add(0x20, result)
        }

        copy(memPtr, destPtr, len);
        return result;
    }

    /*
     * Private Helpers
     */

    // @return number of payload items inside an encoded list.
    function numItems(RLPItem memory item) private pure returns (uint256) {
        if (item.len == 0) return 0;

        uint256 count = 0;
        uint256 currPtr = item.memPtr + _payloadOffset(item.memPtr);
        uint256 endPtr = item.memPtr + item.len;
        while (currPtr < endPtr) {
            currPtr = currPtr + _itemLength(currPtr); // skip over an item
            count++;
        }

        return count;
    }

    // @return entire rlp item byte length
    function _itemLength(uint256 memPtr) private pure returns (uint256) {
        uint256 itemLen;
        uint256 byte0;
        assembly {
            byte0 := byte(0, mload(memPtr))
        }

        if (byte0 < STRING_SHORT_START) {
            itemLen = 1;
        } else if (byte0 < STRING_LONG_START) {
            itemLen = byte0 - STRING_SHORT_START + 1;
        } else if (byte0 < LIST_SHORT_START) {
            assembly {
                let byteLen := sub(byte0, 0xb7) // # of bytes the actual length is
                memPtr := add(memPtr, 1) // skip over the first byte

                /* 32 byte word size */
                let dataLen := div(mload(memPtr), exp(256, sub(32, byteLen))) // right shifting to get the len
                itemLen := add(dataLen, add(byteLen, 1))
            }
        } else if (byte0 < LIST_LONG_START) {
            itemLen = byte0 - LIST_SHORT_START + 1;
        } else {
            assembly {
                let byteLen := sub(byte0, 0xf7)
                memPtr := add(memPtr, 1)

                let dataLen := div(mload(memPtr), exp(256, sub(32, byteLen))) // right shifting to the correct length
                itemLen := add(dataLen, add(byteLen, 1))
            }
        }

        return itemLen;
    }

    // @return number of bytes until the data
    function _payloadOffset(uint256 memPtr) private pure returns (uint256) {
        uint256 byte0;
        assembly {
            byte0 := byte(0, mload(memPtr))
        }

        if (byte0 < STRING_SHORT_START) {
            return 0;
        } else if (byte0 < STRING_LONG_START || (byte0 >= LIST_SHORT_START && byte0 < LIST_LONG_START)) {
            return 1;
        } else if (byte0 < LIST_SHORT_START) {
            // being explicit
            return byte0 - (STRING_LONG_START - 1) + 1;
        } else {
            return byte0 - (LIST_LONG_START - 1) + 1;
        }
    }

    /*
     * @param src Pointer to source
     * @param dest Pointer to destination
     * @param len Amount of memory to copy from the source
     */
    function copy(uint256 src, uint256 dest, uint256 len) private pure {
        if (len == 0) return;

        // copy as many word sizes as possible
        for (; len >= WORD_SIZE; len -= WORD_SIZE) {
            assembly {
                mstore(dest, mload(src))
            }

            src += WORD_SIZE;
            dest += WORD_SIZE;
        }

        if (len > 0) {
            // left over bytes. Mask is used to remove unwanted bytes from the word
            uint256 mask = 256**(WORD_SIZE - len) - 1;
            assembly {
                let srcpart := and(mload(src), not(mask)) // zero out src
                let destpart := and(mload(dest), mask) // retrieve the bytes
                mstore(dest, or(destpart, srcpart))
            }
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.18;

import {MerklePatriciaProofVerifier} from "contracts/libs/MerklePatriciaProofVerifier.sol";
import {RLPReader} from "contracts/RLPReader.sol";

/**
 * @title A helper library for verification of Merkle Patricia account and state proofs.
 */
library StateProofVerifier {
    using RLPReader for RLPReader.RLPItem;
    using RLPReader for bytes;

    uint256 constant HEADER_STATE_ROOT_INDEX = 3;
    uint256 constant HEADER_NUMBER_INDEX = 8;
    uint256 constant HEADER_TIMESTAMP_INDEX = 11;

    struct BlockHeader {
        bytes32 hash;
        bytes32 stateRootHash;
        uint256 number;
        uint256 timestamp;
    }

    struct Account {
        bool exists;
        uint256 nonce;
        uint256 balance;
        bytes32 storageRoot;
        bytes32 codeHash;
    }

    struct SlotValue {
        bool exists;
        uint256 value;
    }


    /**
     * @notice Parses block header and verifies its presence onchain within the latest 256 blocks.
     * @param _headerRlpBytes RLP-encoded block header.
     */
    function verifyBlockHeader(bytes memory _headerRlpBytes)
        internal view returns (BlockHeader memory)
    {
        BlockHeader memory header = parseBlockHeader(_headerRlpBytes);
        // ensure that the block is actually in the blockchain
        require(header.hash == blockhash(header.number), "blockhash mismatch");
        return header;
    }


    /**
     * @notice Parses RLP-encoded block header.
     * @param _headerRlpBytes RLP-encoded block header.
     */
    function parseBlockHeader(bytes memory _headerRlpBytes)
        internal pure returns (BlockHeader memory)
    {
        BlockHeader memory result;
        RLPReader.RLPItem[] memory headerFields = _headerRlpBytes.toRlpItem().toList();

        require(headerFields.length > HEADER_TIMESTAMP_INDEX);

        result.stateRootHash = bytes32(headerFields[HEADER_STATE_ROOT_INDEX].toUint());
        result.number = headerFields[HEADER_NUMBER_INDEX].toUint();
        result.timestamp = headerFields[HEADER_TIMESTAMP_INDEX].toUint();
        result.hash = keccak256(_headerRlpBytes);

        return result;
    }


    /**
     * @notice Verifies Merkle Patricia proof of an account and extracts the account fields.
     *
     * @param _addressHash Keccak256 hash of the address corresponding to the account.
     * @param _stateRootHash MPT root hash of the Ethereum state trie.
     */
    function extractAccountFromProof(
        bytes32 _addressHash, // keccak256(abi.encodePacked(address))
        bytes32 _stateRootHash,
        RLPReader.RLPItem[] memory _proof
    )
        internal pure returns (Account memory)
    {
        bytes memory acctRlpBytes = MerklePatriciaProofVerifier.extractProofValue(
            _stateRootHash,
            abi.encodePacked(_addressHash),
            _proof
        );

        Account memory account;

        if (acctRlpBytes.length == 0) {
            return account;
        }

        RLPReader.RLPItem[] memory acctFields = acctRlpBytes.toRlpItem().toList();
        require(acctFields.length == 4);

        account.exists = true;
        account.nonce = acctFields[0].toUint();
        account.balance = acctFields[1].toUint();
        account.storageRoot = bytes32(acctFields[2].toUint());
        account.codeHash = bytes32(acctFields[3].toUint());

        return account;
    }


    /**
     * @notice Verifies Merkle Patricia proof of a slot and extracts the slot's value.
     *
     * @param _slotHash Keccak256 hash of the slot position.
     * @param _storageRootHash MPT root hash of the account's storage trie.
     */
    function extractSlotValueFromProof(
        bytes32 _slotHash,
        bytes32 _storageRootHash,
        RLPReader.RLPItem[] memory _proof
    )
        internal pure returns (SlotValue memory)
    {
        bytes memory valueRlpBytes = MerklePatriciaProofVerifier.extractProofValue(
            _storageRootHash,
            abi.encodePacked(_slotHash),
            _proof
        );

        SlotValue memory value;

        if (valueRlpBytes.length != 0) {
            value.exists = true;
            value.value = valueRlpBytes.toRlpItem().toUint();
        }

        return value;
    }

}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.18;

import {RLPReader} from "contracts/RLPReader.sol";

/**
 * Copied from https://github.com/lidofinance/curve-merkle-oracle/blob/1033b3e/contracts/MerklePatriciaProofVerifier.sol
 * with minor code style-related modifications and solidity version constraints loosened.
 *
 * Copied from https://github.com/lorenzb/proveth/blob/c74b20e/onchain/ProvethVerifier.sol
 * with minor performance and code style-related modifications.
 */
library MerklePatriciaProofVerifier {
    using RLPReader for RLPReader.RLPItem;
    using RLPReader for bytes;

    /// @dev Validates a Merkle-Patricia-Trie proof.
    ///      If the proof proves the inclusion of some key-value pair in the
    ///      trie, the value is returned. Otherwise, i.e. if the proof proves
    ///      the exclusion of a key from the trie, an empty byte array is
    ///      returned.
    /// @param rootHash is the Keccak-256 hash of the root node of the MPT.
    /// @param path is the key of the node whose inclusion/exclusion we are
    ///        proving.
    /// @param stack is the stack of MPT nodes (starting with the root) that
    ///        need to be traversed during verification.
    /// @return value whose inclusion is proved or an empty byte array for
    ///         a proof of exclusion
    function extractProofValue(
        bytes32 rootHash,
        bytes memory path,
        RLPReader.RLPItem[] memory stack
    ) internal pure returns (bytes memory value) {
        bytes memory mptKey = _decodeNibbles(path, 0);
        uint256 mptKeyOffset = 0;

        bytes32 nodeHashHash;
        RLPReader.RLPItem[] memory node;

        RLPReader.RLPItem memory rlpValue;

        if (stack.length == 0) {
            // Root hash of empty Merkle-Patricia-Trie
            require(
                rootHash ==
                    0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421
            );
            return new bytes(0);
        }

        // Traverse stack of nodes starting at root.
        for (uint256 i = 0; i < stack.length; i++) {
            // We use the fact that an rlp encoded list consists of some
            // encoding of its length plus the concatenation of its
            // *rlp-encoded* items.

            // The root node is hashed with Keccak-256 ...
            if (i == 0 && rootHash != stack[i].rlpBytesKeccak256()) {
                revert();
            }
            // ... whereas all other nodes are hashed with the MPT
            // hash function.
            if (i != 0 && nodeHashHash != _mptHashHash(stack[i])) {
                revert();
            }
            // We verified that stack[i] has the correct hash, so we
            // may safely decode it.
            node = stack[i].toList();

            if (node.length == 2) {
                // Extension or Leaf node

                bool isLeaf;
                bytes memory nodeKey;
                (isLeaf, nodeKey) = _merklePatriciaCompactDecode(
                    node[0].toBytes()
                );

                uint256 prefixLength = _sharedPrefixLength(
                    mptKeyOffset,
                    mptKey,
                    nodeKey
                );
                mptKeyOffset += prefixLength;

                if (prefixLength < nodeKey.length) {
                    // Proof claims divergent extension or leaf. (Only
                    // relevant for proofs of exclusion.)
                    // An Extension/Leaf node is divergent iff it "skips" over
                    // the point at which a Branch node should have been had the
                    // excluded key been included in the trie.
                    // Example: Imagine a proof of exclusion for path [1, 4],
                    // where the current node is a Leaf node with
                    // path [1, 3, 3, 7]. For [1, 4] to be included, there
                    // should have been a Branch node at [1] with a child
                    // at 3 and a child at 4.

                    // Sanity check
                    if (i < stack.length - 1) {
                        // divergent node must come last in proof
                        revert();
                    }

                    return new bytes(0);
                }

                if (isLeaf) {
                    // Sanity check
                    if (i < stack.length - 1) {
                        // leaf node must come last in proof
                        revert();
                    }

                    if (mptKeyOffset < mptKey.length) {
                        return new bytes(0);
                    }

                    rlpValue = node[1];
                    return rlpValue.toBytes();
                } else {
                    // extension
                    // Sanity check
                    if (i == stack.length - 1) {
                        // shouldn't be at last level
                        revert();
                    }

                    if (!node[1].isList()) {
                        // rlp(child) was at least 32 bytes. node[1] contains
                        // Keccak256(rlp(child)).
                        nodeHashHash = node[1].payloadKeccak256();
                    } else {
                        // rlp(child) was less than 32 bytes. node[1] contains
                        // rlp(child).
                        nodeHashHash = node[1].rlpBytesKeccak256();
                    }
                }
            } else if (node.length == 17) {
                // Branch node

                if (mptKeyOffset != mptKey.length) {
                    // we haven't consumed the entire path, so we need to look at a child
                    uint8 nibble = uint8(mptKey[mptKeyOffset]);
                    mptKeyOffset += 1;
                    if (nibble >= 16) {
                        // each element of the path has to be a nibble
                        revert();
                    }

                    if (_isEmptyBytesequence(node[nibble])) {
                        // Sanity
                        if (i != stack.length - 1) {
                            // leaf node should be at last level
                            revert();
                        }

                        return new bytes(0);
                    } else if (!node[nibble].isList()) {
                        nodeHashHash = node[nibble].payloadKeccak256();
                    } else {
                        nodeHashHash = node[nibble].rlpBytesKeccak256();
                    }
                } else {
                    // we have consumed the entire mptKey, so we need to look at what's contained in this node.

                    // Sanity
                    if (i != stack.length - 1) {
                        // should be at last level
                        revert();
                    }

                    return node[16].toBytes();
                }
            }
        }
    }

    /// @dev Computes the hash of the Merkle-Patricia-Trie hash of the RLP item.
    ///      Merkle-Patricia-Tries use a weird "hash function" that outputs
    ///      *variable-length* hashes: If the item is shorter than 32 bytes,
    ///      the MPT hash is the item. Otherwise, the MPT hash is the
    ///      Keccak-256 hash of the item.
    ///      The easiest way to compare variable-length byte sequences is
    ///      to compare their Keccak-256 hashes.
    /// @param item The RLP item to be hashed.
    /// @return Keccak-256(MPT-hash(item))
    function _mptHashHash(
        RLPReader.RLPItem memory item
    ) private pure returns (bytes32) {
        if (item.len < 32) {
            return item.rlpBytesKeccak256();
        } else {
            return keccak256(abi.encodePacked(item.rlpBytesKeccak256()));
        }
    }

    function _isEmptyBytesequence(
        RLPReader.RLPItem memory item
    ) private pure returns (bool) {
        if (item.len != 1) {
            return false;
        }
        uint8 b;
        uint256 memPtr = item.memPtr;
        assembly {
            b := byte(0, mload(memPtr))
        }
        return b == 0x80 /* empty byte string */;
    }

    function _merklePatriciaCompactDecode(
        bytes memory compact
    ) private pure returns (bool isLeaf, bytes memory nibbles) {
        require(compact.length > 0);
        uint256 first_nibble = (uint8(compact[0]) >> 4) & 0xF;
        uint256 skipNibbles;
        if (first_nibble == 0) {
            skipNibbles = 2;
            isLeaf = false;
        } else if (first_nibble == 1) {
            skipNibbles = 1;
            isLeaf = false;
        } else if (first_nibble == 2) {
            skipNibbles = 2;
            isLeaf = true;
        } else if (first_nibble == 3) {
            skipNibbles = 1;
            isLeaf = true;
        } else {
            // Not supposed to happen!
            revert();
        }
        return (isLeaf, _decodeNibbles(compact, skipNibbles));
    }

    function _decodeNibbles(
        bytes memory compact,
        uint256 skipNibbles
    ) private pure returns (bytes memory nibbles) {
        require(compact.length > 0);

        uint256 length = compact.length * 2;
        require(skipNibbles <= length);
        length -= skipNibbles;

        nibbles = new bytes(length);
        uint256 nibblesLength = 0;

        for (uint256 i = skipNibbles; i < skipNibbles + length; i += 1) {
            if (i % 2 == 0) {
                nibbles[nibblesLength] = bytes1(
                    (uint8(compact[i / 2]) >> 4) & 0xF
                );
            } else {
                nibbles[nibblesLength] = bytes1(
                    (uint8(compact[i / 2]) >> 0) & 0xF
                );
            }
            nibblesLength += 1;
        }

        assert(nibblesLength == nibbles.length);
    }

    function _sharedPrefixLength(
        uint256 xsOffset,
        bytes memory xs,
        bytes memory ys
    ) private pure returns (uint256) {
        uint256 i;
        for (i = 0; i + xsOffset < xs.length && i < ys.length; i++) {
            if (xs[i + xsOffset] != ys[i]) {
                return i;
            }
        }
        return i;
    }
}

{
  "evmVersion": "paris",
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "libraries": {
    "ScrvusdProver.sol": {}
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_block_hash_oracle","type":"address"},{"internalType":"address","name":"_gauge_type_oracle","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"BLOCK_HASH_ORACLE","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GAUGE_TYPE_ORACLE","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_gauges","type":"address[]"},{"internalType":"bytes","name":"_block_header_rlp","type":"bytes"},{"internalType":"bytes","name":"_proof_rlp","type":"bytes"}],"name":"verifyGaugeTypeByBlockHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_gauges","type":"address[]"},{"internalType":"uint256","name":"_block_number","type":"uint256"},{"internalType":"bytes","name":"_proof_rlp","type":"bytes"}],"name":"verifyGaugeTypeByStateRoot","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

541:3517:3:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;842:42;;;;;;;;-1:-1:-1;;;;;178:32:4;;;160:51;;148:2;133:18;842:42:3;;;;;;;2269:319;;;;;;:::i;:::-;;:::i;:::-;;890:42;;;;;1375:657;;;;;;:::i;:::-;;:::i;2269:319::-;2449:65;;-1:-1:-1;;;2449:65:3;;;;;3626:25:4;;;2428:18:3;;2466:17;-1:-1:-1;;;;;2449:50:3;;;;3599:18:4;;2449:65:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2428:86;;2532:49;2549:7;2558:10;2570;2532:16;:49::i;:::-;2525:56;2269:319;;;:::o;1375:657::-;1543:40;1586:66;1625:17;1586:25;:66::i;:::-;1670:17;;1543:109;;-1:-1:-1;1662:40:3;;;;;;1868:19;;;;;1796:109;;-1:-1:-1;;;1796:109:3;;;;;3626:25:4;;;;1813:17:3;-1:-1:-1;;;;;1796:50:3;;;;3599:18:4;;1796:109:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1759:17;;:146;1738:177;;;;;;1960:65;1977:7;1986:12;:26;;;2014:10;2594:1462;2794:33;2830:30;:21;:9;-1:-1:-1;;;;;;;;;;;;;;;;;1701:28:0;;;;;;;;1709:11;;1701:28;;1659:15;;;1701:28;;;;;;;;1515:221;2830:21:3;:28;:30::i;:::-;2794:66;;2895:1;2878:6;:13;:18;;:56;;;;;2921:6;:13;2916:1;2900:6;:13;:17;;;;:::i;:::-;:34;2878:56;2870:65;;;;;;800:34;;-1:-1:-1;;;800:34:3;;;4245:66:4;3055:31:3;;3089:187;;4327:12:4;;800:34:3;;;;;;;;;;;;790:45;;;;;;3224:10;3248:18;:6;3255:1;3248:9;;;;;;;;:::i;:::-;;;;;;;:16;:18::i;:::-;3089:32;:187::i;:::-;3294:14;;3055:221;;-1:-1:-1;3286:23:3;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;3502:1:3;3483:567;3511:6;:13;3505:3;:19;3483:567;;;3554:243;3669:1;3672:6;3679:7;3685:1;3679:3;:7;:::i;:::-;3672:15;;;;;;;;:::i;:::-;;;;;;;3658:30;;;;;;;;4692:4:4;4680:17;;;;4662:36;;-1:-1:-1;;;;;4734:32:4;4729:2;4714:18;;4707:60;4650:2;4635:18;;4482:291;3658:30:3;;;;-1:-1:-1;;3658:30:3;;;;;;;;;3648:41;;3658:30;3648:41;;;;3637:53;;;3626:25:4;3599:18;3637:53:3;;;;;;;;;;;;3606:102;;;;;;3726:7;:19;;;3763:20;:6;3770:3;3763:11;;;;;;;;:::i;:20::-;3554:34;:243::i;:::-;3819:11;;3547:250;;-1:-1:-1;3819:30:3;;;;-1:-1:-1;3834:10:3;;;;:15;;3819:30;3811:39;;;;;;-1:-1:-1;;;;;3882:17:3;3865:50;;3933:6;3940:7;3946:1;3940:3;:7;:::i;:::-;3933:15;;;;;;;;:::i;:::-;;;;;;;3979:1;3966:4;:10;;;:14;;;;:::i;:::-;3865:174;;-1:-1:-1;;;;;;3865:174:3;;;;;;;-1:-1:-1;;;;;5152:32:4;;;3865:174:3;;;5134:51:4;5201:18;;;5194:34;5107:18;;3865:174:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3526:5;;;;;:::i;:::-;;;;3483:567;;;;2728:1328;;;2594:1462;;;:::o;1570:610:2:-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1701:28:0;;;;;;;;1709:11;;1701:28;;1659:15;;;1701:28;;;;-1:-1:-1;;;;;1768:36:2;;2830:28:3;:30::i;1768:36:2:-;1726:78;;544:2;1823:12;:19;:44;1815:53;;;;;;1910:46;:12;449:1;1910:37;;;;;;;;:::i;:::-;;;;;;;:44;:46::i;:::-;1879:20;;;:78;1983:33;;:42;;:12;;495:1;;1983:33;;;;;;:::i;:42::-;1967:13;;;:58;2054:36;;:45;;:12;;544:2;;2054:36;;;;;;:::i;:45::-;2035:16;;;:64;-1:-1:-1;2123:26:2;;;;;;;;;;2109:40;;-1:-1:-1;2035:6:2;1570:610::o;2948:519:0:-;3008:16;3044:12;3051:4;3044:6;:12::i;:::-;3036:21;;;;;;3068:13;3084:14;3093:4;3084:8;:14::i;:::-;3068:30;;3108:23;3148:5;3134:20;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;3134:20:0;;;;;;;;;;;;;;;;3108:46;;3165:14;3196:27;3211:4;:11;;;3196:14;:27::i;:::-;3182:4;:11;;;:41;;;;:::i;:::-;3165:58;-1:-1:-1;3233:15:0;;3258:179;3282:5;3278:1;:9;3258:179;;;3318:19;3330:6;3318:11;:19::i;:::-;3308:29;;3363:24;;;;;;;;3371:7;3363:24;;;;3380:6;3363:24;;;3351:6;3358:1;3351:9;;;;;;;;:::i;:::-;;;;;;;;;;:36;3410:16;3419:7;3410:6;:16;:::i;:::-;3401:25;-1:-1:-1;3289:3:0;;;;:::i;:::-;;;;3258:179;;;-1:-1:-1;3454:6:0;;2948:519;-1:-1:-1;;;;;2948:519:0:o;2461:942:2:-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2706:25:2;2734:147;2793:14;2838:12;2821:30;;;;;;5638:19:4;;5682:2;5673:12;;5509:182;2821:30:2;;;;;;;;;;;;;2865:6;2734:45;:147::i;:::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2706:175:2;;-1:-1:-1;2929:12:2;:19;2952:1;2929:24;2925:69;;2976:7;-1:-1:-1;2969:14:2;;-1:-1:-1;2969:14:2;2925:69;3004:37;3044:33;:24;:12;-1:-1:-1;;;;;;;;;;;;;;;;;1701:28:0;;;;;;;;1709:11;;1701:28;;1659:15;;;1701:28;;;;;;;;1515:221;3044:33:2;3004:73;;3095:10;:17;3116:1;3095:22;3087:31;;;;;;3146:4;3129:21;;3176:13;;:22;;:10;;3129:14;;3176:13;;;;:::i;:22::-;3160:13;;;:38;3226:13;;:22;;:10;;3237:1;;3226:13;;;;;;:::i;:22::-;3208:15;;;:40;3288:13;;:22;;:10;;3299:1;;3288:13;;;;;;:::i;:22::-;3258:19;;;:53;3348:13;;:22;;:10;;3359:1;;3348:13;;;;;;:::i;:22::-;3321:16;;;:50;-1:-1:-1;3321:7:2;-1:-1:-1;;2461:942:2;;;;;;:::o;3657:593::-;-1:-1:-1;;;;;;;;;;;;;;;;;3865:26:2;3894:146;3953:16;4000:9;3983:27;;;;;;5638:19:4;;5682:2;5673:12;;5509:182;3894:146:2;-1:-1:-1;;;;;;;;;;;;;;;;;3865:175:2;;-1:-1:-1;4088:20:2;;:25;4084:137;;4144:4;4129:19;;-1:-1:-1;;;;;;;;;;;;;;;;;1701:28:0;;;;;;;;1709:11;;1701:28;;1659:15;;;1701:28;;;;4176:34:2;;:32;:34::i;:::-;4162:11;;;:48;4084:137;4238:5;3657:593;-1:-1:-1;;;;;3657:593:2:o;6051:467:0:-;6138:8;;6111:7;;6138:12;;;;:30;;-1:-1:-1;6154:8:0;;6166:2;-1:-1:-1;6154:14:0;6138:30;6130:39;;;;;;6181:14;6197:11;6212:21;6228:4;6212:15;:21::i;:::-;6301:13;;6180:53;;-1:-1:-1;6180:53:0;-1:-1:-1;6397:2:0;6389:11;;6386:92;;;6454:2;6450:12;;;6445:3;6441:22;6429:35;;6386:92;6505:6;6051:467;-1:-1:-1;;;;6051:467:0:o;3571:321::-;3651:8;;3631:4;;3651:13;;3647:31;;-1:-1:-1;3673:5:0;;3571:321;-1:-1:-1;3571:321:0:o;3647:31::-;3727:11;;;;3788:13;;3689:11;3780:22;;330:4;3826:24;;3822:42;;;-1:-1:-1;3859:5:0;;3571:321;-1:-1:-1;;;3571:321:0:o;3822:42::-;-1:-1:-1;3881:4:0;;3571:321;-1:-1:-1;;;3571:321:0:o;7346:424::-;7430:8;;7407:7;;7430:13;;7426:27;;-1:-1:-1;7452:1:0;;7346:424;-1:-1:-1;7346:424:0:o;7426:27::-;7464:13;7491:15;7523:27;7538:4;:11;;;7523:14;:27::i;:::-;7509:4;:11;;;:41;;;;:::i;:::-;7491:59;;7560:14;7591:4;:8;;;7577:4;:11;;;:22;;;;:::i;:::-;7560:39;;7609:132;7626:6;7616:7;:16;7609:132;;;7668:20;7680:7;7668:11;:20::i;:::-;7658:30;;:7;:30;:::i;:::-;7648:40;-1:-1:-1;7723:7:0;;;;:::i;:::-;;;;7609:132;;;-1:-1:-1;7758:5:0;;7346:424;-1:-1:-1;;;7346:424:0:o;9134:581::-;9278:13;;9196:7;;9270:22;;241:4;9316:26;;9312:397;;;-1:-1:-1;9365:1:0;;9134:581;-1:-1:-1;;9134:581:0:o;9312:397::-;286:4;9387:25;;;:83;;-1:-1:-1;330:4:0;9417:25;;;;;:52;;-1:-1:-1;373:4:0;9446:23;;9417:52;9383:326;;;-1:-1:-1;9493:1:0;;9134:581;-1:-1:-1;;9134:581:0:o;9383:326::-;330:4;9515:24;;9511:198;;;9601:21;9621:1;286:4;9601:21;:::i;:::-;9592:31;;;;:5;:31;:::i;:::-;:35;;9626:1;9592:35;:::i;9511:198::-;9674:19;9692:1;373:4;9674:19;:::i;7819:1263::-;7985:13;;7878:7;;;;7977:22;;241:4;8023:26;;8019:1032;;;8075:1;8065:11;;8019:1032;;;286:4;8097:25;;8093:958;;;8148:26;241:4;8148:5;:26;:::i;:::-;:30;;8177:1;8148:30;:::i;:::-;8138:40;;8093:958;;;330:4;8199:24;;8195:856;;;8292:4;8285:5;8281:16;8371:1;8363:6;8359:14;8349:24;;8510:7;8506:2;8502:16;8497:3;8493:26;8484:6;8478:13;8474:46;8607:1;8598:7;8594:15;8585:7;8581:29;8570:40;;;;8195:856;;;373:4;8644:23;;8640:411;;;8693:24;330:4;8693:5;:24;:::i;8640:411::-;8805:4;8798:5;8794:16;8849:1;8841:6;8837:14;8827:24;;8920:7;8916:2;8912:16;8907:3;8903:26;8894:6;8888:13;8884:46;9024:1;9015:7;9011:15;9002:7;8998:29;8987:40;;;;8640:411;-1:-1:-1;9068:7:0;7819:1263;-1:-1:-1;;7819:1263:0:o;1330:5641:1:-;1481:18;1511:19;1533:23;1548:4;1554:1;1533:14;:23::i;:::-;1511:45;;1566:20;1601;1631:31;1673:33;-1:-1:-1;;;;;;;;;;;;;;;;;;;1673:33:1;1721:5;:12;1737:1;1721:17;1717:273;;1866:66;1834:98;;1809:137;;;;;;-1:-1:-1;;1967:12:1;;;1977:1;1967:12;;;;;;;;;-1:-1:-1;1960:19:1;;-1:-1:-1;;;1960:19:1;1717:273;2058:9;2053:4912;2077:5;:12;2073:1;:16;2053:4912;;;2351:6;;:50;;;;;2373:28;:5;2379:1;2373:8;;;;;;;;:::i;:::-;;;;;;;4158:11:0;;;;4193:8;;4268:19;;;4054:272;2373:28:1;2361:8;:40;;2351:50;2347:97;;;2421:8;;;2347:97;2558:6;;;;;:48;;;2584:22;2597:5;2603:1;2597:8;;;;;;;;:::i;:::-;;;;;;;2584:12;:22::i;:::-;2568:12;:38;;2558:48;2554:95;;;2626:8;;;2554:95;2775:17;:5;2781:1;2775:8;;;;;;;;:::i;:17::-;2768:24;;2811:4;:11;2826:1;2811:16;2807:4148;;2890:11;2919:20;2977:85;3027:17;:4;3032:1;3027:7;;;;;;;;:::i;:::-;;;;;;;:15;:17::i;:::-;2977:28;:85::i;:::-;2957:105;;-1:-1:-1;2957:105:1;-1:-1:-1;3081:20:1;3104:128;3145:12;3179:6;2957:105;3104:19;:128::i;:::-;3081:151;-1:-1:-1;3250:28:1;3081:151;3250:28;;:::i;:::-;;;3316:7;:14;3301:12;:29;3297:994;;;4105:1;4090:5;:12;:16;;;;:::i;:::-;4086:1;:20;4082:149;;;4200:8;;;4082:149;4270:1;4260:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4260:12:1;;4253:19;;;;;;;;;;;;;3297:994;4313:6;4309:1175;;;4402:1;4387:5;:12;:16;;;;:::i;:::-;4383:1;:20;4379:144;;;4492:8;;;4379:144;4564:6;:13;4549:12;:28;4545:102;;;4622:1;4612:12;;4545:102;4680:4;4685:1;4680:7;;;;;;;;:::i;:::-;;;;;;;4669:18;;4716;:8;:16;:18::i;:::-;4709:25;;;;;;;;;;;;;4309:1175;4874:1;4859:5;:12;:16;;;;:::i;:::-;4854:1;:21;4850:138;;4957:8;;;4850:138;5015:16;:4;5020:1;5015:7;;;;;;;;:::i;:::-;;;;;;;:14;:16::i;:::-;5010:456;;5202:26;:4;5207:1;5202:7;;;;;;;;:::i;:::-;;;;;;;:24;:26::i;:::-;5187:41;;5010:456;;;5416:27;:4;5421:1;5416:7;;;;;;;;:::i;:27::-;5401:42;;5010:456;2829:2669;;;2807:4148;;;5508:4;:11;5523:2;5508:17;5504:1451;;5597:6;:13;5581:12;:29;5577:1364;;5724:12;5745:6;5752:12;5745:20;;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1;5788:17:1;5804:1;5788:17;;:::i;:::-;;;5841:2;5831:6;:12;;;5827:146;;5942:8;;;5827:146;5999:34;6020:4;6025:6;6020:12;;;;;;;;;;:::i;:::-;;;;;;;5999:20;:34::i;:::-;5995:556;;;6119:1;6104:5;:12;:16;;;;:::i;:::-;6099:1;:21;6095:157;;6217:8;;;6095:157;-1:-1:-1;;6285:12:1;;;6295:1;6285:12;;;;;;;;;-1:-1:-1;6278:19:1;;-1:-1:-1;;;;;6278:19:1;5995:556;6331:21;:4;6336:6;6331:12;;;;;;;;;;:::i;:21::-;6326:225;;6395:31;:4;6400:6;6395:12;;;;;;;;;;:::i;:31::-;6380:46;;6326:225;;;6496:32;:4;6501:6;6496:12;;;;;;;;;;:::i;:32::-;6481:47;;6326:225;5612:957;5577:1364;;;6764:1;6749:5;:12;:16;;;;:::i;:::-;6744:1;:21;6740:135;;6844:8;;;6740:135;6904:18;:4;6909:2;6904:8;;;;;;;;:::i;:18::-;6897:25;;;;;;;;;;5577:1364;2091:3;;;;:::i;:::-;;;;2053:4912;;;;1501:5470;;;;;1330:5641;;;;;:::o;2392:281:0:-;2461:7;2470;2489:14;2506:27;2521:4;:11;;;2506:14;:27::i;:::-;2489:44;;2543:14;2574:6;2560:4;:11;;;:20;;;;:::i;:::-;2543:37;;2590:11;2615:6;2604:4;:8;;;:17;;;;:::i;:::-;2654:6;;2590:31;;-1:-1:-1;2392:281:0;;-1:-1:-1;;;;2392:281:0:o;8980:845:1:-;9091:20;9148:1;9131:7;:14;:18;9123:27;;;;;;9161:14;9178:7;:14;9195:1;9178:18;;;;:::i;:::-;9161:35;;9229:6;9214:11;:21;;9206:30;;;;;;9246:21;9256:11;9246:21;;:::i;:::-;;;9298:6;9288:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9288:17:1;-1:-1:-1;9278:27:1;-1:-1:-1;9315:21:1;9368:11;9351:418;9385:20;9399:6;9385:11;:20;:::i;:::-;9381:1;:24;9351:418;;;9433:5;9437:1;9433;:5;:::i;:::-;9442:1;9433:10;9429:298;;9542:1;9523:7;9531:5;9535:1;9531;:5;:::i;:::-;9523:14;;;;;;;;:::i;:::-;;;;;;;;;9517:21;;:26;;;;9547:3;9516:34;9488:80;;9463:7;9471:13;9463:22;;;;;;;;:::i;:::-;;;;:105;-1:-1:-1;;;;;9463:105:1;;;;;;;;;9429:298;;;9686:1;9667:7;9675:5;9679:1;9675;:5;:::i;:::-;9667:14;;;;;;;;:::i;:::-;;;;;;;;;9661:21;;:26;;;;9691:3;9660:34;9632:80;;9607:7;9615:13;9607:22;;;;;;;;:::i;:::-;;;;:105;-1:-1:-1;;;;;9607:105:1;;;;;;;;;9429:298;9740:18;9757:1;9740:18;;:::i;:::-;;-1:-1:-1;9407:6:1;9412:1;9407:6;;:::i;:::-;;;9351:418;;;;9803:7;:14;9786:13;:31;9779:39;;;;:::i;:::-;9113:712;;8980:845;;;;:::o;7536:280::-;7625:7;7659:2;7648:4;:8;;;:13;7644:166;;;4158:11:0;;;;4193:8;;4268:19;;7684:24:1;7677:31;7536:280;-1:-1:-1;;7536:280:1:o;7644:166::-;4158:11:0;;;;4193:8;;4268:19;;7756:42:1;;;;;;5638:19:4;;5682:2;5673:12;;5509:182;7756:42:1;;;;;;;;;;;;;7746:53;;;;;;7739:60;;7536:280;;;:::o;6859:379:0:-;6952:8;;6920:12;;6944:21;;;;;;6977:14;6993:11;7008:21;7024:4;7008:15;:21::i;:::-;6976:53;;;;7039:19;7071:3;7061:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7061:14:0;-1:-1:-1;7039:36:0;-1:-1:-1;7149:4:0;7145:17;;7182:26;7187:6;7145:17;7204:3;7182:4;:26::i;:::-;-1:-1:-1;7225:6:0;6859:379;-1:-1:-1;;;;6859:379:0:o;8177:797:1:-;8273:11;8286:20;8343:1;8326:7;:14;:18;8318:27;;;;;;8355:20;8400:1;8385:7;8393:1;8385:10;;;;;;;;:::i;:::-;;;;;;;;8379:22;;8405:3;8378:30;;-1:-1:-1;8418:19:1;8451:17;;;8447:458;;-1:-1:-1;8522:5:1;;-1:-1:-1;8498:1:1;8447:458;;;8548:12;8564:1;8548:17;8544:361;;-1:-1:-1;8619:5:1;;-1:-1:-1;8595:1:1;8544:361;;;8645:12;8661:1;8645:17;8641:264;;-1:-1:-1;8716:4:1;;-1:-1:-1;8692:1:1;8641:264;;;8741:12;8757:1;8741:17;8737:168;;-1:-1:-1;8788:1:1;;-1:-1:-1;8788:1:1;8737:168;8922:6;8930:36;8945:7;8954:11;8930:14;:36::i;:::-;8914:53;;;;;;8177:797;;;:::o;9831:351::-;9964:7;;10002:156;10029:9;;10014:12;10018:8;10014:1;:12;:::i;:::-;:24;:41;;;;;10046:2;:9;10042:1;:13;10014:41;10002:156;;;10100:2;10103:1;10100:5;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;;10100:5:1;10080:2;10083:12;10087:8;10083:1;:12;:::i;:::-;10080:16;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;;10080:16:1;:25;10076:72;;10132:1;-1:-1:-1;10125:8:1;;10076:72;10057:3;;;;:::i;:::-;;;;10002:156;;4484:270:0;4554:7;4574:14;4590:11;4605:21;4621:4;4605:15;:21::i;:::-;4693:22;;;4484:270;-1:-1:-1;;;;4484:270:0:o;7822:349:1:-;7939:8;;7919:4;;7951:1;7939:13;7935:56;;-1:-1:-1;7975:5:1;;7822:349;-1:-1:-1;7822:349:1:o;7935:56::-;-1:-1:-1;8034:11:1;;;8091:13;8000:7;8083:22;8136:4;8131:9;;7822:349::o;9873:768:0:-;9954:3;9961:1;9954:8;9950:21;;9873:768;;;:::o;9950:21::-;410:2;10035:16;;10028:194;;10125:10;;10112:24;;10164:16;410:2;10131:3;10164:16;:::i;:::-;;-1:-1:-1;10194:17:0;410:2;10194:17;;:::i;:::-;;-1:-1:-1;10053:16:0;410:2;10053:16;;:::i;:::-;;;10028:194;;;10236:7;;10232:403;;10343:12;10383:1;10364:15;10376:3;410:2;10364:15;:::i;:::-;10358:22;;:3;:22;:::i;:::-;:26;;;;:::i;:::-;10444:10;;10519:11;;10515:22;;10456:9;;10440:26;10589:21;10576:35;;-1:-1:-1;10232:403:0;9873:768;;;:::o;222:127:4:-;283:10;278:3;274:20;271:1;264:31;314:4;311:1;304:15;338:4;335:1;328:15;354:275;425:2;419:9;490:2;471:13;;-1:-1:-1;;467:27:4;455:40;;525:18;510:34;;546:22;;;507:62;504:88;;;572:18;;:::i;:::-;608:2;601:22;354:275;;-1:-1:-1;354:275:4:o;634:896::-;688:5;741:3;734:4;726:6;722:17;718:27;708:55;;759:1;756;749:12;708:55;795:6;782:20;821:4;844:18;840:2;837:26;834:52;;;866:18;;:::i;:::-;912:2;909:1;905:10;935:28;959:2;955;951:11;935:28;:::i;:::-;997:15;;;1067;;;1063:24;;;1028:12;;;;1099:15;;;1096:35;;;1127:1;1124;1117:12;1096:35;1163:2;1155:6;1151:15;1140:26;;1175:326;1191:6;1186:3;1183:15;1175:326;;;1258:17;;-1:-1:-1;;;;;1308:31:4;;1298:42;;1288:140;;1382:1;1411:2;1407;1400:14;1288:140;1441:18;;1208:12;;;;1479;;;;1175:326;;;1519:5;634:896;-1:-1:-1;;;;;;;634:896:4:o;1535:530::-;1577:5;1630:3;1623:4;1615:6;1611:17;1607:27;1597:55;;1648:1;1645;1638:12;1597:55;1684:6;1671:20;1710:18;1706:2;1703:26;1700:52;;;1732:18;;:::i;:::-;1776:55;1819:2;1800:13;;-1:-1:-1;;1796:27:4;1825:4;1792:38;1776:55;:::i;:::-;1856:2;1847:7;1840:19;1902:3;1895:4;1890:2;1882:6;1878:15;1874:26;1871:35;1868:55;;;1919:1;1916;1909:12;1868:55;1984:2;1977:4;1969:6;1965:17;1958:4;1949:7;1945:18;1932:55;2032:1;2007:16;;;2025:4;2003:27;1996:38;;;;2011:7;1535:530;-1:-1:-1;;;1535:530:4:o;2070:635::-;2181:6;2189;2197;2250:2;2238:9;2229:7;2225:23;2221:32;2218:52;;;2266:1;2263;2256:12;2218:52;2306:9;2293:23;2335:18;2376:2;2368:6;2365:14;2362:34;;;2392:1;2389;2382:12;2362:34;2415:61;2468:7;2459:6;2448:9;2444:22;2415:61;:::i;:::-;2405:71;;2523:2;2512:9;2508:18;2495:32;2485:42;;2580:2;2569:9;2565:18;2552:32;2536:48;;2609:2;2599:8;2596:16;2593:36;;;2625:1;2622;2615:12;2593:36;;2648:51;2691:7;2680:8;2669:9;2665:24;2648:51;:::i;:::-;2638:61;;;2070:635;;;;;:::o;2710:765::-;2830:6;2838;2846;2899:2;2887:9;2878:7;2874:23;2870:32;2867:52;;;2915:1;2912;2905:12;2867:52;2955:9;2942:23;2984:18;3025:2;3017:6;3014:14;3011:34;;;3041:1;3038;3031:12;3011:34;3064:61;3117:7;3108:6;3097:9;3093:22;3064:61;:::i;:::-;3054:71;;3178:2;3167:9;3163:18;3150:32;3134:48;;3207:2;3197:8;3194:16;3191:36;;;3223:1;3220;3213:12;3191:36;3246:51;3289:7;3278:8;3267:9;3263:24;3246:51;:::i;:::-;3236:61;;3350:2;3339:9;3335:18;3322:32;3306:48;;3379:2;3369:8;3366:16;3363:36;;;3395:1;3392;3385:12;3662:184;3732:6;3785:2;3773:9;3764:7;3760:23;3756:32;3753:52;;;3801:1;3798;3791:12;3753:52;-1:-1:-1;3824:16:4;;3662:184;-1:-1:-1;3662:184:4:o;3851:127::-;3912:10;3907:3;3903:20;3900:1;3893:31;3943:4;3940:1;3933:15;3967:4;3964:1;3957:15;3983:128;4050:9;;;4071:11;;;4068:37;;;4085:18;;:::i;4350:127::-;4411:10;4406:3;4402:20;4399:1;4392:31;4442:4;4439:1;4432:15;4466:4;4463:1;4456:15;5239:135;5278:3;5299:17;;;5296:43;;5319:18;;:::i;:::-;-1:-1:-1;5366:1:4;5355:13;;5239:135::o;5379:125::-;5444:9;;;5465:10;;;5462:36;;;5478:18;;:::i;5696:151::-;5786:4;5779:12;;;5765;;;5761:31;;5804:14;;5801:40;;;5821:18;;:::i;5852:168::-;5925:9;;;5956;;5973:15;;;5967:22;;5953:37;5943:71;;5994:18;;:::i;6025:127::-;6086:10;6081:3;6077:20;6074:1;6067:31;6117:4;6114:1;6107:15;6141:4;6138:1;6131:15;6157:112;6189:1;6215;6205:35;;6220:18;;:::i;:::-;-1:-1:-1;6254:9:4;;6157:112::o;6274:120::-;6314:1;6340;6330:35;;6345:18;;:::i;:::-;-1:-1:-1;6379:9:4;;6274:120::o;6399:127::-;6460:10;6455:3;6451:20;6448:1;6441:31;6491:4;6488:1;6481:15;6515:4;6512:1;6505:15;6531:422;6620:1;6663:5;6620:1;6677:270;6698:7;6688:8;6685:21;6677:270;;;6757:4;6753:1;6749:6;6745:17;6739:4;6736:27;6733:53;;;6766:18;;:::i;:::-;6816:7;6806:8;6802:22;6799:55;;;6836:16;;;;6799:55;6915:22;;;;6875:15;;;;6677:270;;;6681:3;6531:422;;;;;:::o;6958:806::-;7007:5;7037:8;7027:80;;-1:-1:-1;7078:1:4;7092:5;;7027:80;7126:4;7116:76;;-1:-1:-1;7163:1:4;7177:5;;7116:76;7208:4;7226:1;7221:59;;;;7294:1;7289:130;;;;7201:218;;7221:59;7251:1;7242:10;;7265:5;;;7289:130;7326:3;7316:8;7313:17;7310:43;;;7333:18;;:::i;:::-;-1:-1:-1;;7389:1:4;7375:16;;7404:5;;7201:218;;7503:2;7493:8;7490:16;7484:3;7478:4;7475:13;7471:36;7465:2;7455:8;7452:16;7447:2;7441:4;7438:12;7434:35;7431:77;7428:159;;;-1:-1:-1;7540:19:4;;;7572:5;;7428:159;7619:34;7644:8;7638:4;7619:34;:::i;:::-;7689:6;7685:1;7681:6;7677:19;7668:7;7665:32;7662:58;;;7700:18;;:::i;:::-;7738:20;;6958:806;-1:-1:-1;;;6958:806:4:o;7769:131::-;7829:5;7858:36;7885:8;7879:4;7858:36;:::i

ipfs://f8641a0db02aba8037f9bb8e97a9796f1229180d7bc5c20442a86e9f6748575e