Merge branch '4844-inbox-reader-fixes' into 4844-batch-posting

arbnode/blob_reader.go

@@ -9,25 +9,28 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"net/url"
 	"path"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/crypto/kzg4844"
 	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/util/blobs"
+	"github.com/offchainlabs/nitro/util/jsonapi"
 	"github.com/offchainlabs/nitro/util/pretty"
 
 	"github.com/spf13/pflag"
 )
 
 type BlobClient struct {
-	config     BlobClientConfig
 	ec         arbutil.L1Interface
+	beaconUrl  *url.URL
 	httpClient *http.Client
 
-	// The genesis time time won't change so only request it once.
-	cachedGenesisTime uint64
+	// The genesis time time and seconds per slot won't change so only request them once.
+	cachedGenesisTime    uint64
+	cachedSecondsPerSlot uint64
 }
 
 type BlobClientConfig struct {
@@ -42,12 +45,16 @@ func BlobClientAddOptions(prefix string, f *pflag.FlagSet) {
 	f.String(prefix+".beacon-chain-url", DefaultBlobClientConfig.BeaconChainUrl, "Beacon Chain url to use for fetching blobs")
 }
 
-func NewBlobClient(config BlobClientConfig, ec arbutil.L1Interface) *BlobClient {
+func NewBlobClient(config BlobClientConfig, ec arbutil.L1Interface) (*BlobClient, error) {
+	beaconUrl, err := url.Parse(config.BeaconChainUrl)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse beacon chain URL: %w", err)
+	}
 	return &BlobClient{
-		config:     config,
 		ec:         ec,
+		beaconUrl:  beaconUrl,
 		httpClient: &http.Client{},
-	}
+	}, nil
 }
 
 type fullResult[T any] struct {
@@ -59,7 +66,11 @@ func beaconRequest[T interface{}](b *BlobClient, ctx context.Context, beaconPath
 
 	var empty T
 
-	req, err := http.NewRequestWithContext(ctx, "GET", path.Join(b.config.BeaconChainUrl, beaconPath), http.NoBody)
+	// not really a deep copy, but copies the Path part we care about
+	url := *b.beaconUrl
+	url.Path = path.Join(url.Path, beaconPath)
+
+	req, err := http.NewRequestWithContext(ctx, "GET", url.String(), http.NoBody)
 	if err != nil {
 		return empty, err
 	}
@@ -89,27 +100,27 @@ func (b *BlobClient) GetBlobs(ctx context.Context, blockHash common.Hash, versio
 	if err != nil {
 		return nil, err
 	}
-
 	genesisTime, err := b.genesisTime(ctx)
 	if err != nil {
 		return nil, err
 	}
-
-	// TODO make denominator configurable for devnets with faster block time
-	slot := (header.Time - genesisTime) / 12
-
+	secondsPerSlot, err := b.secondsPerSlot(ctx)
+	if err != nil {
+		return nil, err
+	}
+	slot := (header.Time - genesisTime) / secondsPerSlot
 	return b.blobSidecars(ctx, slot, versionedHashes)
 }
 
 type blobResponseItem struct {
-	BlockRoot       string        `json:"block_root"`
-	Index           int           `json:"index"`
-	Slot            uint64        `json:"slot"`
-	BlockParentRoot string        `json:"block_parent_root"`
-	ProposerIndex   uint64        `json:"proposer_index"`
-	Blob            hexutil.Bytes `json:"blob"`
-	KzgCommitment   hexutil.Bytes `json:"kzg_commitment"`
-	KzgProof        hexutil.Bytes `json:"kzg_proof"`
+	BlockRoot       string               `json:"block_root"`
+	Index           jsonapi.Uint64String `json:"index"`
+	Slot            jsonapi.Uint64String `json:"slot"`
+	BlockParentRoot string               `json:"block_parent_root"`
+	ProposerIndex   jsonapi.Uint64String `json:"proposer_index"`
+	Blob            hexutil.Bytes        `json:"blob"`
+	KzgCommitment   hexutil.Bytes        `json:"kzg_commitment"`
+	KzgProof        hexutil.Bytes        `json:"kzg_proof"`
 }
 
 func (b *BlobClient) blobSidecars(ctx context.Context, slot uint64, versionedHashes []common.Hash) ([]kzg4844.Blob, error) {
@@ -171,19 +182,35 @@ func (b *BlobClient) blobSidecars(ctx context.Context, slot uint64, versionedHas
 }
 
 type genesisResponse struct {
-	GenesisTime uint64 `json:"genesis_time"`
+	GenesisTime jsonapi.Uint64String `json:"genesis_time"`
 	// don't currently care about other fields, add if needed
 }
 
 func (b *BlobClient) genesisTime(ctx context.Context) (uint64, error) {
 	if b.cachedGenesisTime > 0 {
 		return b.cachedGenesisTime, nil
 	}
-
 	gr, err := beaconRequest[genesisResponse](b, ctx, "/eth/v1/beacon/genesis")
 	if err != nil {
 		return 0, fmt.Errorf("error calling beacon client in genesisTime: %w", err)
 	}
+	b.cachedGenesisTime = uint64(gr.GenesisTime)
+	return b.cachedGenesisTime, nil
+}
+
+type getSpecResponse struct {
+	SecondsPerSlot jsonapi.Uint64String `json:"SECONDS_PER_SLOT"`
+}
+
+func (b *BlobClient) secondsPerSlot(ctx context.Context) (uint64, error) {
+	if b.cachedSecondsPerSlot > 0 {
+		return b.cachedSecondsPerSlot, nil
+	}
+	gr, err := beaconRequest[getSpecResponse](b, ctx, "/eth/v1/config/spec")
+	if err != nil {
+		return 0, fmt.Errorf("error calling beacon client in secondsPerSlot: %w", err)
+	}
+	b.cachedSecondsPerSlot = uint64(gr.SecondsPerSlot)
+	return b.cachedSecondsPerSlot, nil
 
-	return gr.GenesisTime, nil
 }

arbnode/node.go

@@ -517,7 +517,10 @@ func createNodeImpl(
 
 	var blobReader arbstate.BlobReader
 	if config.BlobClient.BeaconChainUrl != "" {
-		blobReader = NewBlobClient(config.BlobClient, l1client)
+		blobReader, err = NewBlobClient(config.BlobClient, l1client)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	inboxTracker, err := NewInboxTracker(arbDb, txStreamer, daReader, blobReader)

arbnode/sequencer_inbox.go

@@ -15,6 +15,7 @@ import (
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/offchainlabs/nitro/arbstate"
 	"github.com/offchainlabs/nitro/arbutil"
 
 	"github.com/offchainlabs/nitro/solgen/go/bridgegen"
@@ -33,6 +34,7 @@ const (
 	batchDataTxInput batchDataLocation = iota
 	batchDataSeparateEvent
 	batchDataNone
+	batchDataBlobHashes
 )
 
 func init() {
@@ -149,6 +151,19 @@ func (m *SequencerInboxBatch) getSequencerData(ctx context.Context, client arbut
 	case batchDataNone:
 		// No data when in a force inclusion batch
 		return nil, nil
+	case batchDataBlobHashes:
+		tx, err := arbutil.GetLogTransaction(ctx, client, m.rawLog)
+		if err != nil {
+			return nil, err
+		}
+		if len(tx.BlobHashes()) == 0 {
+			return nil, fmt.Errorf("blob batch transaction %v has no blobs", tx.Hash())
+		}
+		data := []byte{arbstate.BlobHashesHeaderFlag}
+		for _, h := range tx.BlobHashes() {
+			data = append(data, h[:]...)
+		}
+		return data, nil
 	default:
 		return nil, fmt.Errorf("batch has invalid data location %v", m.dataLocation)
 	}

arbutil/transaction_data.go

@@ -10,15 +10,23 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 )
 
-// GetLogEmitterTxData requires that the tx's data is at least 4 bytes long
-func GetLogEmitterTxData(ctx context.Context, client L1Interface, log types.Log) ([]byte, error) {
+func GetLogTransaction(ctx context.Context, client L1Interface, log types.Log) (*types.Transaction, error) {
 	tx, err := client.TransactionInBlock(ctx, log.BlockHash, log.TxIndex)
 	if err != nil {
 		return nil, err
 	}
 	if tx.Hash() != log.TxHash {
 		return nil, fmt.Errorf("L1 client returned unexpected transaction hash %v when looking up block %v transaction %v with expected hash %v", tx.Hash(), log.BlockHash, log.TxIndex, log.TxHash)
 	}
+	return tx, nil
+}
+
+// GetLogEmitterTxData requires that the tx's data is at least 4 bytes long
+func GetLogEmitterTxData(ctx context.Context, client L1Interface, log types.Log) ([]byte, error) {
+	tx, err := GetLogTransaction(ctx, client, log)
+	if err != nil {
+		return nil, err
+	}
 	if len(tx.Data()) < 4 {
 		return nil, fmt.Errorf("log emitting transaction %v unexpectedly does not have enough data", tx.Hash())
 	}

util/blobs/blobs.go

@@ -4,6 +4,7 @@
 package blobs
 
 import (
+	"bytes"
 	"crypto/sha256"
 	"fmt"
 
@@ -48,7 +49,7 @@ func DecodeBlobs(blobs []kzg4844.Blob) ([]byte, error) {
 		}
 	}
 	var outputData []byte
-	err := rlp.DecodeBytes(rlpData, &outputData)
+	err := rlp.Decode(bytes.NewReader(rlpData), &outputData)
 	return outputData, err
 }
 

util/jsonapi/uint64_string.go

@@ -0,0 +1,32 @@
+// Copyright 2024, Offchain Labs, Inc.
+// For license information, see https://github.com/OffchainLabs/nitro/blob/master/LICENSE
+
+package jsonapi
+
+import (
+	"fmt"
+	"strconv"
+)
+
+// Uint64String is a uint64 that JSON marshals and unmarshals as string in decimal
+type Uint64String uint64
+
+func (u *Uint64String) UnmarshalJSON(b []byte) error {
+	s := string(b)
+	if s == "null" {
+		return nil
+	}
+
+	// Parse string as uint64, removing quotes
+	value, err := strconv.ParseUint(s[1:len(s)-1], 10, 64)
+	if err != nil {
+		return err
+	}
+
+	*u = Uint64String(value)
+	return nil
+}
+
+func (u Uint64String) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("\"%d\"", uint64(u))), nil
+}