Merge pull request #9 from ethereum-optimism/feat/message-passing-tests

Add tests for message passing contracts

packages/contracts/.gitignore

 node_modules/
 artifacts/
 cache/
+yarn-error.log
+build/

packages/contracts/README.md

+# Optimism's Contracts (V2)
+
+This package contains the various Ethereum smart contracts that make up the Layer 1 component of Optimism's Optimistic Rollup construction.
+
+## Building and Running
+
+This package requires that `yarn` be installed on your machine!  Once it is, run `yarn test` to build and run tests.
+
+## Disclaimer
+
+The contracts in this package have **not** been audited. We **do not recommend** deploying these contracts in a production capacity.

packages/contracts/bin/gen_safety_checker_constants.py

+#!/usr/bin/env python3
+# pip3 install pyevmasm
+from pyevmasm import instruction_tables
+
+#print(instruction_tables.keys())
+
+def asm(x):
+  return [instruction_tables['istanbul'][i].opcode for i in x]
+
+push_opcodes = asm(["PUSH%d" % i for i in range(1,33)])
+stop_opcodes = asm(["STOP", "JUMP", "RETURN", "INVALID"])
+caller_opcodes = asm(["CALLER"])
+blacklist_ops = set([
+  "ADDRESS", "BALANCE", "BLOCKHASH",
+  "CALL", "CALLCODE", "CHAINID", "COINBASE",
+  "CREATE", "CREATE2", "DELEGATECALL", "DIFFICULTY",
+  "EXTCODESIZE", "EXTCODECOPY", "EXTCODEHASH",
+  "GASLIMIT", "GASPRICE", "NUMBER",
+  "ORIGIN", "REVERT", "SELFBALANCE", "SELFDESTRUCT",
+  "SLOAD", "SSTORE", "STATICCALL", "TIMESTAMP"])
+whitelist_opcodes = []
+for x in instruction_tables['istanbul']:
+  if x.name not in blacklist_ops:
+    whitelist_opcodes.append(x.opcode)
+
+pushmask = 0
+for x in push_opcodes:
+  pushmask |= 1 << x
+
+stopmask = 0
+for x in stop_opcodes:
+  stopmask |= 1 << x
+
+stoplist = [0]*256
+procmask = 0
+for i in range(256):
+  if i in whitelist_opcodes and \
+      i not in push_opcodes and \
+      i not in stop_opcodes and \
+      i not in caller_opcodes:
+    # can skip this opcode
+    stoplist[i] = 1
+  else:
+    procmask |= 1 << i
+
+# PUSH1 through PUSH4, can't skip in slow
+for i in range(0x60, 0x64):
+  stoplist[i] = i-0x5e
+rr = "uint256[8] memory opcodeSkippableBytes = [\n"
+for i in range(0, 0x100, 0x20):
+  ret = "uint256(0x"
+  for j in range(i, i+0x20, 1):
+    ret += ("%02X" % stoplist[j])
+  rr += ret+"),\n"
+  
+rr = rr[:-2] + "];"
+
+print(rr)
+print("// Mask to gate opcode specific cases")
+print("uint256 opcodeGateMask = ~uint256(0x%x);" % procmask)
+print("// Halting opcodes")
+print("uint256 opcodeHaltingMask = ~uint256(0x%x);" % stopmask)
+print("// PUSH opcodes")
+print("uint256 opcodePushMask = ~uint256(0x%x);" % pushmask)
+

packages/contracts/bin/take-dump.ts

+/* External Imports */
+import * as fs from 'fs'
+import * as path from 'path'
+import * as mkdirp from 'mkdirp'
+
+/* Internal Imports */
+import { makeStateDump } from '../src/contract-dumps'
+;(async () => {
+  const outdir = path.resolve(__dirname, '../build/dumps')
+  const outfile = path.join(outdir, 'state-dump.latest.json')
+  mkdirp.sync(outdir)
+
+  const dump = await makeStateDump()
+  fs.writeFileSync(outfile, JSON.stringify(dump, null, 4))
+})()

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,
+  RUN_OVM_TEST_GAS,
+} from './test/helpers/constants'
 
 usePlugin('@nomiclabs/buidler-ethers')
 usePlugin('@nomiclabs/buidler-waffle')
 
-import './test/helpers/buidler/modify-compiler'
+import '@eth-optimism/smock/build/src/buidler-plugins/compiler-storage-layout'
 
 const config: BuidlerConfig = {
   networks: {
     buidlerevm: {
       accounts: DEFAULT_ACCOUNTS_BUIDLER,
-      blockGasLimit: GAS_LIMIT * 2,
+      blockGasLimit: RUN_OVM_TEST_GAS * 2,
     },
   },
   mocha: {

packages/contracts/contracts/optimistic-ethereum/OVM/accounts/OVM_ECDSAContractAccount.sol

@@ -4,11 +4,11 @@ pragma experimental ABIEncoderV2;
 
 /* Interface Imports */
 import { iOVM_ECDSAContractAccount } from "../../iOVM/accounts/iOVM_ECDSAContractAccount.sol";
-import { iOVM_ExecutionManager } from "../../iOVM/execution/iOVM_ExecutionManager.sol";
 
 /* Library Imports */
 import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
 import { Lib_ECDSAUtils } from "../../libraries/utils/Lib_ECDSAUtils.sol";
+import { Lib_SafeExecutionManagerWrapper } from "../../libraries/wrappers/Lib_SafeExecutionManagerWrapper.sol";
 
 /**
  * @title OVM_ECDSAContractAccount
@@ -43,7 +43,7 @@ contract OVM_ECDSAContractAccount is iOVM_ECDSAContractAccount {
             bytes memory _returndata
         )
     {
-        iOVM_ExecutionManager ovmExecutionManager = iOVM_ExecutionManager(msg.sender);
+        address ovmExecutionManager = msg.sender;
 
         // Address of this contract within the ovm (ovmADDRESS) should be the same as the
         // recovered address of the user who signed this message. This is how we manage to shim
@@ -55,8 +55,8 @@ contract OVM_ECDSAContractAccount is iOVM_ECDSAContractAccount {
                 _v,
                 _r,
                 _s,
-                ovmExecutionManager.ovmCHAINID()
-            ) == ovmExecutionManager.ovmADDRESS(),
+                Lib_SafeExecutionManagerWrapper.safeCHAINID(ovmExecutionManager)
+            ) == Lib_SafeExecutionManagerWrapper.safeADDRESS(ovmExecutionManager),
             "Signature provided for EOA transaction execution is invalid."
         );
 
@@ -64,14 +64,15 @@ contract OVM_ECDSAContractAccount is iOVM_ECDSAContractAccount {
 
         // Need to make sure that the transaction nonce is right and bump it if so.
         require(
-            decodedTx.nonce == ovmExecutionManager.ovmGETNONCE() + 1,
+            decodedTx.nonce == Lib_SafeExecutionManagerWrapper.safeGETNONCE(ovmExecutionManager) + 1,
             "Transaction nonce does not match the expected nonce."
         );
-        ovmExecutionManager.ovmSETNONCE(decodedTx.nonce);
 
         // Contract creations are signalled by sending a transaction to the zero address.
         if (decodedTx.target == address(0)) {
-            address created = ovmExecutionManager.ovmCREATE{gas: decodedTx.gasLimit}(
+            address created = Lib_SafeExecutionManagerWrapper.safeCREATE(
+                ovmExecutionManager,
+                decodedTx.gasLimit,
                 decodedTx.data
             );
 
@@ -79,7 +80,13 @@ contract OVM_ECDSAContractAccount is iOVM_ECDSAContractAccount {
             // initialization. Always return `true` for our success value here.
             return (true, abi.encode(created));
         } else {
-            return ovmExecutionManager.ovmCALL(
+            // We only want to bump the nonce for `ovmCALL` because `ovmCREATE` automatically bumps
+            // the nonce of the calling account. Normally an EOA would bump the nonce for both
+            // cases, but since this is a contract we'd end up bumping the nonce twice.
+            Lib_SafeExecutionManagerWrapper.safeSETNONCE(ovmExecutionManager, decodedTx.nonce);
+
+            return Lib_SafeExecutionManagerWrapper.safeCALL(
+                ovmExecutionManager,
                 decodedTx.gasLimit,
                 decodedTx.target,
                 decodedTx.data

packages/contracts/contracts/optimistic-ethereum/OVM/bridge/OVM_BaseCrossDomainMessenger.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+pragma experimental ABIEncoderV2;
+
+/* Interface Imports */
+import { iOVM_BaseCrossDomainMessenger } from "../../iOVM/bridge/iOVM_BaseCrossDomainMessenger.sol";
+
+/**
+ * @title OVM_BaseCrossDomainMessenger
+ */
+contract OVM_BaseCrossDomainMessenger is iOVM_BaseCrossDomainMessenger {
+
+    /**********************
+     * Contract Variables *
+     **********************/
+
+    mapping (bytes32 => bool) public receivedMessages;
+    mapping (bytes32 => bool) public sentMessages;
+    uint256 public messageNonce;
+    address public xDomainMessageSender;
+
+
+    /********************
+     * Public Functions *
+     ********************/
+
+    /**
+     * Sends a cross domain message to the target messenger.
+     * @param _target Target contract address.
+     * @param _message Message to send to the target.
+     * @param _gasLimit Gas limit for the provided message.
+     */
+    function sendMessage(
+        address _target,
+        bytes memory _message,
+        uint256 _gasLimit
+    )
+        override
+        public
+    {
+        bytes memory xDomainCalldata = _getXDomainCalldata(
+            _target,
+            msg.sender,
+            _message,
+            messageNonce
+        );
+
+        _sendXDomainMessage(xDomainCalldata, _gasLimit);
+
+        messageNonce += 1;
+        sentMessages[keccak256(xDomainCalldata)] = true;
+    }
+
+    /**********************
+     * Internal Functions *
+     **********************/
+
+    /**
+     * Generates the correct cross domain calldata for a message.
+     * @param _target Target contract address.
+     * @param _sender Message sender address.
+     * @param _message Message to send to the target.
+     * @param _messageNonce Nonce for the provided message.
+     * @return ABI encoded cross domain calldata.
+     */
+    function _getXDomainCalldata(
+        address _target,
+        address _sender,
+        bytes memory _message,
+        uint256 _messageNonce
+    )
+        internal
+        pure
+        returns (
+            bytes memory
+        )
+    {
+        return abi.encodeWithSignature(
+            "relayMessage(address,address,bytes,uint256)",
+            _target,
+            _sender,
+            _message,
+            _messageNonce
+        );
+    }
+
+    /**
+     * Sends a cross domain message.
+     * @param _message Message to send.
+     * @param _gasLimit Gas limit for the provided message.
+     */
+    function _sendXDomainMessage(
+        bytes memory _message,
+        uint256 _gasLimit
+    )
+        virtual
+        internal
+    {
+        revert("Implement me in child contracts!");
+    }
+}

packages/contracts/contracts/optimistic-ethereum/OVM/bridge/OVM_L1CrossDomainMessenger.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+pragma experimental ABIEncoderV2;
+
+/* Library Imports */
+import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
+import { Lib_AddressResolver } from "../../libraries/resolver/Lib_AddressResolver.sol";
+import { Lib_SecureMerkleTrie } from "../../libraries/trie/Lib_SecureMerkleTrie.sol";
+import { Lib_BytesUtils } from "../../libraries/utils/Lib_BytesUtils.sol";
+
+/* Interface Imports */
+import { iOVM_L1CrossDomainMessenger } from "../../iOVM/bridge/iOVM_L1CrossDomainMessenger.sol";
+import { iOVM_CanonicalTransactionChain } from "../../iOVM/chain/iOVM_CanonicalTransactionChain.sol";
+import { iOVM_StateCommitmentChain } from "../../iOVM/chain/iOVM_StateCommitmentChain.sol";
+
+/* Contract Imports */
+import { OVM_BaseCrossDomainMessenger } from "./OVM_BaseCrossDomainMessenger.sol";
+
+/* Logging Imports */
+import { console } from "@nomiclabs/buidler/console.sol";
+
+/**
+ * @title OVM_L1CrossDomainMessenger
+ */
+contract OVM_L1CrossDomainMessenger is iOVM_L1CrossDomainMessenger, OVM_BaseCrossDomainMessenger, Lib_AddressResolver {
+    
+    /*******************************************
+     * Contract Variables: Contract References *
+     *******************************************/
+    
+    iOVM_CanonicalTransactionChain internal ovmCanonicalTransactionChain;
+    iOVM_StateCommitmentChain internal ovmStateCommitmentChain;
+
+
+    /***************
+     * Constructor *
+     ***************/
+
+    /**
+     * @param _libAddressManager Address of the Address Manager.
+     */
+    constructor(
+        address _libAddressManager
+    )
+        Lib_AddressResolver(_libAddressManager)
+    {
+        ovmCanonicalTransactionChain = iOVM_CanonicalTransactionChain(resolve("OVM_CanonicalTransactionChain"));
+        ovmStateCommitmentChain = iOVM_StateCommitmentChain(resolve("OVM_StateCommitmentChain"));
+    }
+
+
+    /********************
+     * Public Functions *
+     ********************/
+
+    /**
+     * Relays a cross domain message to a contract.
+     * @inheritdoc iOVM_L1CrossDomainMessenger
+     */
+    function relayMessage(
+        address _target,
+        address _sender,
+        bytes memory _message,
+        uint256 _messageNonce,
+        L2MessageInclusionProof memory _proof
+    )
+        override
+        public
+    {
+        bytes memory xDomainCalldata = _getXDomainCalldata(
+            _target,
+            _sender,
+            _message,
+            _messageNonce
+        );
+
+        require(
+            _verifyXDomainMessage(
+                xDomainCalldata,
+                _proof
+            ) == true,
+            "Provided message could not be verified."
+        );
+
+        require(
+            receivedMessages[keccak256(xDomainCalldata)] == false,
+            "Provided message has already been received."
+        );
+
+        xDomainMessageSender = _sender;
+        _target.call(_message);
+
+        // Messages are considered successfully executed if they complete
+        // without running out of gas (revert or not). As a result, we can
+        // ignore the result of the call and always mark the message as
+        // successfully executed because we won't get here unless we have
+        // enough gas left over.
+        receivedMessages[keccak256(xDomainCalldata)] = true;
+    }
+
+    /**
+     * Replays a cross domain message to the target messenger.
+     * @inheritdoc iOVM_L1CrossDomainMessenger
+     */
+    function replayMessage(
+        address _target,
+        address _sender,
+        bytes memory _message,
+        uint256 _messageNonce,
+        uint32 _gasLimit
+    )
+        override
+        public
+    {
+        bytes memory xDomainCalldata = _getXDomainCalldata(
+            _target,
+            _sender,
+            _message,
+            _messageNonce
+        );
+
+        require(
+            sentMessages[keccak256(xDomainCalldata)] == true,
+            "Provided message has not already been sent."
+        );
+
+        _sendXDomainMessage(xDomainCalldata, _gasLimit);
+    }
+
+
+    /**********************
+     * Internal Functions *
+     **********************/
+
+    /**
+     * Verifies that the given message is valid.
+     * @param _xDomainCalldata Calldata to verify.
+     * @param _proof Inclusion proof for the message.
+     * @return Whether or not the provided message is valid.
+     */
+    function _verifyXDomainMessage(
+        bytes memory _xDomainCalldata,
+        L2MessageInclusionProof memory _proof
+    )
+        internal
+        returns (
+            bool
+        )
+    {
+        return (
+            _verifyStateRootProof(_proof)
+            && _verifyStorageProof(_xDomainCalldata, _proof)
+        );
+    }
+
+    /**
+     * Verifies that the state root within an inclusion proof is valid.
+     * @param _proof Message inclusion proof.
+     * @return Whether or not the provided proof is valid.
+     */
+    function _verifyStateRootProof(
+        L2MessageInclusionProof memory _proof
+    )
+        internal
+        returns (
+            bool
+        )
+    {
+        return (
+            ovmStateCommitmentChain.insideFraudProofWindow(_proof.stateRootBatchHeader) == false
+            && ovmStateCommitmentChain.verifyElement(
+                abi.encodePacked(_proof.stateRoot),
+                _proof.stateRootBatchHeader,
+                _proof.stateRootProof
+            )
+        );
+    }
+
+    /**
+     * Verifies that the storage proof within an inclusion proof is valid.
+     * @param _xDomainCalldata Encoded message calldata.
+     * @param _proof Message inclusion proof.
+     * @return Whether or not the provided proof is valid.
+     */
+    function _verifyStorageProof(
+        bytes memory _xDomainCalldata,
+        L2MessageInclusionProof memory _proof
+    )
+        internal
+        returns (
+            bool
+        )
+    {
+        bytes32 storageKey = keccak256(
+            Lib_BytesUtils.concat(
+                abi.encodePacked(keccak256(_xDomainCalldata)),
+                abi.encodePacked(uint256(0))
+            )
+        );
+
+        (
+            bool exists,
+            bytes memory encodedMessagePassingAccount
+        ) = Lib_SecureMerkleTrie.get(
+            abi.encodePacked(0x4200000000000000000000000000000000000000),
+            _proof.stateTrieWitness,
+            _proof.stateRoot
+        );
+
+        require(
+            exists == true,
+            "Message passing precompile has not been initialized or invalid proof provided."
+        );
+
+        Lib_OVMCodec.EVMAccount memory account = Lib_OVMCodec.decodeEVMAccount(
+            encodedMessagePassingAccount
+        );
+
+        return Lib_SecureMerkleTrie.verifyInclusionProof(
+            abi.encodePacked(storageKey),
+            abi.encodePacked(uint256(1)),
+            _proof.storageTrieWitness,
+            account.storageRoot
+        );
+    }
+
+    /**
+     * Sends a cross domain message.
+     * @param _message Message to send.
+     * @param _gasLimit OVM gas limit for the message.
+     */
+    function _sendXDomainMessage(
+        bytes memory _message,
+        uint256 _gasLimit
+    )
+        override
+        internal
+    {
+        ovmCanonicalTransactionChain.enqueue(
+            resolve("OVM_L2CrossDomainMessenger"),
+            _gasLimit,
+            _message
+        );
+    }
+}

packages/contracts/contracts/optimistic-ethereum/OVM/bridge/OVM_L2CrossDomainMessenger.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+pragma experimental ABIEncoderV2;
+
+/* Library Imports */
+import { Lib_AddressResolver } from "../../libraries/resolver/Lib_AddressResolver.sol";
+
+/* Interface Imports */
+import { iOVM_L2CrossDomainMessenger } from "../../iOVM/bridge/iOVM_L2CrossDomainMessenger.sol";
+import { iOVM_L1MessageSender } from "../../iOVM/precompiles/iOVM_L1MessageSender.sol";
+import { iOVM_L2ToL1MessagePasser } from "../../iOVM/precompiles/iOVM_L2ToL1MessagePasser.sol";
+
+/* Contract Imports */
+import { OVM_BaseCrossDomainMessenger } from "./OVM_BaseCrossDomainMessenger.sol";
+
+/* Logging Imports */
+import { console } from "@nomiclabs/buidler/console.sol";
+
+/**
+ * @title OVM_L2CrossDomainMessenger
+ */
+contract OVM_L2CrossDomainMessenger is iOVM_L2CrossDomainMessenger, OVM_BaseCrossDomainMessenger, Lib_AddressResolver {
+
+    /*******************************************
+     * Contract Variables: Contract References *
+     *******************************************/
+
+    iOVM_L1MessageSender internal ovmL1MessageSender;
+    iOVM_L2ToL1MessagePasser internal ovmL2ToL1MessagePasser;
+
+
+    /***************
+     * Constructor *
+     ***************/
+    
+    /**
+     * @param _libAddressManager Address of the Address Manager.
+     */
+    constructor(
+        address _libAddressManager
+    )
+        Lib_AddressResolver(_libAddressManager)
+    {
+        ovmL1MessageSender = iOVM_L1MessageSender(resolve("OVM_L1MessageSender"));
+        ovmL2ToL1MessagePasser = iOVM_L2ToL1MessagePasser(resolve("OVM_L2ToL1MessagePasser"));
+    }
+
+
+    /********************
+     * Public Functions *
+     ********************/
+
+    /**
+     * Relays a cross domain message to a contract.
+     * @inheritdoc iOVM_L2CrossDomainMessenger
+     */
+    function relayMessage(
+        address _target,
+        address _sender,
+        bytes memory _message,
+        uint256 _messageNonce
+    )
+        override
+        public
+    {
+        require(
+            _verifyXDomainMessage() == true,
+            "Provided message could not be verified."
+        );
+
+        bytes memory xDomainCalldata = _getXDomainCalldata(
+            _target,
+            _sender,
+            _message,
+            _messageNonce
+        );
+
+        require(
+            receivedMessages[keccak256(xDomainCalldata)] == false,
+            "Provided message has already been received."
+        );
+
+        xDomainMessageSender = _sender;
+        _target.call(_message);
+
+        // Messages are considered successfully executed if they complete
+        // without running out of gas (revert or not). As a result, we can
+        // ignore the result of the call and always mark the message as
+        // successfully executed because we won't get here unless we have
+        // enough gas left over.
+        receivedMessages[keccak256(xDomainCalldata)] = true;
+    }
+
+
+    /**********************
+     * Internal Functions *
+     **********************/
+
+    /**
+     * Verifies that a received cross domain message is valid.
+     * @return _valid Whether or not the message is valid.
+     */
+    function _verifyXDomainMessage()
+        internal
+        returns (
+            bool _valid
+        )
+    {
+        return (
+            ovmL1MessageSender.getL1MessageSender() == resolve("OVM_L1CrossDomainMessenger")
+        );
+    }
+
+    /**
+     * Sends a cross domain message.
+     * @param _message Message to send.
+     * @param _gasLimit Gas limit for the provided message.
+     */
+    function _sendXDomainMessage(
+        bytes memory _message,
+        uint256 _gasLimit
+    )
+        override
+        internal
+    {
+        ovmL2ToL1MessagePasser.passMessageToL1(_message);
+    }
+}

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

@@ -8,6 +8,7 @@ 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";
+import { TimeboundRingBuffer, Lib_TimeboundRingBuffer } from "../../libraries/utils/Lib_TimeboundRingBuffer.sol";
 
 /**
  * @title OVM_BaseChain
@@ -18,11 +19,23 @@ contract OVM_BaseChain is iOVM_BaseChain {
      * Contract Variables: Batches *
      *******************************/
 
-    bytes32[] internal batches;
+    using Lib_TimeboundRingBuffer for TimeboundRingBuffer;
+    TimeboundRingBuffer internal batches;
     uint256 internal totalBatches;
     uint256 internal totalElements;
 
 
+    /***************
+     * Constructor *
+     ***************/
+
+    constructor()
+    {
+        // TODO: Add propper customization
+        batches.init(4, 2, 100000);
+    }
+
+
     /*************************************
      * Public Functions: Batch Retrieval *
      *************************************/
@@ -32,6 +45,7 @@ contract OVM_BaseChain is iOVM_BaseChain {
      * @return _totalElements Total submitted elements.
      */
     function getTotalElements()
+        virtual
         override
         public
         view
@@ -39,7 +53,7 @@ contract OVM_BaseChain is iOVM_BaseChain {
             uint256 _totalElements
         )
     {
-        return totalElements;
+        return uint256(uint224(batches.getExtraData()));
     }
 
     /**
@@ -54,7 +68,7 @@ contract OVM_BaseChain is iOVM_BaseChain {
             uint256 _totalBatches
         )
     {
-        return totalBatches;
+        return uint256(batches.getLength());
     }
 
 
@@ -82,7 +96,7 @@ contract OVM_BaseChain is iOVM_BaseChain {
         )
     {
         require(
-            _hashBatchHeader(_batchHeader) == batches[_batchHeader.batchIndex],
+            _hashBatchHeader(_batchHeader) == batches.get(uint32(_batchHeader.batchIndex)),
             "Invalid batch header."
         );
 
@@ -114,9 +128,7 @@ contract OVM_BaseChain is iOVM_BaseChain {
         internal
     {
         bytes32 batchHeaderHash = _hashBatchHeader(_batchHeader);
-        batches.push(batchHeaderHash);
-        totalBatches += 1;
-        totalElements += _batchHeader.batchSize;
+        batches.push(batchHeaderHash, bytes28(uint224(getTotalElements() + _batchHeader.batchSize)));
     }
 
     /**
@@ -131,7 +143,7 @@ contract OVM_BaseChain is iOVM_BaseChain {
         internal
     {
         Lib_OVMCodec.ChainBatchHeader memory batchHeader = Lib_OVMCodec.ChainBatchHeader({
-            batchIndex: batches.length,
+            batchIndex: uint(batches.getLength()),
             batchRoot: Lib_MerkleUtils.getMerkleRoot(_elements),
             batchSize: _elements.length,
             prevTotalElements: totalElements,
@@ -166,24 +178,19 @@ contract OVM_BaseChain is iOVM_BaseChain {
         internal
     {
         require(
-            _batchHeader.batchIndex < batches.length,
+            _batchHeader.batchIndex < batches.getLength(),
             "Invalid batch index."
         );
 
         require(
-            _hashBatchHeader(_batchHeader) == batches[_batchHeader.batchIndex],
+            _hashBatchHeader(_batchHeader) == batches.get(uint32(_batchHeader.batchIndex)),
             "Invalid batch header."
         );
 
-        totalBatches = _batchHeader.batchIndex;
         totalElements = _batchHeader.prevTotalElements;
+        batches.deleteElementsAfter(uint32(_batchHeader.batchIndex - 1), bytes28(uint224(totalElements)));
     }
 
-
-    /*********************
-     * Private Functions *
-     *********************/
-
     /**
      * Calculates a hash for a given batch header.
      * @param _batchHeader Header to hash.
@@ -192,7 +199,7 @@ contract OVM_BaseChain is iOVM_BaseChain {
     function _hashBatchHeader(
         Lib_OVMCodec.ChainBatchHeader memory _batchHeader
     )
-        private
+        internal
         pure
         returns (
             bytes32 _hash

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

@@ -2,11 +2,9 @@
 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_AddressResolver } from "../../libraries/resolver/Lib_AddressResolver.sol";
 
 /* Interface Imports */
 import { iOVM_FraudVerifier } from "../../iOVM/verification/iOVM_FraudVerifier.sol";
@@ -19,7 +17,14 @@ import { OVM_BaseChain } from "./OVM_BaseChain.sol";
 /**
  * @title OVM_StateCommitmentChain
  */
-contract OVM_StateCommitmentChain is iOVM_StateCommitmentChain, OVM_BaseChain, Proxy_Resolver {
+contract OVM_StateCommitmentChain is iOVM_StateCommitmentChain, OVM_BaseChain, Lib_AddressResolver {
+
+    /*************
+     * Constants *
+     *************/
+
+    uint256 constant public FRAUD_PROOF_WINDOW = 7 days;
+
     
     /*******************************************
      * Contract Variables: Contract References *
@@ -34,12 +39,12 @@ contract OVM_StateCommitmentChain is iOVM_StateCommitmentChain, OVM_BaseChain, P
      ***************/
 
     /**
-     * @param _proxyManager Address of the Proxy_Manager.
+     * @param _libAddressManager Address of the Address Manager.
      */
     constructor(
-        address _proxyManager
+        address _libAddressManager
     )
-        Proxy_Resolver(_proxyManager)
+        Lib_AddressResolver(_libAddressManager)
     {
         ovmCanonicalTransactionChain = iOVM_CanonicalTransactionChain(resolve("OVM_CanonicalTransactionChain"));
         ovmFraudVerifier = iOVM_FraudVerifier(resolve("OVM_FraudVerifier"));
@@ -75,7 +80,12 @@ contract OVM_StateCommitmentChain is iOVM_StateCommitmentChain, OVM_BaseChain, P
             elements[i] = abi.encodePacked(_batch[i]);
         }
 
-        _appendBatch(elements);
+        _appendBatch(
+            elements,
+            abi.encode(
+                block.timestamp
+            )
+        );
     }
 
     /**
@@ -93,6 +103,39 @@ contract OVM_StateCommitmentChain is iOVM_StateCommitmentChain, OVM_BaseChain, P
             "State batches can only be deleted by the OVM_FraudVerifier."
         );
 
+        require(
+            insideFraudProofWindow(_batchHeader),
+            "State batches can only be deleted within the fraud proof window."
+        );
+
         _deleteBatch(_batchHeader);
     }
+
+
+    /**********************************
+     * Public Functions: Batch Status *
+     **********************************/
+
+    function insideFraudProofWindow(
+        Lib_OVMCodec.ChainBatchHeader memory _batchHeader
+    )
+        override
+        public
+        view
+        returns (
+            bool _inside
+        )
+    {
+        uint256 timestamp = abi.decode(
+            _batchHeader.extraData,
+            (uint256)
+        );
+
+        require(
+            timestamp != 0,
+            "Batch header timestamp cannot be zero"
+        );
+
+        return timestamp + FRAUD_PROOF_WINDOW > block.timestamp;
+    }
 }

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

@@ -12,22 +12,124 @@ contract OVM_SafetyChecker is iOVM_SafetyChecker {
     /********************
      * Public Functions *
      ********************/
-
     /**
-     * Checks that a given bytecode string is considered safe.
-     * @param _bytecode Bytecode string to check.
-     * @return _safe Whether or not the bytecode is safe.
+     * Returns whether or not all of the provided bytecode is safe.
+     * @param _bytecode The bytecode to safety check.
+     * @return `true` if the bytecode is safe, `false` otherwise.
      */
     function isBytecodeSafe(
         bytes memory _bytecode
     )
         override
-        public
+        external
         view
-        returns (
-            bool _safe
-        )
+        returns (bool)
     {
+        // autogenerated by gen_safety_checker_constants.py
+        // number of bytes to skip for each opcode
+        uint256[8] memory opcodeSkippableBytes = [
+            uint256(0x0001010101010101010101010000000001010101010101010101010101010000),
+            uint256(0x0100000000000000000000000000000000000000010101010101000000010100),
+            uint256(0x0000000000000000000000000000000001010101000000010101010100000000),
+            uint256(0x0203040500000000000000000000000000000000000000000000000000000000),
+            uint256(0x0101010101010101010101010101010101010101010101010101010101010101),
+            uint256(0x0101010101000000000000000000000000000000000000000000000000000000),
+            uint256(0x0000000000000000000000000000000000000000000000000000000000000000),
+            uint256(0x0000000000000000000000000000000000000000000000000000000000000000)
+        ];
+        // Mask to gate opcode specific cases
+        uint256 opcodeGateMask = ~uint256(0xffffffffffffffffffffffe000000000fffffffff070ffff9c0ffffec000f001);
+        // Halting opcodes
+        uint256 opcodeHaltingMask = ~uint256(0x4008000000000000000000000000000000000000004000000000000000000001);
+        // PUSH opcodes
+        uint256 opcodePushMask = ~uint256(0xffffffff000000000000000000000000);
+
+        uint256 codeLength;
+        uint256 _pc;
+        assembly {
+            _pc := add(_bytecode, 0x20)
+        }
+        codeLength = _pc + _bytecode.length;
+        do {
+            // current opcode: 0x00...0xff
+            uint256 opNum;
+
+            // inline assembly removes the extra add + bounds check
+            assembly {
+                let word := mload(_pc) //load the next 32 bytes at pc into word
+
+                // Look up number of bytes to skip from opcodeSkippableBytes and then update indexInWord
+                // E.g. the 02030405 in opcodeSkippableBytes is the number of bytes to skip for PUSH1->4
+                // We repeat this 6 times, thus we can only skip bytes for up to PUSH4 ((1+4) * 6 = 30 < 32).
+                // If we see an opcode that is listed as 0 skippable bytes e.g. PUSH5,
+                // then we will get stuck on that indexInWord and then opNum will be set to the PUSH5 opcode.
+                let indexInWord := byte(0, mload(add(opcodeSkippableBytes, byte(0, word))))
+                indexInWord := add(indexInWord, byte(0, mload(add(opcodeSkippableBytes, byte(indexInWord, word)))))
+                indexInWord := add(indexInWord, byte(0, mload(add(opcodeSkippableBytes, byte(indexInWord, word)))))
+                indexInWord := add(indexInWord, byte(0, mload(add(opcodeSkippableBytes, byte(indexInWord, word)))))
+                indexInWord := add(indexInWord, byte(0, mload(add(opcodeSkippableBytes, byte(indexInWord, word)))))
+                indexInWord := add(indexInWord, byte(0, mload(add(opcodeSkippableBytes, byte(indexInWord, word)))))
+                _pc := add(_pc, indexInWord)
+
+                opNum := byte(indexInWord, word)
+            }
+
+            // + push opcodes
+            // + stop opcodes [STOP(0x00),JUMP(0x56),RETURN(0xf3),INVALID(0xfe)]
+            // + caller opcode CALLER(0x33)
+            // + blacklisted opcodes
+            uint256 opBit = 1 << opNum;
+            if (opBit & opcodeGateMask == 0) {
+                if (opBit & opcodePushMask == 0) {
+                    // all pushes are valid opcodes
+                    // subsequent bytes are not opcodes. Skip them.
+                    _pc += (opNum - 0x5e); // PUSH1 is 0x60, so opNum-0x5f = PUSHed bytes and we +1 to
+                    // skip the _pc++; line below in order to save gas ((-0x5f + 1) = -0x5e)
+                    continue;
+                } else if (opBit & opcodeHaltingMask == 0) {
+                    // STOP or JUMP or RETURN or INVALID (Note: REVERT is blacklisted, so not included here)
+                    // We are now inside unreachable code until we hit a JUMPDEST!
+                    do {
+                        _pc++;
+                        assembly {
+                            opNum := byte(0, mload(_pc))
+                        }
+                        // encountered a JUMPDEST
+                        if (opNum == 0x5b) break;
+                        // skip PUSHed bytes
+                        if ((1 << opNum) & opcodePushMask == 0) _pc += (opNum - 0x5f); // opNum-0x5f = PUSHed bytes (PUSH1 is 0x60)
+                    } while (_pc < codeLength);
+                    // opNum is 0x5b, so we don't continue here since the pc++ is fine
+                } else if (opNum == 0x33) { // Caller opcode
+                    uint256 firstOps; // next 32 bytes of bytecode
+                    uint256 secondOps; // following 32 bytes of bytecode
+
+                    assembly {
+                        firstOps := mload(_pc)
+                        // 32 - 4 bytes = 28 bytes = 224 bits
+                        secondOps := shr(224, mload(add(_pc, 0x20)))
+                    }
+
+                    // Call identity precompile
+                    // CALLER POP PUSH1 0x00 PUSH1 0x04 GAS CALL
+                    // 32 - 8 bytes = 24 bytes = 192
+                    if ((firstOps >> 192) == 0x3350600060045af1) {
+                        _pc += 8;
+                    // Call EM and abort execution if instructed
+                    // CALLER PUSH1 0x00 SWAP1 GAS CALL PC PUSH1 0x1d ADD EQ JUMPI RETURNDATASIZE PUSH1 0x00 DUP1 RETURNDATACOPY PUSH1 0x00 REVERT JUMPDEST PUSH1 0x01 PUSH1 0x00 RETURN JUMPDEST
+                    } else if (firstOps == 0x336000905af158601d0157586012013d600114573d6000803e3d6000fd5b6001 && secondOps == 0x6000f35b) {
+                        _pc += 36;
+                    } else {
+                        return false;
+                    }
+                    continue;
+                } else {
+                    // encountered a non-whitelisted opcode!
+                    return false;
+                }
+            }
+            _pc++;
+        } while (_pc < codeLength);
         return true;
     }
 }

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

@@ -25,8 +25,8 @@ contract OVM_StateManager is iOVM_StateManager {
      * Contract Variables: Contract References *
      *******************************************/
 
-    address internal owner;
-    address internal ovmExecutionManager;
+    address override public owner;
+    address override public ovmExecutionManager;
 
 
     /****************************************
@@ -111,6 +111,20 @@ contract OVM_StateManager is iOVM_StateManager {
         accounts[_address] = _account;
     }
 
+    /**
+     * Marks an account as empty.
+     * @param _address Address of the account to mark.
+     */
+    function putEmptyAccount(
+        address _address
+    )
+        override
+        public
+        authenticated
+    {
+        accounts[_address].codeHash = EMPTY_ACCOUNT_CODE_HASH;
+    }
+
     /**
      * Retrieves an account from the state.
      * @param _address Address of the account to retrieve.
@@ -215,6 +229,24 @@ contract OVM_StateManager is iOVM_StateManager {
         return accounts[_address].ethAddress;
     }
 
+    /**
+     * Retrieves the storage root of an account.
+     * @param _address Address of the account to access.
+     * @return _storageRoot Corresponding storage root.
+     */
+    function getAccountStorageRoot(
+        address _address
+    )
+        override
+        public
+        view
+        returns (
+            bytes32 _storageRoot
+        )
+    {
+        return accounts[_address].storageRoot;
+    }
+
     /**
      * Initializes a pending account (during CREATE or CREATE2) with the default values.
      * @param _address Address of the account to initialize.
@@ -228,7 +260,7 @@ contract OVM_StateManager is iOVM_StateManager {
     {
         Lib_OVMCodec.Account storage account = accounts[_address];
         account.nonce = 1;
-        account.codeHash = keccak256(hex'80');
+        account.codeHash = keccak256(hex'');
         account.isFresh = true;
     }
 
@@ -376,10 +408,7 @@ contract OVM_StateManager is iOVM_StateManager {
         // storage because writing to zero when the actual value is nonzero causes a gas
         // discrepancy. Could be moved into a new `putVerifiedContractStorage` function, or
         // something along those lines.
-        if (
-            verifiedContractStorage[_contract][_key] == false
-            && accounts[_contract].isFresh == false
-        ) {
+        if (verifiedContractStorage[_contract][_key] == false) {
             verifiedContractStorage[_contract][_key] = true;
         }
     }
@@ -401,6 +430,15 @@ contract OVM_StateManager is iOVM_StateManager {
             bytes32 _value
         )
     {
+        // Storage XOR system doesn't work for newly created contracts that haven't set this
+        // storage slot value yet.
+        if (
+            verifiedContractStorage[_contract][_key] == false
+            && accounts[_contract].isFresh
+        ) {
+            return bytes32(0);
+        }
+
         // See `putContractStorage` for more information about the XOR here.
         return contractStorage[_contract][_key] ^ STORAGE_XOR_VALUE;
     }

packages/contracts/contracts/optimistic-ethereum/OVM/precompiles/OVM_DeployerWhitelist.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+
+/* Library Imports */
+import { Lib_Bytes32Utils } from "../../libraries/utils/Lib_Bytes32Utils.sol";
+
+/* Interface Imports */
+import { iOVM_DeployerWhitelist } from "../../iOVM/precompiles/iOVM_DeployerWhitelist.sol";
+import { iOVM_ExecutionManager } from "../../iOVM/execution/iOVM_ExecutionManager.sol";
+
+/**
+ * @title OVM_DeployerWhitelist
+ */
+contract OVM_DeployerWhitelist is iOVM_DeployerWhitelist {
+
+    /**********************
+     * Contract Constants *
+     **********************/
+
+    bytes32 internal constant KEY_INITIALIZED =                0x0000000000000000000000000000000000000000000000000000000000000010;
+    bytes32 internal constant KEY_OWNER =                      0x0000000000000000000000000000000000000000000000000000000000000011;
+    bytes32 internal constant KEY_ALLOW_ARBITRARY_DEPLOYMENT = 0x0000000000000000000000000000000000000000000000000000000000000012;
+
+
+    /**********************
+     * Function Modifiers *
+     **********************/
+    
+    /**
+     * Blocks functions to anyone except the contract owner.
+     */
+    modifier onlyOwner() {
+        iOVM_ExecutionManager ovmExecutionManager = iOVM_ExecutionManager(msg.sender);
+
+        address owner = Lib_Bytes32Utils.toAddress(
+            ovmExecutionManager.ovmSLOAD(
+                KEY_OWNER
+            )
+        );
+
+        require(
+            ovmExecutionManager.ovmCALLER() == owner,
+            "Function can only be called by the owner of this contract."
+        );
+        _;
+    }
+
+
+    /********************
+     * Public Functions *
+     ********************/
+    
+    /**
+     * Initializes the whitelist.
+     * @param _owner Address of the owner for this contract.
+     * @param _allowArbitraryDeployment Whether or not to allow arbitrary contract deployment.
+     */
+    function initialize(
+        address _owner,
+        bool _allowArbitraryDeployment
+    )
+        override
+        public
+    {
+        iOVM_ExecutionManager ovmExecutionManager = iOVM_ExecutionManager(msg.sender);
+
+        bool initialized = Lib_Bytes32Utils.toBool(
+            ovmExecutionManager.ovmSLOAD(KEY_INITIALIZED)
+        );
+
+        if (initialized == true) {
+            return;
+        }
+
+        ovmExecutionManager.ovmSSTORE(
+            KEY_INITIALIZED,
+            Lib_Bytes32Utils.fromBool(true)
+        );
+        ovmExecutionManager.ovmSSTORE(
+            KEY_OWNER,
+            Lib_Bytes32Utils.fromAddress(_owner)
+        );
+        ovmExecutionManager.ovmSSTORE(
+            KEY_ALLOW_ARBITRARY_DEPLOYMENT,
+            Lib_Bytes32Utils.fromBool(_allowArbitraryDeployment)
+        );
+    }
+
+    /**
+     * Adds or removes an address from the deployment whitelist.
+     * @param _deployer Address to update permissions for.
+     * @param _isWhitelisted Whether or not the address is whitelisted.
+     */
+    function setWhitelistedDeployer(
+        address _deployer,
+        bool _isWhitelisted
+    )
+        override
+        public
+        onlyOwner
+    {
+        iOVM_ExecutionManager ovmExecutionManager = iOVM_ExecutionManager(msg.sender);
+
+        ovmExecutionManager.ovmSSTORE(
+            Lib_Bytes32Utils.fromAddress(_deployer),
+            Lib_Bytes32Utils.fromBool(_isWhitelisted)
+        );
+    }
+
+    /**
+     * Updates the owner of this contract.
+     * @param _owner Address of the new owner.
+     */
+    function setOwner(
+        address _owner
+    )
+        override
+        public
+        onlyOwner
+    {
+        iOVM_ExecutionManager ovmExecutionManager = iOVM_ExecutionManager(msg.sender);
+
+        ovmExecutionManager.ovmSSTORE(
+            KEY_OWNER,
+            Lib_Bytes32Utils.fromAddress(_owner)
+        );
+    }
+
+    /**
+     * Updates the arbitrary deployment flag.
+     * @param _allowArbitraryDeployment Whether or not to allow arbitrary contract deployment.
+     */
+    function setAllowArbitraryDeployment(
+        bool _allowArbitraryDeployment
+    )
+        override
+        public
+        onlyOwner
+    {
+        iOVM_ExecutionManager ovmExecutionManager = iOVM_ExecutionManager(msg.sender);
+
+        ovmExecutionManager.ovmSSTORE(
+            KEY_ALLOW_ARBITRARY_DEPLOYMENT,
+            Lib_Bytes32Utils.fromBool(_allowArbitraryDeployment)
+        );
+    }
+
+    /**
+     * Permanently enables arbitrary contract deployment and deletes the owner.
+     */
+    function enableArbitraryContractDeployment()
+        override
+        public
+        onlyOwner
+    {
+        setAllowArbitraryDeployment(true);
+        setOwner(address(0));
+    }
+
+    /**
+     * Checks whether an address is allowed to deploy contracts.
+     * @param _deployer Address to check.
+     * @return _allowed Whether or not the address can deploy contracts.
+     */
+    function isDeployerAllowed(
+        address _deployer
+    )
+        override
+        public
+        returns (
+            bool _allowed
+        )
+    {
+        iOVM_ExecutionManager ovmExecutionManager = iOVM_ExecutionManager(msg.sender);
+
+        bool initialized = Lib_Bytes32Utils.toBool(
+            ovmExecutionManager.ovmSLOAD(KEY_INITIALIZED)
+        );
+
+        if (initialized == false) {
+            return true;
+        }
+
+        bool allowArbitraryDeployment = Lib_Bytes32Utils.toBool(
+            ovmExecutionManager.ovmSLOAD(KEY_ALLOW_ARBITRARY_DEPLOYMENT)
+        );
+
+        if (allowArbitraryDeployment == true) {
+            return true;
+        }
+
+        bool isWhitelisted = Lib_Bytes32Utils.toBool(
+            ovmExecutionManager.ovmSLOAD(
+                Lib_Bytes32Utils.fromAddress(_deployer)
+            )
+        );
+
+        return isWhitelisted;        
+    }
+}

packages/contracts/contracts/optimistic-ethereum/OVM/precompiles/OVM_L1MessageSender.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+
+/* Interface Imports */
+import { iOVM_L1MessageSender } from "../../iOVM/precompiles/iOVM_L1MessageSender.sol";
+import { iOVM_ExecutionManager } from "../../iOVM/execution/iOVM_ExecutionManager.sol";
+
+/**
+ * @title OVM_L1MessageSender
+ */
+contract OVM_L1MessageSender is iOVM_L1MessageSender {
+
+    /********************
+     * Public Functions *
+     ********************/
+
+    /**
+     * @return _l1MessageSender L1 message sender address (msg.sender).
+     */
+    function getL1MessageSender()
+        override
+        public
+        returns (
+            address _l1MessageSender
+        )
+    {
+        return iOVM_ExecutionManager(msg.sender).ovmL1TXORIGIN();
+    }
+}

packages/contracts/contracts/optimistic-ethereum/OVM/precompiles/OVM_L2ToL1MessagePasser.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+
+/* Interface Imports */
+import { iOVM_L2ToL1MessagePasser } from "../../iOVM/precompiles/iOVM_L2ToL1MessagePasser.sol";
+import { iOVM_ExecutionManager } from "../../iOVM/execution/iOVM_ExecutionManager.sol";
+
+/**
+ * @title OVM_L2ToL1MessagePasser
+ */
+contract OVM_L2ToL1MessagePasser is iOVM_L2ToL1MessagePasser {
+
+    /**********************
+     * Contract Variables *
+     **********************/
+
+    uint256 internal nonce;
+
+
+    /********************
+     * Public Functions *
+     ********************/
+
+    /**
+     * Passes a message to L1.
+     * @param _message Message to pass to L1.
+     */
+    function passMessageToL1(
+        bytes memory _message
+    )
+        override
+        public
+    {
+        // For now, to be trustfully relayed by sequencer to L1, so just emit
+        // an event for the sequencer to pick up.
+        emit L2ToL1Message(
+            nonce,
+            iOVM_ExecutionManager(msg.sender).ovmCALLER(),
+            _message
+        );
+
+        nonce = nonce + 1;
+    }
+}

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

@@ -2,11 +2,9 @@
 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_AddressResolver } from "../../libraries/resolver/Lib_AddressResolver.sol";
 
 /* Interface Imports */
 import { iOVM_FraudVerifier } from "../../iOVM/verification/iOVM_FraudVerifier.sol";
@@ -17,7 +15,7 @@ import { iOVM_StateManagerFactory } from "../../iOVM/execution/iOVM_StateManager
 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 OVM_FraudVerifier is iOVM_FraudVerifier, Lib_AddressResolver {
 
     /*******************************************
      * Contract Variables: Contract References *
@@ -39,12 +37,12 @@ contract OVM_FraudVerifier is iOVM_FraudVerifier, Proxy_Resolver {
      ***************/
 
     /**
-     * @param _proxyManager Address of the Proxy_Manager.
+     * @param _libAddressManager Address of the Address Manager.
      */
     constructor(
-        address _proxyManager
+        address _libAddressManager
     )
-        Proxy_Resolver(_proxyManager)
+        Lib_AddressResolver(_libAddressManager)
     {
         ovmStateCommitmentChain = iOVM_StateCommitmentChain(resolve("OVM_StateCommitmentChain"));
         ovmCanonicalTransactionChain = iOVM_CanonicalTransactionChain(resolve("OVM_CanonicalTransactionChain"));
@@ -123,7 +121,7 @@ contract OVM_FraudVerifier is iOVM_FraudVerifier, Proxy_Resolver {
         transitioners[_preStateRoot] = iOVM_StateTransitionerFactory(
             resolve("OVM_StateTransitionerFactory")
         ).create(
-            address(proxyManager),
+            address(libAddressManager),
             _preStateRootProof.index,
             _preStateRoot,
             Lib_OVMCodec.hashTransaction(_transaction)

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

@@ -19,14 +19,14 @@ contract OVM_StateTransitionerFactory is iOVM_StateTransitionerFactory {
 
     /**
      * Creates a new OVM_StateTransitioner
-     * @param _proxyManager Address of the Proxy_Manager.
+     * @param _libAddressManager Address of the Address 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,
+        address _libAddressManager,
         uint256 _stateTransitionIndex,
         bytes32 _preStateRoot,
         bytes32 _transactionHash
@@ -38,7 +38,7 @@ contract OVM_StateTransitionerFactory is iOVM_StateTransitionerFactory {
         )
     {
         return new OVM_StateTransitioner(
-            _proxyManager,
+            _libAddressManager,
             _stateTransitionIndex,
             _preStateRoot,
             _transactionHash

packages/contracts/contracts/optimistic-ethereum/iOVM/bridge/iOVM_BaseCrossDomainMessenger.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+pragma experimental ABIEncoderV2;
+
+/**
+ * @title iOVM_BaseCrossDomainMessenger
+ */
+interface iOVM_BaseCrossDomainMessenger {
+
+    /********************
+     * Public Functions *
+     ********************/
+
+    /**
+     * Sends a cross domain message to the target messenger.
+     * @param _target Target contract address.
+     * @param _message Message to send to the target.
+     * @param _gasLimit Gas limit for the provided message.
+     */
+    function sendMessage(
+        address _target,
+        bytes memory _message,
+        uint256 _gasLimit
+    ) external;
+}

packages/contracts/contracts/optimistic-ethereum/iOVM/bridge/iOVM_L1CrossDomainMessenger.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_BaseCrossDomainMessenger } from "./iOVM_BaseCrossDomainMessenger.sol";
+
+/**
+ * @title iOVM_L1CrossDomainMessenger
+ */
+interface iOVM_L1CrossDomainMessenger is iOVM_BaseCrossDomainMessenger {
+
+    /*******************
+     * Data Structures *
+     *******************/
+    
+    struct L2MessageInclusionProof {
+        bytes32 stateRoot;
+        Lib_OVMCodec.ChainBatchHeader stateRootBatchHeader;
+        Lib_OVMCodec.ChainInclusionProof stateRootProof;
+        bytes stateTrieWitness;
+        bytes storageTrieWitness;
+    }
+
+
+    /********************
+     * Public Functions * 
+     ********************/
+    
+    /**
+     * Relays a cross domain message to a contract.
+     * @param _target Target contract address.
+     * @param _sender Message sender address.
+     * @param _message Message to send to the target.
+     * @param _messageNonce Nonce for the provided message.
+     * @param _proof Inclusion proof for the given message.
+     */
+    function relayMessage(
+        address _target,
+        address _sender,
+        bytes memory _message,
+        uint256 _messageNonce,
+        L2MessageInclusionProof memory _proof
+    ) external;
+
+    /**
+     * Replays a cross domain message to the target messenger.
+     * @param _target Target contract address.
+     * @param _sender Original sender address.
+     * @param _message Message to send to the target.
+     * @param _messageNonce Nonce for the provided message.
+     * @param _gasLimit Gas limit for the provided message.
+     */
+    function replayMessage(
+        address _target,
+        address _sender,
+        bytes memory _message,
+        uint256 _messageNonce,
+        uint32 _gasLimit
+    ) external;
+}

packages/contracts/contracts/optimistic-ethereum/iOVM/bridge/iOVM_L2CrossDomainMessenger.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+pragma experimental ABIEncoderV2;
+
+/* Interface Imports */
+import { iOVM_BaseCrossDomainMessenger } from "./iOVM_BaseCrossDomainMessenger.sol";
+
+/**
+ * @title iOVM_L2CrossDomainMessenger
+ */
+interface iOVM_L2CrossDomainMessenger is iOVM_BaseCrossDomainMessenger {
+
+    /********************
+     * Public Functions * 
+     ********************/
+
+    /**
+     * Relays a cross domain message to a contract.
+     * @param _target Target contract address.
+     * @param _sender Message sender address.
+     * @param _message Message to send to the target.
+     * @param _messageNonce Nonce for the provided message.
+     */
+    function relayMessage(
+        address _target,
+        address _sender,
+        bytes memory _message,
+        uint256 _messageNonce
+    ) external;
+}

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

@@ -2,6 +2,9 @@
 pragma solidity ^0.7.0;
 pragma experimental ABIEncoderV2;
 
+/* Library Imports */
+import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
+
 /* Interface Imports */
 import { iOVM_BaseChain } from "./iOVM_BaseChain.sol";
 
@@ -10,10 +13,90 @@ import { iOVM_BaseChain } from "./iOVM_BaseChain.sol";
  */
 interface iOVM_CanonicalTransactionChain is iOVM_BaseChain {
 
-    /****************************************
-     * Public Functions: Batch Manipulation *
-     ****************************************/
+    /**********
+     * Events *
+     **********/
+
+    event QueueTransactionAppended(
+        bytes _transaction,
+        bytes32 _timestampAndBlockNumber
+    );
+
+    event ChainBatchAppended(
+        uint256 _startingQueueIndex,
+        uint256 _numQueueElements
+    );
+
+
+    /***********
+     * Structs *
+     ***********/
+
+    struct BatchContext {
+        uint256 numSequencedTransactions;
+        uint256 numSubsequentQueueTransactions;
+        uint256 timestamp;
+        uint256 blockNumber;
+    }
+
+    struct TransactionChainElement {
+        bool isSequenced;
+        uint256 queueIndex;  // QUEUED TX ONLY
+        uint256 timestamp;   // SEQUENCER TX ONLY
+        uint256 blockNumber; // SEQUENCER TX ONLY
+        bytes txData;        // SEQUENCER TX ONLY
+    }
+
 
-    function appendQueueBatch() external;
-    function appendSequencerBatch(bytes[] calldata _batch, uint256 _timestamp) external;
+    /********************
+     * Public Functions *
+     ********************/
+
+    /**
+     * Gets the queue element at a particular index.
+     * @param _index Index of the queue element to access.
+     * @return _element Queue element at the given index.
+     */
+    function getQueueElement(
+        uint256 _index
+    )
+        external
+        view
+        returns (
+            Lib_OVMCodec.QueueElement memory _element
+        );
+
+    /**
+     * Adds a transaction to the queue.
+     * @param _target Target contract to send the transaction to.
+     * @param _gasLimit Gas limit for the given transaction.
+     * @param _data Transaction data.
+     */
+    function enqueue(
+        address _target,
+        uint256 _gasLimit,
+        bytes memory _data
+    ) external;
+
+    /**
+     * Appends a given number of queued transactions as a single batch.
+     * @param _numQueuedTransactions Number of transactions to append.
+     */
+    function appendQueueBatch(
+        uint256 _numQueuedTransactions
+    ) external;
+
+    /**
+     * Allows the sequencer to append a batch of transactions.
+     * @param _transactions Array of raw transaction data.
+     * @param _contexts Array of batch contexts.
+     * @param _shouldStartAtBatch Specific batch we expect to start appending to.
+     * @param _totalElementsToAppend Total number of batch elements we expect to append.
+     */
+    function appendSequencerBatch(
+        bytes[] memory _transactions,
+        BatchContext[] memory _contexts,
+        uint256 _shouldStartAtBatch,
+        uint _totalElementsToAppend
+    ) external;
 }

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

@@ -19,4 +19,10 @@ interface iOVM_StateCommitmentChain is iOVM_BaseChain {
 
     function appendStateBatch(bytes32[] calldata _batch) external;
     function deleteStateBatch(Lib_OVMCodec.ChainBatchHeader memory _batchHeader) external;
+
+    /**********************************
+     * Public Functions: Batch Status *
+     **********************************/
+
+    function insideFraudProofWindow(Lib_OVMCodec.ChainBatchHeader memory _batchHeader) external view returns (bool _inside);
 }

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

@@ -30,12 +30,6 @@ interface iOVM_ExecutionManager {
         PREV_EPOCH_L1TOL2_QUEUE_GAS
     }
     
-    enum QueueOrigin {
-        SEQUENCER_QUEUE,
-        L1TOL2_QUEUE
-    }
-
-    
     /***********
      * Structs *
      ***********/
@@ -52,11 +46,12 @@ interface iOVM_ExecutionManager {
     }
 
     struct TransactionContext {
-        address ovmORIGIN;
+        Lib_OVMCodec.QueueOrigin ovmL1QUEUEORIGIN;
         uint256 ovmTIMESTAMP;
+        uint256 ovmNUMBER;
         uint256 ovmGASLIMIT;
         uint256 ovmTXGASLIMIT;
-        uint256 ovmQUEUEORIGIN;
+        address ovmL1TXORIGIN;
     }
 
     struct TransactionRecord {
@@ -67,7 +62,6 @@ interface iOVM_ExecutionManager {
         address ovmCALLER;
         address ovmADDRESS;
         bool isStatic;
-        bool isCreation;
     }
 
     struct MessageRecord {
@@ -92,12 +86,20 @@ interface iOVM_ExecutionManager {
 
     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 ovmNUMBER() external view returns (uint256 _number);
     function ovmGASLIMIT() external view returns (uint256 _gasLimit);
     function ovmCHAINID() external view returns (uint256 _chainId);
 
     
+    /**********************
+     * L2 Context Opcodes *
+     **********************/
+
+    function ovmL1QUEUEORIGIN() external view returns (Lib_OVMCodec.QueueOrigin _queueOrigin);
+    function ovmL1TXORIGIN() external view returns (address _l1TxOrigin);
+
+    
     /*******************
      * Halting Opcodes *
      *******************/

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

@@ -10,5 +10,5 @@ interface iOVM_SafetyChecker {
      * Public Functions *
      ********************/
 
-    function isBytecodeSafe(bytes memory _bytecode) external view returns (bool _safe);
+    function isBytecodeSafe(bytes memory _bytecode) external view returns (bool);
 }

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

@@ -26,6 +26,8 @@ interface iOVM_StateManager {
      * Public Functions: Setup *
      ***************************/
 
+    function owner() external view returns (address _owner); 
+    function ovmExecutionManager() external view returns (address _ovmExecutionManager); 
     function setExecutionManager(address _ovmExecutionManager) external;
 
 
@@ -34,12 +36,14 @@ interface iOVM_StateManager {
      ************************************/
 
     function putAccount(address _address, Lib_OVMCodec.Account memory _account) external;
+    function putEmptyAccount(address _address) external;
     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 view returns (uint256 _nonce);
     function getAccountEthAddress(address _address) external view returns (address _ethAddress);
+    function getAccountStorageRoot(address _address) external view returns (bytes32 _storageRoot);
     function initPendingAccount(address _address) external;
     function commitPendingAccount(address _address, address _ethAddress, bytes32 _codeHash) external;
     function testAndSetAccountLoaded(address _address) external returns (bool _wasAccountAlreadyLoaded);

packages/contracts/contracts/optimistic-ethereum/iOVM/precompiles/iOVM_DeployerWhitelist.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+
+/**
+ * @title iOVM_DeployerWhitelist
+ */
+interface iOVM_DeployerWhitelist {
+    
+    /********************
+     * Public Functions *
+     ********************/
+    
+    function initialize(address _owner, bool _allowArbitraryDeployment) external;
+    function setWhitelistedDeployer(address _deployer, bool _isWhitelisted) external;
+    function setOwner(address _newOwner) external;
+    function setAllowArbitraryDeployment(bool _allowArbitraryDeployment) external;
+    function enableArbitraryContractDeployment() external;
+    function isDeployerAllowed(address _deployer) external returns (bool _allowed);
+}

packages/contracts/contracts/optimistic-ethereum/iOVM/precompiles/iOVM_L1MessageSender.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+
+/**
+ * @title iOVM_L1MessageSender
+ */
+interface iOVM_L1MessageSender {
+    
+    /********************
+     * Public Functions *
+     ********************/
+    
+    function getL1MessageSender() external returns (address _l1MessageSender);
+}

packages/contracts/contracts/optimistic-ethereum/iOVM/precompiles/iOVM_L2ToL1MessagePasser.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+
+/**
+ * @title iOVM_L2ToL1MessagePasser
+ */
+interface iOVM_L2ToL1MessagePasser {
+
+    /**********
+     * Events *
+     **********/
+
+    event L2ToL1Message(
+       uint _nonce,
+       address _sender,
+       bytes _data
+    );
+
+
+    /********************
+     * Public Functions *
+     ********************/
+    
+    function passMessageToL1(bytes memory _message) external;
+}

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_StateTransitioner.sol

@@ -25,7 +25,13 @@ interface iOVM_StateTransitioner {
 
     function proveContractState(
         address _ovmContractAddress,
-        Lib_OVMCodec.Account calldata _account,
+        address _ethContractAddress,
+        Lib_OVMCodec.EVMAccount calldata _account,
+        bytes calldata _stateTrieWitness
+    ) external;
+
+    function proveEmptyContractState(
+        address _ovmContractAddress,
         bytes calldata _stateTrieWitness
     ) external;
 
@@ -33,7 +39,6 @@ interface iOVM_StateTransitioner {
         address _ovmContractAddress,
         bytes32 _key,
         bytes32 _value,
-        bytes calldata _stateTrieWitness,
         bytes calldata _storageTrieWitness
     ) external;
 
@@ -53,7 +58,7 @@ interface iOVM_StateTransitioner {
 
     function commitContractState(
         address _ovmContractAddress,
-        Lib_OVMCodec.Account calldata _account,
+        Lib_OVMCodec.EVMAccount calldata _account,
         bytes calldata _stateTrieWitness
     ) external;
 

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

@@ -4,15 +4,42 @@ pragma experimental ABIEncoderV2;
 
 /* Library Imports */
 import { Lib_RLPReader } from "../rlp/Lib_RLPReader.sol";
+import { Lib_RLPWriter } from "../rlp/Lib_RLPWriter.sol";
 
 /**
  * @title Lib_OVMCodec
  */
 library Lib_OVMCodec {
 
-    /*******************
-     * Data Structures *
-     *******************/
+    /*************
+     * Constants *
+     *************/
+
+    bytes constant internal RLP_NULL_BYTES = hex'80';
+    bytes constant internal NULL_BYTES = bytes('');
+    bytes32 constant internal NULL_BYTES32 = bytes32('');
+    bytes32 constant internal KECCAK256_RLP_NULL_BYTES = keccak256(RLP_NULL_BYTES);
+    bytes32 constant internal KECCAK256_NULL_BYTES = keccak256(NULL_BYTES);
+
+
+    /*********
+     * Enums *
+     *********/
+    
+    enum EOASignatureType {
+        ETH_SIGNED_MESSAGE,
+        NATIVE_TRANSACTON
+    }
+
+    enum QueueOrigin {
+        SEQUENCER_QUEUE,
+        L1TOL2_QUEUE
+    }
+
+
+    /***********
+     * Structs *
+     ***********/
 
     struct Account {
         uint256 nonce;
@@ -45,25 +72,18 @@ library Lib_OVMCodec {
 
     struct Transaction {
         uint256 timestamp;
-        uint256 queueOrigin;
+        uint256 number;
+        QueueOrigin l1QueueOrigin;
+        address l1Txorigin;
         address entrypoint;
-        address origin;
-        address msgSender;
         uint256 gasLimit;
         bytes data;
     }
 
-    struct ProofMatrix {
-        bool checkNonce;
-        bool checkBalance;
-        bool checkStorageRoot;
-        bool checkCodeHash;
-    }
-
     struct QueueElement {
-        uint256 timestamp;
-        bytes32 batchRoot;
-        bool isL1ToL2Batch;
+        bytes32 queueRoot;
+        uint40 timestamp;
+        uint32 blockNumber;
     }
 
     struct EOATransaction {
@@ -73,11 +93,6 @@ library Lib_OVMCodec {
         bytes data;
     }
 
-    enum EOASignatureType {
-        ETH_SIGNED_MESSAGE,
-        NATIVE_TRANSACTON
-    }
-
 
     /*********************************************
      * Internal Functions: Encoding and Decoding *
@@ -97,13 +112,13 @@ library Lib_OVMCodec {
             EOATransaction memory _decoded
         )
     {
-        Lib_RLPReader.RLPItem[] memory decoded = Lib_RLPReader.toList(Lib_RLPReader.toRlpItem(_transaction));
+        Lib_RLPReader.RLPItem[] memory decoded = Lib_RLPReader.readList(_transaction);
 
         return EOATransaction({
-            nonce: Lib_RLPReader.toUint(decoded[0]),
-            gasLimit: Lib_RLPReader.toUint(decoded[2]),
-            target: Lib_RLPReader.toAddress(decoded[3]),
-            data: Lib_RLPReader.toBytes(decoded[5])
+            nonce: Lib_RLPReader.readUint256(decoded[0]),
+            gasLimit: Lib_RLPReader.readUint256(decoded[2]),
+            target: Lib_RLPReader.readAddress(decoded[3]),
+            data: Lib_RLPReader.readBytes(decoded[5])
         });
     }
 
@@ -123,10 +138,10 @@ library Lib_OVMCodec {
     {
         return abi.encodePacked(
             _transaction.timestamp,
-            _transaction.queueOrigin,
+            _transaction.number,
+            _transaction.l1QueueOrigin,
+            _transaction.l1Txorigin,
             _transaction.entrypoint,
-            _transaction.origin,
-            _transaction.msgSender,
             _transaction.gasLimit,
             _transaction.data
         );
@@ -148,4 +163,77 @@ library Lib_OVMCodec {
     {
         return keccak256(encodeTransaction(_transaction));
     }
+
+    /**
+     * Converts an OVM account to an EVM account.
+     * @param _in OVM account to convert.
+     * @return _out Converted EVM account.
+     */
+    function toEVMAccount(
+        Account memory _in
+    )
+        internal
+        pure
+        returns (
+            EVMAccount memory _out
+        )
+    {
+        return EVMAccount({
+            nonce: _in.nonce,
+            balance: _in.balance,
+            storageRoot: _in.storageRoot,
+            codeHash: _in.codeHash
+        });
+    }
+
+    /**
+     * @notice RLP-encodes an account state struct.
+     * @param _account Account state struct.
+     * @return _encoded RLP-encoded account state.
+     */
+    function encodeEVMAccount(
+        EVMAccount memory _account
+    )
+        internal
+        pure
+        returns (
+            bytes memory _encoded
+        )
+    {
+        bytes[] memory raw = new bytes[](4);
+
+        // Unfortunately we can't create this array outright because
+        // RLPWriter.encodeList will reject fixed-size arrays. Assigning
+        // index-by-index circumvents this issue.
+        raw[0] = Lib_RLPWriter.writeUint(_account.nonce);
+        raw[1] = Lib_RLPWriter.writeUint(_account.balance);
+        raw[2] = Lib_RLPWriter.writeBytes(abi.encodePacked(_account.storageRoot));
+        raw[3] = Lib_RLPWriter.writeBytes(abi.encodePacked(_account.codeHash));
+
+        return Lib_RLPWriter.writeList(raw);
+    }
+
+    /**
+     * @notice Decodes an RLP-encoded account state into a useful struct.
+     * @param _encoded RLP-encoded account state.
+     * @return _account Account state struct.
+     */
+    function decodeEVMAccount(
+        bytes memory _encoded
+    )
+        internal
+        pure
+        returns (
+            EVMAccount memory _account
+        )
+    {
+        Lib_RLPReader.RLPItem[] memory accountState = Lib_RLPReader.readList(_encoded);
+
+        return EVMAccount({
+            nonce: Lib_RLPReader.readUint256(accountState[0]),
+            balance: Lib_RLPReader.readUint256(accountState[1]),
+            storageRoot: Lib_RLPReader.readBytes32(accountState[2]),
+            codeHash: Lib_RLPReader.readBytes32(accountState[3])
+        });
+    }
 }

packages/contracts/contracts/optimistic-ethereum/libraries/resolver/Lib_AddressManager.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+
+/* Contract Imports */
+import { Ownable } from "./Lib_Ownable.sol";
+
+/**
+ * @title Lib_AddressManager
+ */
+contract Lib_AddressManager is Ownable {
+
+    /*******************************************
+     * Contract Variables: Internal Accounting *
+     *******************************************/
+
+    mapping (bytes32 => address) private addresses;
+
+
+    /********************
+     * Public Functions *
+     ********************/
+
+    function setAddress(
+        string memory _name,
+        address _address
+    )
+        public
+        onlyOwner
+    {
+        addresses[_getNameHash(_name)] = _address;
+    }
+
+    function getAddress(
+        string memory _name
+    )
+        public
+        view
+        returns (address)
+    {
+        return addresses[_getNameHash(_name)];
+    }
+
+
+    /**********************
+     * Internal Functions *
+     **********************/
+
+    function _getNameHash(
+        string memory _name
+    )
+        internal
+        pure
+        returns (
+            bytes32 _hash
+        )
+    {
+        return keccak256(abi.encodePacked(_name));
+    }
+}

packages/contracts/contracts/optimistic-ethereum/libraries/resolver/Lib_AddressResolver.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+
+/* Library Imports */
+import { Lib_AddressManager } from "./Lib_AddressManager.sol";
+
+/**
+ * @title Lib_AddressResolver
+ */
+contract Lib_AddressResolver {
+
+    /*******************************************
+     * Contract Variables: Contract References *
+     *******************************************/
+
+    Lib_AddressManager internal libAddressManager;
+
+
+    /***************
+     * Constructor *
+     ***************/
+
+    /**
+     * @param _libAddressManager Address of the Lib_AddressManager.
+     */
+    constructor(
+        address _libAddressManager
+    )
+        public
+    {
+        libAddressManager = Lib_AddressManager(_libAddressManager);
+    }
+
+
+    /********************
+     * Public Functions *
+     ********************/
+
+    function resolve(
+        string memory _name
+    )
+        public
+        view
+        returns (
+            address _contract
+        )
+    {
+        return libAddressManager.getAddress(_name);
+    }
+}

packages/contracts/contracts/optimistic-ethereum/libraries/resolver/Lib_Ownable.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.7.0;
+
+/**
+ * @title Ownable
+ * @dev Adapted from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol
+ */
+abstract contract Ownable {
+
+    /*************
+     * Variables *
+     *************/
+
+    address public owner;
+
+
+    /**********
+     * Events *
+     **********/
+
+    event OwnershipTransferred(
+        address indexed previousOwner,
+        address indexed newOwner
+    );
+
+
+    /***************
+     * Constructor *
+     ***************/
+
+    constructor()
+        internal
+    {
+        owner = msg.sender;
+        emit OwnershipTransferred(address(0), owner);
+    }
+
+
+    /**********************
+     * Function Modifiers *
+     **********************/
+
+    modifier onlyOwner() {
+        require(
+            owner == msg.sender,
+            "Ownable: caller is not the owner"
+        );
+        _;
+    }
+
+
+    /********************
+     * Public Functions *
+     ********************/
+
+    function renounceOwnership()
+        public
+        virtual
+        onlyOwner 
+    {
+        emit OwnershipTransferred(owner, address(0));
+        owner = address(0);
+    }
+
+    function transferOwnership(address _newOwner)
+        public
+        virtual
+        onlyOwner
+    {
+        require(
+            _newOwner != address(0),
+            "Ownable: new owner cannot be the zero address"
+        );
+
+        emit OwnershipTransferred(owner, _newOwner);
+        owner = _newOwner;
+    }
+}

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

@@ -24,7 +24,7 @@ library Lib_SecureMerkleTrie {
      * 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.
+     * @return _verified `true` if the k/v pair exists in the trie, `false` otherwise.
      */
     function verifyInclusionProof(
         bytes memory _key,
@@ -35,7 +35,7 @@ library Lib_SecureMerkleTrie {
         internal
         view
         returns (
-            bool
+            bool _verified
         )
     {
         bytes memory key = _getSecureKey(_key);
@@ -43,31 +43,28 @@ library Lib_SecureMerkleTrie {
     }
 
     /**
-     * @notice Verifies a proof that a given key/value pair is *not* present in
+     * @notice Verifies a proof that a given key 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.
+     * 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 is absent in the trie, `false` otherwise.
+     * @return _verified `true` if the key is not present in the trie, `false` otherwise.
      */
     function verifyExclusionProof(
         bytes memory _key,
-        bytes memory _value,
         bytes memory _proof,
         bytes32 _root
     )
         internal
         view
         returns (
-            bool
+            bool _verified
         )
     {
         bytes memory key = _getSecureKey(_key);
-        return Lib_MerkleTrie.verifyExclusionProof(key, _value, _proof, _root);
+        return Lib_MerkleTrie.verifyExclusionProof(key, _proof, _root);
     }
 
     /**
@@ -79,7 +76,7 @@ library Lib_SecureMerkleTrie {
      * 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.
+     * @return _updatedRoot Root hash of the newly constructed trie.
      */
     function update(
         bytes memory _key,
@@ -90,7 +87,7 @@ library Lib_SecureMerkleTrie {
         internal
         view
         returns (
-            bytes32
+            bytes32 _updatedRoot
         )
     {
         bytes memory key = _getSecureKey(_key);
@@ -102,7 +99,8 @@ library Lib_SecureMerkleTrie {
      * @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.
+     * @return _exists Whether or not the key exists.
+     * @return _value Value of the key if it exists.
      */
     function get(
         bytes memory _key,
@@ -112,8 +110,8 @@ library Lib_SecureMerkleTrie {
         internal
         view
         returns (
-            bool,
-            bytes memory
+            bool _exists,
+            bytes memory _value
         )
     {
         bytes memory key = _getSecureKey(_key);
@@ -124,7 +122,7 @@ library Lib_SecureMerkleTrie {
      * 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.
+     * @return _updatedRoot Hash of the trie.
      */
     function getSingleNodeRootHash(
         bytes memory _key,
@@ -133,7 +131,7 @@ library Lib_SecureMerkleTrie {
         internal
         view
         returns (
-            bytes32
+            bytes32 _updatedRoot
         )
     {
         bytes memory key = _getSecureKey(_key);
@@ -145,13 +143,18 @@ library Lib_SecureMerkleTrie {
      * Private Functions *
      *********************/
 
+    /**
+     * Computes the secure counterpart to a key.
+     * @param _key Key to get a secure key from.
+     * @return _secureKey Secure version of the key.
+     */
     function _getSecureKey(
         bytes memory _key
     )
         private
         pure
         returns (
-            bytes memory
+            bytes memory _secureKey
         )
     {
         return abi.encodePacked(keccak256(_key));

packages/contracts/contracts/optimistic-ethereum/libraries/utils/Lib_ByteUtils.sol → packages/contracts/contracts/optimistic-ethereum/libraries/utils/Lib_BytesUtils.sol

 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.7.0;
 
-/*
- * @title Lib_ByteUtils
+/**
+ * @title Lib_BytesUtils
  */
-library Lib_ByteUtils {
+library Lib_BytesUtils {
 
     /**********************
      * Internal Functions *

packages/contracts/contracts/optimistic-ethereum/libraries/utils/Lib_MerkleUtils.sol

@@ -15,6 +15,11 @@ library Lib_MerkleUtils {
             bytes32 _root
         )
     {
+        require(
+            _hashes.length > 0,
+            "Must provide at least one leaf hash."
+        );
+
         if (_hashes.length == 1) {
             return _hashes[0];
         }