[Provers M01] Proof Stale Time in Optimism

snapshots/verifyBroadcastMessage.json

@@ -1,9 +1,9 @@
 {
-  "EthereumToOptimism": "1639239",
+  "EthereumToOptimism": "1642677",
   "EthereumToTaikoL2": "1052244",
   "LineaL2ToEthereum": "2551806",
   "ScrollL2ToEthereum": "1361970",
-  "ScrollToOptimism": "1348710",
+  "ScrollToOptimism": "1352078",
   "TaikoL2ToEthereum": "1022307",
   "ZkSyncL2ToEthereum": "125693"
 }

src/contracts/block-hash-pusher/optimism/OptimismBuffer.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.30;
+
+import {BaseBuffer} from "../BaseBuffer.sol";
+import {IBuffer} from "../interfaces/IBuffer.sol";
+import {ICrossDomainMessenger} from "@eth-optimism/contracts/libraries/bridge/ICrossDomainMessenger.sol";
+
+/// @title OptimismBuffer
+/// @notice Implementation of BaseBuffer for storing Ethereum L1 block hashes on Optimism L2.
+/// @dev This contract extends BaseBuffer with access control specific to Optimism's L1->L2 messaging.
+///      The pusher address on L1 must send the message via L1CrossDomainMessengerProxy to the buffer address on L2.
+///      The L2CrossDomainMessenger contract on L2 is responsible for relaying the message to the buffer contract on L2.
+/// @custom:security-contact security@openzeppelin.com
+contract OptimismBuffer is BaseBuffer {
+    /// @dev The address of the L2CrossDomainMessenger contract on L2.
+    address private immutable _l2CrossDomainMessenger;
+
+    /// @dev The address of the pusher contract on L1.
+    address private immutable _pusher;
+
+    /// @notice Thrown when attempting to set an invalid L2CrossDomainMessenger address.
+    error InvalidL2CrossDomainMessengerAddress();
+
+    /// @notice Thrown when attempting to set an invalid pusher address.
+    error InvalidPusherAddress();
+
+    /// @notice Thrown when the domain message sender does not match the pusher address.
+    error DomainMessageSenderMismatch();
+
+    /// @notice Thrown when the sender is not the L2CrossDomainMessenger contract.
+    error InvalidSender();
+
+    constructor(address l2CrossDomainMessenger_, address pusher_) {
+        require(l2CrossDomainMessenger_ != address(0), InvalidL2CrossDomainMessengerAddress());
+        require(pusher_ != address(0), InvalidPusherAddress());
+
+        _l2CrossDomainMessenger = l2CrossDomainMessenger_;
+        _pusher = pusher_;
+    }
+
+    /// @inheritdoc IBuffer
+    function receiveHashes(uint256 firstBlockNumber, bytes32[] calldata blockHashes) external {
+        ICrossDomainMessenger l2CrossDomainMessengerCached = ICrossDomainMessenger(l2CrossDomainMessenger());
+
+        require(msg.sender == address(l2CrossDomainMessengerCached), InvalidSender());
+        require(l2CrossDomainMessengerCached.xDomainMessageSender() == _pusher, DomainMessageSenderMismatch());
+
+        _receiveHashes(firstBlockNumber, blockHashes);
+    }
+
+    /// @inheritdoc IBuffer
+    function pusher() public view returns (address) {
+        return _pusher;
+    }
+
+    /// @notice The address of the L2CrossDomainMessenger contract on L2.
+    /// @return The address of the L2CrossDomainMessenger contract on L2.
+    function l2CrossDomainMessenger() public view returns (address) {
+        return _l2CrossDomainMessenger;
+    }
+}

src/contracts/block-hash-pusher/optimism/OptimismPusher.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.30;
+
+import {BlockHashArrayBuilder} from "../BlockHashArrayBuilder.sol";
+import {IBuffer} from "../interfaces/IBuffer.sol";
+import {IPusher} from "../interfaces/IPusher.sol";
+import {ICrossDomainMessenger} from "@eth-optimism/contracts/libraries/bridge/ICrossDomainMessenger.sol";
+
+/// @title OPtimismPusher
+/// @notice Implementation of IPusher for pushing block hashes to Optimism L2.
+/// @dev This contract sends block hashes from Ethereum L1 to a OptimismBuffer contract on Optimism L2
+///      via the Optimism L1CrossDomainMessenger's `sendMessage` function. The pusher must be configured
+///      with the correct L1CrossDomainMessengerProxy address.
+/// @custom:security-contact security@openzeppelin.com
+contract OptimismPusher is BlockHashArrayBuilder, IPusher {
+    /// @dev The address of the Optimism L1CrossDomainMessengerProxy contract on L1.
+    address private immutable _l1CrossDomainMessengerProxy;
+
+    /// @notice Parameters for the L2 transaction that will be executed on Optimism.
+    /// @param gasLimit The gas limit for the L2 transaction.
+    struct OptimismL2Transaction {
+        uint32 gasLimit;
+    }
+
+    /// @notice Thrown when attempting to set an invalid L1CrossDomainMessengerProxy address.
+    error InvalidL1CrossDomainMessengerProxyAddress();
+
+    constructor(address l1CrossDomainMessengerProxy_) {
+        require(l1CrossDomainMessengerProxy_ != address(0), InvalidL1CrossDomainMessengerProxyAddress());
+
+        _l1CrossDomainMessengerProxy = l1CrossDomainMessengerProxy_;
+    }
+
+    /// @inheritdoc IPusher
+    function pushHashes(address buffer, uint256 firstBlockNumber, uint256 batchSize, bytes calldata l2TransactionData)
+        external
+        payable
+    {
+        require(buffer != address(0), InvalidBuffer(buffer));
+        require(msg.value == 0, IncorrectMsgValue(0, msg.value));
+
+        bytes32[] memory blockHashes = _buildBlockHashArray(firstBlockNumber, batchSize);
+        bytes memory l2Calldata = abi.encodeCall(IBuffer.receiveHashes, (firstBlockNumber, blockHashes));
+
+        OptimismL2Transaction memory l2Transaction = abi.decode(l2TransactionData, (OptimismL2Transaction));
+
+        ICrossDomainMessenger(l1CrossDomainMessengerProxy()).sendMessage(buffer, l2Calldata, l2Transaction.gasLimit);
+
+        emit BlockHashesPushed(firstBlockNumber, firstBlockNumber + batchSize - 1);
+    }
+
+    /// @notice The address of the Optimism L1CrossDomainMessengerProxy contract on L1.
+    /// @return The address of the Optimism L1CrossDomainMessengerProxy contract on L1.
+    function l1CrossDomainMessengerProxy() public view returns (address) {
+        return _l1CrossDomainMessengerProxy;
+    }
+}

src/contracts/provers/linea/ChildToParentProver.sol

@@ -45,7 +45,7 @@ contract ChildToParentProver is IStateProver {
             abi.decode(input, (bytes, uint256, bytes, bytes));
 
         // calculate the slot based on the provided block number
-        // see: https://github.com/OffchainLabs/block-hash-pusher/blob/a1e26f2e42e6306d1e7f03c5d20fa6aa64ff7a12/contracts/Buffer.sol#L32
+        // see: https://github.com/openintentsframework/broadcaster/blob/8d02f8e8e39de27de8f0ded481d3c4e5a129351f/src/contracts/block-hash-pusher/BaseBuffer.sol#L24
         uint256 slot = uint256(SlotDerivation.deriveMapping(bytes32(BLOCK_HASH_MAPPING_SLOT), targetBlockNumber));
 
         // verify proofs and get the block hash