feat: resend message (ethereum-optimism#15300)

* feat: add re emit sent msg event logic on l2 to l2 cdm

* feat: add tests for the re emit feature

* fix: review comments

chore: run pre pr

* refactor: rename to resend msg

* chore: return msg hash (ethereum-optimism#361)

---------

Co-authored-by: 0xDiscotech <[email protected]>

Author: 2 people

packages/contracts-bedrock/interfaces/L2/IL2ToL2CrossDomainMessenger.sol

@@ -36,6 +36,9 @@ interface IL2ToL2CrossDomainMessenger {
     /// @notice Thrown when a reentrant call is detected.
     error ReentrantCall();
 
+    /// @notice Thrown when the provided message parameters do not match any hash of a previously sent message.
+    error InvalidMessage();
+
     /// @notice Emitted whenever a message is sent to a destination
     /// @param destination  Chain ID of the destination chain.
     /// @param target       Target contract or wallet address.
@@ -66,6 +69,11 @@ interface IL2ToL2CrossDomainMessenger {
     /// @return Nonce of the next message to be sent, with added message version.
     function messageNonce() external view returns (uint256);
 
+    /// @notice Mapping of message hashes to boolean sent values. Note that a message will only be present in this
+    ///         mapping if it has been sent from this chain to a destination chain.
+    /// @return Returns true if the message corresponding to the `_msgHash` was successfully sent.
+    function sentMessages(bytes32) external view returns (bool);
+
     /// @notice Retrieves the sender of the current cross domain message.
     /// @return sender_ Address of the sender of the current cross domain message.
     function crossDomainMessageSender() external view returns (address sender_);
@@ -86,9 +94,35 @@ interface IL2ToL2CrossDomainMessenger {
     /// @param _destination Chain ID of the destination chain.
     /// @param _target      Target contract or wallet address.
     /// @param _message     Message to trigger the target address with.
-    /// @return msgHash_ The hash of the message being sent, which can be used for tracking whether
-    ///                  the message has successfully been relayed.
-    function sendMessage(uint256 _destination, address _target, bytes calldata _message) external returns (bytes32);
+    /// @return messageHash_ The hash of the message being sent, used to track whether the message
+    ///                      has successfully been relayed.
+    function sendMessage(
+        uint256 _destination,
+        address _target,
+        bytes calldata _message
+    )
+        external
+        returns (bytes32 messageHash_);
+
+    /// @notice Re-emits a previously sent message event for old messages that haven't been
+    ///         relayed yet, allowing offchain infrastructure to pick them up and relay them.
+    /// @dev    Emitting a message that has already been relayed will have no effect, as it is only
+    ///         relayed once on the destination chain.
+    /// @param _destination Chain ID of the destination chain.
+    /// @param _nonce Nonce of the message sent
+    /// @param _sender Address that sent the message
+    /// @param _target Target contract or wallet address.
+    /// @param _message Message payload to call target with.
+    /// @return messageHash_ The hash of the message being re-sent.
+    function resendMessage(
+        uint256 _destination,
+        uint256 _nonce,
+        address _sender,
+        address _target,
+        bytes calldata _message
+    )
+        external
+        returns (bytes32 messageHash_);
 
     /// @notice Relays a message that was sent by the other CrossDomainMessenger contract. Can only
     ///         be executed via cross-chain call from the other messenger OR if the message was

packages/contracts-bedrock/snapshots/abi/L2ToL2CrossDomainMessenger.json

@@ -120,6 +120,45 @@
     "stateMutability": "payable",
     "type": "function"
   },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "_destination",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_nonce",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address",
+        "name": "_sender",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "_target",
+        "type": "address"
+      },
+      {
+        "internalType": "bytes",
+        "name": "_message",
+        "type": "bytes"
+      }
+    ],
+    "name": "resendMessage",
+    "outputs": [
+      {
+        "internalType": "bytes32",
+        "name": "messageHash_",
+        "type": "bytes32"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
   {
     "inputs": [
       {
@@ -142,13 +181,32 @@
     "outputs": [
       {
         "internalType": "bytes32",
-        "name": "",
+        "name": "messageHash_",
         "type": "bytes32"
       }
     ],
     "stateMutability": "nonpayable",
     "type": "function"
   },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes32",
+        "name": "",
+        "type": "bytes32"
+      }
+    ],
+    "name": "sentMessages",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [
       {
@@ -253,6 +311,11 @@
     "name": "IdOriginNotL2ToL2CrossDomainMessenger",
     "type": "error"
   },
+  {
+    "inputs": [],
+    "name": "InvalidMessage",
+    "type": "error"
+  },
   {
     "inputs": [],
     "name": "MessageAlreadyRelayed",

packages/contracts-bedrock/snapshots/semver-lock.json

@@ -84,8 +84,8 @@
     "sourceCodeHash": "0xaef8ea36c5b78cd12e0e62811d51db627ccf0dfd2cc5479fb707a10ef0d42048"
   },
   "src/L2/L2ToL2CrossDomainMessenger.sol:L2ToL2CrossDomainMessenger": {
-    "initCodeHash": "0x7ad26c308c506ca65e080c8a33eceac48201221cd291030844021cf1cfde4871",
-    "sourceCodeHash": "0xe59eec8a64d6c42d9cc2a67aa649718cad590961f92787d62435bf8cde93f7f3"
+    "initCodeHash": "0xcf875a2073bf91cecffea3308c11f7160274c5eeabe1490065378401d6a8ff3d",
+    "sourceCodeHash": "0x4f14cd11f43a2efe041b6e8aabccddb5d6c7826362f831c584eccf2ad7c50293"
   },
   "src/L2/OperatorFeeVault.sol:OperatorFeeVault": {
     "initCodeHash": "0x3d8c0d7736e8767f2f797da1c20c5fe30bd7f48a4cf75f376290481ad7c0f91f",

packages/contracts-bedrock/snapshots/storageLayout/L2ToL2CrossDomainMessenger.json

@@ -12,5 +12,12 @@
     "offset": 0,
     "slot": "1",
     "type": "uint240"
+  },
+  {
+    "bytes": "32",
+    "label": "sentMessages",
+    "offset": 0,
+    "slot": "2",
+    "type": "mapping(bytes32 => bool)"
   }
 ]

packages/contracts-bedrock/src/L2/L2ToL2CrossDomainMessenger.sol

@@ -35,6 +35,9 @@ error MessageAlreadyRelayed();
 /// @notice Thrown when a reentrant call is detected.
 error ReentrantCall();
 
+/// @notice Thrown when the provided message parameters do not match any hash of a previously sent message.
+error InvalidMessage();
+
 /// @custom:proxied true
 /// @custom:predeploy 0x4200000000000000000000000000000000000023
 /// @title L2ToL2CrossDomainMessenger
@@ -61,8 +64,8 @@ contract L2ToL2CrossDomainMessenger is ISemver, TransientReentrancyAware {
     uint16 public constant messageVersion = uint16(0);
 
     /// @notice Semantic version.
-    /// @custom:semver 1.0.0-beta.16
-    string public constant version = "1.0.0-beta.16";
+    /// @custom:semver 1.1.0
+    string public constant version = "1.1.0";
 
     /// @notice Mapping of message hashes to boolean receipt values. Note that a message will only be present in this
     ///         mapping if it has successfully been relayed on this chain, and can therefore not be relayed again.
@@ -73,6 +76,10 @@ contract L2ToL2CrossDomainMessenger is ISemver, TransientReentrancyAware {
     ///         message.
     uint240 internal msgNonce;
 
+    /// @notice Mapping of message hashes to boolean sent values. Note that a message will only be present in this
+    ///         mapping if it has been sent from this chain to a destination chain.
+    mapping(bytes32 => bool) public sentMessages;
+
     /// @notice Emitted whenever a message is sent to a destination
     /// @param destination  Chain ID of the destination chain.
     /// @param target       Target contract or wallet address.
@@ -121,24 +128,67 @@ contract L2ToL2CrossDomainMessenger is ISemver, TransientReentrancyAware {
     /// @param _destination Chain ID of the destination chain.
     /// @param _target      Target contract or wallet address.
     /// @param _message     Message payload to call target with.
-    /// @return The hash of the message being sent, used to track whether the message has successfully been relayed.
-    function sendMessage(uint256 _destination, address _target, bytes calldata _message) external returns (bytes32) {
+    /// @return messageHash_ The hash of the message being sent, used to track whether the message
+    ///                      has successfully been relayed.
+    function sendMessage(
+        uint256 _destination,
+        address _target,
+        bytes calldata _message
+    )
+        external
+        returns (bytes32 messageHash_)
+    {
         if (_destination == block.chainid) revert MessageDestinationSameChain();
         if (_target == Predeploys.L2_TO_L2_CROSS_DOMAIN_MESSENGER) revert MessageTargetL2ToL2CrossDomainMessenger();
 
         uint256 nonce = messageNonce();
-        emit SentMessage(_destination, _target, nonce, msg.sender, _message);
+        messageHash_ = Hashing.hashL2toL2CrossDomainMessage({
+            _destination: _destination,
+            _source: block.chainid,
+            _nonce: nonce,
+            _sender: msg.sender,
+            _target: _target,
+            _message: _message
+        });
 
+        sentMessages[messageHash_] = true;
         msgNonce++;
 
-        return Hashing.hashL2toL2CrossDomainMessage({
+        emit SentMessage(_destination, _target, nonce, msg.sender, _message);
+    }
+
+    /// @notice Re-emits a previously sent message event for old messages that haven't been
+    ///         relayed yet, allowing offchain infrastructure to pick them up and relay them.
+    /// @dev    Emitting a message that has already been relayed will have no effect, as it is only
+    ///         relayed once on the destination chain.
+    /// @param _destination Chain ID of the destination chain.
+    /// @param _nonce Nonce of the message sent
+    /// @param _sender Address that sent the message
+    /// @param _target Target contract or wallet address.
+    /// @param _message Message payload to call target with.
+    /// @return messageHash_ The hash of the message being re-sent.
+    function resendMessage(
+        uint256 _destination,
+        uint256 _nonce,
+        address _sender,
+        address _target,
+        bytes calldata _message
+    )
+        external
+        returns (bytes32 messageHash_)
+    {
+        messageHash_ = Hashing.hashL2toL2CrossDomainMessage({
             _destination: _destination,
             _source: block.chainid,
-            _nonce: nonce,
-            _sender: msg.sender,
+            _nonce: _nonce,
+            _sender: _sender,
             _target: _target,
             _message: _message
         });
+
+        if (!sentMessages[messageHash_]) revert InvalidMessage();
+
+        emit SentMessage(_destination, _target, _nonce, _sender, _message);
     }
 
     /// @notice Relays a message that was sent by the other L2ToL2CrossDomainMessenger contract. Can only be executed