Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity ^0.8.20;

import { IAMB } from "./IAMB.sol";
import { BlockHashAdapter } from "../BlockHashAdapter.sol";

contract AMBAdapter is BlockHashAdapter {
    string public constant PROVIDER = "amb";

    IAMB public immutable AMB;
    address public immutable REPORTER;
    bytes32 public immutable SOURCE_CHAIN_ID;

    error ArrayLengthMissmatch();
    error UnauthorizedAMB(address sender, address expectedSender);
    error UnauthorizedChainId(bytes32 sourceChainId, bytes32 expectedSourceChainId);
    error UnauthorizedHashReporter(address reporter, address expectedReporter);

    constructor(address amb, address reporter, bytes32 sourceChainId) {
        AMB = IAMB(amb);
        REPORTER = reporter;
        SOURCE_CHAIN_ID = sourceChainId;
    }

    modifier onlyValid() {
        bytes32 ambSourceChainId = AMB.messageSourceChainId();
        address ambMessageSender = AMB.messageSender();
        if (msg.sender != address(AMB)) revert UnauthorizedAMB(msg.sender, address(AMB));
        if (ambSourceChainId != SOURCE_CHAIN_ID) revert UnauthorizedChainId(ambSourceChainId, SOURCE_CHAIN_ID);
        if (ambMessageSender != REPORTER) revert UnauthorizedHashReporter(ambMessageSender, REPORTER);
        _;
    }

    function storeHashes(uint256[] memory ids, bytes32[] memory _hashes) public onlyValid {
        if (ids.length != _hashes.length) revert ArrayLengthMissmatch();
        _storeHashes(uint256(SOURCE_CHAIN_ID), ids, _hashes);
    }
}

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity ^0.8.20;

import { IAdapter } from "../interfaces/IAdapter.sol";

abstract contract Adapter is IAdapter {
    mapping(uint256 => mapping(uint256 => bytes32)) private _hashes;

    /// @inheritdoc IAdapter
    function getHash(uint256 domain, uint256 id) public view returns (bytes32) {
        return _hashes[domain][id];
    }

    function _storeHashes(uint256 domain, uint256[] memory ids, bytes32[] memory hashes) internal {
        for (uint256 i = 0; i < ids.length; ) {
            _storeHash(domain, ids[i], hashes[i]);
            unchecked {
                ++i;
            }
        }
    }

    function _storeHash(uint256 domain, uint256 id, bytes32 hash) internal {
        bytes32 currentHash = _hashes[domain][id];
        if (currentHash != hash) {
            _hashes[domain][id] = hash;
            emit HashStored(id, hash);
        }
    }
}

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity ^0.8.20;

interface IAMB {
    function messageSender() external view returns (address);

    function messageSourceChainId() external view returns (bytes32);

    function requireToPassMessage(address _contract, bytes memory _data, uint256 _gas) external returns (bytes32);
}

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity ^0.8.20;

import { RLPReader } from "solidity-rlp/contracts/RLPReader.sol";
import { Adapter } from "./Adapter.sol";
import { IBlockHashAdapter } from "../interfaces/IBlockHashAdapter.sol";

abstract contract BlockHashAdapter is IBlockHashAdapter, Adapter {
    using RLPReader for RLPReader.RLPItem;

    /// @inheritdoc IBlockHashAdapter
    function proveAncestralBlockHashes(uint256 chainId, bytes[] memory blockHeaders) external {
        for (uint256 i = 0; i < blockHeaders.length; i++) {
            RLPReader.RLPItem memory blockHeaderRLP = RLPReader.toRlpItem(blockHeaders[i]);

            if (!blockHeaderRLP.isList()) revert InvalidBlockHeaderRLP();

            RLPReader.RLPItem[] memory blockHeaderContent = blockHeaderRLP.toList();

            // A block header should have between 15 and 17 elements (baseFee and withdrawalsRoot have been added later)
            if (blockHeaderContent.length < 15 || blockHeaderContent.length > 17)
                revert InvalidBlockHeaderLength(blockHeaderContent.length);

            bytes32 blockParent = bytes32(blockHeaderContent[0].toUint());
            uint256 blockNumber = uint256(blockHeaderContent[8].toUint());

            bytes32 blockHash = keccak256(blockHeaders[i]);
            bytes32 storedBlockHash = getHash(chainId, blockNumber);

            if (blockHash != storedBlockHash) revert ConflictingBlockHeader(blockNumber, blockHash, storedBlockHash);

            _storeHash(chainId, blockNumber - 1, blockParent);
        }
    }
}

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity ^0.8.0;

/**
 * @title IAdapter
 */
interface IAdapter {
    error ConflictingBlockHeader(uint256 blockNumber, bytes32 blockHash, bytes32 storedBlockHash);
    error InvalidBlockHeaderLength(uint256 length);
    error InvalidBlockHeaderRLP();

    /**
     * @dev Emitted when a hash is stored.
     * @param id - The ID of the stored hash.
     * @param hash - The stored hash as bytes32 values.
     */
    event HashStored(uint256 indexed id, bytes32 indexed hash);

    /**
     * @dev Returns the hash for a given ID.
     * @param domain - Identifier for the domain to query.
     * @param id - Identifier for the ID to query.
     * @return hash Bytes32 hash for the given ID on the given domain.
     * @notice MUST return bytes32(0) if the hash is not present.
     */
    function getHash(uint256 domain, uint256 id) external view returns (bytes32 hash);
}

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity ^0.8.0;

import { IAdapter } from "./IAdapter.sol";

/**
 * @title IBlockHashAdapter
 */
interface IBlockHashAdapter is IAdapter {
    /**
     * @dev Proves and stores valid ancestral block hashes for a given chain ID.
     * @param chainId - The ID of the chain to prove block hashes for.
     * @param blockHeaders - The RLP encoded block headers to prove the hashes for.
     * @notice Block headers should be ordered by descending block number and should start with a known block header.
     */
    function proveAncestralBlockHashes(uint256 chainId, bytes[] memory blockHeaders) external;
}

// 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.9.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 {
        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))
            }
        }
    }
}

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

[{"inputs":[{"internalType":"address","name":"amb","type":"address"},{"internalType":"address","name":"reporter","type":"address"},{"internalType":"bytes32","name":"sourceChainId","type":"bytes32"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ArrayLengthMissmatch","type":"error"},{"inputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"},{"internalType":"bytes32","name":"blockHash","type":"bytes32"},{"internalType":"bytes32","name":"storedBlockHash","type":"bytes32"}],"name":"ConflictingBlockHeader","type":"error"},{"inputs":[{"internalType":"uint256","name":"length","type":"uint256"}],"name":"InvalidBlockHeaderLength","type":"error"},{"inputs":[],"name":"InvalidBlockHeaderRLP","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"expectedSender","type":"address"}],"name":"UnauthorizedAMB","type":"error"},{"inputs":[{"internalType":"bytes32","name":"sourceChainId","type":"bytes32"},{"internalType":"bytes32","name":"expectedSourceChainId","type":"bytes32"}],"name":"UnauthorizedChainId","type":"error"},{"inputs":[{"internalType":"address","name":"reporter","type":"address"},{"internalType":"address","name":"expectedReporter","type":"address"}],"name":"UnauthorizedHashReporter","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":true,"internalType":"bytes32","name":"hash","type":"bytes32"}],"name":"HashStored","type":"event"},{"inputs":[],"name":"AMB","outputs":[{"internalType":"contract IAMB","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PROVIDER","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REPORTER","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SOURCE_CHAIN_ID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"domain","type":"uint256"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"getHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"bytes[]","name":"blockHeaders","type":"bytes[]"}],"name":"proveAncestralBlockHashes","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"bytes32[]","name":"_hashes","type":"bytes32[]"}],"name":"storeHashes","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000f2546d6648bd2af6a008a7e7c1542bb240329e11000000000000000000000000c6755144d60548f3dd420f47cf48dae553bbf04200000000000000000000000000000000000000000000000000000000000027d8

-----Decoded View---------------
Arg [0] : amb (address): 0xf2546D6648BD2af6a008A7e7C1542BB240329E11
Arg [1] : reporter (address): 0xc6755144d60548f3DD420F47Cf48DAe553bBf042
Arg [2] : sourceChainId (bytes32): 0x00000000000000000000000000000000000000000000000000000000000027d8

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000f2546d6648bd2af6a008a7e7c1542bb240329e11
Arg [1] : 000000000000000000000000c6755144d60548f3dd420f47cf48dae553bbf042
Arg [2] : 00000000000000000000000000000000000000000000000000000000000027d8