Merge branch 'master' into NIT-3501

Author: KolbyML

arbos/arbostypes/messagewithmeta.go

@@ -2,18 +2,10 @@ package arbostypes
 
 import (
 	"context"
-	"encoding/binary"
-	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/rlp"
-
-	"github.com/offchainlabs/nitro/arbutil"
 )
 
-var uniquifyingPrefix = []byte("Arbitrum Nitro Feed:")
-
 type MessageWithMetadata struct {
 	Message             *L1IncomingMessage `json:"message"`
 	DelayedMessagesRead uint64             `json:"delayedMessagesRead"`
@@ -35,20 +27,6 @@ var TestMessageWithMetadataAndRequestId = MessageWithMetadata{
 	Message: &TestIncomingMessageWithRequestId,
 }
 
-func (m *MessageWithMetadata) Hash(sequenceNumber arbutil.MessageIndex, chainId uint64) (common.Hash, error) {
-	serializedExtraData := make([]byte, 24)
-	binary.BigEndian.PutUint64(serializedExtraData[:8], uint64(sequenceNumber))
-	binary.BigEndian.PutUint64(serializedExtraData[8:16], chainId)
-	binary.BigEndian.PutUint64(serializedExtraData[16:], m.DelayedMessagesRead)
-
-	serializedMessage, err := rlp.EncodeToBytes(m.Message)
-	if err != nil {
-		return common.Hash{}, fmt.Errorf("unable to serialize message %v: %w", sequenceNumber, err)
-	}
-
-	return crypto.Keccak256Hash(uniquifyingPrefix, serializedExtraData, serializedMessage), nil
-}
-
 type InboxMultiplexer interface {
 	Pop(context.Context) (*MessageWithMetadata, error)
 	DelayedMessagesRead() uint64

broadcastclient/broadcastclient.go

@@ -563,9 +563,6 @@ func (bc *BroadcastClient) isValidSignature(ctx context.Context, message *messag
 		// Verifier disabled
 		return nil
 	}
-	hash, err := message.Hash(bc.chainId)
-	if err != nil {
-		return fmt.Errorf("error getting message hash for sequence number %v: %w", message.SequenceNumber, err)
-	}
+	hash := message.SignatureHash(bc.chainId)
 	return bc.sigVerifier.VerifyHash(ctx, message.Signature, hash)
 }

broadcaster/broadcaster.go

@@ -45,25 +45,22 @@ func (b *Broadcaster) NewBroadcastFeedMessage(
 	blockHash *common.Hash,
 	blockMetadata common.BlockMetadata,
 ) (*m.BroadcastFeedMessage, error) {
-	var messageSignature []byte
+	feedMessage := m.BroadcastFeedMessage{
+		SequenceNumber: sequenceNumber,
+		Message:        message,
+		BlockHash:      blockHash,
+		Signature:      []byte{},
+		BlockMetadata:  blockMetadata,
+	}
 	if b.dataSigner != nil {
-		hash, err := message.Hash(sequenceNumber, b.chainId)
-		if err != nil {
-			return nil, err
-		}
-		messageSignature, err = b.dataSigner(hash.Bytes())
+		hash := feedMessage.SignatureHash(b.chainId)
+		var err error
+		feedMessage.Signature, err = b.dataSigner(hash.Bytes())
 		if err != nil {
 			return nil, err
 		}
 	}
-
-	return &m.BroadcastFeedMessage{
-		SequenceNumber: sequenceNumber,
-		Message:        message,
-		BlockHash:      blockHash,
-		Signature:      messageSignature,
-		BlockMetadata:  blockMetadata,
-	}, nil
+	return &feedMessage, nil
 }
 
 func (b *Broadcaster) BroadcastSingle(

broadcaster/message/message.go

@@ -1,7 +1,10 @@
 package message
 
 import (
+	"encoding/binary"
+
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
 
 	"github.com/offchainlabs/nitro/arbos/arbostypes"
 	"github.com/offchainlabs/nitro/arbutil"
@@ -12,6 +15,8 @@ const (
 	TimeboostedVersion = byte(0)
 )
 
+var uniquifyingPrefix = []byte("Arbitrum Nitro Feed:")
+
 // BroadcastMessage is the base message type for messages to send over the network.
 //
 // Acts as a variant holding the message types. The type of the message is
@@ -37,7 +42,7 @@ type BroadcastFeedMessage struct {
 	SequenceNumber arbutil.MessageIndex           `json:"sequenceNumber"`
 	Message        arbostypes.MessageWithMetadata `json:"message"`
 	BlockHash      *common.Hash                   `json:"blockHash,omitempty"`
-	Signature      []byte                         `json:"signature"`
+	Signature      []byte                         `json:"signatureV2"`
 	BlockMetadata  common.BlockMetadata           `json:"blockMetadata,omitempty"`
 
 	CumulativeSumMsgSize uint64 `json:"-"`
@@ -52,8 +57,34 @@ func (m *BroadcastFeedMessage) UpdateCumulativeSumMsgSize(val uint64) {
 	m.CumulativeSumMsgSize += val + m.Size()
 }
 
-func (m *BroadcastFeedMessage) Hash(chainId uint64) (common.Hash, error) {
-	return m.Message.Hash(m.SequenceNumber, chainId)
+// SignatureHash creates a hash for the feed message that include all fields that need to
+// be signed. Be aware that changing this function can break compatibility with older clients.
+func (m *BroadcastFeedMessage) SignatureHash(chainId uint64) common.Hash {
+	data := []byte{}
+	data = append(data, uniquifyingPrefix...)
+
+	data = binary.BigEndian.AppendUint64(data, chainId)
+	data = binary.BigEndian.AppendUint64(data, uint64(m.SequenceNumber))
+	if m.BlockHash != nil {
+		data = append(data, m.BlockHash.Bytes()...)
+	}
+	data = append(data, m.BlockMetadata...)
+	data = binary.BigEndian.AppendUint64(data, m.Message.DelayedMessagesRead)
+
+	l1IncomingMessage := m.Message.Message
+	data = append(data, l1IncomingMessage.Header.Kind)
+	data = append(data, l1IncomingMessage.Header.Poster.Bytes()...)
+	data = binary.BigEndian.AppendUint64(data, l1IncomingMessage.Header.BlockNumber)
+	data = binary.BigEndian.AppendUint64(data, l1IncomingMessage.Header.Timestamp)
+	if l1IncomingMessage.Header.RequestId != nil {
+		data = append(data, l1IncomingMessage.Header.RequestId.Bytes()...)
+	}
+	if l1IncomingMessage.Header.L1BaseFee != nil {
+		data = append(data, l1IncomingMessage.Header.L1BaseFee.Bytes()...)
+	}
+	data = append(data, l1IncomingMessage.L2msg...)
+
+	return crypto.Keccak256Hash(data)
 }
 
 type ConfirmedSequenceNumberMessage struct {

broadcaster/message/message_serialization_test.go

@@ -45,7 +45,7 @@ func ExampleBroadcastMessage_broadcastfeedmessageWithBlockHashAndBlockMetadata()
 	encoder := json.NewEncoder(&buf)
 	_ = encoder.Encode(msg)
 	fmt.Println(buf.String())
-	// Output: {"version":1,"messages":[{"sequenceNumber":12345,"message":{"message":{"header":{"kind":0,"sender":"0x0000000000000000000000000000000000000000","blockNumber":0,"timestamp":0,"requestId":"0x0000000000000000000000000000000000000000000000000000000000000000","baseFeeL1":0},"l2Msg":"3q2+7w=="},"delayedMessagesRead":3333},"blockHash":"0xff00000000000000000000000000000000000000000000000000000000000000","signature":null,"blockMetadata":"AAI="}]}
+	// Output: {"version":1,"messages":[{"sequenceNumber":12345,"message":{"message":{"header":{"kind":0,"sender":"0x0000000000000000000000000000000000000000","blockNumber":0,"timestamp":0,"requestId":"0x0000000000000000000000000000000000000000000000000000000000000000","baseFeeL1":0},"l2Msg":"3q2+7w=="},"delayedMessagesRead":3333},"blockHash":"0xff00000000000000000000000000000000000000000000000000000000000000","signatureV2":null,"blockMetadata":"AAI="}]}
 }
 
 func ExampleBroadcastMessage_broadcastfeedmessageWithoutBlockHashAndBlockMetadata() {
@@ -78,7 +78,7 @@ func ExampleBroadcastMessage_broadcastfeedmessageWithoutBlockHashAndBlockMetadat
 	encoder := json.NewEncoder(&buf)
 	_ = encoder.Encode(msg)
 	fmt.Println(buf.String())
-	// Output: {"version":1,"messages":[{"sequenceNumber":12345,"message":{"message":{"header":{"kind":0,"sender":"0x0000000000000000000000000000000000000000","blockNumber":0,"timestamp":0,"requestId":"0x0000000000000000000000000000000000000000000000000000000000000000","baseFeeL1":0},"l2Msg":"3q2+7w=="},"delayedMessagesRead":3333},"signature":null}]}
+	// Output: {"version":1,"messages":[{"sequenceNumber":12345,"message":{"message":{"header":{"kind":0,"sender":"0x0000000000000000000000000000000000000000","blockNumber":0,"timestamp":0,"requestId":"0x0000000000000000000000000000000000000000000000000000000000000000","baseFeeL1":0},"l2Msg":"3q2+7w=="},"delayedMessagesRead":3333},"signatureV2":null}]}
 }
 
 func ExampleBroadcastMessage_emptymessage() {

broadcaster/message/message_signature_test.go

@@ -0,0 +1,44 @@
+// Copyright 2025, Offchain Labs, Inc.
+// For license information, see https://github.com/OffchainLabs/nitro/blob/master/LICENSE.md
+
+package message
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/offchainlabs/nitro/arbos/arbostypes"
+)
+
+func TestBroadcastFeedMessageSignature(t *testing.T) {
+	var requestId common.Hash
+	msg := BroadcastFeedMessage{
+		SequenceNumber: 12345,
+		Message: arbostypes.MessageWithMetadata{
+			Message: &arbostypes.L1IncomingMessage{
+				Header: &arbostypes.L1IncomingMessageHeader{
+					Kind:        0,
+					Poster:      [20]byte{},
+					BlockNumber: 0,
+					Timestamp:   0,
+					RequestId:   &requestId,
+					L1BaseFee:   big.NewInt(0),
+				},
+				L2msg: []byte{0xde, 0xad, 0xbe, 0xef},
+			},
+			DelayedMessagesRead: 3333,
+		},
+		Signature:     nil,
+		BlockMetadata: []byte{0xde, 0xad, 0xbe, 0xaf},
+	}
+
+	const chainId = 0xa4b1
+	hash := msg.SignatureHash(chainId)
+	// Compare against hard-coded hash to ensure it won't break in the future
+	expected := common.HexToHash("0x3d79853de5f9e4354e5d6c6d4cad19dcd969f9646f0cab21e5bdfee4902dfa2e")
+	require.Equal(t, expected, hash)
+}