Adding L1 blocknumber to OVM context

packages/contracts/contracts/optimistic-ethereum/chain/CanonicalTransactionChain.sol

@@ -29,9 +29,11 @@ contract CanonicalTransactionChain is ContractResolver {
 
     address public sequencer;
     uint public forceInclusionPeriodSeconds;
+    uint public forceInclusionPeriodBlocks;
     uint public cumulativeNumElements;
     bytes32[] public batches;
     uint public lastOVMTimestamp;
+    uint public lastOVMBlockNumber;
 
 
     /*
@@ -53,6 +55,7 @@ contract CanonicalTransactionChain is ContractResolver {
     {
         sequencer = _sequencer;
         forceInclusionPeriodSeconds = _forceInclusionPeriodSeconds;
+        forceInclusionPeriodBlocks = _forceInclusionPeriodSeconds / 13;
         lastOVMTimestamp = 0;
     }
 
@@ -86,6 +89,7 @@ contract CanonicalTransactionChain is ContractResolver {
     {
         return keccak256(abi.encodePacked(
             _batchHeader.timestamp,
+            _batchHeader.blockNumber,
             _batchHeader.isL1ToL2Tx, // TODO REPLACE WITH QUEUE ORIGIN (if you are a PR reviewer please lmk!)
             _batchHeader.elementsMerkleRoot,
             _batchHeader.numElementsInBatch,
@@ -94,11 +98,11 @@ contract CanonicalTransactionChain is ContractResolver {
     }
 
     /**
-     * Checks whether a sender is allowed to append to the chain.
+     * Checks whether an address is the sequencer.
      * @param _sender Address to check.
-     * @return Whether or not the address can append.
+     * @return Whether or not the address is the sequencer.
      */
-    function authenticateAppend(
+    function isSequencer(
         address _sender
     )
         public
@@ -121,7 +125,7 @@ contract CanonicalTransactionChain is ContractResolver {
 
         require(
             safetyQueue.isEmpty() || l1ToL2Header.timestamp <= safetyQueue.peekTimestamp(),
-            "Must process older SafetyQueue batches first to enforce timestamp monotonicity"
+            "Must process older SafetyQueue batches first to enforce OVM timestamp monotonicity"
         );
 
         _appendQueueBatch(l1ToL2Header, true);
@@ -141,7 +145,7 @@ contract CanonicalTransactionChain is ContractResolver {
 
         require(
             l1ToL2Queue.isEmpty() || safetyHeader.timestamp <= l1ToL2Queue.peekTimestamp(),
-            "Must process older L1ToL2Queue batches first to enforce timestamp monotonicity"
+            "Must process older L1ToL2Queue batches first to enforce OVM timestamp monotonicity"
         );
 
         _appendQueueBatch(safetyHeader, false);
@@ -155,15 +159,16 @@ contract CanonicalTransactionChain is ContractResolver {
      */
     function appendSequencerBatch(
         bytes[] memory _txBatch,
-        uint _timestamp
+        uint _timestamp,
+        uint _blockNumber
     )
         public
     {
         L1ToL2TransactionQueue l1ToL2Queue = resolveL1ToL2TransactionQueue();
         SafetyTransactionQueue safetyQueue = resolveSafetyTransactionQueue();
 
         require(
-            authenticateAppend(msg.sender),
+            isSequencer(msg.sender),
             "Message sender does not have permission to append a batch"
         );
 
@@ -178,31 +183,62 @@ contract CanonicalTransactionChain is ContractResolver {
         );
 
         require(
-            _timestamp <= now,
-            "Cannot submit a batch with a timestamp in the future"
+            _blockNumber + forceInclusionPeriodBlocks > block.number,
+            "Cannot submit a batch with a blockNumber older than the sequencer inclusion period"
         );
 
         require(
-            l1ToL2Queue.isEmpty() || _timestamp <= l1ToL2Queue.peekTimestamp(),
-            "Must process older L1ToL2Queue batches first to enforce timestamp monotonicity"
+            _timestamp <= now,
+            "Cannot submit a batch with a timestamp in the future"
         );
 
         require(
-            safetyQueue.isEmpty() || _timestamp <= safetyQueue.peekTimestamp(),
-            "Must process older SafetyQueue batches first to enforce timestamp monotonicity"
+            _blockNumber <= block.number,
+            "Cannot submit a batch with a blockNumber in the future"
         );
 
+        if (!l1ToL2Queue.isEmpty()) {
+            require(
+                _timestamp <= l1ToL2Queue.peekTimestamp(),
+                "Must process older L1ToL2Queue batches first to enforce OVM timestamp monotonicity"
+            );
+
+            require(
+                _blockNumber <= l1ToL2Queue.peekBlockNumber(),
+                "Must process older L1ToL2Queue batches first to enforce OVM blockNumber monotonicity"
+            );
+        }
+
+        if (!safetyQueue.isEmpty()) {
+            require(
+                _timestamp <= safetyQueue.peekTimestamp(),
+                "Must process older SafetyQueue batches first to enforce OVM timestamp monotonicity"
+            );
+
+            require(
+                _blockNumber <= safetyQueue.peekBlockNumber(),
+                "Must process older SafetyQueue batches first to enforce OVM blockNumber monotonicity"
+            );
+        }
+
         require(
             _timestamp >= lastOVMTimestamp,
             "Timestamps must monotonically increase"
         );
 
+        require(
+            _blockNumber >= lastOVMBlockNumber,
+            "BlockNumbers must monotonically increase"
+        );
+
         lastOVMTimestamp = _timestamp;
+        lastOVMBlockNumber = _blockNumber;
 
         RollupMerkleUtils merkleUtils = resolveRollupMerkleUtils();
         bytes32 batchHeaderHash = keccak256(abi.encodePacked(
             _timestamp,
-            false, // isL1ToL2Tx
+            _blockNumber,
+            false, // isL1ToL2Tx TODO: replace with queue origin
             merkleUtils.getMerkleRoot(_txBatch), // elementsMerkleRoot
             _txBatch.length, // numElementsInBatch
             cumulativeNumElements // cumulativeNumElements
@@ -270,18 +306,21 @@ contract CanonicalTransactionChain is ContractResolver {
         internal
     {
         uint timestamp = _timestampedHash.timestamp;
+        uint blockNumber = _timestampedHash.blockNumber;
 
         require(
-            timestamp + forceInclusionPeriodSeconds <= now || authenticateAppend(msg.sender),
+            timestamp + forceInclusionPeriodSeconds <= now || isSequencer(msg.sender),
             "Message sender does not have permission to append this batch"
         );
 
         lastOVMTimestamp = timestamp;
+        lastOVMBlockNumber = blockNumber;
         bytes32 elementsMerkleRoot = _timestampedHash.txHash;
         uint numElementsInBatch = 1;
 
         bytes32 batchHeaderHash = keccak256(abi.encodePacked(
             timestamp,
+            blockNumber,
             _isL1ToL2Tx,
             elementsMerkleRoot,
             numElementsInBatch,

packages/contracts/contracts/optimistic-ethereum/ovm/ExecutionManager.sol

@@ -200,6 +200,7 @@ contract ExecutionManager is ContractResolver {
         // Make the EOA call for the account
         executeTransaction(
             _timestamp,
+            0, // note: since executeEOACall is soon to be deprecated, not bothering to add blockNumber here.
             _queueOrigin,
             _ovmEntrypoint,
             _callBytes,
@@ -214,6 +215,7 @@ contract ExecutionManager is ContractResolver {
      * Execute a transaction. Note that unsigned EOA calls are unauthenticated.
      * This means that they should not be allowed for normal execution.
      * @param _timestamp The timestamp which should be used for this call's context.
+     * @param _blockNumber The blockNumber which should be used for this call's context.
      * @param _queueOrigin The parent-chain queue from which this call originated.
      * @param _ovmEntrypoint The contract which this transaction should be executed against.
      * @param _callBytes The calldata for this ovm transaction.
@@ -223,6 +225,7 @@ contract ExecutionManager is ContractResolver {
      */
     function executeTransaction(
         uint _timestamp,
+        uint _blockNumber,
         uint _queueOrigin,
         address _ovmEntrypoint,
         bytes memory _callBytes,
@@ -238,7 +241,7 @@ contract ExecutionManager is ContractResolver {
         require(_timestamp > 0, "Timestamp must be greater than 0");
 
         // Initialize our context
-        initializeContext(_timestamp, _queueOrigin, _fromAddress, _l1MsgSenderAddress, _ovmTxGasLimit);
+        initializeContext(_timestamp, _blockNumber, _queueOrigin, _fromAddress, _l1MsgSenderAddress, _ovmTxGasLimit);
 
         // Set the active contract to be our EOA address
         switchActiveContract(_fromAddress);
@@ -479,6 +482,28 @@ contract ExecutionManager is ContractResolver {
         }
     }
 
+    /**
+     * @notice NUMBER opcode
+     * This gets the current blockNumber. Since the L2 value for this
+     * will necessarily be different than L1, this needs to be overridden for the OVM.
+     * Note: This is a raw function, so there are no listed (ABI-encoded) inputs / outputs.
+     * Below format of the bytes expected as input and written as output:
+     * calldata: 4 bytes: [methodID (bytes4)]
+     * returndata: uint256 representing the current blockNumber.
+     */
+    function ovmNUMBER()
+        public
+        view
+    {
+        uint t = executionContext.blockNumber;
+
+        assembly {
+            let timestampMemory := mload(0x40)
+            mstore(timestampMemory, t)
+            return(timestampMemory, 32)
+        }
+    }
+
     /**
      * @notice CHAINID opcode
      * This gets the chain id. Since the L2 value for this
@@ -1315,6 +1340,7 @@ contract ExecutionManager is ContractResolver {
      */
     function initializeContext(
         uint _timestamp,
+        uint _blockNumber,
         uint _queueOrigin,
         address _ovmTxOrigin,
         address _l1MsgSender,
@@ -1326,9 +1352,10 @@ contract ExecutionManager is ContractResolver {
         // reserved for the genesis contract & initial msgSender).
         restoreContractContext(ZERO_ADDRESS, ZERO_ADDRESS);
 
-        // And finally set the timestamp, queue origin, tx origin, and
+        // And finally set the timestamp, blockNumber, queue origin, tx origin, and
         // l1MessageSender.
         executionContext.timestamp = _timestamp;
+        executionContext.blockNumber = _blockNumber;
         executionContext.queueOrigin = _queueOrigin;
         executionContext.ovmTxOrigin = _ovmTxOrigin;
         executionContext.l1MessageSender = _l1MsgSender;

packages/contracts/contracts/optimistic-ethereum/ovm/StateTransitioner.sol

@@ -232,6 +232,7 @@ contract StateTransitioner is IStateTransitioner, ContractResolver {
         // Execute the transaction via the execution manager.
         executionManager.executeTransaction(
             _transactionData.timestamp,
+            _transactionData.blockNumber,
             _transactionData.queueOrigin,
             _transactionData.ovmEntrypoint,
             _transactionData.callBytes,

packages/contracts/contracts/optimistic-ethereum/queue/RollupQueue.sol

@@ -58,7 +58,7 @@ contract RollupQueue {
 
     /**
      * Peeks the timestamp of the front element on the queue.
-     * @return Front queue element timestamp.
+     * @return Front queue element timestamp (lowest in queue).
      */
     function peekTimestamp()
         public
@@ -70,14 +70,16 @@ contract RollupQueue {
     }
 
     /**
-     * Checks if this is a calldata transaction queue.
-     * @return Whether or not this is a calldata tx queue.
+     * Peeks the blockNumber of the front element on the queue.
+     * @return Front queue element blockNumber (lowest in queue).
      */
-    function isCalldataTxQueue()
+    function peekBlockNumber()
         public
-        returns (bool)
+        view
+        returns (uint)
     {
-        return true;
+        DataTypes.TimestampedHash memory frontBatch = peek();
+        return frontBatch.blockNumber;
     }
 
     /*
@@ -96,8 +98,9 @@ contract RollupQueue {
         bytes32 txHash = keccak256(_data);
 
         batchHeaders.push(DataTypes.TimestampedHash({
+            txHash: txHash,
             timestamp: now,
-            txHash: txHash
+            blockNumber: block.number
         }));
     }
 

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

@@ -26,6 +26,7 @@ library DataTypes {
         bool inStaticContext;
         uint chainId;
         uint timestamp;
+        uint blockNumber;
         uint queueOrigin;
         address ovmActiveContract;
         address ovmMsgSender;
@@ -64,15 +65,17 @@ library DataTypes {
 
     struct TxChainBatchHeader {
        uint timestamp;
+       uint blockNumber;
        bool isL1ToL2Tx;
        bytes32 elementsMerkleRoot;
        uint numElementsInBatch;
        uint cumulativePrevElements;
     }
 
     struct TimestampedHash {
-       uint timestamp;
        bytes32 txHash;
+       uint timestamp;
+       uint blockNumber;
     }
 
     struct AccountState {
@@ -91,6 +94,7 @@ library DataTypes {
 
     struct OVMTransactionData {
         uint256 timestamp;
+        uint256 blockNumber;
         uint256 queueOrigin;
         address ovmEntrypoint;
         bytes callBytes;

packages/contracts/contracts/test-helpers/ContextContract.sol

@@ -67,6 +67,33 @@ contract ContextContract {
         }
     }
 
+    function getNUMBER() public {
+        // bitwise right shift 28 * 8 bits so the 4 method ID bytes are in the right-most bytes
+        bytes32 methodId = keccak256("ovmNUMBER()") >> 224;
+        address addr = executionManagerAddress;
+
+        assembly {
+            let callBytes := mload(0x40)
+            calldatacopy(callBytes, 0, calldatasize)
+
+            // replace the first 4 bytes with the right methodID
+            mstore8(callBytes, shr(24, methodId))
+            mstore8(add(callBytes, 1), shr(16, methodId))
+            mstore8(add(callBytes, 2), shr(8, methodId))
+            mstore8(add(callBytes, 3), methodId)
+
+            // overwrite call params
+            let result := mload(0x40)
+            let success := call(gas, addr, 0, callBytes, calldatasize, result, 32)
+
+            if eq(success, 0) {
+                revert(result, returndatasize)
+            }
+
+            return(result, returndatasize)
+        }
+    }
+
     function getADDRESS() public {
         // bitwise right shift 28 * 8 bits so the 4 method ID bytes are in the right-most bytes
         bytes32 methodId = keccak256("ovmADDRESS()") >> 224;