Enable dataposter for validator contract wallet

arbnode/dataposter/data_poster.go

@@ -22,6 +22,7 @@ import (
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/go-redis/redis/v8"
 	"github.com/offchainlabs/nitro/arbnode/dataposter/leveldb"
+	"github.com/offchainlabs/nitro/arbnode/dataposter/noop"
 	"github.com/offchainlabs/nitro/arbnode/dataposter/slice"
 	"github.com/offchainlabs/nitro/arbnode/dataposter/storage"
 	"github.com/offchainlabs/nitro/arbutil"
@@ -97,8 +98,10 @@ func NewDataPoster(db ethdb.Database, headerReader *headerreader.HeaderReader, a
 	}
 	var queue QueueStorage
 	switch {
-	case config().EnableLevelDB:
+	case config().UseLevelDB:
 		queue = leveldb.New(db)
+	case config().UseNoOpStorage:
+		queue = &noop.Storage{}
 	case redisClient == nil:
 		queue = slice.NewStorage()
 	default:
@@ -280,6 +283,7 @@ func (p *DataPoster) PostTransaction(ctx context.Context, dataCreatedAt time.Tim
 	if err != nil {
 		return nil, fmt.Errorf("failed to update data poster balance: %w", err)
 	}
+
 	feeCap, tipCap, err := p.feeAndTipCaps(ctx, gasLimit, nil, nil, dataCreatedAt, 0)
 	if err != nil {
 		return nil, err
@@ -560,6 +564,8 @@ type DataPosterConfig struct {
 	UrgencyGwei            float64                    `koanf:"urgency-gwei" reload:"hot"`
 	MinFeeCapGwei          float64                    `koanf:"min-fee-cap-gwei" reload:"hot"`
 	MinTipCapGwei          float64                    `koanf:"min-tip-cap-gwei" reload:"hot"`
+	UseLevelDB             bool                       `koanf:"use-leveldb" reload:"hot"`
+	UseNoOpStorage         bool                       `koanf:"use-noop-storage" reload:"hot"`
 	MaxTipCapGwei          float64                    `koanf:"max-tip-cap-gwei" reload:"hot"`
 	EnableLevelDB          bool                       `koanf:"enable-leveldb" reload:"hot"`
 }
@@ -577,7 +583,8 @@ func DataPosterConfigAddOptions(prefix string, f *pflag.FlagSet) {
 	f.Float64(prefix+".urgency-gwei", DefaultDataPosterConfig.UrgencyGwei, "the urgency to use for maximum fee cap calculation")
 	f.Float64(prefix+".min-fee-cap-gwei", DefaultDataPosterConfig.MinFeeCapGwei, "the minimum fee cap to post transactions at")
 	f.Float64(prefix+".min-tip-cap-gwei", DefaultDataPosterConfig.MinTipCapGwei, "the minimum tip cap to post transactions at")
-	f.Bool(prefix+".enable-leveldb", DefaultDataPosterConfig.EnableLevelDB, "uses leveldb when enabled")
+	f.Bool(prefix+".use-leveldb", DefaultDataPosterConfig.UseLevelDB, "uses leveldb when enabled")
+	f.Bool(prefix+".use-noop-storage", DefaultDataPosterConfig.UseLevelDB, "uses noop storage, it doesn't store anything")
 	signature.SimpleHmacConfigAddOptions(prefix+".redis-signer", f)
 }
 
@@ -588,6 +595,8 @@ var DefaultDataPosterConfig = DataPosterConfig{
 	UrgencyGwei:            2.,
 	MaxMempoolTransactions: 64,
 	MinTipCapGwei:          0.05,
+	UseLevelDB:             false,
+	UseNoOpStorage:         false,
 	MaxTipCapGwei:          5,
 	EnableLevelDB:          false,
 }
@@ -600,6 +609,8 @@ var TestDataPosterConfig = DataPosterConfig{
 	UrgencyGwei:            2.,
 	MaxMempoolTransactions: 64,
 	MinTipCapGwei:          0.05,
+	UseLevelDB:             false,
+	UseNoOpStorage:         false,
 	MaxTipCapGwei:          5,
 	EnableLevelDB:          false,
 }

arbnode/dataposter/noop/storage.go

@@ -0,0 +1,37 @@
+// Copyright 2021-2023, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+package noop
+
+import (
+	"context"
+
+	"github.com/offchainlabs/nitro/arbnode/dataposter/storage"
+)
+
+// Storage implements noop storage for dataposter. This is for clients that want
+// to have option to directly post to geth without keeping state.
+type Storage struct{}
+
+func (s *Storage) FetchContents(_ context.Context, _, _ uint64) ([]*storage.QueuedTransaction, error) {
+	return nil, nil
+}
+
+func (s *Storage) FetchLast(ctx context.Context) (*storage.QueuedTransaction, error) {
+	return nil, nil
+}
+
+func (s *Storage) Prune(_ context.Context, _ uint64) error {
+	return nil
+}
+
+func (s *Storage) Put(_ context.Context, _ uint64, _, _ *storage.QueuedTransaction) error {
+	return nil
+}
+
+func (s *Storage) Length(context.Context) (int, error) {
+	return 0, nil
+}
+
+func (s *Storage) IsPersistent() bool {
+	return false
+}

arbnode/node.go

@@ -823,7 +823,7 @@ func createNodeImpl(
 				tmpAddress := common.HexToAddress(config.Staker.ContractWalletAddress)
 				existingWalletAddress = &tmpAddress
 			}
-			wallet, err = staker.NewContractValidatorWallet(existingWalletAddress, deployInfo.ValidatorWalletCreator, deployInfo.Rollup, l1Reader, txOptsValidator, int64(deployInfo.DeployedAt), func(common.Address) {})
+			wallet, err = staker.NewContractValidatorWallet(dp, existingWalletAddress, deployInfo.ValidatorWalletCreator, deployInfo.Rollup, l1Reader, txOptsValidator, int64(deployInfo.DeployedAt), func(common.Address) {}, config.BlockValidator.ExtraGas)
 			if err != nil {
 				return nil, err
 			}

staker/block_validator.go

@@ -91,6 +91,7 @@ type BlockValidatorConfig struct {
 	DataPoster               dataposter.DataPosterConfig   `koanf:"data-poster" reload:"hot"`
 	RedisUrl                 string                        `koanf:"redis-url"`
 	RedisLock                redislock.SimpleCfg           `koanf:"redis-lock" reload:"hot"`
+	ExtraGas                 uint64                        `koanf:"extra-gas" reload:"hot"`
 }
 
 func (c *BlockValidatorConfig) Validate() error {
@@ -112,6 +113,7 @@ func BlockValidatorConfigAddOptions(prefix string, f *flag.FlagSet) {
 	f.String(prefix+".current-module-root", DefaultBlockValidatorConfig.CurrentModuleRoot, "current wasm module root ('current' read from chain, 'latest' from machines/latest dir, or provide hash)")
 	f.String(prefix+".pending-upgrade-module-root", DefaultBlockValidatorConfig.PendingUpgradeModuleRoot, "pending upgrade wasm module root to additionally validate (hash, 'latest' or empty)")
 	f.Bool(prefix+".failure-is-fatal", DefaultBlockValidatorConfig.FailureIsFatal, "failing a validation is treated as a fatal error")
+	f.Uint64(prefix+".extra-gas", DefaultBlockValidatorConfig.ExtraGas, "use this much more gas than estimation says is necessary to post transactions")
 	BlockValidatorDangerousConfigAddOptions(prefix+".dangerous", f)
 	dataposter.DataPosterConfigAddOptions(prefix+".data-poster", f)
 	f.String(prefix+".redis-url", DefaultBlockValidatorConfig.RedisUrl, "redis url for block validator")
@@ -135,6 +137,7 @@ var DefaultBlockValidatorConfig = BlockValidatorConfig{
 	DataPoster:               dataposter.DefaultDataPosterConfig,
 	RedisUrl:                 "",
 	RedisLock:                redislock.DefaultCfg,
+	ExtraGas:                 50000,
 }
 
 var TestBlockValidatorConfig = BlockValidatorConfig{
@@ -150,6 +153,7 @@ var TestBlockValidatorConfig = BlockValidatorConfig{
 	DataPoster:               dataposter.TestDataPosterConfig,
 	RedisUrl:                 "",
 	RedisLock:                redislock.DefaultCfg,
+	ExtraGas:                 50000,
 }
 
 var DefaultBlockValidatorDangerousConfig = BlockValidatorDangerousConfig{

staker/validator_wallet.go

@@ -6,18 +6,24 @@ package staker
 import (
 	"context"
 	"errors"
+	"fmt"
 	"math/big"
 	"strings"
 	"sync/atomic"
+	"time"
 
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/params"
+	"github.com/offchainlabs/nitro/arbnode/dataposter"
 	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/solgen/go/rollupgen"
+	"github.com/offchainlabs/nitro/util/arbmath"
+	"github.com/offchainlabs/nitro/util/headerreader"
 	"github.com/offchainlabs/nitro/util/stopwaiter"
 )
 
@@ -62,18 +68,21 @@ type ContractValidatorWallet struct {
 	con                     *rollupgen.ValidatorWallet
 	address                 atomic.Pointer[common.Address]
 	onWalletCreated         func(common.Address)
-	l1Reader                L1ReaderInterface
+	l1Reader                *headerreader.HeaderReader
 	auth                    *bind.TransactOpts
 	walletFactoryAddr       common.Address
 	rollupFromBlock         int64
 	rollup                  *rollupgen.RollupUserLogic
 	rollupAddress           common.Address
 	challengeManagerAddress common.Address
+	dataPoster              *dataposter.DataPoster
+	extraGas                uint64
 }
 
 var _ ValidatorWalletInterface = (*ContractValidatorWallet)(nil)
 
-func NewContractValidatorWallet(address *common.Address, walletFactoryAddr, rollupAddress common.Address, l1Reader L1ReaderInterface, auth *bind.TransactOpts, rollupFromBlock int64, onWalletCreated func(common.Address)) (*ContractValidatorWallet, error) {
+func NewContractValidatorWallet(dp *dataposter.DataPoster, address *common.Address, walletFactoryAddr, rollupAddress common.Address, l1Reader *headerreader.HeaderReader, auth *bind.TransactOpts, rollupFromBlock int64, onWalletCreated func(common.Address),
+	extraGas uint64) (*ContractValidatorWallet, error) {
 	var con *rollupgen.ValidatorWallet
 	if address != nil {
 		var err error
@@ -95,6 +104,8 @@ func NewContractValidatorWallet(address *common.Address, walletFactoryAddr, roll
 		rollupAddress:     rollupAddress,
 		rollup:            rollup,
 		rollupFromBlock:   rollupFromBlock,
+		dataPoster:        dp,
+		extraGas:          extraGas,
 	}
 	// Go complains if we make an address variable before wallet and copy it in
 	wallet.address.Store(address)
@@ -180,7 +191,15 @@ func (v *ContractValidatorWallet) executeTransaction(ctx context.Context, tx *ty
 	if err != nil {
 		return nil, err
 	}
-	return v.con.ExecuteTransactionWithGasRefunder(auth, gasRefunder, tx.Data(), *tx.To(), tx.Value())
+	data, err := validatorABI.Pack("executeTransactionWithGasRefunder", gasRefunder, tx.Data(), *tx.To(), tx.Value())
+	if err != nil {
+		return nil, fmt.Errorf("packing arguments for executeTransactionWithGasRefunder: %w", err)
+	}
+	gas, err := v.gasForTxData(ctx, auth, data)
+	if err != nil {
+		return nil, fmt.Errorf("getting gas for tx data: %w", err)
+	}
+	return v.dataPoster.PostTransaction(ctx, time.Now(), auth.Nonce.Uint64(), nil, *v.Address(), data, gas, auth.Value)
 }
 
 func (v *ContractValidatorWallet) populateWallet(ctx context.Context, createIfMissing bool) error {
@@ -283,20 +302,73 @@ func (v *ContractValidatorWallet) ExecuteTransactions(ctx context.Context, build
 	if err != nil {
 		return nil, err
 	}
-	arbTx, err := v.con.ExecuteTransactionsWithGasRefunder(auth, gasRefunder, data, dest, amount)
+	txData, err := validatorABI.Pack("executeTransactionsWithGasRefunder", gasRefunder, data, dest, amount)
+	if err != nil {
+		return nil, fmt.Errorf("packing arguments for executeTransactionWithGasRefunder: %w", err)
+	}
+	gas, err := v.gasForTxData(ctx, auth, txData)
+	if err != nil {
+		return nil, fmt.Errorf("getting gas for tx data: %w", err)
+	}
+	arbTx, err := v.dataPoster.PostTransaction(ctx, time.Now(), auth.Nonce.Uint64(), nil, *v.Address(), txData, gas, auth.Value)
 	if err != nil {
 		return nil, err
 	}
 	builder.transactions = nil
 	return arbTx, nil
 }
 
+func (v *ContractValidatorWallet) estimateGas(ctx context.Context, value *big.Int, data []byte) (uint64, error) {
+	h, err := v.l1Reader.LastHeader(ctx)
+	if err != nil {
+		return 0, fmt.Errorf("getting the last header: %w", err)
+	}
+	gasFeeCap := new(big.Int).Mul(h.BaseFee, big.NewInt(2))
+	gasFeeCap = arbmath.BigMax(gasFeeCap, arbmath.FloatToBig(params.GWei))
+
+	gasTipCap, err := v.l1Reader.Client().SuggestGasTipCap(ctx)
+	if err != nil {
+		return 0, fmt.Errorf("getting suggested gas tip cap: %w", err)
+	}
+	g, err := v.l1Reader.Client().EstimateGas(
+		ctx,
+		ethereum.CallMsg{
+			From:      v.auth.From,
+			To:        v.Address(),
+			Value:     value,
+			Data:      data,
+			GasFeeCap: gasFeeCap,
+			GasTipCap: gasTipCap,
+		},
+	)
+	if err != nil {
+		return 0, fmt.Errorf("estimating gas: %w", err)
+	}
+	return g + v.extraGas, nil
+}
+
 func (v *ContractValidatorWallet) TimeoutChallenges(ctx context.Context, challenges []uint64) (*types.Transaction, error) {
 	auth, err := v.getAuth(ctx, nil)
 	if err != nil {
 		return nil, err
 	}
-	return v.con.TimeoutChallenges(auth, v.challengeManagerAddress, challenges)
+	data, err := validatorABI.Pack("timeoutChallenges", v.challengeManagerAddress, challenges)
+	if err != nil {
+		return nil, fmt.Errorf("packing arguments for timeoutChallenges: %w", err)
+	}
+	gas, err := v.gasForTxData(ctx, auth, data)
+	if err != nil {
+		return nil, fmt.Errorf("getting gas for tx data: %w", err)
+	}
+	return v.dataPoster.PostTransaction(ctx, time.Now(), auth.Nonce.Uint64(), nil, *v.Address(), data, gas, auth.Value)
+}
+
+// gasForTxData returns auth.GasLimit if it's nonzero, otherwise returns estimate.
+func (v *ContractValidatorWallet) gasForTxData(ctx context.Context, auth *bind.TransactOpts, data []byte) (uint64, error) {
+	if auth.GasLimit != 0 {
+		return auth.GasLimit, nil
+	}
+	return v.estimateGas(ctx, auth.Value, data)
 }
 
 func (v *ContractValidatorWallet) L1Client() arbutil.L1Interface {

system_tests/staker_test.go

@@ -130,7 +130,11 @@ func stakerTestImpl(t *testing.T, faultyStaker bool, honestStakerInactive bool)
 
 	valConfig := staker.L1ValidatorConfig{}
 
-	valWalletA, err := staker.NewContractValidatorWallet(nil, l2nodeA.DeployInfo.ValidatorWalletCreator, l2nodeA.DeployInfo.Rollup, l2nodeA.L1Reader, &l1authA, 0, func(common.Address) {})
+	dpA, err := arbnode.ValidatorDataposter(rawdb.NewTable(l2nodeB.ArbDB, storage.BlockValidatorPrefix), l2nodeA.L1Reader, &l1authA, NewFetcherFromConfig(arbnode.ConfigDefaultL1NonSequencerTest()), nil)
+	if err != nil {
+		t.Fatalf("Error creating validator dataposter: %v", err)
+	}
+	valWalletA, err := staker.NewContractValidatorWallet(dpA, nil, l2nodeA.DeployInfo.ValidatorWalletCreator, l2nodeA.DeployInfo.Rollup, l2nodeA.L1Reader, &l1authA, 0, func(common.Address) {}, 10000)
 	Require(t, err)
 	if honestStakerInactive {
 		valConfig.Strategy = "Defensive"
@@ -174,11 +178,11 @@ func stakerTestImpl(t *testing.T, faultyStaker bool, honestStakerInactive bool)
 	}
 	Require(t, err)
 
-	dp, err := arbnode.ValidatorDataposter(rawdb.NewTable(l2nodeB.ArbDB, storage.BlockValidatorPrefix), l2nodeB.L1Reader, &l1authB, NewFetcherFromConfig(arbnode.ConfigDefaultL1NonSequencerTest()), nil)
+	dpB, err := arbnode.ValidatorDataposter(rawdb.NewTable(l2nodeB.ArbDB, storage.BlockValidatorPrefix), l2nodeB.L1Reader, &l1authB, NewFetcherFromConfig(arbnode.ConfigDefaultL1NonSequencerTest()), nil)
 	if err != nil {
 		t.Fatalf("Error creating validator dataposter: %v", err)
 	}
-	valWalletB, err := staker.NewEoaValidatorWallet(dp, l2nodeB.DeployInfo.Rollup, l2nodeB.L1Reader.Client(), &l1authB)
+	valWalletB, err := staker.NewEoaValidatorWallet(dpB, l2nodeB.DeployInfo.Rollup, l2nodeB.L1Reader.Client(), &l1authB)
 	Require(t, err)
 	valConfig.Strategy = "MakeNodes"
 	statelessB, err := staker.NewStatelessBlockValidator(
@@ -213,8 +217,11 @@ func stakerTestImpl(t *testing.T, faultyStaker bool, honestStakerInactive bool)
 		err = valWalletB.Initialize(ctx)
 		Require(t, err)
 	}
-
-	valWalletC, err := staker.NewContractValidatorWallet(nil, l2nodeA.DeployInfo.ValidatorWalletCreator, l2nodeA.DeployInfo.Rollup, l2nodeA.L1Reader, nil, 0, func(common.Address) {})
+	dpC, err := arbnode.ValidatorDataposter(rawdb.NewTable(l2nodeB.ArbDB, storage.BlockValidatorPrefix), l2nodeA.L1Reader, &l1authA, NewFetcherFromConfig(arbnode.ConfigDefaultL1NonSequencerTest()), nil)
+	if err != nil {
+		t.Fatalf("Error creating validator dataposter: %v", err)
+	}
+	valWalletC, err := staker.NewContractValidatorWallet(dpC, nil, l2nodeA.DeployInfo.ValidatorWalletCreator, l2nodeA.DeployInfo.Rollup, l2nodeA.L1Reader, nil, 0, func(common.Address) {}, 10000)
 	Require(t, err)
 	valConfig.Strategy = "Watchtower"
 	stakerC, err := staker.NewStaker(