Merge remote-tracking branch 'origin/master' into filter-submit-retryable

Author: Tristan-Wilson

.github/workflows/_rust-tests.yml

@@ -52,6 +52,9 @@ jobs:
       - name: Make arbitrator libraries
         run: make -j wasm-ci-build
 
+      - name: Prepare replay.wasm env
+        run: make build-replay-env
+
       - name: Clippy check
         run: cargo clippy --all -- -D warnings -A static_mut_refs
 

.github/workflows/automated-changelog.yml

@@ -15,6 +15,8 @@ jobs:
     steps:
       - name: Checkout Code
         uses: actions/checkout@v6
+        with:
+          token: ${{ secrets.CHANGELOG_PUSH_TOKEN }}
 
       - name: Create Changelog File
         uses: actions/github-script@v8

Cargo.lock

@@ -10,25 +10,75 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/metrics"
 
 	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/staker"
 	"github.com/offchainlabs/nitro/validator"
 	"github.com/offchainlabs/nitro/validator/server_api"
 )
 
+var (
+	getL1ConfirmationCallsCounter        = metrics.NewRegisteredCounter("arb/consensus_rpc_get_l1_confirmation_calls", nil)
+	findBatchContainingBlockCallsCounter = metrics.NewRegisteredCounter("arb/consensus_rpc_find_batch_containing_block_calls", nil)
+)
+
 type BlockValidatorAPI struct {
 	val *staker.BlockValidator
 }
 
+func NewBlockValidatorAPI(val *staker.BlockValidator) *BlockValidatorAPI {
+	return &BlockValidatorAPI{
+		val: val,
+	}
+}
+
 func (a *BlockValidatorAPI) LatestValidated(ctx context.Context) (*staker.GlobalStateValidatedInfo, error) {
 	return a.val.ReadLastValidatedInfo()
 }
 
+type ArbAPI struct {
+	consensusNode   *Node
+	genesisBlockNum uint64
+}
+
+func NewArbAPI(consensusNode *Node, genesisBlockNum uint64) *ArbAPI {
+	return &ArbAPI{
+		consensusNode:   consensusNode,
+		genesisBlockNum: genesisBlockNum,
+	}
+}
+
+func (a *ArbAPI) GetL1Confirmations(ctx context.Context, blockNum uint64) (uint64, error) {
+	getL1ConfirmationCallsCounter.Inc(1)
+
+	msgIdx, err := arbutil.BlockNumberToMessageIndex(blockNum, a.genesisBlockNum)
+	if err != nil {
+		return 0, err
+	}
+	return a.consensusNode.GetL1Confirmations(msgIdx).Await(ctx)
+}
+
+func (a *ArbAPI) FindBatchContainingBlock(ctx context.Context, blockNum uint64) (uint64, error) {
+	findBatchContainingBlockCallsCounter.Inc(1)
+
+	msgIdx, err := arbutil.BlockNumberToMessageIndex(blockNum, a.genesisBlockNum)
+	if err != nil {
+		return 0, err
+	}
+	return a.consensusNode.FindBatchContainingMessage(msgIdx).Await(ctx)
+}
+
 type BlockValidatorDebugAPI struct {
 	val *staker.StatelessBlockValidator
 }
 
+func NewBlockValidatorDebugAPI(val *staker.StatelessBlockValidator) *BlockValidatorDebugAPI {
+	return &BlockValidatorDebugAPI{
+		val: val,
+	}
+}
+
 type ValidateBlockResult struct {
 	Valid       bool                    `json:"valid"`
 	Latency     string                  `json:"latency"`

addressfilter/config.go

@@ -25,7 +25,8 @@ func TestSequencerReorgFromDelayed(t *testing.T) {
 
 	err = streamer.Start(ctx)
 	Require(t, err)
-	exec.Start(ctx)
+	err = exec.Start(ctx)
+	Require(t, err)
 	init, err := streamer.GetMessage(0)
 	Require(t, err)
 
@@ -225,7 +226,8 @@ func TestSequencerReorgFromLastDelayedMsg(t *testing.T) {
 
 	err = streamer.Start(ctx)
 	Require(t, err)
-	exec.Start(ctx)
+	err = exec.Start(ctx)
+	Require(t, err)
 	init, err := streamer.GetMessage(0)
 	Require(t, err)
 

arbnode/api.go

@@ -88,7 +88,7 @@ var TestDelayedSequencerConfig = DelayedSequencerConfig{
 	RequireFullFinality:         false,
 	UseMergeFinality:            false,
 	RescanInterval:              time.Millisecond * 100,
-	FilteredTxFullRetryInterval: 30 * time.Second,
+	FilteredTxFullRetryInterval: 1 * time.Second,
 }
 
 func NewDelayedSequencer(l1Reader *headerreader.HeaderReader, reader *InboxReader, exec execution.ExecutionSequencer, coordinator *SeqCoordinator, config DelayedSequencerConfigFetcher) (*DelayedSequencer, error) {

arbnode/delayed_seq_reorg_test.go

@@ -142,10 +142,7 @@ func NewTransactionStreamerForTest(t *testing.T, ctx context.Context, ownerAddre
 	}
 
 	transactionStreamerConfigFetcher := func() *TransactionStreamerConfig { return &DefaultTransactionStreamerConfig }
-	execEngine, err := gethexec.NewExecutionEngine(bc, 0, false)
-	if err != nil {
-		Fail(t, err)
-	}
+	execEngine := gethexec.NewExecutionEngine(bc, 0, false)
 	stylusTargetConfig := &gethexec.DefaultStylusTargetConfig
 	Require(t, stylusTargetConfig.Validate()) // pre-processes config (i.a. parses wasmTargets)
 	if err := execEngine.Initialize(gethexec.DefaultCachingConfig.StylusLRUCacheCapacity, &gethexec.DefaultStylusTargetConfig); err != nil {
@@ -183,7 +180,8 @@ func TestTransactionStreamer(t *testing.T) {
 
 	err := inbox.Start(ctx)
 	Require(t, err)
-	exec.Start(ctx)
+	err = exec.Start(ctx)
+	Require(t, err)
 
 	maxExpectedGasCost := big.NewInt(l2pricing.InitialBaseFeeWei)
 	maxExpectedGasCost.Mul(maxExpectedGasCost, big.NewInt(2100*2))

arbnode/delayed_sequencer.go

@@ -60,12 +60,6 @@ func ParseBatchesFromBlock(
 			return nil, nil, fmt.Errorf("error fetching tx by hash: %v in ParseBatchesFromBlock: %w ", log.TxHash, err)
 		}
 
-		// Record this log for MEL validation. This is a very cheap operation in native mode
-		// and is optimized for recording mode as well.
-		if _, err := logsFetcher.LogsForTxIndex(ctx, parentChainHeader.Hash(), log.TxIndex); err != nil {
-			return nil, nil, fmt.Errorf("error recording relevant logs: %w", err)
-		}
-
 		batch := &mel.SequencerInboxBatch{
 			BlockHash:              log.BlockHash,
 			ParentChainBlockNumber: log.BlockNumber,

arbnode/inbox_test.go

@@ -39,11 +39,6 @@ func parseDelayedMessagesFromBlock(
 		// On Arbitrum One, this is the bridge contract which emits a MessageDelivered event.
 		if log.Address == melState.DelayedMessagePostingTargetAddress {
 			relevantLogs = append(relevantLogs, log)
-			// Record this log for MEL validation. This is a very cheap operation in native mode
-			// and is optimized for recording mode as well.
-			if _, err := logsFetcher.LogsForTxIndex(ctx, parentChainHeader.Hash(), log.TxIndex); err != nil {
-				return nil, fmt.Errorf("error recording relevant logs: %w", err)
-			}
 		}
 	}
 	if len(relevantLogs) > 0 {
@@ -83,11 +78,6 @@ func parseDelayedMessagesFromBlock(
 			return nil, err
 		}
 		messageData[common.BigToHash(msgNum)] = msg
-		// Record this log for MEL validation. This is a very cheap operation in native mode
-		// and is optimized for recording mode as well.
-		if _, err := logsFetcher.LogsForTxIndex(ctx, parentChainHeader.Hash(), inboxMsgLog.TxIndex); err != nil {
-			return nil, fmt.Errorf("error recording relevant logs: %w", err)
-		}
 	}
 	for i, parsedLog := range messageDeliveredEvents {
 		msgKey := common.BigToHash(parsedLog.MessageIndex)