Automatic L1 gas pricing

arbnode/api.go

@@ -63,7 +63,6 @@ type PricingModelHistory struct {
 	GasBacklog               []uint64   `json:"gasBacklog"`
 	GasUsed                  []uint64   `json:"gasUsed"`
 	L1BaseFeeEstimate        []*big.Int `json:"l1BaseFeeEstimate"`
-	L1BaseFeeUpdateTime      []uint64   `json:"l1BaseFeeUpdateTime"`
 	MinBaseFee               *big.Int   `json:"minBaseFee"`
 	SpeedLimit               uint64     `json:"speedLimit"`
 	MaxPerBlockGasLimit      uint64     `json:"maxPerBlockGasLimit"`
@@ -82,26 +81,12 @@ func (api *ArbDebugAPI) PricingModel(ctx context.Context, start, end rpc.BlockNu
 	}
 
 	history := PricingModelHistory{
-		First:               uint64(start),
-		Timestamp:           make([]uint64, blocks),
-		BaseFee:             make([]*big.Int, blocks),
-		GasBacklog:          make([]uint64, blocks),
-		GasUsed:             make([]uint64, blocks),
-		L1BaseFeeEstimate:   make([]*big.Int, blocks),
-		L1BaseFeeUpdateTime: make([]uint64, blocks+1),
-	}
-
-	genesisBlock := api.blockchain.Config().ArbitrumChainParams.GenesisBlockNum
-	if start > rpc.BlockNumber(genesisBlock) {
-		state, _, err := stateAndHeader(api.blockchain, uint64(start)-1)
-		if err != nil {
-			return history, err
-		}
-		l1BaseFeeUpdateTime, err := state.L1PricingState().LastL1BaseFeeUpdateTime()
-		if err != nil {
-			return history, err
-		}
-		history.L1BaseFeeUpdateTime[0] = l1BaseFeeUpdateTime
+		First:             uint64(start),
+		Timestamp:         make([]uint64, blocks),
+		BaseFee:           make([]*big.Int, blocks),
+		GasBacklog:        make([]uint64, blocks),
+		GasUsed:           make([]uint64, blocks),
+		L1BaseFeeEstimate: make([]*big.Int, blocks),
 	}
 
 	for i := uint64(0); i < uint64(blocks); i++ {
@@ -116,21 +101,16 @@ func (api *ArbDebugAPI) PricingModel(ctx context.Context, start, end rpc.BlockNu
 		history.BaseFee[i] = header.BaseFee
 
 		gasBacklog, _ := l2Pricing.GasBacklog()
-		l1BaseFeeEstimate, _ := l1Pricing.L1BaseFeeEstimateWei()
-		l1BaseFeeUpdateTime, err := l1Pricing.LastL1BaseFeeUpdateTime()
-		if err != nil {
-			return history, err
-		}
+		l1BaseFeeEstimate, _ := l1Pricing.PricePerUnit()
 
 		history.GasBacklog[i] = gasBacklog
 		history.GasUsed[i] = header.GasUsed
 		history.L1BaseFeeEstimate[i] = l1BaseFeeEstimate
-		history.L1BaseFeeUpdateTime[i+1] = l1BaseFeeUpdateTime
 
 		if i == uint64(blocks)-1 {
 			speedLimit, _ := l2Pricing.SpeedLimitPerSecond()
 			maxPerBlockGasLimit, _ := l2Pricing.PerBlockGasLimit()
-			l1BaseFeeEstimateInertia, err := l1Pricing.L1BaseFeeEstimateInertia()
+			l1BaseFeeEstimateInertia, err := l1Pricing.Inertia()
 			minBaseFee, _ := l2Pricing.MinBaseFeeWei()
 			pricingInertia, _ := l2Pricing.PricingInertia()
 			backlogTolerance, _ := l2Pricing.BacklogTolerance()

arbnode/batch_poster.go

@@ -10,6 +10,7 @@ import (
 	"math/big"
 	"time"
 
+	"github.com/offchainlabs/nitro/arbos"
 	"github.com/offchainlabs/nitro/util/headerreader"
 
 	"github.com/andybalholm/brotli"
@@ -353,30 +354,39 @@ func (b *BatchPoster) maybePostSequencerBatch(ctx context.Context, batchSeqNum u
 	if err != nil {
 		return nil, err
 	}
+
 	forcePostBatch := timeSinceNextMessage >= b.config.MaxBatchPostInterval
+	haveUsefulMessage := false
+
 	for b.building.msgCount < msgCount {
 		msg, err := b.streamer.GetMessage(b.building.msgCount)
 		if err != nil {
 			log.Error("error getting message from streamer", "error", err)
 			break
 		}
+		if msg.Message.Header.Kind != arbos.L1MessageType_BatchPostingReport {
+			haveUsefulMessage = true
+		}
 		success, err := b.building.segments.AddMessage(&msg)
 		if err != nil {
 			log.Error("error adding message to batch", "error", err)
 			break
 		}
 		if !success {
-			forcePostBatch = true // this batch is full
+			// this batch is full
+			forcePostBatch = true
+			haveUsefulMessage = true
 			break
 		}
 		b.building.msgCount++
 	}
+
 	if b.building.segments.IsEmpty() {
 		// we don't need to post a batch for the time being
 		b.pendingMsgTimestamp = time.Now()
 		return nil, nil
 	}
-	if !forcePostBatch {
+	if !forcePostBatch || !haveUsefulMessage {
 		// the batch isn't full yet and we've posted a batch recently
 		// don't post anything for now
 		return nil, nil

arbnode/node.go

@@ -682,6 +682,7 @@ func createNodeImpl(
 	if err != nil {
 		return nil, err
 	}
+	txStreamer.SetInboxReader(inboxReader)
 
 	nitroMachineConfig := validator.DefaultNitroMachineConfig
 	if config.Wasm.RootPath != "" {

arbnode/sequencer.go

@@ -86,13 +86,6 @@ func (s *Sequencer) PublishTransaction(ctx context.Context, tx *types.Transactio
 }
 
 func (s *Sequencer) preTxFilter(state *arbosState.ArbosState, tx *types.Transaction, sender common.Address) error {
-	agg, err := state.L1PricingState().ReimbursableAggregatorForSender(sender)
-	if err != nil {
-		return err
-	}
-	if agg == nil || *agg != l1pricing.SequencerAddress {
-		return errors.New("transaction sender's preferred aggregator is not the sequencer")
-	}
 	return nil
 }
 
@@ -217,7 +210,7 @@ func (s *Sequencer) sequenceTransactions(ctx context.Context) {
 
 	header := &arbos.L1IncomingMessageHeader{
 		Kind:        arbos.L1MessageType_L2Message,
-		Poster:      l1pricing.SequencerAddress,
+		Poster:      l1pricing.BatchPosterAddress,
 		BlockNumber: l1Block,
 		Timestamp:   uint64(timestamp),
 		RequestId:   nil,

arbnode/transaction_streamer.go

@@ -54,6 +54,7 @@ type TransactionStreamer struct {
 	coordinator     *SeqCoordinator
 	broadcastServer *broadcaster.Broadcaster
 	validator       *validator.BlockValidator
+	inboxReader     *InboxReader
 }
 
 func NewTransactionStreamer(db ethdb.Database, bc *core.BlockChain, broadcastServer *broadcaster.Broadcaster) (*TransactionStreamer, error) {
@@ -96,6 +97,16 @@ func (s *TransactionStreamer) SetSeqCoordinator(coordinator *SeqCoordinator) {
 	s.coordinator = coordinator
 }
 
+func (s *TransactionStreamer) SetInboxReader(inboxReader *InboxReader) {
+	if s.Started() {
+		panic("trying to set inbox reader after start")
+	}
+	if s.inboxReader != nil {
+		panic("trying to set inbox reader when already set")
+	}
+	s.inboxReader = inboxReader
+}
+
 func (s *TransactionStreamer) cleanupInconsistentState() error {
 	// If it doesn't exist yet, set the message count to 0
 	hasMessageCount, err := s.db.Has(messageCountKey)
@@ -695,6 +706,10 @@ func (s *TransactionStreamer) createBlocks(ctx context.Context) error {
 		}
 	}()
 
+	batchFetcher := func(batchNum uint64) ([]byte, error) {
+		return s.inboxReader.GetSequencerMessageBytes(ctx, batchNum)
+	}
+
 	for pos < msgCount {
 
 		statedb, err = s.bc.StateAt(lastBlockHeader.Root)
@@ -719,14 +734,18 @@ func (s *TransactionStreamer) createBlocks(ctx context.Context) error {
 			return err
 		}
 
-		block, receipts := arbos.ProduceBlock(
+		block, receipts, err := arbos.ProduceBlock(
 			msg.Message,
 			msg.DelayedMessagesRead,
 			lastBlockHeader,
 			statedb,
 			s.bc,
 			s.bc.Config(),
+			batchFetcher,
 		)
+		if err != nil {
+			return err
+		}
 
 		// ProduceBlock advances one message
 		pos++

arbos/addressSet/addressSet.go

@@ -44,9 +44,9 @@ func (aset *AddressSet) GetAnyMember() (*common.Address, error) {
 	if err != nil || size == 0 {
 		return nil, err
 	}
-	addrAsHash, err := aset.backingStorage.GetByUint64(1)
-	addr := common.BytesToAddress(addrAsHash.Bytes())
-	return &addr, err
+	sba := aset.backingStorage.OpenStorageBackedAddressOrNil(1)
+	addr, err := sba.Get()
+	return addr, err
 }
 
 func (aset *AddressSet) Clear() error {
@@ -65,18 +65,21 @@ func (aset *AddressSet) Clear() error {
 	return aset.size.Clear()
 }
 
-func (aset *AddressSet) AllMembers() ([]common.Address, error) {
+func (aset *AddressSet) AllMembers(maxNumToReturn uint64) ([]common.Address, error) {
 	size, err := aset.size.Get()
 	if err != nil {
 		return nil, err
 	}
+	if size > maxNumToReturn {
+		size = maxNumToReturn
+	}
 	ret := make([]common.Address, size)
 	for i := range ret {
-		bytes, err := aset.backingStorage.GetByUint64(uint64(i + 1))
+		sba := aset.backingStorage.OpenStorageBackedAddress(uint64(i + 1))
+		ret[i], err = sba.Get()
 		if err != nil {
 			return nil, err
 		}
-		ret[i] = common.BytesToAddress(bytes.Bytes())
 	}
 	return ret, nil
 }
@@ -90,13 +93,15 @@ func (aset *AddressSet) Add(addr common.Address) error {
 	if err != nil {
 		return err
 	}
+	sba := aset.backingStorage.OpenStorageBackedAddress(1 + size)
 	slot := util.UintToHash(1 + size)
 	addrAsHash := common.BytesToHash(addr.Bytes())
 	err = aset.byAddress.Set(addrAsHash, slot)
 	if err != nil {
 		return err
 	}
-	err = aset.backingStorage.Set(slot, addrAsHash)
+	sba = aset.backingStorage.OpenStorageBackedAddress(1 + size)
+	err = sba.Set(addr)
 	if err != nil {
 		return err
 	}

arbos/addressSet/addressSet_test.go

@@ -4,6 +4,7 @@
 package addressSet
 
 import (
+	"github.com/ethereum/go-ethereum/common/math"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -92,7 +93,7 @@ func TestAddressSet(t *testing.T) {
 	}
 
 	Require(t, aset.Add(addr1))
-	all, err := aset.AllMembers()
+	all, err := aset.AllMembers(math.MaxUint64)
 	Require(t, err)
 	if len(all) != 2 {
 		Fail(t)

arbos/arbosState/initialization_test.go

@@ -142,6 +142,7 @@ func checkRetryables(arbState *ArbosState, expected []statetransfer.Initializati
 
 func checkAccounts(db *state.StateDB, arbState *ArbosState, accts []statetransfer.AccountInitializationInfo, t *testing.T) {
 	l1p := arbState.L1PricingState()
+	posterTable := l1p.BatchPosterTable()
 	for _, acct := range accts {
 		addr := acct.Addr
 		if db.GetNonce(addr) != acct.Nonce {
@@ -168,20 +169,17 @@ func checkAccounts(db *state.StateDB, arbState *ArbosState, accts []statetransfe
 				t.Fatal(err)
 			}
 		}
-		if acct.AggregatorInfo != nil {
-			fc, err := l1p.AggregatorFeeCollector(addr)
+		isPoster, err := posterTable.ContainsPoster(addr)
+		Require(t, err)
+		if acct.AggregatorInfo != nil && isPoster {
+			posterInfo, err := posterTable.OpenPoster(addr, false)
+			Require(t, err)
+			fc, err := posterInfo.PayTo()
 			Require(t, err)
 			if fc != acct.AggregatorInfo.FeeCollector {
 				t.Fatal()
 			}
 		}
-		if acct.AggregatorToPay != nil {
-			aggregator, err := l1p.ReimbursableAggregatorForSender(addr)
-			Require(t, err)
-			if aggregator == nil || *aggregator != *acct.AggregatorToPay {
-				Fail(t)
-			}
-		}
 	}
 	_ = l1p
 }

arbos/arbosState/initialize.go

@@ -154,16 +154,22 @@ func initializeRetryables(rs *retryables.RetryableState, initData statetransfer.
 
 func initializeArbosAccount(statedb *state.StateDB, arbosState *ArbosState, account statetransfer.AccountInitializationInfo) error {
 	l1pState := arbosState.L1PricingState()
+	posterTable := l1pState.BatchPosterTable()
 	if account.AggregatorInfo != nil {
-		err := l1pState.SetAggregatorFeeCollector(account.Addr, account.AggregatorInfo.FeeCollector)
+		isPoster, err := posterTable.ContainsPoster(account.Addr)
 		if err != nil {
 			return err
 		}
-	}
-	if account.AggregatorToPay != nil {
-		err := l1pState.SetUserSpecifiedAggregator(account.Addr, account.AggregatorToPay)
-		if err != nil {
-			return err
+		if isPoster {
+			// poster is already authorized, just set its fee collector
+			poster, err := posterTable.OpenPoster(account.Addr, false)
+			if err != nil {
+				return err
+			}
+			err = poster.SetPayTo(account.AggregatorInfo.FeeCollector)
+			if err != nil {
+				return err
+			}
 		}
 	}