ctb: Rename event in the L2ToL1MessagePasser

.changeset/five-grapes-march.md

@@ -0,0 +1,6 @@
+---
+'@eth-optimism/contracts-bedrock': patch
+'@eth-optimism/sdk': patch
+---
+
+Rename the event emitted in the L2ToL1MessagePasser

op-node/withdrawals/testdata/bridge-withdrawal.json

@@ -37,7 +37,7 @@
     {
       "address": "0x4200000000000000000000000000000000000016",
       "topics": [
-        "0x87bf7b546c8de873abb0db5b579ec131f8d0cf5b14f39933551cf9ced23a6136",
+        "0x7744840cae4793a72467311120512aa98e4398bcd2b9d379b2b9c3b60fa03d72",
         "0x0000000000000000000000000000000000000000000000000000000000000000",
         "0x0000000000000000000000004200000000000000000000000000000000000007",
         "0x0000000000000000000000006900000000000000000000000000000000000002"
@@ -53,7 +53,7 @@
     {
       "address": "0x4200000000000000000000000000000000000016",
       "topics": [
-        "0x2ef6ceb1668fdd882b1f89ddd53a666b0c1113d14cf90c0fbf97c7b1ad880fbb",
+        "0xedd348f9c36ef1a5b0747bb5039752707059f0b934c8e508b3271e08fbd0122c",
         "0x0d827f8148288e3a2466018f71b968ece4ea9f9e2a81c30da9bd46cce2868285"
       ],
       "data": "0x",
@@ -131,4 +131,4 @@
   "blockHash": "0xfdd4ad8a984b45687aca0463db491cbd0e85273d970019a3f8bf618b614938df",
   "blockNumber": "0x36",
   "transactionIndex": "0x1"
-}
+}

op-node/withdrawals/utils.go

@@ -21,8 +21,8 @@ import (
 	"github.com/ethereum/go-ethereum/rpc"
 )
 
-var WithdrawalInitiatedTopic = crypto.Keccak256Hash([]byte("WithdrawalInitiated(uint256,address,address,uint256,uint256,bytes)"))
-var WithdrawalInitiatedExtension1Topic = crypto.Keccak256Hash([]byte("WithdrawalInitiatedExtension1(bytes32)"))
+var MessagePassedTopic = crypto.Keccak256Hash([]byte("MessagePassed(uint256,address,address,uint256,uint256,bytes)"))
+var MessagePassedExtension1Topic = crypto.Keccak256Hash([]byte("MessagePassedExtension1(bytes32)"))
 
 // WaitForFinalizationPeriod waits until there is OutputProof for an L2 block number larger than the supplied l2BlockNumber
 // and that the output is finalized.
@@ -172,11 +172,11 @@ func FinalizeWithdrawalParameters(ctx context.Context, l2client ProofClient, txH
 		return FinalizedWithdrawalParameters{}, err
 	}
 	// Parse the receipt
-	ev, err := ParseWithdrawalInitiated(receipt)
+	ev, err := ParseMessagePassed(receipt)
 	if err != nil {
 		return FinalizedWithdrawalParameters{}, err
 	}
-	ev1, err := ParseWithdrawalInitiatedExtension1(receipt)
+	ev1, err := ParseMessagePassedExtension1(receipt)
 	if err != nil {
 		return FinalizedWithdrawalParameters{}, err
 	}
@@ -244,7 +244,7 @@ var (
 //   - I don't like having to use the ABI Generated struct
 //   - There should be a better way to run the ABI encoding
 //   - These needs to be fuzzed against the solidity
-func WithdrawalHash(ev *bindings.L2ToL1MessagePasserWithdrawalInitiated) (common.Hash, error) {
+func WithdrawalHash(ev *bindings.L2ToL1MessagePasserMessagePassed) (common.Hash, error) {
 	//  abi.encode(nonce, msg.sender, _target, msg.value, _gasLimit, _data)
 	args := abi.Arguments{
 		{Name: "nonce", Type: Uint256Type},
@@ -261,50 +261,50 @@ func WithdrawalHash(ev *bindings.L2ToL1MessagePasserWithdrawalInitiated) (common
 	return crypto.Keccak256Hash(enc), nil
 }
 
-// ParseWithdrawalInitiated parses WithdrawalInitiated events from
+// ParseMessagePassed parses MessagePassed events from
 // a transaction receipt. It does not support multiple withdrawals
 // per receipt.
-func ParseWithdrawalInitiated(receipt *types.Receipt) (*bindings.L2ToL1MessagePasserWithdrawalInitiated, error) {
+func ParseMessagePassed(receipt *types.Receipt) (*bindings.L2ToL1MessagePasserMessagePassed, error) {
 	contract, err := bindings.NewL2ToL1MessagePasser(common.Address{}, nil)
 	if err != nil {
 		return nil, err
 	}
 
 	for _, log := range receipt.Logs {
-		if len(log.Topics) == 0 || log.Topics[0] != WithdrawalInitiatedTopic {
+		if len(log.Topics) == 0 || log.Topics[0] != MessagePassedTopic {
 			continue
 		}
 
-		ev, err := contract.ParseWithdrawalInitiated(*log)
+		ev, err := contract.ParseMessagePassed(*log)
 		if err != nil {
 			return nil, fmt.Errorf("failed to parse log: %w", err)
 		}
 		return ev, nil
 	}
-	return nil, errors.New("Unable to find WithdrawalInitiated event")
+	return nil, errors.New("Unable to find MessagePassed event")
 }
 
-// ParseWithdrawalInitiatedExtension1 parses WithdrawalInitiatedExtension1 events
+// ParseMessagePassedExtension1 parses MessagePassedExtension1 events
 // from a transaction receipt. It does not support multiple withdrawals per
 // receipt.
-func ParseWithdrawalInitiatedExtension1(receipt *types.Receipt) (*bindings.L2ToL1MessagePasserWithdrawalInitiatedExtension1, error) {
+func ParseMessagePassedExtension1(receipt *types.Receipt) (*bindings.L2ToL1MessagePasserMessagePassedExtension1, error) {
 	contract, err := bindings.NewL2ToL1MessagePasser(common.Address{}, nil)
 	if err != nil {
 		return nil, err
 	}
 
 	for _, log := range receipt.Logs {
-		if len(log.Topics) == 0 || log.Topics[0] != WithdrawalInitiatedExtension1Topic {
+		if len(log.Topics) == 0 || log.Topics[0] != MessagePassedExtension1Topic {
 			continue
 		}
 
-		ev, err := contract.ParseWithdrawalInitiatedExtension1(*log)
+		ev, err := contract.ParseMessagePassedExtension1(*log)
 		if err != nil {
 			return nil, fmt.Errorf("failed to parse log: %w", err)
 		}
 		return ev, nil
 	}
-	return nil, errors.New("Unable to find WithdrawalInitiatedExtension1 event")
+	return nil, errors.New("Unable to find MessagePassedExtension1 event")
 }
 
 // StorageSlotOfWithdrawalHash determines the storage slot of the Withdrawer contract to look at

op-node/withdrawals/utils_test.go

@@ -15,16 +15,16 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestParseWithdrawalInitiated(t *testing.T) {
+func TestParseMessagePassed(t *testing.T) {
 	tests := []struct {
 		name     string
 		file     string
-		expected *bindings.L2ToL1MessagePasserWithdrawalInitiated
+		expected *bindings.L2ToL1MessagePasserMessagePassed
 	}{
 		{
 			"withdrawal through bridge",
 			"bridge-withdrawal.json",
-			&bindings.L2ToL1MessagePasserWithdrawalInitiated{
+			&bindings.L2ToL1MessagePasserMessagePassed{
 				Nonce:    new(big.Int),
 				Sender:   common.HexToAddress("0x4200000000000000000000000000000000000007"),
 				Target:   common.HexToAddress("0x6900000000000000000000000000000000000002"),
@@ -51,7 +51,7 @@ func TestParseWithdrawalInitiated(t *testing.T) {
 				Raw: types.Log{
 					Address: common.HexToAddress("0x4200000000000000000000000000000000000016"),
 					Topics: []common.Hash{
-						common.HexToHash("0x87bf7b546c8de873abb0db5b579ec131f8d0cf5b14f39933551cf9ced23a6136"),
+						common.HexToHash("0x7744840cae4793a72467311120512aa98e4398bcd2b9d379b2b9c3b60fa03d72"),
 						common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"),
 						common.HexToHash("0x0000000000000000000000004200000000000000000000000000000000000007"),
 						common.HexToHash("0x0000000000000000000000006900000000000000000000000000000000000002"),
@@ -95,7 +95,7 @@ func TestParseWithdrawalInitiated(t *testing.T) {
 			dec := json.NewDecoder(f)
 			receipt := new(types.Receipt)
 			require.NoError(t, dec.Decode(receipt))
-			parsed, err := ParseWithdrawalInitiated(receipt)
+			parsed, err := ParseMessagePassed(receipt)
 			require.NoError(t, err)
 
 			// Have to do this weird thing to compare zero bigints.
@@ -117,21 +117,21 @@ func TestParseWithdrawalInitiated(t *testing.T) {
 	}
 }
 
-func TestParseWithdrawalInitiatedExtension1(t *testing.T) {
+func TestParseMessagePassedExtension1(t *testing.T) {
 	tests := []struct {
 		name     string
 		file     string
-		expected *bindings.L2ToL1MessagePasserWithdrawalInitiatedExtension1
+		expected *bindings.L2ToL1MessagePasserMessagePassedExtension1
 	}{
 		{
 			"withdrawal through bridge",
 			"bridge-withdrawal.json",
-			&bindings.L2ToL1MessagePasserWithdrawalInitiatedExtension1{
+			&bindings.L2ToL1MessagePasserMessagePassedExtension1{
 				Hash: common.HexToHash("0x0d827f8148288e3a2466018f71b968ece4ea9f9e2a81c30da9bd46cce2868285"),
 				Raw: types.Log{
 					Address: common.HexToAddress("0x4200000000000000000000000000000000000016"),
 					Topics: []common.Hash{
-						common.HexToHash("0x2ef6ceb1668fdd882b1f89ddd53a666b0c1113d14cf90c0fbf97c7b1ad880fbb"),
+						common.HexToHash("0xedd348f9c36ef1a5b0747bb5039752707059f0b934c8e508b3271e08fbd0122c"),
 						common.HexToHash("0x0d827f8148288e3a2466018f71b968ece4ea9f9e2a81c30da9bd46cce2868285"),
 					},
 					Data:        []byte{},
@@ -152,7 +152,7 @@ func TestParseWithdrawalInitiatedExtension1(t *testing.T) {
 			dec := json.NewDecoder(f)
 			receipt := new(types.Receipt)
 			require.NoError(t, dec.Decode(receipt))
-			parsed, err := ParseWithdrawalInitiatedExtension1(receipt)
+			parsed, err := ParseMessagePassedExtension1(receipt)
 			require.NoError(t, err)
 			require.EqualValues(t, test.expected, parsed)
 		})

packages/contracts-bedrock/contracts/L2/L2ToL1MessagePasser.sol

@@ -40,7 +40,7 @@ contract L2ToL1MessagePasser is Semver {
      * @param gasLimit The minimum amount of gas that must be provided when withdrawing on L1.
      * @param data     The data to be forwarded to the target on L1.
      */
-    event WithdrawalInitiated(
+    event MessagePassed(
         uint256 indexed nonce,
         address indexed sender,
         address indexed target,
@@ -51,11 +51,11 @@ contract L2ToL1MessagePasser is Semver {
 
     /**
      * @notice Emitted any time a withdrawal is initiated. An extension to
-     *         WithdrawalInitiated so that the interface is maintained.
+     *         MessagePassed to allow for a 4th indexed argument.
      *
      * @param hash The hash of the withdrawal
      */
-    event WithdrawalInitiatedExtension1(bytes32 indexed hash);
+    event MessagePassedExtension1(bytes32 indexed hash);
 
     /**
      * @notice Emitted when the balance of this contract is burned.
@@ -113,8 +113,8 @@ contract L2ToL1MessagePasser is Semver {
 
         sentMessages[withdrawalHash] = true;
 
-        emit WithdrawalInitiated(nonce, msg.sender, _target, msg.value, _gasLimit, _data);
-        emit WithdrawalInitiatedExtension1(withdrawalHash);
+        emit MessagePassed(nonce, msg.sender, _target, msg.value, _gasLimit, _data);
+        emit MessagePassedExtension1(withdrawalHash);
 
         unchecked {
             ++nonce;

packages/contracts-bedrock/contracts/test/CommonTest.t.sol

@@ -190,7 +190,7 @@ contract Messenger_Initializer is L2OutputOracle_Initializer {
         uint256 value
     );
 
-    event WithdrawalInitiated(
+    event MessagePassed(
         uint256 indexed nonce,
         address indexed sender,
         address indexed target,