Merge branch 'dev-chain' of github.com:ethereum-optimism/contracts-v2 into master

packages/contracts/buidler.config.ts

 import { usePlugin, BuidlerConfig } from '@nomiclabs/buidler/config'
 
-import {
-  DEFAULT_ACCOUNTS_BUIDLER,
-  GAS_LIMIT,
-} from './test/helpers/constants'
+import { DEFAULT_ACCOUNTS_BUIDLER, GAS_LIMIT } from './test/helpers/constants'
 
 usePlugin('@nomiclabs/buidler-ethers')
 usePlugin('@nomiclabs/buidler-waffle')
@@ -21,7 +18,7 @@ const config: BuidlerConfig = {
     timeout: 50000,
   },
   solc: {
-    version: "0.7.0",
+    version: '0.7.0',
     optimizer: { enabled: true, runs: 200 },
   },
 }

packages/contracts/contracts/optimistic-ethereum/OVM/chain/OVM_BaseChain.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+pragma experimental ABIEncoderV2;
+
+/* Interface Imports */
+import { iOVM_BaseChain } from "../../iOVM/chain/iOVM_BaseChain.sol";
+
+/* Library Imports */
+import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
+import { Lib_MerkleUtils } from "../../libraries/utils/Lib_MerkleUtils.sol";
+
+/**
+ * @title OVM_BaseChain
+ */
+contract OVM_BaseChain is iOVM_BaseChain {
+
+    /*******************************
+     * Contract Variables: Batches *
+     *******************************/
+
+    bytes32[] internal batches;
+    uint256 internal totalBatches;
+    uint256 internal totalElements;
+
+
+    /*************************************
+     * Public Functions: Batch Retrieval *
+     *************************************/
+
+    /**
+     * Gets the total number of submitted elements.
+     * @return _totalElements Total submitted elements.
+     */
+    function getTotalElements()
+        override
+        public
+        view
+        returns (
+            uint256 _totalElements
+        )
+    {
+        return totalElements;
+    }
+
+    /**
+     * Gets the total number of submitted batches.
+     * @return _totalBatches Total submitted batches.
+     */
+    function getTotalBatches()
+        override
+        public
+        view
+        returns (
+            uint256 _totalBatches
+        )
+    {
+        return totalBatches;
+    }
+
+
+    /****************************************
+     * Public Functions: Batch Verification *
+     ****************************************/
+
+    /**
+     * Verifies an inclusion proof for a given element.
+     * @param _element Element to verify.
+     * @param _batchHeader Header of the batch in which this element was included.
+     * @param _proof Inclusion proof for the element.
+     * @return _verified Whether or not the element was included in the batch.
+     */
+    function verifyElement(
+        bytes calldata _element,
+        Lib_OVMCodec.ChainBatchHeader memory _batchHeader,
+        Lib_OVMCodec.ChainInclusionProof memory _proof
+    )
+        override
+        public
+        view
+        returns (
+            bool _verified
+        )
+    {
+        require(
+            _hashBatchHeader(_batchHeader) == batches[_batchHeader.batchIndex],
+            "Invalid batch header."
+        );
+
+        require(
+            Lib_MerkleUtils.verify(
+                _batchHeader.batchRoot,
+                _element,
+                _proof.index,
+                _proof.siblings
+            ),
+            "Invalid inclusion proof."
+        );
+
+        return true;
+    }
+
+
+    /******************************************
+     * Internal Functions: Batch Modification *
+     ******************************************/
+
+    /**
+     * Appends a batch to the chain.
+     * @param _batchHeader Batch header to append.
+     */
+    function _appendBatch(
+        Lib_OVMCodec.ChainBatchHeader memory _batchHeader
+    )
+        internal
+    {
+        bytes32 batchHeaderHash = _hashBatchHeader(_batchHeader);
+        batches.push(batchHeaderHash);
+        totalBatches += 1;
+        totalElements += _batchHeader.batchSize;
+    }
+
+    /**
+     * Appends a batch to the chain.
+     * @param _elements Elements within the batch.
+     * @param _extraData Any extra data to append to the batch.
+     */
+    function _appendBatch(
+        bytes[] memory _elements,
+        bytes memory _extraData
+    )
+        internal
+    {
+        Lib_OVMCodec.ChainBatchHeader memory batchHeader = Lib_OVMCodec.ChainBatchHeader({
+            batchIndex: batches.length,
+            batchRoot: Lib_MerkleUtils.getMerkleRoot(_elements),
+            batchSize: _elements.length,
+            prevTotalElements: totalElements,
+            extraData: _extraData
+        });
+
+        _appendBatch(batchHeader);
+    }
+
+    /**
+     * Appends a batch to the chain.
+     * @param _elements Elements within the batch.
+     */
+    function _appendBatch(
+        bytes[] memory _elements
+    )
+        internal
+    {
+        _appendBatch(
+            _elements,
+            bytes('')
+        );
+    }
+
+    /**
+     * Removes a batch from the chain.
+     * @param _batchHeader Header of the batch to remove.
+     */
+    function _deleteBatch(
+        Lib_OVMCodec.ChainBatchHeader memory _batchHeader
+    )
+        internal
+    {
+        require(
+            _batchHeader.batchIndex < batches.length,
+            "Invalid batch index."
+        );
+
+        require(
+            _hashBatchHeader(_batchHeader) == batches[_batchHeader.batchIndex],
+            "Invalid batch header."
+        );
+
+        totalBatches = _batchHeader.batchIndex;
+        totalElements = _batchHeader.prevTotalElements;
+    }
+
+
+    /*********************
+     * Private Functions *
+     *********************/
+
+    /**
+     * Calculates a hash for a given batch header.
+     * @param _batchHeader Header to hash.
+     * @return _hash Hash of the header.
+     */
+    function _hashBatchHeader(
+        Lib_OVMCodec.ChainBatchHeader memory _batchHeader
+    )
+        private
+        pure
+        returns (
+            bytes32 _hash
+        )
+    {
+        return keccak256(abi.encodePacked(
+            _batchHeader.batchRoot,
+            _batchHeader.batchSize,
+            _batchHeader.prevTotalElements,
+            _batchHeader.extraData
+        ));
+    }
+}

packages/contracts/contracts/optimistic-ethereum/OVM/chain/OVM_CanonicalTransactionChain.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+pragma experimental ABIEncoderV2;
+
+/* Proxy Imports */
+import { Proxy_Resolver } from "../../proxy/Proxy_Resolver.sol";
+
+/* Library Imports */
+import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
+import { Lib_MerkleUtils } from "../../libraries/utils/Lib_MerkleUtils.sol";
+
+/* Interface Imports */
+import { iOVM_CanonicalTransactionChain } from "../../iOVM/chain/iOVM_CanonicalTransactionChain.sol";
+import { iOVM_L1ToL2TransactionQueue } from "../../iOVM/queue/iOVM_L1ToL2TransactionQueue.sol";
+
+/* Contract Imports */
+import { OVM_BaseChain } from "./OVM_BaseChain.sol";
+
+/**
+ * @title OVM_CanonicalTransactionChain
+ */
+contract OVM_CanonicalTransactionChain is iOVM_CanonicalTransactionChain, OVM_BaseChain, Proxy_Resolver {
+
+    /*******************************************
+     * Contract Variables: Contract References *
+     *******************************************/
+    
+    iOVM_L1ToL2TransactionQueue internal ovmL1ToL2TransactionQueue;
+
+
+    /*******************************************
+     * Contract Variables: Internal Accounting *
+     *******************************************/
+
+    uint256 internal forceInclusionPeriodSeconds;
+    uint256 internal lastOVMTimestamp;
+
+
+    /***************
+     * Constructor *
+     ***************/
+
+    /**
+     * @param _proxyManager Address of the Proxy_Manager.
+     * @param _forceInclusionPeriodSeconds Period during which only the sequencer can submit.
+     */
+    constructor(
+        address _proxyManager,
+        uint256 _forceInclusionPeriodSeconds
+    )
+        Proxy_Resolver(_proxyManager)
+    {
+        ovmL1ToL2TransactionQueue = iOVM_L1ToL2TransactionQueue(resolve("OVM_L1ToL2TransactionQueue"));
+        forceInclusionPeriodSeconds = _forceInclusionPeriodSeconds;
+    }
+
+
+    /****************************************
+     * Public Functions: Batch Manipulation *
+     ****************************************/
+
+    /**
+     * Appends a batch from the L1ToL2TransactionQueue.
+     */
+    function appendQueueBatch()
+        override
+        public
+    {
+        require(
+            ovmL1ToL2TransactionQueue.size() > 0,
+            "No batches are currently queued to be appended."
+        );
+
+        Lib_OVMCodec.QueueElement memory queueElement = ovmL1ToL2TransactionQueue.peek();
+        
+        require(
+            queueElement.timestamp + forceInclusionPeriodSeconds <= block.timestamp,
+            "Cannot append until the inclusion delay period has elapsed."
+        );
+
+        _appendQueueBatch(queueElement, 1);
+        ovmL1ToL2TransactionQueue.dequeue();
+    }
+
+    /**
+     * Appends a sequencer batch.
+     * @param _batch Batch of transactions to append.
+     * @param _timestamp Timestamp for the provided batch.
+     */
+    function appendSequencerBatch(
+        bytes[] memory _batch,
+        uint256 _timestamp
+    )
+        override
+        public
+    {
+        require(
+            msg.sender == resolve("Sequencer"),
+            "Function can only be called by the Sequencer."
+        );
+
+        require(
+            _batch.length > 0,
+            "Cannot submit an empty batch."
+        );
+
+        require(
+            _timestamp > lastOVMTimestamp,
+            "Batch timestamp must be later than the last OVM timestamp."
+        );
+
+        if (ovmL1ToL2TransactionQueue.size() > 0) {
+            require(
+                _timestamp <= ovmL1ToL2TransactionQueue.peek().timestamp,
+                "Older queue batches must be processed before a newer sequencer batch."
+            );
+        }
+
+        Lib_OVMCodec.QueueElement memory queueElement = Lib_OVMCodec.QueueElement({
+            timestamp: _timestamp,
+            batchRoot: Lib_MerkleUtils.getMerkleRoot(_batch),
+            isL1ToL2Batch: false
+        });
+        _appendQueueBatch(queueElement, _batch.length);
+    }
+
+
+    /******************************************
+     * Internal Functions: Batch Manipulation *
+     ******************************************/
+
+    /**
+     * Appends a queue batch to the chain.
+     * @param _queueElement Queue element to append.
+     * @param _batchSize Number of elements in the batch.
+     */
+    function _appendQueueBatch(
+        Lib_OVMCodec.QueueElement memory _queueElement,
+        uint256 _batchSize
+    )
+        internal
+    {
+        Lib_OVMCodec.ChainBatchHeader memory batchHeader = Lib_OVMCodec.ChainBatchHeader({
+            batchIndex: getTotalBatches(),
+            batchRoot: _queueElement.batchRoot,
+            batchSize: _batchSize,
+            prevTotalElements: getTotalElements(),
+            extraData: abi.encodePacked(
+                _queueElement.timestamp,
+                _queueElement.isL1ToL2Batch
+            )
+        });
+
+        _appendBatch(batchHeader);
+        lastOVMTimestamp = _queueElement.timestamp;
+    }
+}

packages/contracts/contracts/optimistic-ethereum/OVM/chain/OVM_StateCommitmentChain.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+pragma experimental ABIEncoderV2;
+
+/* Proxy Imports */
+import { Proxy_Resolver } from "../../proxy/Proxy_Resolver.sol";
+
+/* Library Imports */
+import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
+
+/* Interface Imports */
+import { iOVM_FraudVerifier } from "../../iOVM/verification/iOVM_FraudVerifier.sol";
+import { iOVM_StateCommitmentChain } from "../../iOVM/chain/iOVM_StateCommitmentChain.sol";
+import { iOVM_CanonicalTransactionChain } from "../../iOVM/chain/iOVM_CanonicalTransactionChain.sol";
+
+/* Contract Imports */
+import { OVM_BaseChain } from "./OVM_BaseChain.sol";
+
+/**
+ * @title OVM_StateCommitmentChain
+ */
+contract OVM_StateCommitmentChain is iOVM_StateCommitmentChain, OVM_BaseChain, Proxy_Resolver {
+    
+    /*******************************************
+     * Contract Variables: Contract References *
+     *******************************************/
+
+    iOVM_CanonicalTransactionChain internal ovmCanonicalTransactionChain;
+    iOVM_FraudVerifier internal ovmFraudVerifier;
+
+
+    /***************
+     * Constructor *
+     ***************/
+
+    /**
+     * @param _proxyManager Address of the Proxy_Manager.
+     */
+    constructor(
+        address _proxyManager
+    )
+        Proxy_Resolver(_proxyManager)
+    {
+        ovmCanonicalTransactionChain = iOVM_CanonicalTransactionChain(resolve("OVM_CanonicalTransactionChain"));
+        ovmFraudVerifier = iOVM_FraudVerifier(resolve("OVM_FraudVerifier"));
+    }
+
+
+    /****************************************
+     * Public Functions: Batch Manipulation *
+     ****************************************/
+
+    /**
+     * Appends a batch of state roots to the chain.
+     * @param _batch Batch of state roots.
+     */
+    function appendStateBatch(
+        bytes32[] memory _batch
+    )
+        override
+        public
+    {
+        require(
+            _batch.length > 0,
+            "Cannot submit an empty state batch."
+        );
+
+        require(
+            getTotalElements() + _batch.length <= ovmCanonicalTransactionChain.getTotalElements(),
+            "Number of state roots cannot exceed the number of canonical transactions."
+        );
+
+        bytes[] memory elements = new bytes[](_batch.length);
+        for (uint256 i = 0; i < _batch.length; i++) {
+            elements[i] = abi.encodePacked(_batch[i]);
+        }
+
+        _appendBatch(elements);
+    }
+
+    /**
+     * Deletes all state roots after (and including) a given batch.
+     * @param _batchHeader Header of the batch to start deleting from.
+     */
+    function deleteStateBatch(
+        Lib_OVMCodec.ChainBatchHeader memory _batchHeader
+    )
+        override
+        public
+    {
+        require(
+            msg.sender == address(ovmFraudVerifier),
+            "State batches can only be deleted by the OVM_FraudVerifier."
+        );
+
+        _deleteBatch(_batchHeader);
+    }
+}

packages/contracts/contracts/optimistic-ethereum/OVM/execution/OVM_StateManagerFactory.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+
+/* Interface Imports */
+import { iOVM_StateManager } from "../../iOVM/execution/iOVM_StateManager.sol";
+import { iOVM_StateManagerFactory } from "../../iOVM/execution/iOVM_StateManagerFactory.sol";
+
+/* Contract Imports */
+import { OVM_StateManager } from "./OVM_StateManager.sol";
+
+/**
+ * @title OVM_StateManagerFactory
+ */
+contract OVM_StateManagerFactory is iOVM_StateManagerFactory {
+
+    /***************************************
+     * Public Functions: Contract Creation *
+     ***************************************/
+
+    /**
+     * Creates a new OVM_StateManager
+     * @param _owner Owner of the created contract.
+     * @return _ovmStateManager New OVM_StateManager instance.
+     */
+    function create(
+        address _owner
+    )
+        override
+        public
+        returns (
+            iOVM_StateManager _ovmStateManager
+        )
+    {
+        return new OVM_StateManager(_owner);
+    }
+}

packages/contracts/contracts/optimistic-ethereum/OVM/queue/OVM_BaseQueue.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+pragma experimental ABIEncoderV2;
+
+/* Library Imports */
+import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
+
+/* Interface Imports */
+import { iOVM_BaseQueue } from "../../iOVM/queue/iOVM_BaseQueue.sol";
+
+/**
+ * @title OVM_BaseQueue
+ */
+contract OVM_BaseQueue is iOVM_BaseQueue {
+
+    /****************************************
+     * Contract Variables: Internal Storage *
+     ****************************************/
+
+    Lib_OVMCodec.QueueElement[] internal queue;
+    uint256 internal front;
+
+
+    /**********************
+     * Function Modifiers *
+     **********************/
+
+    /**
+     * Asserts that the queue is not empty.
+     */
+    modifier notEmpty() {
+        require(
+            size() > 0,
+            "Queue is empty."
+        );
+        _;
+    }
+
+
+    /**********************************
+     * Public Functions: Queue Access *
+     **********************************/
+
+    /**
+     * Gets the size of the queue.
+     * @return _size Number of elements in the queue.
+     */
+    function size()
+        override
+        public
+        view
+        returns (
+            uint256 _size
+        )
+    {
+        return front >= queue.length ? 0 : queue.length - front;
+    }
+
+    /**
+     * Gets the top element of the queue.
+     * @return _element First element in the queue.
+     */
+    function peek()
+        override
+        public
+        view
+        notEmpty
+        returns (
+            Lib_OVMCodec.QueueElement memory _element
+        )
+    {
+        return queue[front];
+    }
+
+
+    /******************************************
+     * Internal Functions: Queue Manipulation *
+     ******************************************/
+
+    /**
+     * Adds an element to the queue.
+     * @param _element Queue element to add to the queue.
+     */
+    function _enqueue(
+        Lib_OVMCodec.QueueElement memory _element
+    )
+        internal
+    {
+        queue.push(_element);
+    }
+
+    /**
+     * Pops an element from the queue.
+     * @return _element Queue element popped from the queue.
+     */
+    function _dequeue()
+        internal
+        notEmpty
+        returns (
+            Lib_OVMCodec.QueueElement memory _element
+        )
+    {
+        _element = queue[front];
+        delete queue[front];
+        front += 1;
+        return _element;
+    }
+}

packages/contracts/contracts/optimistic-ethereum/OVM/queue/OVM_L1ToL2TransactionQueue.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+pragma experimental ABIEncoderV2;
+
+/* Proxy Imports */
+import { Proxy_Resolver } from "../../proxy/Proxy_Resolver.sol";
+
+/* Library Imports */
+import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
+
+/* Interface Imports */
+import { iOVM_L1ToL2TransactionQueue } from "../../iOVM/queue/iOVM_L1ToL2TransactionQueue.sol";
+
+/* Contract Imports */
+import { OVM_BaseQueue } from "./OVM_BaseQueue.sol";
+
+/**
+ * @title OVM_L1ToL2TransactionQueue
+ */
+contract OVM_L1ToL2TransactionQueue is iOVM_L1ToL2TransactionQueue, OVM_BaseQueue, Proxy_Resolver {
+
+    /*******************************************
+     * Contract Variables: Contract References *
+     *******************************************/
+
+    address internal ovmCanonicalTransactionChain;
+
+
+    /***************
+     * Constructor *
+     ***************/
+
+    /**
+     * @param _proxyManager Address of the Proxy_Manager.
+     */
+    constructor(
+        address _proxyManager
+    )
+        Proxy_Resolver(_proxyManager)
+    {
+        ovmCanonicalTransactionChain = resolve("OVM_CanonicalTransactionChain");
+    }
+
+
+    /****************************************
+     * Public Functions: Queue Manipulation *
+     ****************************************/
+
+    /**
+     * Adds an element to the queue.
+     * @param _element Queue element to add to the queue.
+     */
+    function enqueue(
+        Lib_OVMCodec.QueueElement memory _element
+    )
+        override
+        public
+    {
+        _enqueue(_element);
+    }
+
+    /**
+     * Pops an element from the queue.
+     * @return _element Queue element popped from the queue.
+     */
+    function dequeue()
+        override
+        public
+        returns (
+            Lib_OVMCodec.QueueElement memory _element
+        )
+    {
+        require(
+            msg.sender == ovmCanonicalTransactionChain,
+            "Sender is not allowed to enqueue."
+        );
+
+        return _dequeue();
+    }
+}

packages/contracts/contracts/optimistic-ethereum/OVM/verification/OVM_FraudVerifier.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+pragma experimental ABIEncoderV2;
+
+/* Proxy Imports */
+import { Proxy_Resolver } from "../../proxy/Proxy_Resolver.sol";
+
+/* Library Imports */
+import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
+
+/* Interface Imports */
+import { iOVM_FraudVerifier } from "../../iOVM/verification/iOVM_FraudVerifier.sol";
+import { iOVM_StateTransitioner } from "../../iOVM/verification/iOVM_StateTransitioner.sol";
+import { iOVM_StateTransitionerFactory } from "../../iOVM/verification/iOVM_StateTransitionerFactory.sol";
+import { iOVM_ExecutionManager } from "../../iOVM/execution/iOVM_ExecutionManager.sol";
+import { iOVM_StateManagerFactory } from "../../iOVM/execution/iOVM_StateManagerFactory.sol";
+import { iOVM_StateCommitmentChain } from "../../iOVM/chain/iOVM_StateCommitmentChain.sol";
+import { iOVM_CanonicalTransactionChain } from "../../iOVM/chain/iOVM_CanonicalTransactionChain.sol";
+
+contract OVM_FraudVerifier is iOVM_FraudVerifier, Proxy_Resolver {
+
+    /*******************************************
+     * Contract Variables: Contract References *
+     *******************************************/
+
+    iOVM_StateCommitmentChain internal ovmStateCommitmentChain;
+    iOVM_CanonicalTransactionChain internal ovmCanonicalTransactionChain;
+
+    
+    /*******************************************
+     * Contract Variables: Internal Accounting *
+     *******************************************/
+
+    mapping (bytes32 => iOVM_StateTransitioner) internal transitioners;
+    
+
+    /***************
+     * Constructor *
+     ***************/
+
+    /**
+     * @param _proxyManager Address of the Proxy_Manager.
+     */
+    constructor(
+        address _proxyManager
+    )
+        Proxy_Resolver(_proxyManager)
+    {
+        ovmStateCommitmentChain = iOVM_StateCommitmentChain(resolve("OVM_StateCommitmentChain"));
+        ovmCanonicalTransactionChain = iOVM_CanonicalTransactionChain(resolve("OVM_CanonicalTransactionChain"));
+    }
+
+
+    /***************************************
+     * Public Functions: Transition Status *
+     ***************************************/
+
+    /**
+     * Retrieves the state transitioner for a given root.
+     * @param _preStateRoot State root to query a transitioner for.
+     * @return _transitioner Corresponding state transitioner contract.
+     */
+    function getStateTransitioner(
+        bytes32 _preStateRoot
+    )
+        override
+        public
+        view
+        returns (
+            iOVM_StateTransitioner _transitioner
+        )
+    {
+        return transitioners[_preStateRoot];
+    }
+
+
+    /****************************************
+     * Public Functions: Fraud Verification *
+     ****************************************/
+
+    /**
+     * Begins the fraud verification process.
+     * @param _preStateRoot State root before the fraudulent transaction.
+     * @param _preStateRootBatchHeader Batch header for the provided pre-state root.
+     * @param _preStateRootProof Inclusion proof for the provided pre-state root.
+     * @param _transaction OVM transaction claimed to be fraudulent.
+     * @param _transactionBatchHeader Batch header for the provided transaction.
+     * @param _transactionProof Inclusion proof for the provided transaction.
+     */
+    function initializeFraudVerification(
+        bytes32 _preStateRoot,
+        Lib_OVMCodec.ChainBatchHeader memory _preStateRootBatchHeader,
+        Lib_OVMCodec.ChainInclusionProof memory _preStateRootProof,
+        Lib_OVMCodec.Transaction memory _transaction,
+        Lib_OVMCodec.ChainBatchHeader memory _transactionBatchHeader,
+        Lib_OVMCodec.ChainInclusionProof memory _transactionProof
+    )
+        override
+        public
+    {
+        if (_hasStateTransitioner(_preStateRoot)) {
+            return;
+        }
+
+        require(
+            _verifyStateRoot(
+                _preStateRoot,
+                _preStateRootBatchHeader,
+                _preStateRootProof
+            ),
+            "Invalid pre-state root inclusion proof."
+        );
+
+        require(
+            _verifyTransaction(
+                _transaction,
+                _transactionBatchHeader,
+                _transactionProof
+            ),
+            "Invalid transaction inclusion proof."
+        );
+
+        transitioners[_preStateRoot] = iOVM_StateTransitionerFactory(
+            resolve("OVM_StateTransitionerFactory")
+        ).create(
+            address(proxyManager),
+            _preStateRootProof.index,
+            _preStateRoot,
+            Lib_OVMCodec.hashTransaction(_transaction)
+        );
+    }
+
+    /**
+     * Finalizes the fraud verification process.
+     * @param _preStateRoot State root before the fraudulent transaction.
+     * @param _preStateRootBatchHeader Batch header for the provided pre-state root.
+     * @param _preStateRootProof Inclusion proof for the provided pre-state root.
+     * @param _postStateRoot State root after the fraudulent transaction.
+     * @param _postStateRootBatchHeader Batch header for the provided post-state root.
+     * @param _postStateRootProof Inclusion proof for the provided post-state root.
+     */
+    function finalizeFraudVerification(
+        bytes32 _preStateRoot,
+        Lib_OVMCodec.ChainBatchHeader memory _preStateRootBatchHeader,
+        Lib_OVMCodec.ChainInclusionProof memory _preStateRootProof,
+        bytes32 _postStateRoot,
+        Lib_OVMCodec.ChainBatchHeader memory _postStateRootBatchHeader,
+        Lib_OVMCodec.ChainInclusionProof memory _postStateRootProof
+    )
+        override
+        public
+    {
+        iOVM_StateTransitioner transitioner = transitioners[_preStateRoot];
+
+        require(
+            transitioner.isComplete() == true,
+            "State transition process must be completed prior to finalization."
+        );
+
+        require(
+            _postStateRootProof.index == _preStateRootProof.index + 1,
+            "Invalid post-state root index."
+        );
+
+        require(
+            _verifyStateRoot(
+                _preStateRoot,
+                _preStateRootBatchHeader,
+                _preStateRootProof
+            ),
+            "Invalid pre-state root inclusion proof."
+        );
+
+        require(
+            _verifyStateRoot(
+                _postStateRoot,
+                _postStateRootBatchHeader,
+                _postStateRootProof
+            ),
+            "Invalid post-state root inclusion proof."
+        );
+
+        require(
+            _postStateRoot != transitioner.getPostStateRoot(),
+            "State transition has not been proven fraudulent."
+        );
+
+        ovmStateCommitmentChain.deleteStateBatch(
+            _postStateRootBatchHeader
+        );
+    }
+
+
+    /************************************
+     * Internal Functions: Verification *
+     ************************************/
+
+    /**
+     * Checks whether a transitioner already exists for a given pre-state root.
+     * @param _preStateRoot Pre-state root to check.
+     * @return _exists Whether or not we already have a transitioner for the root.
+     */
+    function _hasStateTransitioner(
+        bytes32 _preStateRoot
+    )
+        internal
+        view
+        returns (
+            bool _exists
+        )
+    {
+        return address(transitioners[_preStateRoot]) != address(0);
+    }
+
+    /**
+     * Verifies inclusion of a state root.
+     * @param _stateRoot State root to verify
+     * @param _stateRootBatchHeader Batch header for the provided state root.
+     * @param _stateRootProof Inclusion proof for the provided state root.
+     * @return _verified Whether or not the root was included.
+     */
+    function _verifyStateRoot(
+        bytes32 _stateRoot,
+        Lib_OVMCodec.ChainBatchHeader memory _stateRootBatchHeader,
+        Lib_OVMCodec.ChainInclusionProof memory _stateRootProof
+    )
+        internal
+        view
+        returns (
+            bool _verified
+        )
+    {
+        return ovmStateCommitmentChain.verifyElement(
+            abi.encodePacked(_stateRoot),
+            _stateRootBatchHeader,
+            _stateRootProof
+        );
+    }
+
+    /**
+     * Verifies inclusion of a given transaction.
+     * @param _transaction OVM transaction to verify.
+     * @param _transactionBatchHeader Batch header for the provided transaction.
+     * @param _transactionProof Inclusion proof for the provided transaction.
+     * @return _verified Whether or not the transaction was included.
+     */
+    function _verifyTransaction(
+        Lib_OVMCodec.Transaction memory _transaction,
+        Lib_OVMCodec.ChainBatchHeader memory _transactionBatchHeader,
+        Lib_OVMCodec.ChainInclusionProof memory _transactionProof
+    )
+        internal
+        view
+        returns (
+            bool _verified
+        )
+    {
+        return ovmCanonicalTransactionChain.verifyElement(
+            Lib_OVMCodec.encodeTransaction(_transaction),
+            _transactionBatchHeader,
+            _transactionProof
+        );
+    }
+}

packages/contracts/contracts/optimistic-ethereum/OVM/verification/OVM_StateTransitionerFactory.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+
+/* Interface Imports */
+import { iOVM_StateTransitioner } from "../../iOVM/verification/iOVM_StateTransitioner.sol";
+import { iOVM_StateTransitionerFactory } from "../../iOVM/verification/iOVM_StateTransitionerFactory.sol";
+
+/* Contract Imports */
+import { OVM_StateTransitioner } from "./OVM_StateTransitioner.sol";
+
+/**
+ * @title OVM_StateTransitionerFactory
+ */
+contract OVM_StateTransitionerFactory is iOVM_StateTransitionerFactory {
+
+    /***************************************
+     * Public Functions: Contract Creation *
+     ***************************************/
+
+    /**
+     * Creates a new OVM_StateTransitioner
+     * @param _proxyManager Address of the Proxy_Manager.
+     * @param _stateTransitionIndex Index of the state transition being verified.
+     * @param _preStateRoot State root before the transition was executed.
+     * @param _transactionHash Hash of the executed transaction.
+     * @return _ovmStateTransitioner New OVM_StateTransitioner instance.
+     */
+    function create(
+        address _proxyManager,
+        uint256 _stateTransitionIndex,
+        bytes32 _preStateRoot,
+        bytes32 _transactionHash
+    )
+        override
+        public
+        returns (
+            iOVM_StateTransitioner _ovmStateTransitioner
+        )
+    {
+        return new OVM_StateTransitioner(
+            _proxyManager,
+            _stateTransitionIndex,
+            _preStateRoot,
+            _transactionHash
+        );
+    }
+}

packages/contracts/contracts/optimistic-ethereum/iOVM/chain/iOVM_BaseChain.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+pragma experimental ABIEncoderV2;
+
+/* Library Imports */
+import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
+
+/**
+ * @title iOVM_BaseChain
+ */
+interface iOVM_BaseChain {
+
+    /*************************************
+     * Public Functions: Batch Retrieval *
+     *************************************/
+
+    function getTotalElements() external view returns (uint256 _totalElements);
+    function getTotalBatches() external view returns (uint256 _totalBatches);
+
+
+    /****************************************
+     * Public Functions: Batch Verification *
+     ****************************************/
+
+    function verifyElement(
+        bytes calldata _element,
+        Lib_OVMCodec.ChainBatchHeader calldata _batchHeader,
+        Lib_OVMCodec.ChainInclusionProof calldata _proof
+    ) external view returns (bool _verified);
+}

packages/contracts/contracts/optimistic-ethereum/iOVM/chain/iOVM_CanonicalTransactionChain.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+pragma experimental ABIEncoderV2;
+
+/* Interface Imports */
+import { iOVM_BaseChain } from "./iOVM_BaseChain.sol";
+
+/**
+ * @title iOVM_CanonicalTransactionChain
+ */
+interface iOVM_CanonicalTransactionChain is iOVM_BaseChain {
+
+    /****************************************
+     * Public Functions: Batch Manipulation *
+     ****************************************/
+
+    function appendQueueBatch() external;
+    function appendSequencerBatch(bytes[] calldata _batch, uint256 _timestamp) external;
+}

packages/contracts/contracts/optimistic-ethereum/iOVM/chain/iOVM_StateCommitmentChain.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+pragma experimental ABIEncoderV2;
+
+/* Interface Imports */
+import { iOVM_BaseChain } from "./iOVM_BaseChain.sol";
+
+/* Library Imports */
+import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
+
+/**
+ * @title iOVM_StateCommitmentChain
+ */
+interface iOVM_StateCommitmentChain is iOVM_BaseChain {
+
+    /****************************************
+     * Public Functions: Batch Manipulation *
+     ****************************************/
+
+    function appendStateBatch(bytes32[] calldata _batch) external;
+    function deleteStateBatch(Lib_OVMCodec.ChainBatchHeader memory _batchHeader) external;
+}

packages/contracts/contracts/optimistic-ethereum/iOVM/execution/iOVM_ExecutionManager.sol

@@ -6,9 +6,9 @@ pragma experimental ABIEncoderV2;
 import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
 
 interface iOVM_ExecutionManager {
-    /*******************
-     * Data Structures *
-     *******************/
+    /**********
+     * Enums *
+     *********/
 
     enum RevertFlag {
         DID_NOT_REVERT,
@@ -16,7 +16,35 @@ interface iOVM_ExecutionManager {
         INTENTIONAL_REVERT,
         EXCEEDS_NUISANCE_GAS,
         INVALID_STATE_ACCESS,
-        UNSAFE_BYTECODE
+        UNSAFE_BYTECODE,
+        CREATE_COLLISION,
+        STATIC_VIOLATION,
+        CREATE_EXCEPTION
+    }
+
+    enum GasMetadataKey {
+        CURRENT_EPOCH_START_TIMESTAMP,
+        CUMULATIVE_SEQUENCER_QUEUE_GAS,
+        CUMULATIVE_L1TOL2_QUEUE_GAS,
+        PREV_EPOCH_SEQUENCER_QUEUE_GAS,
+        PREV_EPOCH_L1TOL2_QUEUE_GAS
+    }
+
+    enum QueueOrigin {
+        SEQUENCER_QUEUE,
+        L1TOL2_QUEUE
+    }
+
+    
+    /***********
+     * Structs *
+     ***********/
+
+    struct GasMeterConfig {
+        uint256 minTransactionGasLimit;
+        uint256 maxTransactionGasLimit;
+        uint256 maxGasPerQueuePerEpoch;
+        uint256 secondsPerEpoch;
     }
 
     struct GlobalContext {
@@ -39,6 +67,7 @@ interface iOVM_ExecutionManager {
         address ovmCALLER;
         address ovmADDRESS;
         bool isStatic;
+        bool isCreation;
     }
 
     struct MessageRecord {
@@ -61,12 +90,12 @@ interface iOVM_ExecutionManager {
      * Context Opcodes *
      *******************/
 
-    function ovmCALLER() external returns (address _caller);
-    function ovmADDRESS() external returns (address _address);
-    function ovmORIGIN() external returns (address _origin);
-    function ovmTIMESTAMP() external returns (uint256 _timestamp);
-    function ovmGASLIMIT() external returns (uint256 _gasLimit);
-    function ovmCHAINID() external returns (uint256 _chainId);
+    function ovmCALLER() external view returns (address _caller);
+    function ovmADDRESS() external view returns (address _address);
+    function ovmORIGIN() external view returns (address _origin);
+    function ovmTIMESTAMP() external view returns (uint256 _timestamp);
+    function ovmGASLIMIT() external view returns (uint256 _gasLimit);
+    function ovmCHAINID() external view returns (uint256 _chainId);
 
 
     /*******************

packages/contracts/contracts/optimistic-ethereum/iOVM/execution/iOVM_StateManager.sol

@@ -17,24 +17,36 @@ interface iOVM_StateManager {
     enum ItemState {
         ITEM_UNTOUCHED,
         ITEM_LOADED,
-        ITEM_CHANGED
+        ITEM_CHANGED,
+        ITEM_COMMITTED
     }
 
 
+    /***************************
+     * Public Functions: Setup *
+     ***************************/
+    
+    function setExecutionManager(address _ovmExecutionManager) external;
+
+
     /************************************
      * Public Functions: Account Access *
      ************************************/
 
     function putAccount(address _address, Lib_OVMCodec.Account memory _account) external;
-    function getAccount(address _address) external returns (Lib_OVMCodec.Account memory _account);
-    function hasAccount(address _address) external returns (bool _exists);
+    function getAccount(address _address) external view returns (Lib_OVMCodec.Account memory _account);
+    function hasAccount(address _address) external view returns (bool _exists);
+    function hasEmptyAccount(address _address) external view returns (bool _exists);
     function setAccountNonce(address _address, uint256 _nonce) external;
-    function getAccountNonce(address _address) external returns (uint256 _nonce);
-    function getAccountEthAddress(address _address) external returns (address _ethAddress);
+    function getAccountNonce(address _address) external view returns (uint256 _nonce);
+    function getAccountEthAddress(address _address) external view returns (address _ethAddress);
     function initPendingAccount(address _address) external;
     function commitPendingAccount(address _address, address _ethAddress, bytes32 _codeHash) external;
     function testAndSetAccountLoaded(address _address) external returns (bool _wasAccountAlreadyLoaded);
     function testAndSetAccountChanged(address _address) external returns (bool _wasAccountAlreadyChanged);
+    function commitAccount(address _address) external returns (bool _wasAccountCommitted);
+    function incrementTotalUncommittedAccounts() external;
+    function getTotalUncommittedAccounts() external view returns (uint256 _total);
 
     
     /************************************
@@ -42,8 +54,11 @@ interface iOVM_StateManager {
      ************************************/
 
     function putContractStorage(address _contract, bytes32 _key, bytes32 _value) external;
-    function getContractStorage(address _contract, bytes32 _key) external returns (bytes32 _value);
+    function getContractStorage(address _contract, bytes32 _key) external view returns (bytes32 _value);
     function hasContractStorage(address _contract, bytes32 _key) external returns (bool _exists);
     function testAndSetContractStorageLoaded(address _contract, bytes32 _key) external returns (bool _wasContractStorageAlreadyLoaded);
     function testAndSetContractStorageChanged(address _contract, bytes32 _key) external returns (bool _wasContractStorageAlreadyChanged);
+    function commitContractStorage(address _contract, bytes32 _key) external returns (bool _wasContractStorageCommitted);
+    function incrementTotalUncommittedContractStorage() external;
+    function getTotalUncommittedContractStorage() external view returns (uint256 _total);
 }

packages/contracts/contracts/optimistic-ethereum/iOVM/execution/iOVM_StateManagerFactory.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+
+/* Contract Imports */
+import { iOVM_StateManager } from "./iOVM_StateManager.sol";
+
+/**
+ * @title iOVM_StateManagerFactory
+ */
+interface iOVM_StateManagerFactory {
+
+    /***************************************
+     * Public Functions: Contract Creation *
+     ***************************************/
+
+    function create(
+        address _owner
+    )
+        external
+        returns (
+            iOVM_StateManager _ovmStateManager
+        );
+}

packages/contracts/contracts/optimistic-ethereum/iOVM/queue/iOVM_BaseQueue.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+pragma experimental ABIEncoderV2;
+
+/* Library Imports */
+import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
+
+/**
+ * @title iOVM_BaseQueue
+ */
+interface iOVM_BaseQueue {
+
+    /**********************************
+     * Public Functions: Queue Access *
+     **********************************/
+
+    function size() external view returns (uint256 _size);
+    function peek() external view returns (Lib_OVMCodec.QueueElement memory _element);
+}

packages/contracts/contracts/optimistic-ethereum/iOVM/queue/iOVM_L1ToL2TransactionQueue.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+pragma experimental ABIEncoderV2;
+
+/* Library Imports */
+import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
+
+/* Interface Imports */
+import { iOVM_BaseQueue } from "./iOVM_BaseQueue.sol";
+
+/**
+ * @title iOVM_L1ToL2TransactionQueue
+ */
+interface iOVM_L1ToL2TransactionQueue is iOVM_BaseQueue {
+
+    /****************************************
+     * Public Functions: Queue Manipulation *
+     ****************************************/
+
+    function enqueue(Lib_OVMCodec.QueueElement memory _element) external;
+    function dequeue() external returns (Lib_OVMCodec.QueueElement memory _element);
+}

packages/contracts/contracts/optimistic-ethereum/iOVM/verification/iOVM_FraudVerifier.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+pragma experimental ABIEncoderV2;
+
+/* Library Imports */
+import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
+
+/* Interface Imports */
+import { iOVM_StateTransitioner } from "./iOVM_StateTransitioner.sol";
+
+/**
+ * @title iOVM_FraudVerifier
+ */
+interface iOVM_FraudVerifier {
+
+    /***************************************
+     * Public Functions: Transition Status *
+     ***************************************/
+
+    function getStateTransitioner(bytes32 _preStateRoot) external view returns (iOVM_StateTransitioner _transitioner);
+
+
+    /****************************************
+     * Public Functions: Fraud Verification *
+     ****************************************/
+
+    function initializeFraudVerification(
+        bytes32 _preStateRoot,
+        Lib_OVMCodec.ChainBatchHeader calldata _preStateRootBatchHeader,
+        Lib_OVMCodec.ChainInclusionProof calldata _preStateRootProof,
+        Lib_OVMCodec.Transaction calldata _transaction,
+        Lib_OVMCodec.ChainBatchHeader calldata _transactionBatchHeader,
+        Lib_OVMCodec.ChainInclusionProof calldata _transactionProof
+    ) external;
+
+    function finalizeFraudVerification(
+        bytes32 _preStateRoot,
+        Lib_OVMCodec.ChainBatchHeader calldata _preStateRootBatchHeader,
+        Lib_OVMCodec.ChainInclusionProof calldata _preStateRootProof,
+        bytes32 _postStateRoot,
+        Lib_OVMCodec.ChainBatchHeader calldata _postStateRootBatchHeader,
+        Lib_OVMCodec.ChainInclusionProof calldata _postStateRootProof
+    ) external;
+}

packages/contracts/contracts/optimistic-ethereum/iOVM/verification/iOVM_StateTransitioner.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+pragma experimental ABIEncoderV2;
+
+/* Library Imports */
+import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
+
+/**
+ * @title iOVM_StateTransitioner
+ */
+interface iOVM_StateTransitioner {
+
+    /**********************************
+     * Public Functions: State Access *
+     **********************************/
+
+    function getPreStateRoot() external view returns (bytes32 _preStateRoot);
+    function getPostStateRoot() external view returns (bytes32 _postStateRoot);
+    function isComplete() external view returns (bool _complete);
+
+    
+    /***********************************
+     * Public Functions: Pre-Execution *
+     ***********************************/
+
+    function proveContractState(
+        address _ovmContractAddress,
+        Lib_OVMCodec.Account calldata _account,
+        bytes calldata _stateTrieWitness
+    ) external;
+
+    function proveStorageSlot(
+        address _ovmContractAddress,
+        bytes32 _key,
+        bytes32 _value,
+        bytes calldata _stateTrieWitness,
+        bytes calldata _storageTrieWitness
+    ) external;
+
+
+    /*******************************
+     * Public Functions: Execution *
+     *******************************/
+
+    function applyTransaction(
+        Lib_OVMCodec.Transaction calldata _transaction
+    ) external;
+
+
+    /************************************
+     * Public Functions: Post-Execution *
+     ************************************/
+
+    function commitContractState(
+        address _ovmContractAddress,
+        Lib_OVMCodec.Account calldata _account,
+        bytes calldata _stateTrieWitness
+    ) external;
+
+    function commitStorageSlot(
+        address _ovmContractAddress,
+        bytes32 _key,
+        bytes32 _value,
+        bytes calldata _stateTrieWitness,
+        bytes calldata _storageTrieWitness
+    ) external;
+
+
+    /**********************************
+     * Public Functions: Finalization *
+     **********************************/
+
+    function completeTransition() external;
+}

packages/contracts/contracts/optimistic-ethereum/iOVM/verification/iOVM_StateTransitionerFactory.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+
+/* Contract Imports */
+import { iOVM_StateTransitioner } from "./iOVM_StateTransitioner.sol";
+
+/**
+ * @title iOVM_StateTransitionerFactory
+ */
+interface iOVM_StateTransitionerFactory {
+
+    /***************************************
+     * Public Functions: Contract Creation *
+     ***************************************/
+
+    function create(
+        address _proxyManager,
+        uint256 _stateTransitionIndex,
+        bytes32 _preStateRoot,
+        bytes32 _transactionHash
+    )
+        external
+        returns (
+            iOVM_StateTransitioner _ovmStateTransitioner
+        );
+}

packages/contracts/contracts/optimistic-ethereum/libraries/codec/Lib_OVMCodec.sol

@@ -20,6 +20,14 @@ library Lib_OVMCodec {
         bytes32 storageRoot;
         bytes32 codeHash;
         address ethAddress;
+        bool isFresh;
+    }
+
+    struct EVMAccount {
+        uint256 nonce;
+        uint256 balance;
+        bytes32 storageRoot;
+        bytes32 codeHash;
     }
 
     struct ChainBatchHeader {
@@ -98,4 +106,46 @@ library Lib_OVMCodec {
             data: Lib_RLPReader.toBytes(decoded[5])
         });
     }
+
+    /**
+     * Encodes a standard OVM transaction.
+     * @param _transaction OVM transaction to encode.
+     * @return _encoded Encoded transaction bytes.
+     */
+    function encodeTransaction(
+        Transaction memory _transaction
+    )
+        internal
+        pure
+        returns (
+            bytes memory _encoded
+        )
+    {
+        return abi.encodePacked(
+            _transaction.timestamp,
+            _transaction.queueOrigin,
+            _transaction.entrypoint,
+            _transaction.origin,
+            _transaction.msgSender,
+            _transaction.gasLimit,
+            _transaction.data
+        );
+    }
+
+    /**
+     * Hashes a standard OVM transaction.
+     * @param _transaction OVM transaction to encode.
+     * @return _hash Hashed transaction
+     */
+    function hashTransaction(
+        Transaction memory _transaction
+    )
+        internal
+        pure
+        returns (
+            bytes32 _hash
+        )
+    {
+        return keccak256(encodeTransaction(_transaction));
+    }
 }

packages/contracts/contracts/optimistic-ethereum/libraries/trie/Lib_SecureMerkleTrie.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+pragma experimental ABIEncoderV2;
+
+/* Library Imports */
+import { Lib_MerkleTrie } from "./Lib_MerkleTrie.sol";
+
+/**
+ * @title Lib_SecureMerkleTrie
+ */
+library Lib_SecureMerkleTrie {
+
+    /**********************
+     * Internal Functions *
+     **********************/
+
+    /**
+     * @notice Verifies a proof that a given key/value pair is present in the
+     * Merkle trie.
+     * @param _key Key of the node to search for, as a hex string.
+     * @param _value Value of the node to search for, as a hex string.
+     * @param _proof Merkle trie inclusion proof for the desired node. Unlike
+     * traditional Merkle trees, this proof is executed top-down and consists
+     * of a list of RLP-encoded nodes that make a path down to the target node.
+     * @param _root Known root of the Merkle trie. Used to verify that the
+     * included proof is correctly constructed.
+     * @return `true` if the k/v pair exists in the trie, `false` otherwise.
+     */
+    function verifyInclusionProof(
+        bytes memory _key,
+        bytes memory _value,
+        bytes memory _proof,
+        bytes32 _root
+    )
+        internal
+        view
+        returns (
+            bool
+        )
+    {
+        bytes memory key = _getSecureKey(_key);
+        return Lib_MerkleTrie.verifyInclusionProof(key, _value, _proof, _root);
+    }
+
+    /**
+     * @notice Verifies a proof that a given key/value pair is *not* present in
+     * the Merkle trie.
+     * @param _key Key of the node to search for, as a hex string.
+     * @param _value Value of the node to search for, as a hex string.
+     * @param _proof Merkle trie inclusion proof for the node *nearest* the
+     * target node. We effectively need to show that either the key exists and
+     * its value differs, or the key does not exist at all.
+     * @param _root Known root of the Merkle trie. Used to verify that the
+     * included proof is correctly constructed.
+     * @return `true` if the k/v pair is absent in the trie, `false` otherwise.
+     */
+    function verifyExclusionProof(
+        bytes memory _key,
+        bytes memory _value,
+        bytes memory _proof,
+        bytes32 _root
+    )
+        internal
+        view
+        returns (
+            bool
+        )
+    {
+        bytes memory key = _getSecureKey(_key);
+        return Lib_MerkleTrie.verifyExclusionProof(key, _value, _proof, _root);
+    }
+
+    /**
+     * @notice Updates a Merkle trie and returns a new root hash.
+     * @param _key Key of the node to update, as a hex string.
+     * @param _value Value of the node to update, as a hex string.
+     * @param _proof Merkle trie inclusion proof for the node *nearest* the
+     * target node. If the key exists, we can simply update the value.
+     * Otherwise, we need to modify the trie to handle the new k/v pair.
+     * @param _root Known root of the Merkle trie. Used to verify that the
+     * included proof is correctly constructed.
+     * @return Root hash of the newly constructed trie.
+     */
+    function update(
+        bytes memory _key,
+        bytes memory _value,
+        bytes memory _proof,
+        bytes32 _root
+    )
+        internal
+        view
+        returns (
+            bytes32
+        )
+    {
+        bytes memory key = _getSecureKey(_key);
+        return Lib_MerkleTrie.update(key, _value, _proof, _root);
+    }
+
+    /**
+     * @notice Retrieves the value associated with a given key.
+     * @param _key Key to search for, as hex bytes.
+     * @param _proof Merkle trie inclusion proof for the key.
+     * @param _root Known root of the Merkle trie.
+     * @return Whether the node exists, value associated with the key if so.
+     */
+    function get(
+        bytes memory _key,
+        bytes memory _proof,
+        bytes32 _root
+    )
+        internal
+        view
+        returns (
+            bool,
+            bytes memory
+        )
+    {
+        bytes memory key = _getSecureKey(_key);
+        return Lib_MerkleTrie.get(key, _proof, _root);
+    }
+
+    /**
+     * Computes the root hash for a trie with a single node.
+     * @param _key Key for the single node.
+     * @param _value Value for the single node.
+     * @return Hash of the trie.
+     */
+    function getSingleNodeRootHash(
+        bytes memory _key,
+        bytes memory _value
+    )
+        internal
+        view
+        returns (
+            bytes32
+        )
+    {
+        bytes memory key = _getSecureKey(_key);
+        return Lib_MerkleTrie.getSingleNodeRootHash(key, _value);
+    }
+
+
+    /*********************
+     * Private Functions *
+     *********************/
+
+    function _getSecureKey(
+        bytes memory _key
+    )
+        private
+        pure
+        returns (
+            bytes memory
+        )
+    {
+        return abi.encodePacked(keccak256(_key));
+    }
+}
\ No newline at end of file

packages/contracts/prettier-config.json

+{
+  "$schema": "http://json.schemastore.org/prettierrc",
+  "trailingComma": "es5",
+  "tabWidth": 2,
+  "semi": false,
+  "singleQuote": true,
+  "arrowParens": "always"
+}

packages/contracts/test/helpers/constants.ts

@@ -19,3 +19,6 @@ export const NULL_BYTES32 = makeHexString('00', 32)
 export const NON_NULL_BYTES32 = makeHexString('11', 32)
 export const ZERO_ADDRESS = makeAddress('00')
 export const NON_ZERO_ADDRESS = makeAddress('11')
+
+export const VERIFIED_EMPTY_CONTRACT_HASH =
+  '0x00004B1DC0DE000000004B1DC0DE000000004B1DC0DE000000004B1DC0DE0000'

packages/contracts/test/helpers/test-utils/index.ts

+export * from './test-runner'
+export * from './test.types'