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.0;

import "../libraries/RLPReader.sol";

contract MptVerifier {
    using RLPReader for RLPReader.RLPItem;
    using RLPReader for bytes;

    struct Proof {
        bytes32 receiptsHash;
        bytes mptKey;
        RLPReader.RLPItem[] stack;
    }

    struct Receipt {
        bytes32 receiptHash;
        bytes logs;
    }

    function validateMPT(bytes calldata _proof) external pure returns (Receipt memory receipt) {
        Proof memory proof = decodeProofBlob(_proof);
        bytes memory rlpTx = validateMPTProof(proof.receiptsHash, proof.mptKey, proof.stack);
        require(rlpTx.length != 0, "invalid proof");
        receipt = decodeReceipt(proof.receiptsHash, rlpTx);
    }

    /// @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 _mptKey is the key (consisting of nibbles) 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 validateMPTProof(
        bytes32 _rootHash,
        bytes memory _mptKey,
        RLPReader.RLPItem[] memory _stack
    ) internal pure returns (bytes memory value) {
        uint256 mptKeyOffset = 0;

        bytes32 nodeHashHash;
        bytes32 rlpNodeHash;
        RLPReader.RLPItem[] memory node;

        RLPReader.RLPItem memory rlpValue;

        if (_stack.length == 0) {
            // Root hash of empty Merkle-Patricia-Trie
            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.
            rlpNodeHash = _stack[i].rlpBytesKeccak256();
            uint256 rlpNodeLen = _stack[i].len;
            // The root node is hashed with Keccak-256 ...
            if (i == 0 && _rootHash != rlpNodeHash) {
                revert();
            }
            // ... whereas all other nodes are hashed with the MPT
            // hash function.
            if (i != 0 && nodeHashHash != mptHashHashByHash(rlpNodeHash, rlpNodeLen)) {
                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 at 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();
                }
            }
        }
    }

    function isEmptyByteSequence(RLPReader.RLPItem memory _item) internal 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 decodeReceipt(bytes32 _receiptHash, bytes memory _rlpSignedTx) internal pure returns (Receipt memory t) {
        t = Receipt(_receiptHash, _rlpSignedTx.toRlpItemWithTxType().listIndex(3).toRlpBytes());
    }

    function decodeNibbles(bytes memory _compact, uint256 _skipNibbles) internal 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;

        unchecked {
            for (uint256 i = _skipNibbles; i < _skipNibbles + length; i += 1) {
                assembly {
                    let b := byte(0, mload(add(add(_compact, 0x20), shr(1, i))))
                    let newByte := and(0xf, shr(mul(sub(1, and(i, 1)), 4), b))
                    mstore8(add(nibbles, add(0x20, nibblesLength)), newByte)
                }
                // if (i % 2 == 0) {
                //     nibbles[nibblesLength] = bytes1((uint8(_compact[i / 2]) >> 4) & 0xF);// no need and f
                // } else {
                //     nibbles[nibblesLength] = bytes1((uint8(_compact[i / 2]) >> 0) & 0xF);
                // }
                nibblesLength += 1;
            }
        }

        assert(nibblesLength == nibbles.length);
    }

    function merklePatriciaCompactDecode(
        bytes memory _compact
    ) internal 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 sharedPrefixLength(uint256 _xsOffset, bytes memory _xs, bytes memory _ys) internal 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;
    }

    function decodeProofBlob(bytes memory _proof) internal pure returns (Proof memory proof) {
        RLPReader.RLPItem[] memory proofFields = _proof.toRlpItem().toList();
        proof = Proof(
            bytes32(proofFields[0].toUint()),
            decodeNibbles(proofFields[1].toRlpBytes(), 0),
            proofFields[2].toList()
        );
    }

    function mptHashHashByHash(bytes32 _inputHash, uint256 _inputLen) internal pure returns (bytes32) {
        if (_inputLen < 32) {
            return _inputHash;
        } else {
            return keccak256(abi.encodePacked(_inputHash));
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

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 {
        uint len;
        uint memPtr;
    }

    struct Iterator {
        RLPItem item; // Item that's being iterated over.
        uint 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));

        uint ptr = self.nextPtr;
        uint 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) {
        uint memPtr;
        assembly {
            memPtr := add(item, 0x20)
        }
        uint len = item.length;
        return RLPItem(len, memPtr);
    }

    function toRlpItemWithTxType(bytes memory item) internal pure returns (RLPItem memory) {
        uint memPtr;
        assembly {
            memPtr := add(item, 0x20)
        }
        uint len = item.length;

        uint8 byte0;
        assembly {
            byte0 := byte(0, mload(memPtr))
        }
        if (len > 0 && byte0 < LIST_SHORT_START) {
            assembly {
                memPtr := add(memPtr, 0x01)
            }
            len -= 1;
        }

        return RLPItem(len, 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));

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

    /*
     * @param the RLP item.
     */
    function rlpLen(RLPItem memory item) internal pure returns (uint) {
        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 (uint, uint) {
        uint offset = _payloadOffset(item.memPtr);
        uint memPtr;
        uint len;
        unchecked {
            memPtr = item.memPtr + offset;
            len = item.len - offset; // data length
        }
        return (memPtr, len);
    }

    /*
     * @param the RLP item.
     */
    function payloadLen(RLPItem memory item) internal pure returns (uint) {
        (, uint 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));

        RLPItem[] memory result;

        uint memPtr = item.memPtr + _payloadOffset(item.memPtr);
        uint endPtr = item.memPtr + item.len;
        uint count = 0;
        uint freeMemPtr;
        assembly {
            freeMemPtr := mload(0x40)
        }
        unchecked {
            while (memPtr < endPtr) {
                uint dataLen = _itemLength(memPtr);
                assembly {
                    let offset := add(freeMemPtr, mul(count, 0x40))
                    mstore(offset, dataLen)
                    mstore(add(offset, 0x20), memPtr)
                }
                memPtr = memPtr + dataLen;
                count++;
            }
        }
        assembly {
            result := add(freeMemPtr, mul(count, 0x40))
            mstore(result, count)
            let j := add(result, 0x20)
            for {
                let i := freeMemPtr
            } lt(i, result) {
                i := add(i, 0x40)
                j := add(j, 0x20)
            } {
                mstore(j, i)
            }
            mstore(0x40, j)
        }

        return result;
    }

    function listIndex(RLPItem memory item, uint256 index) internal pure returns (RLPItem memory) {
        require(isList(item));

        uint memPtr = item.memPtr + _payloadOffset(item.memPtr);
        uint endPtr = item.memPtr + item.len;
        uint count = 0;
        unchecked {
            while (memPtr < endPtr) {
                uint dataLen = _itemLength(memPtr);
                if (count == index) return RLPItem(dataLen, memPtr);
                memPtr = memPtr + dataLen;
                count++;
            }
        }
        revert();
    }

    // @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;
        uint 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) {
        (uint memPtr, uint 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;

        uint 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);
        uint result;
        uint 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 (uint) {
        require(item.len > 0 && item.len <= 33);

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

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

            // shfit to the correct location if neccesary
            if lt(len, 32) {
                result := shr(shl(3, sub(32, len)), result)
            }
        }

        return result;
    }

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

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

        return result;
    }

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

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

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

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

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

        if (byte0 < STRING_SHORT_START) itemLen = 1;
        else if (byte0 < STRING_LONG_START) {
            unchecked {
                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 := shr(shl(3, sub(32, byteLen)), mload(memPtr)) // right shifting to get the len
                itemLen := add(dataLen, add(byteLen, 1))
            }
        } else if (byte0 < LIST_LONG_START) {
            unchecked {
                itemLen = byte0 - LIST_SHORT_START + 1;
            }
        } else {
            assembly {
                let byteLen := sub(byte0, 0xf7)
                memPtr := add(memPtr, 1)

                let dataLen := shr(shl(3, sub(32, byteLen)), mload(memPtr)) // right shifting to the correct length
                itemLen := add(dataLen, add(byteLen, 1))
            }
        }

        return itemLen;
    }

    // @return number of bytes until the data
    function _payloadOffset(uint memPtr) private pure returns (uint) {
        uint 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
            unchecked {
                return byte0 - (STRING_LONG_START - 1) + 1;
            }
        } else {
            unchecked {
                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(uint src, uint dest, uint len) private pure {
        if (len <= 32) {
            assembly {
                let mask := shr(shl(3, len), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
                let srcpart := and(mload(src), not(mask))
                let destpart := and(mload(dest), mask)
                mstore(dest, or(destpart, srcpart))
            }
            return;
        }

        function (uint, uint, uint) view impureCopy = __copy;
        function (uint, uint, uint) pure pureCopy;

        assembly {
            pureCopy := impureCopy
        }

        pureCopy(src, dest, len);
    }

    function __copy(uint src, uint dest, uint len) private view {
        assembly {
            if iszero(staticcall(gas(), 0x04, src, len, dest, len)) {
                revert(0, 0)
            }
        }
    }

    function toBytes32(RLPItem memory self) internal pure returns (bytes32 data) {
        return bytes32(toUint(self));
    }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"bytes","name":"_proof","type":"bytes"}],"name":"validateMPT","outputs":[{"components":[{"internalType":"bytes32","name":"receiptHash","type":"bytes32"},{"internalType":"bytes","name":"logs","type":"bytes"}],"internalType":"struct MptVerifier.Receipt","name":"receipt","type":"tuple"}],"stateMutability":"pure","type":"function"}]

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