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);
}

interface IScrvusdOracle {
    function update_price(
        uint256[2 + 6] memory _parameters
    ) external returns (uint256);
}

/// @title Scrvusd Prover
/// @author Curve Finance
contract ScrvusdProver {
    using RLPReader for bytes;
    using RLPReader for RLPReader.RLPItem;

    address constant SCRVUSD =
        0x0655977FEb2f289A4aB78af67BAB0d17aAb84367;
    bytes32 constant SCRVUSD_HASH =
        keccak256(abi.encodePacked(SCRVUSD));

    address public immutable BLOCK_HASH_ORACLE;
    address public immutable SCRVUSD_ORACLE;

    uint256 constant PARAM_CNT = 2 + 6;
    uint256 constant PROOF_CNT = PARAM_CNT - 1;  // -1 for timestamp obtained from block header

    constructor(address _block_hash_oracle, address _scrvusd_oracle) {
        BLOCK_HASH_ORACLE = _block_hash_oracle;
        SCRVUSD_ORACLE = _scrvusd_oracle;
    }

    /// Prove parameters of scrvUSD rate.
    /// @param _block_header_rlp The block header of any block.
    /// @param _proof_rlp The state proof of the parameters.
    function prove(
        bytes memory _block_header_rlp,
        bytes memory _proof_rlp
    ) external returns (uint256) {
        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

        // convert _proof_rlp into a list of `RLPItem`s
        RLPReader.RLPItem[] memory proofs = _proof_rlp.toRlpItem().toList();
        require(proofs.length == 1 + PROOF_CNT); // dev: invalid number of proofs

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

        // iterate over proofs
        uint256[PROOF_CNT] memory PARAM_SLOTS = [
            // Assets parameters
            uint256(21),  // total_debt
            22,  // total_idle

            // Supply parameters
            20,  // totalSupply
            38,  // full_profit_unlock_date
            39,  // profit_unlocking_rate
            40,  // last_profit_update
            uint256(keccak256(abi.encode(18, SCRVUSD)))  // balance_of_self
            // ts from block header
        ];
        uint256[PARAM_CNT] memory params;
        Verifier.SlotValue memory slot;
        uint256 i = 0;
        for (uint256 idx = 1; idx < 1 + PROOF_CNT; idx++) {
            slot = Verifier.extractSlotValueFromProof(
                keccak256(abi.encode(PARAM_SLOTS[i])),
                account.storageRoot,
                proofs[idx].toList()
            );
            // Some slots may not be used => not exist, e.g. total_idle
            // require(slot.exists);

            params[i] = slot.value;
            i++;
        }
        params[i] = block_header.timestamp;
        return IScrvusdOracle(SCRVUSD_ORACLE).update_price(params);
    }
}

// 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":"_scrvusd_oracle","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"BLOCK_HASH_ORACLE","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SCRVUSD_ORACLE","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"_block_header_rlp","type":"bytes"},{"internalType":"bytes","name":"_proof_rlp","type":"bytes"}],"name":"prove","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000988d1037e9608b21050a8efba0c6c45e01a3bce7000000000000000000000000c772063ce3e622b458b706dd2e36309418a1ae42

-----Decoded View---------------
Arg [0] : _block_hash_oracle (address): 0x988d1037e9608B21050A8EFba0c6C45e01A3Bce7
Arg [1] : _scrvusd_oracle (address): 0xC772063cE3e622B458B706Dd2e36309418A1aE42

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000988d1037e9608b21050a8efba0c6c45e01a3bce7
Arg [1] : 000000000000000000000000c772063ce3e622b458b706dd2e36309418a1ae42

490:3118:3:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;760:42;;;;;;;;-1:-1:-1;;;;;178:32:4;;;160:51;;148:2;133:18;760:42:3;;;;;;;;808:39;;;;;1326:2280;;;;;;:::i;:::-;;:::i;:::-;;;1767:25:4;;;1755:2;1740:18;1326:2280:3;1621:177:4;1326:2280:3;1438:7;1457:40;1500:66;1539:17;1500:25;:66::i;:::-;1584:17;;1457:109;;-1:-1:-1;1576:40:3;;;;;;1782:19;;;;;1710:109;;-1:-1:-1;;;1710:109:3;;;;;1767:25:4;;;;1727:17:3;-1:-1:-1;;;;;1710:50:3;;;;1740:18:4;;1710:109:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1673:17;;:146;1652:177;;;;;;1923:33;1959:31;:22;:10;-1:-1:-1;;;;;;;;;;;;;;;;;1701:28:0;;;;;;;;1709:11;;1701:28;;1659:15;;;1701:28;;;;;;;;1515:221;1959:22:3;:29;:31::i;:::-;1923:67;-1:-1:-1;923:13:3;935:1;883:5;923:13;:::i;:::-;2025;;:1;:13;:::i;:::-;2008:6;:13;:30;2000:39;;;;;;727:25;;-1:-1:-1;;;727:25:3;;;2516:66:4;2150:31:3;;2184:194;;2598:12:4;;727:25:3;;;;;;;;;;;;717:36;;;;;;2310:12;:26;;;2350:18;:6;2357:1;2350:9;;;;;;;;:::i;:::-;;;;;;;:16;:18::i;:::-;2184:32;:194::i;:::-;2396:14;;2150:228;;-1:-1:-1;2388:23:3;;;;;;2492:37;:458;;;;;;;;2587:2;2492:458;;;;2619:2;2492:458;;;;2684:2;2492:458;;;;2716:2;2492:458;;;;2760:2;2492:458;;;;2802:2;2492:458;;;;2870:2;629:42;2859:23;;;;;;;;2964:4:4;2952:17;;;;2934:36;;-1:-1:-1;;;;;3006:32:4;3001:2;2986:18;;2979:60;2922:2;2907:18;;2753:292;2859:23:3;;;;-1:-1:-1;;2859:23:3;;;;;;;;;2849:34;;2859:23;2849:34;;;;2492:458;;;-1:-1:-1;2960:32:3;;:::i;:::-;-1:-1:-1;;;;;;;;;;;;;;;;;3042:9:3;3084:1;3065:423;923:13;935:1;883:5;923:13;:::i;:::-;3093;;:1;:13;:::i;:::-;3087:3;:19;3065:423;;;3136:178;3209:11;3221:1;3209:14;;;;;;;:::i;:::-;;;;;3198:26;;;;;;1767:25:4;;1755:2;1740:18;;1621:177;3198:26:3;;;;;;;;;;;;;3188:37;;;;;;3243:7;:19;;;3280:20;:6;3287:3;3280:11;;;;;;;;:::i;:20::-;3136:34;:178::i;:::-;3129:185;;3450:4;:10;;;3438:6;3445:1;3438:9;;;;;;;:::i;:::-;;;;:22;3474:3;;;;:::i;:::-;;;;3108:5;;;;;:::i;:::-;;;;3065:423;;;;3509:12;:22;;;3497:6;3504:1;3497:9;;;;;;;:::i;:::-;;;;:34;3548:51;;-1:-1:-1;;;3548:51:3;;-1:-1:-1;;;;;3563:14:3;3548:43;;;;:51;;3592:6;;3548:51;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3541:58;;;;;;;;;1326:2280;;;;;:::o;1570:610:2:-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1701:28:0;;;;;;;;1709:11;;1701:28;;1659:15;;;1701:28;;;;-1:-1:-1;;;;;1768:36:2;;1959:29:3;:31::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;;;;;;4008:19:4;;4052:2;4043:12;;3879: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;;;;;;4008:19:4;;4052:2;4043:12;;3879: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;4054:272:0;7644:166:1;4158:11:0;;;;4193:8;;4268:19;;7756:42:1;;;;;;4008:19:4;;4052:2;4043:12;;3879: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;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;:::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:718;396:5;449:3;442:4;434:6;430:17;426:27;416:55;;467:1;464;457:12;416:55;503:6;490:20;529:18;566:2;562;559:10;556:36;;;572:18;;:::i;:::-;647:2;641:9;615:2;701:13;;-1:-1:-1;;697:22:4;;;721:2;693:31;689:40;677:53;;;745:18;;;765:22;;;742:46;739:72;;;791:18;;:::i;:::-;831:10;827:2;820:22;866:2;858:6;851:18;912:3;905:4;900:2;892:6;888:15;884:26;881:35;878:55;;;929:1;926;919:12;878:55;993:2;986:4;978:6;974:17;967:4;959:6;955:17;942:54;1040:1;1033:4;1028:2;1020:6;1016:15;1012:26;1005:37;1060:6;1051:15;;;;;;354:718;;;;:::o;1077:539::-;1163:6;1171;1224:2;1212:9;1203:7;1199:23;1195:32;1192:52;;;1240:1;1237;1230:12;1192:52;1280:9;1267:23;1309:18;1350:2;1342:6;1339:14;1336:34;;;1366:1;1363;1356:12;1336:34;1389:49;1430:7;1421:6;1410:9;1406:22;1389:49;:::i;:::-;1379:59;;1491:2;1480:9;1476:18;1463:32;1447:48;;1520:2;1510:8;1507:16;1504:36;;;1536:1;1533;1526:12;1504:36;;1559:51;1602:7;1591:8;1580:9;1576:24;1559:51;:::i;:::-;1549:61;;;1077:539;;;;;:::o;1803:184::-;1873:6;1926:2;1914:9;1905:7;1901:23;1897:32;1894:52;;;1942:1;1939;1932:12;1894:52;-1:-1:-1;1965:16:4;;1803:184;-1:-1:-1;1803:184:4:o;1992:127::-;2053:10;2048:3;2044:20;2041:1;2034:31;2084:4;2081:1;2074:15;2108:4;2105:1;2098:15;2124:128;2191:9;;;2212:11;;;2209:37;;;2226:18;;:::i;2257:125::-;2322:9;;;2343:10;;;2340:36;;;2356:18;;:::i;2621:127::-;2682:10;2677:3;2673:20;2670:1;2663:31;2713:4;2710:1;2703:15;2737:4;2734:1;2727:15;3050:135;3089:3;3110:17;;;3107:43;;3130:18;;:::i;:::-;-1:-1:-1;3177:1:4;3166:13;;3050:135::o;3190:495::-;3370:3;3355:19;;3359:9;3451:6;3328:4;3485:194;3499:4;3496:1;3493:11;3485:194;;;3558:13;;3546:26;;3595:4;3619:12;;;;3654:15;;;;3519:1;3512:9;3485:194;;;3489:3;;;3190:495;;;;:::o;4066:151::-;4156:4;4149:12;;;4135;;;4131:31;;4174:14;;4171:40;;;4191:18;;:::i;4222:168::-;4295:9;;;4326;;4343:15;;;4337:22;;4323:37;4313:71;;4364:18;;:::i;4395:127::-;4456:10;4451:3;4447:20;4444:1;4437:31;4487:4;4484:1;4477:15;4511:4;4508:1;4501:15;4527:112;4559:1;4585;4575:35;;4590:18;;:::i;:::-;-1:-1:-1;4624:9:4;;4527:112::o;4644:120::-;4684:1;4710;4700:35;;4715:18;;:::i;:::-;-1:-1:-1;4749:9:4;;4644:120::o;4769:127::-;4830:10;4825:3;4821:20;4818:1;4811:31;4861:4;4858:1;4851:15;4885:4;4882:1;4875:15;4901:422;4990:1;5033:5;4990:1;5047:270;5068:7;5058:8;5055:21;5047:270;;;5127:4;5123:1;5119:6;5115:17;5109:4;5106:27;5103:53;;;5136:18;;:::i;:::-;5186:7;5176:8;5172:22;5169:55;;;5206:16;;;;5169:55;5285:22;;;;5245:15;;;;5047:270;;;5051:3;4901:422;;;;;:::o;5328:806::-;5377:5;5407:8;5397:80;;-1:-1:-1;5448:1:4;5462:5;;5397:80;5496:4;5486:76;;-1:-1:-1;5533:1:4;5547:5;;5486:76;5578:4;5596:1;5591:59;;;;5664:1;5659:130;;;;5571:218;;5591:59;5621:1;5612:10;;5635:5;;;5659:130;5696:3;5686:8;5683:17;5680:43;;;5703:18;;:::i;:::-;-1:-1:-1;;5759:1:4;5745:16;;5774:5;;5571:218;;5873:2;5863:8;5860:16;5854:3;5848:4;5845:13;5841:36;5835:2;5825:8;5822:16;5817:2;5811:4;5808:12;5804:35;5801:77;5798:159;;;-1:-1:-1;5910:19:4;;;5942:5;;5798:159;5989:34;6014:8;6008:4;5989:34;:::i;:::-;6059:6;6055:1;6051:6;6047:19;6038:7;6035:32;6032:58;;;6070:18;;:::i;:::-;6108:20;;5328:806;-1:-1:-1;;;5328:806:4:o;6139:131::-;6199:5;6228:36;6255:8;6249:4;6228:36;:::i

ipfs://d87a8d9ba9042d76dd2032c658adc7aac064210f0607166162ce40a3b1e965c1