Merge branch 'master' into add-gasused-metric

arbnode/dataposter/data_poster.go

@@ -42,6 +42,8 @@ type queuedTransaction[Meta any] struct {
 	NextReplacement time.Time
 }
 
+// Note: one of the implementation of this interface (Redis storage) does not
+// support duplicate values.
 type QueueStorage[Item any] interface {
 	GetContents(ctx context.Context, startingIndex uint64, maxResults uint64) ([]*Item, error)
 	GetLast(ctx context.Context) (*Item, error)

arbnode/dataposter/redis/redisstorage.go

@@ -15,7 +15,10 @@ import (
 	"github.com/offchainlabs/nitro/util/signature"
 )
 
-// Storage requires that Item is RLP encodable/decodable
+// Storage implements redis sorted set backed storage. It does not support
+// duplicate keys or values. That is, putting the same element on different
+// indexes will not yield expected behavior.
+// More  at: https://redis.io/commands/zadd/.
 type Storage[Item any] struct {
 	client redis.UniversalClient
 	signer *signature.SimpleHmac

das/syncing_fallback_storage.go

@@ -370,20 +370,25 @@ func (s *l1SyncService) readMore(ctx context.Context) error {
 func (s *l1SyncService) mainThread(ctx context.Context) {
 	headerChan, unsubscribe := s.l1Reader.Subscribe(false)
 	defer unsubscribe()
+	errCount := 0
 	for {
 		err := s.readMore(ctx)
 		if err != nil {
 			if ctx.Err() != nil {
 				return
 			}
-			log.Error("error trying to sync from L1", "err", err)
+			errCount++
+			if errCount > 5 {
+				log.Error("error trying to sync from L1", "err", err)
+			}
 			select {
 			case <-ctx.Done():
 				return
-			case <-time.After(s.config.DelayOnError):
+			case <-time.After(s.config.DelayOnError * time.Duration(errCount)):
 			}
 			continue
 		}
+		errCount = 0
 		if s.catchingUp {
 			// we're behind. Don't wait.
 			continue

staker/block_validator.go

@@ -984,9 +984,12 @@ func (v *BlockValidator) checkLegacyValid() error {
 		log.Warn("legacy valid batch ahead of db", "current", batchCount, "required", requiredBatchCount)
 		return nil
 	}
-	msgCount, err := v.inboxTracker.GetBatchMessageCount(v.legacyValidInfo.AfterPosition.BatchNumber)
-	if err != nil {
-		return err
+	var msgCount arbutil.MessageIndex
+	if v.legacyValidInfo.AfterPosition.BatchNumber > 0 {
+		msgCount, err = v.inboxTracker.GetBatchMessageCount(v.legacyValidInfo.AfterPosition.BatchNumber - 1)
+		if err != nil {
+			return err
+		}
 	}
 	msgCount += arbutil.MessageIndex(v.legacyValidInfo.AfterPosition.PosInBatch)
 	processedCount, err := v.streamer.GetProcessedMessageCount()

system_tests/retryable_test.go

@@ -60,13 +60,14 @@ func retryableSetup(t *testing.T) (
 		}
 		var submissionTxs []*types.Transaction
 		for _, message := range messages {
-			if message.Message.Header.Kind != arbostypes.L1MessageType_SubmitRetryable {
+			k := message.Message.Header.Kind
+			if k != arbostypes.L1MessageType_SubmitRetryable && k != arbostypes.L1MessageType_EthDeposit {
 				continue
 			}
 			txs, err := arbos.ParseL2Transactions(message.Message, params.ArbitrumDevTestChainConfig().ChainID, nil)
 			Require(t, err)
 			for _, tx := range txs {
-				if tx.Type() == types.ArbitrumSubmitRetryableTxType {
+				if tx.Type() == types.ArbitrumSubmitRetryableTxType || tx.Type() == types.ArbitrumDepositTxType {
 					submissionTxs = append(submissionTxs, tx)
 				}
 			}
@@ -398,6 +399,52 @@ func waitForL1DelayBlocks(t *testing.T, ctx context.Context, l1client *ethclient
 	}
 }
 
+func TestDepositETH(t *testing.T) {
+	t.Parallel()
+	_, l1info, l2client, l1client, delayedInbox, lookupSubmitRetryableL2TxHash, ctx, teardown := retryableSetup(t)
+	defer teardown()
+
+	faucetAddr := l1info.GetAddress("Faucet")
+
+	oldBalance, err := l2client.BalanceAt(ctx, faucetAddr, nil)
+	if err != nil {
+		t.Fatalf("BalanceAt(%v) unexpected error: %v", faucetAddr, err)
+	}
+
+	txOpts := l1info.GetDefaultTransactOpts("Faucet", ctx)
+	txOpts.Value = big.NewInt(13)
+
+	l1tx, err := delayedInbox.DepositEth0(&txOpts)
+	if err != nil {
+		t.Fatalf("DepositEth0() unexected error: %v", err)
+	}
+
+	l1Receipt, err := EnsureTxSucceeded(ctx, l1client, l1tx)
+	if err != nil {
+		t.Fatalf("EnsureTxSucceeded() unexpected error: %v", err)
+	}
+	if l1Receipt.Status != types.ReceiptStatusSuccessful {
+		t.Errorf("Got transaction status: %v, want: %v", l1Receipt.Status, types.ReceiptStatusSuccessful)
+	}
+	waitForL1DelayBlocks(t, ctx, l1client, l1info)
+
+	txHash := lookupSubmitRetryableL2TxHash(l1Receipt)
+	l2Receipt, err := WaitForTx(ctx, l2client, txHash, time.Second*5)
+	if err != nil {
+		t.Fatalf("WaitForTx(%v) unexpected error: %v", txHash, err)
+	}
+	if l2Receipt.Status != types.ReceiptStatusSuccessful {
+		t.Errorf("Got transaction status: %v, want: %v", l2Receipt.Status, types.ReceiptStatusSuccessful)
+	}
+	newBalance, err := l2client.BalanceAt(ctx, faucetAddr, l2Receipt.BlockNumber)
+	if err != nil {
+		t.Fatalf("BalanceAt(%v) unexpected error: %v", faucetAddr, err)
+	}
+	if got := new(big.Int); got.Sub(newBalance, oldBalance).Cmp(txOpts.Value) != 0 {
+		t.Errorf("Got transferred: %v, want: %v", got, txOpts.Value)
+	}
+}
+
 func TestL1FundedUnsignedTransaction(t *testing.T) {
 	t.Parallel()
 	ctx := context.Background()