Gas price optimisations for timely inclusion (#194)

Author: hazim-j

go.mod

@@ -12,7 +12,6 @@ require (
 	github.com/go-logr/zerologr v1.2.3
 	github.com/go-playground/validator/v10 v10.12.0
 	github.com/google/go-cmp v0.5.9
-	github.com/google/uuid v1.3.0
 	github.com/metachris/flashbotsrpc v0.5.0
 	github.com/mitchellh/mapstructure v1.5.0
 	github.com/rs/zerolog v1.29.0
@@ -47,6 +46,7 @@ require (
 	github.com/golang/protobuf v1.5.2 // indirect
 	github.com/golang/snappy v0.0.4 // indirect
 	github.com/google/flatbuffers v1.12.1 // indirect
+	github.com/google/uuid v1.3.0 // indirect
 	github.com/gorilla/websocket v1.4.2 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
 	github.com/holiman/uint256 v1.2.0 // indirect

internal/start/private.go

@@ -19,7 +19,9 @@ import (
 	"github.com/stackup-wallet/stackup-bundler/pkg/gas"
 	"github.com/stackup-wallet/stackup-bundler/pkg/jsonrpc"
 	"github.com/stackup-wallet/stackup-bundler/pkg/mempool"
+	"github.com/stackup-wallet/stackup-bundler/pkg/modules/batch"
 	"github.com/stackup-wallet/stackup-bundler/pkg/modules/checks"
+	"github.com/stackup-wallet/stackup-bundler/pkg/modules/gasprice"
 	"github.com/stackup-wallet/stackup-bundler/pkg/modules/paymaster"
 	"github.com/stackup-wallet/stackup-bundler/pkg/modules/relay"
 	"github.com/stackup-wallet/stackup-bundler/pkg/signer"
@@ -108,8 +110,13 @@ func PrivateMode() {
 
 	// Init Bundler
 	b := bundler.New(mem, chain, conf.SupportedEntryPoints)
+	b.SetGetBaseFeeFunc(gasprice.GetBaseFeeWithEthClient(eth))
+	b.SetGetLegacyGasPriceFunc(gasprice.GetLegacyGasPriceWithEthClient(eth))
 	b.UseLogger(logr)
 	b.UseModules(
+		gasprice.SortByGasPrice(),
+		gasprice.FilterUnderpriced(),
+		batch.SortByNonce(),
 		check.CodeHashes(),
 		check.PaymasterDeposit(),
 		relayer.SendUserOperation(),
@@ -126,6 +133,7 @@ func PrivateMode() {
 		d = client.NewDebug(eoa, eth, mem, b, chain, conf.SupportedEntryPoints[0], beneficiary)
 		b.SetMaxBatch(1)
 		relayer.SetBannedThreshold(relay.NoBanThreshold)
+		relayer.SetWaitTimeout(0)
 	}
 
 	// Init HTTP server

internal/start/searcher.go

@@ -20,8 +20,10 @@ import (
 	"github.com/stackup-wallet/stackup-bundler/pkg/gas"
 	"github.com/stackup-wallet/stackup-bundler/pkg/jsonrpc"
 	"github.com/stackup-wallet/stackup-bundler/pkg/mempool"
+	"github.com/stackup-wallet/stackup-bundler/pkg/modules/batch"
 	"github.com/stackup-wallet/stackup-bundler/pkg/modules/builder"
 	"github.com/stackup-wallet/stackup-bundler/pkg/modules/checks"
+	"github.com/stackup-wallet/stackup-bundler/pkg/modules/gasprice"
 	"github.com/stackup-wallet/stackup-bundler/pkg/modules/paymaster"
 	"github.com/stackup-wallet/stackup-bundler/pkg/signer"
 )
@@ -101,8 +103,13 @@ func SearcherMode() {
 
 	// Init Bundler
 	b := bundler.New(mem, chain, conf.SupportedEntryPoints)
+	b.SetGetBaseFeeFunc(gasprice.GetBaseFeeWithEthClient(eth))
+	b.SetGetLegacyGasPriceFunc(gasprice.GetLegacyGasPriceWithEthClient(eth))
 	b.UseLogger(logr)
 	b.UseModules(
+		gasprice.SortByGasPrice(),
+		gasprice.FilterUnderpriced(),
+		batch.SortByNonce(),
 		check.CodeHashes(),
 		check.PaymasterDeposit(),
 		builder.SendUserOperation(),

internal/testutils/constants.go

@@ -13,6 +13,7 @@ var (
 	DefaultUnstakeDelaySec  = uint32(86400)
 	ValidAddress1           = common.HexToAddress("0x7357b8a705328FC283dF72D7Ac546895B596DC12")
 	ValidAddress2           = common.HexToAddress("0x7357c9504B8686c008CCcD6ea47f1c21B7475dE3")
+	ValidAddress3           = common.HexToAddress("0x7357C8D931e8cde8ea1b777Cf8578f4A7071f100")
 	ChainID                 = big.NewInt(1)
 	MaxOpsForUnstakedSender = 1
 	StakedDepositInfo       = &entrypoint.IStakeManagerDepositInfo{

internal/testutils/opmock.go

@@ -19,7 +19,7 @@ var (
 		"maxFeePerGas":         "0xa862145e",
 		"maxPriorityFeePerGas": "0xa8621440",
 		"paymasterAndData":     "0x",
-		"preVerificationGas":   "0xc650",
+		"preVerificationGas":   "0xc869",
 		"signature":            "0xa925dcc5e5131636e244d4405334c25f034ebdd85c0cb12e8cdb13c15249c2d466d0bade18e2cafd3513497f7f968dcbb63e519acd9b76dcae7acd61f11aa8421b",
 	}
 	MockByteCode = common.Hex2Bytes("6080604052")

pkg/gas/buffer.go renamed to internal/utils/buffer.go

@@ -1,8 +1,12 @@
-package gas
+package utils
 
 import "math/big"
 
-func addBuffer(amt *big.Int, factor int64) *big.Int {
+func AddBuffer(amt *big.Int, factor int64) *big.Int {
+	if amt == nil {
+		return nil
+	}
+
 	a := big.NewInt(0).Mul(amt, big.NewInt(1000+(factor*10)))
 	return big.NewInt(0).Div(a, big.NewInt(1000))
 }

internal/utils/buffer_test.go

@@ -0,0 +1,36 @@
+package utils_test
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/stackup-wallet/stackup-bundler/internal/utils"
+)
+
+// TestAddBuffer verifies that AddBuffer returns a new big.Int that is increased by a given percent value.
+func TestAddBuffer(t *testing.T) {
+	factor := int64(10)
+	amt := big.NewInt(10)
+	want := big.NewInt(11)
+	if utils.AddBuffer(amt, factor).Cmp(want) != 0 {
+		t.Fatalf("got %d, want %d", utils.AddBuffer(amt, factor).Int64(), want.Int64())
+	}
+}
+
+// TestAddBufferZeroFactor verifies that AddBuffer returns a new big.Int that is unchanged when the factor is
+// 0.
+func TestAddBufferZeroFactor(t *testing.T) {
+	factor := int64(0)
+	amt := big.NewInt(100)
+	if utils.AddBuffer(amt, factor).Cmp(amt) != 0 {
+		t.Fatalf("got %d, want %d", utils.AddBuffer(amt, factor).Int64(), amt.Int64())
+	}
+}
+
+// TestAddBufferNilAmt verifies that AddBuffer returns nil if amt is nil.
+func TestAddBufferNilAmt(t *testing.T) {
+	factor := int64(10)
+	if utils.AddBuffer(nil, factor) != nil {
+		t.Fatalf("got %d, want nil", utils.AddBuffer(nil, factor).Int64())
+	}
+}

pkg/bundler/bundler.go

@@ -10,6 +10,7 @@ import (
 	"github.com/stackup-wallet/stackup-bundler/internal/logger"
 	"github.com/stackup-wallet/stackup-bundler/pkg/mempool"
 	"github.com/stackup-wallet/stackup-bundler/pkg/modules"
+	"github.com/stackup-wallet/stackup-bundler/pkg/modules/gasprice"
 	"github.com/stackup-wallet/stackup-bundler/pkg/modules/noop"
 	"github.com/stackup-wallet/stackup-bundler/pkg/userop"
 )
@@ -23,10 +24,11 @@ type Bundler struct {
 	batchHandler         modules.BatchHandlerFunc
 	logger               logr.Logger
 	isRunning            bool
-	stop                 chan bool
-	watch                chan bool
-	onStop               func()
+	done                 chan bool
+	stop                 func()
 	maxBatch             int
+	gbf                  gasprice.GetBaseFeeFunc
+	ggp                  gasprice.GetLegacyGasPriceFunc
 }
 
 // New initializes a new EIP-4337 bundler which can be extended with modules for validating batches and
@@ -39,10 +41,11 @@ func New(mempool *mempool.Mempool, chainID *big.Int, supportedEntryPoints []comm
 		batchHandler:         noop.BatchHandler,
 		logger:               logger.NewZeroLogr().WithName("bundler"),
 		isRunning:            false,
-		stop:                 make(chan bool),
-		watch:                make(chan bool),
-		onStop:               func() {},
+		done:                 make(chan bool),
+		stop:                 func() {},
 		maxBatch:             0,
+		gbf:                  gasprice.NoopGetBaseFeeFunc(),
+		ggp:                  gasprice.NoopGetLegacyGasPriceFunc(),
 	}
 }
 
@@ -51,6 +54,17 @@ func (i *Bundler) SetMaxBatch(max int) {
 	i.maxBatch = max
 }
 
+// SetGetBaseFeeFunc defines the function used to retrieve an estimate for basefee during each bundler run.
+func (i *Bundler) SetGetBaseFeeFunc(gbf gasprice.GetBaseFeeFunc) {
+	i.gbf = gbf
+}
+
+// SetGetLegacyGasPriceFunc defines the function used to retrieve an estimate for gas price during each
+// bundler run.
+func (i *Bundler) SetGetLegacyGasPriceFunc(ggp gasprice.GetLegacyGasPriceFunc) {
+	i.ggp = ggp
+}
+
 // UseLogger defines the logger object used by the Bundler instance based on the go-logr/logr interface.
 func (i *Bundler) UseLogger(logger logr.Logger) {
 	i.logger = logger.WithName("bundler")
@@ -63,13 +77,30 @@ func (i *Bundler) UseModules(handlers ...modules.BatchHandlerFunc) {
 
 // Process will create a batch from the mempool and send it through to the EntryPoint.
 func (i *Bundler) Process(ep common.Address) (*modules.BatchHandlerCtx, error) {
+	// Init logger
 	start := time.Now()
 	l := i.logger.
 		WithName("run").
 		WithValues("entrypoint", ep.String()).
 		WithValues("chain_id", i.chainID.String())
 
-	batch, err := i.mempool.BundleOps(ep)
+	// Get current block basefee
+	bf, err := i.gbf()
+	if err != nil {
+		l.Error(err, "bundler run error")
+		return nil, err
+	}
+
+	// Get suggested gas price (for networks that don't support EIP-1559)
+	gp, err := i.ggp()
+	if err != nil {
+		l.Error(err, "bundler run error")
+		return nil, err
+	}
+
+	// Get all pending userOps from the mempool. This will be in FIFO order. Downstream modules should sort it
+	// based on more specific strategies.
+	batch, err := i.mempool.Dump(ep)
 	if err != nil {
 		l.Error(err, "bundler run error")
 		return nil, err
@@ -79,19 +110,22 @@ func (i *Bundler) Process(ep common.Address) (*modules.BatchHandlerCtx, error) {
 	}
 	batch = adjustBatchSize(i.maxBatch, batch)
 
-	ctx := modules.NewBatchHandlerContext(batch, ep, i.chainID)
+	// Create context and execute modules.
+	ctx := modules.NewBatchHandlerContext(batch, ep, i.chainID, bf, gp)
 	if err := i.batchHandler(ctx); err != nil {
 		l.Error(err, "bundler run error")
 		return nil, err
 	}
 
+	// Remove userOps that remain in the context from mempool.
 	rmOps := append([]*userop.UserOperation{}, ctx.Batch...)
 	rmOps = append(rmOps, ctx.PendingRemoval...)
 	if err := i.mempool.RemoveOps(ep, rmOps...); err != nil {
 		l.Error(err, "bundler run error")
 		return nil, err
 	}
 
+	// Update logs for the current run.
 	bat := []string{}
 	for _, op := range ctx.Batch {
 		bat = append(bat, op.GetUserOpHash(ep, i.chainID).String())
@@ -118,12 +152,13 @@ func (i *Bundler) Run() error {
 		return nil
 	}
 
+	ticker := time.NewTicker(1 * time.Second)
 	go func(i *Bundler) {
 		for {
 			select {
-			case <-i.stop:
+			case <-i.done:
 				return
-			case <-i.watch:
+			case <-ticker.C:
 				for _, ep := range i.supportedEntryPoints {
 					_, err := i.Process(ep)
 					if err != nil {
@@ -136,7 +171,7 @@ func (i *Bundler) Run() error {
 	}(i)
 
 	i.isRunning = true
-	i.onStop = i.mempool.OnAdd(i.watch)
+	i.stop = ticker.Stop
 	return nil
 }
 
@@ -147,6 +182,6 @@ func (i *Bundler) Stop() {
 	}
 
 	i.isRunning = false
-	i.stop <- true
-	i.onStop()
+	i.stop()
+	i.done <- true
 }

pkg/entrypoint/transaction/gas.go

@@ -0,0 +1,65 @@
+package transaction
+
+import (
+	"context"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/stackup-wallet/stackup-bundler/pkg/userop"
+)
+
+// SuggestMeanGasTipCap suggests a Max Priority Fee for an EIP-1559 transaction to submit a batch of
+// UserOperations to the EntryPoint. It returns the larger value between the gas tip suggested by the
+// underlying node (i.e. eth_maxPriorityFeePerGas) or the average maxPriorityFeePerGas of the entire batch.
+func SuggestMeanGasTipCap(eth *ethclient.Client, batch []*userop.UserOperation) (*big.Int, error) {
+	tip, err := eth.SuggestGasTipCap(context.Background())
+	if err != nil {
+		return nil, err
+	}
+
+	sum := big.NewInt(0)
+	for _, op := range batch {
+		sum = big.NewInt(0).Add(sum, op.MaxPriorityFeePerGas)
+	}
+	avg := big.NewInt(0).Div(sum, big.NewInt(int64(len(batch))))
+
+	if avg.Cmp(tip) == 1 {
+		return avg, nil
+	}
+	return tip, nil
+}
+
+// SuggestMeanGasFeeCap suggests a Max Fee for an EIP-1559 transaction to submit a batch of UserOperations to
+// the EntryPoint. It returns the larger value between the recommended max fee or the average maxFeePerGas of
+// the entire batch.
+func SuggestMeanGasFeeCap(basefee *big.Int, batch []*userop.UserOperation) *big.Int {
+	mf := big.NewInt(0).Mul(basefee, common.Big2)
+
+	sum := big.NewInt(0)
+	for _, op := range batch {
+		sum = big.NewInt(0).Add(sum, op.MaxFeePerGas)
+	}
+	avg := big.NewInt(0).Div(sum, big.NewInt(int64(len(batch))))
+
+	if avg.Cmp(mf) == 1 {
+		return avg
+	}
+	return mf
+}
+
+// SuggestMeanGasPrice suggests a Gas Price for a legacy transaction to submit a batch of UserOperations to
+// the EntryPoint. It returns the larger value between a given gas price or the average maxFeePerGas of the
+// entire batch.
+func SuggestMeanGasPrice(gasPrice *big.Int, batch []*userop.UserOperation) *big.Int {
+	sum := big.NewInt(0)
+	for _, op := range batch {
+		sum = big.NewInt(0).Add(sum, op.MaxFeePerGas)
+	}
+	avg := big.NewInt(0).Div(sum, big.NewInt(int64(len(batch))))
+
+	if avg.Cmp(gasPrice) == 1 {
+		return avg
+	}
+	return gasPrice
+}