Contract

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

import { HeaderStorage } from "../../utils/HeaderStorage.sol";
import { IAMB } from "./IAMB.sol";
import { AMBAdapter } from "./AMBAdapter.sol";

contract AMBHeaderReporter {
    IAMB public immutable amb;
    HeaderStorage public immutable headerStorage;

    event HeaderReported(address indexed emitter, uint256 indexed blockNumber, bytes32 indexed blockHeader);

    constructor(IAMB _amb, HeaderStorage _headerStorage) {
        amb = _amb;
        headerStorage = _headerStorage;
    }

    /// @dev Reports the given block headers to the oracleAdapter via the AMB.
    /// @param blockNumbers Uint256 array of block number to pass over the AMB.
    /// @param ambAdapter Address of the oracle adapter to pass the header to over the AMB.
    /// @param receipt Bytes32 receipt for the transaction.
    function reportHeaders(
        uint256[] memory blockNumbers,
        address ambAdapter,
        uint256 gas
    ) public returns (bytes32 receipt) {
        bytes32[] memory blockHeaders = headerStorage.storeBlockHeaders(blockNumbers);
        bytes memory data = abi.encodeCall(AMBAdapter.storeHashes, (blockNumbers, blockHeaders));
        receipt = amb.requireToPassMessage(ambAdapter, data, gas);
        for (uint256 i = 0; i < blockNumbers.length; i++) {
            emit HeaderReported(address(this), blockNumbers[i], blockHeaders[i]);
        }
    }
}

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

import { IAMB } from "./IAMB.sol";
import { OracleAdapter } from "../OracleAdapter.sol";
import { BlockHashOracleAdapter } from "../BlockHashOracleAdapter.sol";

contract AMBAdapter is OracleAdapter, BlockHashOracleAdapter {
    IAMB public amb;
    address public reporter;
    bytes32 public chainId;

    error ArrayLengthMissmatch(address emitter);
    error UnauthorizedAMB(address emitter, address sender);
    error UnauthorizedChainId(address emitter, bytes32 chainId);
    error UnauthorizedHashReporter(address emitter, address reporter);

    constructor(IAMB _amb, address _reporter, bytes32 _chainId) {
        amb = _amb;
        reporter = _reporter;
        chainId = _chainId;
    }

    /// @dev Check that the amb, chainId, and owner are valid.
    modifier onlyValid() {
        if (msg.sender != address(amb)) revert UnauthorizedAMB(address(this), msg.sender);
        if (amb.messageSourceChainId() != chainId) revert UnauthorizedChainId(address(this), chainId);
        if (amb.messageSender() != reporter) revert UnauthorizedHashReporter(address(this), reporter);
        _;
    }

    /// @dev Stores the hashes for a given array of idss.
    /// @param ids Array of ids number for which to set the hashes.
    /// @param _hashes Array of hashes to set for the given ids.
    /// @notice Only callable by `amb` with a message passed from `reporter.
    /// @notice Will revert if given array lengths do not match.
    function storeHashes(uint256[] memory ids, bytes32[] memory _hashes) public onlyValid {
        if (ids.length != _hashes.length) revert ArrayLengthMissmatch(address(this));
        for (uint256 i = 0; i < ids.length; i++) {
            _storeHash(uint256(chainId), ids[i], _hashes[i]);
        }
    }
}

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

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

contract HeaderStorage {
    mapping(uint256 => bytes32) public headers;

    event HeaderStored(uint256 indexed blockNumber, bytes32 indexed blockHeader);

    error HeaderOutOfRange(address emitter, uint256 blockNumber);

    /// @dev Stores and returns the header for the given block.
    /// @param blockNumber Block number.
    /// @return blockHeader Block header stored.
    /// @notice Reverts if the given block header was not previously stored and is now out of range.
    function storeBlockHeader(uint256 blockNumber) public returns (bytes32 blockHeader) {
        blockHeader = headers[blockNumber];
        if (blockHeader == 0) {
            blockHeader = blockhash(blockNumber);
            if (blockHeader == 0) revert HeaderOutOfRange(address(this), blockNumber);
            headers[blockNumber] = blockHeader;
            emit HeaderStored(blockNumber, blockHeader);
        }
    }

    /// @dev Stores and returns the header for an array of given blocks.
    /// @param blockNumbers Array of block numbers.
    /// @return Array of block headers.
    /// @notice Reverts if the given block header was not previously stored and is now out of range.
    function storeBlockHeaders(uint256[] memory blockNumbers) public returns (bytes32[] memory) {
        bytes32[] memory blockHeaders = new bytes32[](blockNumbers.length);
        for (uint256 i = 0; i < blockNumbers.length; i++) {
            blockHeaders[i] = storeBlockHeader(blockNumbers[i]);
        }
        return blockHeaders;
    }
}

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

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

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

abstract contract BlockHashOracleAdapter is OracleAdapter {
    using RLPReader for RLPReader.RLPItem;

    /// @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 {
        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 reportedBlockHash = keccak256(blockHeaders[i]);
            bytes32 storedBlockHash = hashes[chainId][blockNumber];

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

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

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

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

abstract contract OracleAdapter is IOracleAdapter {
    mapping(uint256 => mapping(uint256 => bytes32)) public hashes;

    /// @dev Returns the hash for a given domain and ID, as reported by the oracle.
    /// @param domain Identifier for the domain to query.
    /// @param id Identifier for the ID to query.
    /// @return hash Bytes32 hash reported by the oracle for the given ID on the given domain.
    /// @notice MUST return bytes32(0) if the oracle has not yet reported a hash for the given ID.
    function getHashFromOracle(uint256 domain, uint256 id) external view returns (bytes32 hash) {
        hash = hashes[domain][id];
    }

    /// @dev Stores a hash for a given domain and ID.
    /// @param domain Identifier for the domain.
    /// @param id Identifier for the ID of the hash.
    /// @param hash Bytes32 hash value to store.
    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.17;

interface IOracleAdapter {
    event HashStored(uint256 indexed id, bytes32 indexed hashes);

    error InvalidBlockHeaderLength(uint256 length);
    error InvalidBlockHeaderRLP();
    error ConflictingBlockHeader(uint256 blockNumber, bytes32 reportedBlockHash, bytes32 storedBlockHash);

    /// @dev Returns the hash for a given ID, as reported by the oracle.
    /// @param domain Identifier for the domain to query.
    /// @param id Identifier for the ID to query.
    /// @return hash Bytes32 hash reported by the oracle for the given ID on the given domain.
    /// @notice MUST return bytes32(0) if the oracle has not yet reported a hash for the given ID.
    function getHashFromOracle(uint256 domain, uint256 id) external view returns (bytes32 hash);
}

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

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

[{"inputs":[{"internalType":"contract IAMB","name":"_amb","type":"address"},{"internalType":"contract HeaderStorage","name":"_headerStorage","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"emitter","type":"address"},{"indexed":true,"internalType":"uint256","name":"blockNumber","type":"uint256"},{"indexed":true,"internalType":"bytes32","name":"blockHeader","type":"bytes32"}],"name":"HeaderReported","type":"event"},{"inputs":[],"name":"amb","outputs":[{"internalType":"contract IAMB","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"headerStorage","outputs":[{"internalType":"contract HeaderStorage","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"blockNumbers","type":"uint256[]"},{"internalType":"address","name":"ambAdapter","type":"address"},{"internalType":"uint256","name":"gas","type":"uint256"}],"name":"reportHeaders","outputs":[{"internalType":"bytes32","name":"receipt","type":"bytes32"}],"stateMutability":"nonpayable","type":"function"}]

60c06040523480156200001157600080fd5b5060405162000d6d38038062000d6d83398181016040528101906200003791906200016a565b8173ffffffffffffffffffffffffffffffffffffffff1660808173ffffffffffffffffffffffffffffffffffffffff16815250508073ffffffffffffffffffffffffffffffffffffffff1660a08173ffffffffffffffffffffffffffffffffffffffff16815250505050620001b1565b600080fd5b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000620000d982620000ac565b9050919050565b6000620000ed82620000cc565b9050919050565b620000ff81620000e0565b81146200010b57600080fd5b50565b6000815190506200011f81620000f4565b92915050565b60006200013282620000cc565b9050919050565b620001448162000125565b81146200015057600080fd5b50565b600081519050620001648162000139565b92915050565b60008060408385031215620001845762000183620000a7565b5b600062000194858286016200010e565b9250506020620001a78582860162000153565b9150509250929050565b60805160a051610b8b620001e26000396000818160d8015260ff01526000818160b401526101fe0152610b8b6000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c80631062b39a14610046578063124e181f14610064578063e2eb6f8614610082575b600080fd5b61004e6100b2565b60405161005b91906103bf565b60405180910390f35b61006c6100d6565b60405161007991906103fb565b60405180910390f35b61009c600480360381019061009791906105f7565b6100fa565b6040516100a9919061067f565b60405180910390f35b7f000000000000000000000000000000000000000000000000000000000000000081565b7f000000000000000000000000000000000000000000000000000000000000000081565b6000807f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663ceee6e55866040518263ffffffff1660e01b81526004016101569190610758565b6000604051808303816000875af1158015610175573d6000803e3d6000fd5b505050506040513d6000823e3d601f19601f8201168201806040525081019061019e9190610869565b9050600085826040516024016101b5929190610970565b6040516020818303038152906040526369f5590360e01b6020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff838183161783525050505090507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663dc8601b38683876040518463ffffffff1660e01b815260040161025993929190610a44565b6020604051808303816000875af1158015610278573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061029c9190610a82565b925060005b8651811015610336578281815181106102bd576102bc610aaf565b5b60200260200101518782815181106102d8576102d7610aaf565b5b60200260200101513073ffffffffffffffffffffffffffffffffffffffff167f91d88cce380da58b1f18fc437a4a6342ddea08c9a496e31ae03e16c08fc4fce160405160405180910390a4808061032e90610b0d565b9150506102a1565b5050509392505050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600061038561038061037b84610340565b610360565b610340565b9050919050565b60006103978261036a565b9050919050565b60006103a98261038c565b9050919050565b6103b98161039e565b82525050565b60006020820190506103d460008301846103b0565b92915050565b60006103e58261038c565b9050919050565b6103f5816103da565b82525050565b600060208201905061041060008301846103ec565b92915050565b6000604051905090565b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6104788261042f565b810181811067ffffffffffffffff8211171561049757610496610440565b5b80604052505050565b60006104aa610416565b90506104b6828261046f565b919050565b600067ffffffffffffffff8211156104d6576104d5610440565b5b602082029050602081019050919050565b600080fd5b6000819050919050565b6104ff816104ec565b811461050a57600080fd5b50565b60008135905061051c816104f6565b92915050565b6000610535610530846104bb565b6104a0565b90508083825260208201905060208402830185811115610558576105576104e7565b5b835b81811015610581578061056d888261050d565b84526020840193505060208101905061055a565b5050509392505050565b600082601f8301126105a05761059f61042a565b5b81356105b0848260208601610522565b91505092915050565b60006105c482610340565b9050919050565b6105d4816105b9565b81146105df57600080fd5b50565b6000813590506105f1816105cb565b92915050565b6000806000606084860312156106105761060f610420565b5b600084013567ffffffffffffffff81111561062e5761062d610425565b5b61063a8682870161058b565b935050602061064b868287016105e2565b925050604061065c8682870161050d565b9150509250925092565b6000819050919050565b61067981610666565b82525050565b60006020820190506106946000830184610670565b92915050565b600081519050919050565b600082825260208201905092915050565b6000819050602082019050919050565b6106cf816104ec565b82525050565b60006106e183836106c6565b60208301905092915050565b6000602082019050919050565b60006107058261069a565b61070f81856106a5565b935061071a836106b6565b8060005b8381101561074b57815161073288826106d5565b975061073d836106ed565b92505060018101905061071e565b5085935050505092915050565b6000602082019050818103600083015261077281846106fa565b905092915050565b600067ffffffffffffffff82111561079557610794610440565b5b602082029050602081019050919050565b6107af81610666565b81146107ba57600080fd5b50565b6000815190506107cc816107a6565b92915050565b60006107e56107e08461077a565b6104a0565b90508083825260208201905060208402830185811115610808576108076104e7565b5b835b81811015610831578061081d88826107bd565b84526020840193505060208101905061080a565b5050509392505050565b600082601f8301126108505761084f61042a565b5b81516108608482602086016107d2565b91505092915050565b60006020828403121561087f5761087e610420565b5b600082015167ffffffffffffffff81111561089d5761089c610425565b5b6108a98482850161083b565b91505092915050565b600081519050919050565b600082825260208201905092915050565b6000819050602082019050919050565b6108e781610666565b82525050565b60006108f983836108de565b60208301905092915050565b6000602082019050919050565b600061091d826108b2565b61092781856108bd565b9350610932836108ce565b8060005b8381101561096357815161094a88826108ed565b975061095583610905565b925050600181019050610936565b5085935050505092915050565b6000604082019050818103600083015261098a81856106fa565b9050818103602083015261099e8184610912565b90509392505050565b6109b0816105b9565b82525050565b600081519050919050565b600082825260208201905092915050565b60005b838110156109f05780820151818401526020810190506109d5565b60008484015250505050565b6000610a07826109b6565b610a1181856109c1565b9350610a218185602086016109d2565b610a2a8161042f565b840191505092915050565b610a3e816104ec565b82525050565b6000606082019050610a5960008301866109a7565b8181036020830152610a6b81856109fc565b9050610a7a6040830184610a35565b949350505050565b600060208284031215610a9857610a97610420565b5b6000610aa6848285016107bd565b91505092915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b6000610b18826104ec565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8203610b4a57610b49610ade565b5b60018201905091905056fea2646970667358221220184abe0bedc27b02c257c27c2e68a599c320a45b15caf778dc2a8e57c92d915f64736f6c6343000812003300000000000000000000000001268db05965ceac2a89566c42cd550ed7ee5ecd0000000000000000000000004cd014ac64aaa899b46bf3a477b68bb67e33edc4

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

00000000000000000000000001268db05965ceac2a89566c42cd550ed7ee5ecd0000000000000000000000004cd014ac64aaa899b46bf3a477b68bb67e33edc4

-----Decoded View---------------
Arg [0] : _amb (address): 0x01268DB05965CeAc2a89566c42CD550ED7eE5ECD
Arg [1] : _headerStorage (address): 0x4cD014AC64AAa899b46BF3a477B68bb67e33eDC4

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 00000000000000000000000001268db05965ceac2a89566c42cd550ed7ee5ecd
Arg [1] : 0000000000000000000000004cd014ac64aaa899b46bf3a477b68bb67e33edc4