@arbitrum/nitro-contracts 1.0.0-beta.5 → 1.0.0-beta.8

package/src/mocks/BridgeStub.sol

@@ -14,19 +14,28 @@ contract BridgeStub is IBridge {
         bool allowed;
     }
 
-    mapping(address => InOutInfo) private allowedInboxesMap;
+    mapping(address => InOutInfo) private allowedDelayedInboxesMap;
     //mapping(address => InOutInfo) private allowedOutboxesMap;
 
-    address[] public allowedInboxList;
+    address[] public allowedDelayedInboxList;
     address[] public allowedOutboxList;
 
     address public override activeOutbox;
 
     // Accumulator for delayed inbox; tail represents hash of the current state; each element represents the inclusion of a new message.
-    bytes32[] public override inboxAccs;
+    bytes32[] public override delayedInboxAccs;
 
-    function allowedInboxes(address inbox) external view override returns (bool) {
-        return allowedInboxesMap[inbox].allowed;
+    bytes32[] public override sequencerInboxAccs;
+
+    address public sequencerInbox;
+
+    function setSequencerInbox(address _sequencerInbox) external override {
+        sequencerInbox = _sequencerInbox;
+        emit SequencerInboxUpdated(_sequencerInbox);
+    }
+
+    function allowedDelayedInboxes(address inbox) external view override returns (bool) {
+        return allowedDelayedInboxesMap[inbox].allowed;
     }
 
     function allowedOutboxes(address) external pure override returns (bool) {
@@ -38,9 +47,9 @@ contract BridgeStub is IBridge {
         address sender,
         bytes32 messageDataHash
     ) external payable override returns (uint256) {
-        require(allowedInboxesMap[msg.sender].allowed, "NOT_FROM_INBOX");
+        require(allowedDelayedInboxesMap[msg.sender].allowed, "NOT_FROM_INBOX");
         return
-            addMessageToAccumulator(
+            addMessageToDelayedAccumulator(
                 kind,
                 sender,
                 block.number,
@@ -50,7 +59,34 @@ contract BridgeStub is IBridge {
             );
     }
 
-    function addMessageToAccumulator(
+    function enqueueSequencerMessage(bytes32 dataHash, uint256 afterDelayedMessagesRead)
+        external
+        returns (
+            uint256 seqMessageIndex,
+            bytes32 beforeAcc,
+            bytes32 delayedAcc,
+            bytes32 acc
+        )
+    {
+        seqMessageIndex = sequencerInboxAccs.length;
+        if (sequencerInboxAccs.length > 0) {
+            beforeAcc = sequencerInboxAccs[sequencerInboxAccs.length - 1];
+        }
+        if (afterDelayedMessagesRead > 0) {
+            delayedAcc = delayedInboxAccs[afterDelayedMessagesRead - 1];
+        }
+        acc = keccak256(abi.encodePacked(beforeAcc, dataHash, delayedAcc));
+        sequencerInboxAccs.push(acc);
+    }
+
+    function submitBatchSpendingReport(address batchPoster, bytes32 dataHash)
+        external
+        returns (uint256)
+    {
+        // TODO: implement stub
+    }
+
+    function addMessageToDelayedAccumulator(
         uint8,
         address,
         uint256,
@@ -58,7 +94,7 @@ contract BridgeStub is IBridge {
         uint256,
         bytes32 messageDataHash
     ) internal returns (uint256) {
-        uint256 count = inboxAccs.length;
+        uint256 count = delayedInboxAccs.length;
         bytes32 messageHash = Messages.messageHash(
             0,
             address(uint160(0)),
@@ -70,9 +106,9 @@ contract BridgeStub is IBridge {
         );
         bytes32 prevAcc = 0;
         if (count > 0) {
-            prevAcc = inboxAccs[count - 1];
+            prevAcc = delayedInboxAccs[count - 1];
         }
-        inboxAccs.push(Messages.accumulateInboxMessage(prevAcc, messageHash));
+        delayedInboxAccs.push(Messages.accumulateInboxMessage(prevAcc, messageHash));
         return count;
     }
 
@@ -84,21 +120,23 @@ contract BridgeStub is IBridge {
         revert("NOT_IMPLEMENTED");
     }
 
-    function setInbox(address inbox, bool enabled) external override {
-        InOutInfo storage info = allowedInboxesMap[inbox];
+    function setDelayedInbox(address inbox, bool enabled) external override {
+        InOutInfo storage info = allowedDelayedInboxesMap[inbox];
         bool alreadyEnabled = info.allowed;
         emit InboxToggle(inbox, enabled);
         if ((alreadyEnabled && enabled) || (!alreadyEnabled && !enabled)) {
             return;
         }
         if (enabled) {
-            allowedInboxesMap[inbox] = InOutInfo(allowedInboxList.length, true);
-            allowedInboxList.push(inbox);
+            allowedDelayedInboxesMap[inbox] = InOutInfo(allowedDelayedInboxList.length, true);
+            allowedDelayedInboxList.push(inbox);
         } else {
-            allowedInboxList[info.index] = allowedInboxList[allowedInboxList.length - 1];
-            allowedInboxesMap[allowedInboxList[info.index]].index = info.index;
-            allowedInboxList.pop();
-            delete allowedInboxesMap[inbox];
+            allowedDelayedInboxList[info.index] = allowedDelayedInboxList[
+                allowedDelayedInboxList.length - 1
+            ];
+            allowedDelayedInboxesMap[allowedDelayedInboxList[info.index]].index = info.index;
+            allowedDelayedInboxList.pop();
+            delete allowedDelayedInboxesMap[inbox];
         }
     }
 
@@ -109,7 +147,17 @@ contract BridgeStub is IBridge {
         revert("NOT_IMPLEMENTED");
     }
 
-    function messageCount() external view override returns (uint256) {
-        return inboxAccs.length;
+    function delayedMessageCount() external view override returns (uint256) {
+        return delayedInboxAccs.length;
+    }
+
+    function sequencerMessageCount() external view override returns (uint256) {
+        return sequencerInboxAccs.length;
     }
+
+    function rollup() external pure override returns (IOwnable) {
+        revert("NOT_IMPLEMENTED");
+    }
+
+    function acceptFundsFromOldBridge() external payable {}
 }

package/src/mocks/InboxStub.sol

@@ -132,4 +132,6 @@ contract InboxStub is IInbox {
     function depositEth(uint256) external payable override returns (uint256) {
         revert("NOT_IMPLEMENTED");
     }
+
+    function postUpgradeInit(IBridge _bridge) external {}
 }

package/src/mocks/SequencerInboxStub.sol

@@ -8,24 +8,26 @@ import "../bridge/SequencerInbox.sol";
 
 contract SequencerInboxStub is SequencerInbox {
     constructor(
-        IBridge delayedBridge_,
+        IBridge bridge_,
         address sequencer_,
         ISequencerInbox.MaxTimeVariation memory maxTimeVariation_
     ) {
-        delayedBridge = delayedBridge_;
-        rollup = msg.sender;
+        bridge = bridge_;
+        rollup = IOwnable(msg.sender);
         maxTimeVariation = maxTimeVariation_;
         isBatchPoster[sequencer_] = true;
     }
 
     function addInitMessage() external {
         (bytes32 dataHash, TimeBounds memory timeBounds) = formEmptyDataHash(0);
-        (bytes32 beforeAcc, bytes32 delayedAcc, bytes32 afterAcc) = addSequencerL2BatchImpl(
-            dataHash,
-            0
-        );
+        (
+            uint256 sequencerMessageCount,
+            bytes32 beforeAcc,
+            bytes32 delayedAcc,
+            bytes32 afterAcc
+        ) = addSequencerL2BatchImpl(dataHash, 0, 0);
         emit SequencerBatchDelivered(
-            inboxAccs.length - 1,
+            sequencerMessageCount,
             beforeAcc,
             afterAcc,
             delayedAcc,

package/src/mocks/Simple.sol

@@ -4,10 +4,13 @@
 
 pragma solidity ^0.8.0;
 
+import "../precompiles/ArbRetryableTx.sol";
+
 contract Simple {
     uint64 public counter;
 
     event CounterEvent(uint64 count);
+    event RedeemedEvent(address caller, address redeemer);
     event NullEvent();
 
     function increment() external {
@@ -19,6 +22,11 @@ contract Simple {
         emit CounterEvent(counter);
     }
 
+    function incrementRedeem() external {
+        counter++;
+        emit RedeemedEvent(msg.sender, ArbRetryableTx(address(110)).getCurrentRedeemer());
+    }
+
     function emitNullEvent() external {
         emit NullEvent();
     }

package/src/node-interface/NodeInterface.sol

@@ -11,7 +11,8 @@ pragma solidity >=0.4.21 <0.9.0;
  */
 interface NodeInterface {
     /**
-     * @notice Estimate the cost of putting a message in the L2 inbox that is reexecuted
+     * @notice Estimate the cost of putting a message in the L2 inbox that is reexecuted.
+     * @dev Use eth_estimateGas to call.
      * @param sender sender of the L1 and L2 transaction
      * @param deposit amount to deposit to sender in L2
      * @param to destination L2 contract address
@@ -31,7 +32,8 @@ interface NodeInterface {
     ) external;
 
     /**
-     * @notice Constructs an outbox proof of an l2->l1 send's existence in the outbox accumulator
+     * @notice Constructs an outbox proof of an l2->l1 send's existence in the outbox accumulator.
+     * @dev Use eth_call to call.
      * @param size the number of elements in the accumulator
      * @param leaf the position of the send in the accumulator
      * @return send the l2->l1 send's hash
@@ -48,8 +50,9 @@ interface NodeInterface {
         );
 
     /**
-     * @notice Finds the L1 batch containing a requested L2 block, reverting if none does
-     * Throws if block doesn't exist, or if block number is 0
+     * @notice Finds the L1 batch containing a requested L2 block, reverting if none does.
+     * Use eth_call to call.
+     * Throws if block doesn't exist, or if block number is 0. Use eth_call
      * @param blockNum The L2 block being queried
      * @return batch The L1 block containing the requested L2 block
      */
@@ -60,8 +63,63 @@ interface NodeInterface {
      * This gets the number of L1 confirmations for the input message producing the L2 block,
      * which happens well before the L1 rollup contract confirms the L2 block.
      * Throws if block doesnt exist in the L2 chain.
+     * @dev Use eth_call to call.
      * @param blockHash The hash of the L2 block being queried
      * @return confirmations The number of L1 confirmations the sequencer batch has. Returns 0 if block not yet included in an L1 batch.
      */
     function getL1Confirmations(bytes32 blockHash) external view returns (uint64 confirmations);
+
+    /**
+     * @notice Same as native gas estimation, but with additional info on the l1 costs.
+     * @dev Use eth_call to call.
+     * @param data the tx's calldata. Everything else like "From" and "Gas" are copied over
+     * @param to the tx's "To" (ignored when contractCreation is true)
+     * @param contractCreation whether "To" is omitted
+     * @return gasEstimate an estimate of the total amount of gas needed for this tx
+     * @return gasEstimateForL1 an estimate of the amount of gas needed for the l1 component of this tx
+     * @return baseFee the l2 base fee
+     * @return l1BaseFeeEstimate ArbOS's l1 estimate of the l1 base fee
+     */
+    function gasEstimateComponents(
+        address to,
+        bool contractCreation,
+        bytes calldata data
+    )
+        external
+        payable
+        returns (
+            uint64 gasEstimate,
+            uint64 gasEstimateForL1,
+            uint256 baseFee,
+            uint256 l1BaseFeeEstimate
+        );
+
+    /**
+     * @notice Returns the proof necessary to redeem a message
+     * @param batchNum index of outbox entry (i.e., outgoing messages Merkle root) in array of outbox entries
+     * @param index index of outgoing message in outbox entry
+     * @return proof Merkle proof of message inclusion in outbox entry
+     * @return path Merkle path to message
+     * @return l2Sender sender if original message (i.e., caller of ArbSys.sendTxToL1)
+     * @return l1Dest destination address for L1 contract call
+     * @return l2Block l2 block number at which sendTxToL1 call was made
+     * @return l1Block l1 block number at which sendTxToL1 call was made
+     * @return timestamp l2 Timestamp at which sendTxToL1 call was made
+     * @return amount value in L1 message in wei
+     * @return calldataForL1 abi-encoded L1 message data
+     */
+    function legacyLookupMessageBatchProof(uint256 batchNum, uint64 index)
+        external
+        view
+        returns (
+            bytes32[] memory proof,
+            uint256 path,
+            address l2Sender,
+            address l1Dest,
+            uint256 l2Block,
+            uint256 l1Block,
+            uint256 timestamp,
+            uint256 amount,
+            bytes memory calldataForL1
+        );
 }

package/src/osp/IOneStepProver.sol

@@ -12,8 +12,7 @@ import "../bridge/IBridge.sol";
 
 struct ExecutionContext {
     uint256 maxInboxMessagesRead;
-    ISequencerInbox sequencerInbox;
-    IBridge delayedBridge;
+    IBridge bridge;
 }
 
 abstract contract IOneStepProver {

package/src/osp/OneStepProver0.sol

@@ -12,7 +12,6 @@ import "./IOneStepProver.sol";
 
 contract OneStepProver0 is IOneStepProver {
     using MerkleProofLib for MerkleProof;
-    using PcStackLib for PcStack;
     using StackFrameLib for StackFrameWindow;
     using ValueLib for Value;
     using ValueStackLib for ValueStack;
@@ -51,8 +50,6 @@ contract OneStepProver0 is IOneStepProver {
             ty = ValueType.F32;
         } else if (opcode == Instructions.F64_CONST) {
             ty = ValueType.F64;
-        } else if (opcode == Instructions.PUSH_STACK_BOUNDARY) {
-            ty = ValueType.STACK_BOUNDARY;
         } else {
             revert("CONST_PUSH_INVALID_OPCODE");
         }
@@ -86,39 +83,6 @@ contract OneStepProver0 is IOneStepProver {
         }
     }
 
-    function executeBlock(
-        Machine memory mach,
-        Module memory,
-        Instruction calldata inst,
-        bytes calldata
-    ) internal pure {
-        uint32 targetPc = uint32(inst.argumentData);
-        require(targetPc == inst.argumentData, "BAD_BLOCK_PC");
-        mach.blockStack.push(targetPc);
-    }
-
-    function executeBranch(
-        Machine memory mach,
-        Module memory,
-        Instruction calldata,
-        bytes calldata
-    ) internal pure {
-        mach.functionPc = mach.blockStack.pop();
-    }
-
-    function executeBranchIf(
-        Machine memory mach,
-        Module memory,
-        Instruction calldata,
-        bytes calldata
-    ) internal pure {
-        uint32 cond = mach.valueStack.pop().assumeI32();
-        if (cond != 0) {
-            // Jump to target
-            mach.functionPc = mach.blockStack.pop();
-        }
-    }
-
     function executeReturn(
         Machine memory mach,
         Module memory,
@@ -419,27 +383,6 @@ contract OneStepProver0 is IOneStepProver {
         );
     }
 
-    function executeEndBlock(
-        Machine memory mach,
-        Module memory,
-        Instruction calldata,
-        bytes calldata
-    ) internal pure {
-        mach.blockStack.pop();
-    }
-
-    function executeEndBlockIf(
-        Machine memory mach,
-        Module memory,
-        Instruction calldata,
-        bytes calldata
-    ) internal pure {
-        uint32 cond = mach.valueStack.peek().assumeI32();
-        if (cond != 0) {
-            mach.blockStack.pop();
-        }
-    }
-
     function executeInitFrame(
         Machine memory mach,
         Module memory,
@@ -476,20 +419,6 @@ contract OneStepProver0 is IOneStepProver {
         }
     }
 
-    function executeIsStackBoundary(
-        Machine memory mach,
-        Module memory,
-        Instruction calldata,
-        bytes calldata
-    ) internal pure {
-        Value memory val = mach.valueStack.pop();
-        uint32 newContents = 0;
-        if (val.valueType == ValueType.STACK_BOUNDARY) {
-            newContents = 1;
-        }
-        mach.valueStack.push(ValueLib.newI32(newContents));
-    }
-
     function executeDup(
         Machine memory mach,
         Module memory,
@@ -519,12 +448,6 @@ contract OneStepProver0 is IOneStepProver {
             impl = executeUnreachable;
         } else if (opcode == Instructions.NOP) {
             impl = executeNop;
-        } else if (opcode == Instructions.BLOCK) {
-            impl = executeBlock;
-        } else if (opcode == Instructions.BRANCH) {
-            impl = executeBranch;
-        } else if (opcode == Instructions.BRANCH_IF) {
-            impl = executeBranchIf;
         } else if (opcode == Instructions.RETURN) {
             impl = executeReturn;
         } else if (opcode == Instructions.CALL) {
@@ -535,10 +458,6 @@ contract OneStepProver0 is IOneStepProver {
             impl = executeCallerModuleInternalCall;
         } else if (opcode == Instructions.CALL_INDIRECT) {
             impl = executeCallIndirect;
-        } else if (opcode == Instructions.END_BLOCK) {
-            impl = executeEndBlock;
-        } else if (opcode == Instructions.END_BLOCK_IF) {
-            impl = executeEndBlockIf;
         } else if (opcode == Instructions.ARBITRARY_JUMP) {
             impl = executeArbitraryJump;
         } else if (opcode == Instructions.ARBITRARY_JUMP_IF) {
@@ -557,18 +476,13 @@ contract OneStepProver0 is IOneStepProver {
             impl = executeDrop;
         } else if (opcode == Instructions.SELECT) {
             impl = executeSelect;
-        } else if (
-            (opcode >= Instructions.I32_CONST && opcode <= Instructions.F64_CONST) ||
-            opcode == Instructions.PUSH_STACK_BOUNDARY
-        ) {
+        } else if (opcode >= Instructions.I32_CONST && opcode <= Instructions.F64_CONST) {
             impl = executeConstPush;
         } else if (
             opcode == Instructions.MOVE_FROM_STACK_TO_INTERNAL ||
             opcode == Instructions.MOVE_FROM_INTERNAL_TO_STACK
         ) {
             impl = executeMoveInternal;
-        } else if (opcode == Instructions.IS_STACK_BOUNDARY) {
-            impl = executeIsStackBoundary;
         } else if (opcode == Instructions.DUP) {
             impl = executeDup;
         } else {

package/src/osp/OneStepProverHostIo.sol

@@ -10,7 +10,6 @@ import "../state/Deserialize.sol";
 import "./IOneStepProver.sol";
 import "../bridge/Messages.sol";
 import "../bridge/IBridge.sol";
-import "../bridge/ISequencerInbox.sol";
 
 contract OneStepProverHostIo is IOneStepProver {
     using GlobalStateLib for GlobalState;
@@ -165,13 +164,13 @@ contract OneStepProverHostIo is IOneStepProver {
         bytes32 delayedAcc;
 
         if (msgIndex > 0) {
-            beforeAcc = execCtx.sequencerInbox.inboxAccs(msgIndex - 1);
+            beforeAcc = execCtx.bridge.sequencerInboxAccs(msgIndex - 1);
         }
         if (afterDelayedMsg > 0) {
-            delayedAcc = execCtx.delayedBridge.inboxAccs(afterDelayedMsg - 1);
+            delayedAcc = execCtx.bridge.delayedInboxAccs(afterDelayedMsg - 1);
         }
         bytes32 acc = keccak256(abi.encodePacked(beforeAcc, messageHash, delayedAcc));
-        require(acc == execCtx.sequencerInbox.inboxAccs(msgIndex), "BAD_SEQINBOX_MESSAGE");
+        require(acc == execCtx.bridge.sequencerInboxAccs(msgIndex), "BAD_SEQINBOX_MESSAGE");
         return true;
     }
 
@@ -185,7 +184,7 @@ contract OneStepProverHostIo is IOneStepProver {
         bytes32 beforeAcc;
 
         if (msgIndex > 0) {
-            beforeAcc = execCtx.delayedBridge.inboxAccs(msgIndex - 1);
+            beforeAcc = execCtx.bridge.delayedInboxAccs(msgIndex - 1);
         }
 
         bytes32 messageDataHash = keccak256(message[DELAYED_HEADER_LEN:]);
@@ -198,7 +197,7 @@ contract OneStepProverHostIo is IOneStepProver {
         );
         bytes32 acc = Messages.accumulateInboxMessage(beforeAcc, messageHash);
 
-        require(acc == execCtx.delayedBridge.inboxAccs(msgIndex), "BAD_DELAYED_MESSAGE");
+        require(acc == execCtx.bridge.delayedInboxAccs(msgIndex), "BAD_DELAYED_MESSAGE");
         return true;
     }
 

package/src/osp/OneStepProverMath.sol

@@ -210,38 +210,38 @@ contract OneStepProverMath is IOneStepProver {
         uint64 a,
         uint64 b,
         uint16 opcodeOffset
-    ) internal pure returns (uint64) {
+    ) internal pure returns (uint64, bool) {
         unchecked {
             if (opcodeOffset == 0) {
                 // add
-                return a + b;
+                return (a + b, false);
             } else if (opcodeOffset == 1) {
                 // sub
-                return a - b;
+                return (a - b, false);
             } else if (opcodeOffset == 2) {
                 // mul
-                return a * b;
+                return (a * b, false);
             } else if (opcodeOffset == 4) {
                 // div_u
                 if (b == 0) {
-                    return 0;
+                    return (0, true);
                 }
-                return a / b;
+                return (a / b, false);
             } else if (opcodeOffset == 6) {
                 // rem_u
                 if (b == 0) {
-                    return 0;
+                    return (0, true);
                 }
-                return a % b;
+                return (a % b, false);
             } else if (opcodeOffset == 7) {
                 // and
-                return a & b;
+                return (a & b, false);
             } else if (opcodeOffset == 8) {
                 // or
-                return a | b;
+                return (a | b, false);
             } else if (opcodeOffset == 9) {
                 // xor
-                return a ^ b;
+                return (a ^ b, false);
             } else {
                 revert("INVALID_GENERIC_BIN_OP");
             }
@@ -263,18 +263,18 @@ contract OneStepProverMath is IOneStepProver {
         unchecked {
             if (opcodeOffset == 3) {
                 // div_s
-                if (b == 0) {
-                    res = 0;
-                } else {
-                    res = uint32(int32(a) / int32(b));
+                if (b == 0 || (int32(a) == -2147483648 && int32(b) == -1)) {
+                    mach.status = MachineStatus.ERRORED;
+                    return;
                 }
+                res = uint32(int32(a) / int32(b));
             } else if (opcodeOffset == 5) {
                 // rem_s
                 if (b == 0) {
-                    res = 0;
-                } else {
-                    res = uint32(int32(a) % int32(b));
+                    mach.status = MachineStatus.ERRORED;
+                    return;
                 }
+                res = uint32(int32(a) % int32(b));
             } else if (opcodeOffset == 10) {
                 // shl
                 res = a << (b % 32);
@@ -291,7 +291,12 @@ contract OneStepProverMath is IOneStepProver {
                 // rotr
                 res = rotr32(a, b);
             } else {
-                res = uint32(genericBinOp(a, b, opcodeOffset));
+                (uint64 computed, bool err) = genericBinOp(a, b, opcodeOffset);
+                if (err) {
+                    mach.status = MachineStatus.ERRORED;
+                    return;
+                }
+                res = uint32(computed);
             }
         }
 
@@ -313,18 +318,18 @@ contract OneStepProverMath is IOneStepProver {
         unchecked {
             if (opcodeOffset == 3) {
                 // div_s
-                if (b == 0) {
-                    res = 0;
-                } else {
-                    res = uint64(int64(a) / int64(b));
+                if (b == 0 || (int64(a) == -9223372036854775808 && int64(b) == -1)) {
+                    mach.status = MachineStatus.ERRORED;
+                    return;
                 }
+                res = uint64(int64(a) / int64(b));
             } else if (opcodeOffset == 5) {
                 // rem_s
                 if (b == 0) {
-                    res = 0;
-                } else {
-                    res = uint64(int64(a) % int64(b));
+                    mach.status = MachineStatus.ERRORED;
+                    return;
                 }
+                res = uint64(int64(a) % int64(b));
             } else if (opcodeOffset == 10) {
                 // shl
                 res = a << (b % 64);
@@ -341,7 +346,12 @@ contract OneStepProverMath is IOneStepProver {
                 // rotr
                 res = rotr64(a, b);
             } else {
-                res = genericBinOp(a, b, opcodeOffset);
+                bool err;
+                (res, err) = genericBinOp(a, b, opcodeOffset);
+                if (err) {
+                    mach.status = MachineStatus.ERRORED;
+                    return;
+                }
             }
         }
 

package/src/osp/OneStepProverMemory.sol

@@ -271,10 +271,9 @@ contract OneStepProverMemory is IOneStepProver {
         uint32 oldPages = uint32(mod.moduleMemory.size / PAGE_SIZE);
         uint32 growingPages = mach.valueStack.pop().assumeI32();
         // Safe as the input integers are too small to overflow a uint256
-        uint256 newSize = (uint256(oldPages) + uint256(growingPages)) * PAGE_SIZE;
-        // Note: we require the size remain *below* 2^32, meaning the actual limit is 2^32-PAGE_SIZE
-        if (newSize < (1 << 32)) {
-            mod.moduleMemory.size = uint64(newSize);
+        uint256 newSize = uint256(oldPages) + uint256(growingPages);
+        if (newSize <= mod.moduleMemory.maxSize) {
+            mod.moduleMemory.size = uint64(newSize * PAGE_SIZE);
             mach.valueStack.push(ValueLib.newI32(oldPages));
         } else {
             mach.valueStack.push(ValueLib.newI32(~uint32(0)));