FreeClaimGasLimit as a config param

cmd/run.go

@@ -99,13 +99,13 @@ func start(cliCtx *cli.Context) error {
 			go runAggregator(ctx, c.Aggregator, etherman, ethTxManager, st)
 		case SEQUENCER:
 			log.Info("Running sequencer")
-			poolInstance := createPool(c.PoolDB, c.NetworkConfig.L2BridgeAddr, l2ChainID, st)
+			poolInstance := createPool(c.Pool, c.NetworkConfig.L2BridgeAddr, l2ChainID, st)
 			gpe := createGasPriceEstimator(c.GasPriceEstimator, st, poolInstance)
 			seq := createSequencer(*c, poolInstance, st, etherman, ethTxManager, gpe)
 			go seq.Start(ctx)
 		case RPC:
 			log.Info("Running JSON-RPC server")
-			poolInstance := createPool(c.PoolDB, c.NetworkConfig.L2BridgeAddr, l2ChainID, st)
+			poolInstance := createPool(c.Pool, c.NetworkConfig.L2BridgeAddr, l2ChainID, st)
 			gpe := createGasPriceEstimator(c.GasPriceEstimator, st, poolInstance)
 			apis := map[string]bool{}
 			for _, a := range cliCtx.StringSlice(config.FlagHTTPAPI) {
@@ -304,13 +304,13 @@ func newState(ctx context.Context, c *config.Config, l2ChainID uint64, sqlDB *pg
 	return st
 }
 
-func createPool(poolDBConfig db.Config, l2BridgeAddr common.Address, l2ChainID uint64, st *state.State) *pool.Pool {
-	runPoolMigrations(poolDBConfig)
-	poolStorage, err := pgpoolstorage.NewPostgresPoolStorage(poolDBConfig)
+func createPool(cfgPool pool.Config, l2BridgeAddr common.Address, l2ChainID uint64, st *state.State) *pool.Pool {
+	runPoolMigrations(cfgPool.DB)
+	poolStorage, err := pgpoolstorage.NewPostgresPoolStorage(cfgPool.DB)
 	if err != nil {
 		log.Fatal(err)
 	}
-	poolInstance := pool.NewPool(poolStorage, st, l2BridgeAddr, l2ChainID)
+	poolInstance := pool.NewPool(cfgPool, poolStorage, st, l2BridgeAddr, l2ChainID)
 	return poolInstance
 }
 

config/config.go

@@ -14,6 +14,7 @@ import (
 	"github.com/0xPolygonHermez/zkevm-node/log"
 	"github.com/0xPolygonHermez/zkevm-node/merkletree"
 	"github.com/0xPolygonHermez/zkevm-node/metrics"
+	"github.com/0xPolygonHermez/zkevm-node/pool"
 	"github.com/0xPolygonHermez/zkevm-node/pricegetter"
 	"github.com/0xPolygonHermez/zkevm-node/sequencer"
 	"github.com/0xPolygonHermez/zkevm-node/sequencer/broadcast"
@@ -49,6 +50,7 @@ type Config struct {
 	Log                log.Config
 	Etherman           etherman.Config
 	EthTxManager       ethtxmanager.Config
+	Pool               pool.Config
 	RPC                jsonrpc.Config
 	Synchronizer       synchronizer.Config
 	Sequencer          sequencer.Config
@@ -60,7 +62,6 @@ type Config struct {
 	BroadcastServer    broadcast.ServerConfig
 	MTClient           merkletree.Config
 	StateDB            db.Config
-	PoolDB             db.Config
 	Metrics            metrics.Config
 }
 

config/default.go

@@ -18,14 +18,16 @@ Port = "5432"
 EnableLog = false
 MaxConns = 200
 
-[PoolDB]
-User = "pool_user"
-Password = "pool_password"
-Name = "pool_db"
-Host = "localhost"
-Port = "5432"
-EnableLog = false
-MaxConns = 200
+[Pool]
+FreeClaimGasLimit = 150000
+	[Pool.DB]
+	User = "pool_user"
+	Password = "pool_password"
+	Name = "pool_db"
+	Host = "localhost"
+	Port = "5432"
+	EnableLog = false
+	MaxConns = 200
 
 [Etherman]
 URL = "http://localhost:8545"

config/environments/local/local.node.config.toml

@@ -14,14 +14,16 @@ Port = "5432"
 EnableLog = false
 MaxConns = 200
 
-[PoolDB]
-User = "pool_user"
-Password = "pool_password"
-Name = "pool_db"
-Host = "zkevm-pool-db"
-Port = "5432"
-EnableLog = false
-MaxConns = 200
+[Pool]
+FreeClaimGasLimit = 150000
+	[Pool.DB]
+	User = "pool_user"
+	Password = "pool_password"
+	Name = "pool_db"
+	Host = "zkevm-pool-db"
+	Port = "5432"
+	EnableLog = false
+	MaxConns = 200
 
 [Etherman]
 URL = "http://your.L1node.url"

config/environments/public/public.node.config.toml

@@ -12,14 +12,16 @@ Port = "5432"
 EnableLog = false
 MaxConns = 200
 
-[PoolDB]
-User = "pool_user"
-Password = "pool_password"
-Name = "pool_db"
-Host = "zkevm-pool-db"
-Port = "5432"
-EnableLog = false
-MaxConns = 200
+[Pool]
+FreeClaimGasLimit = 150000
+	[Pool.DB]
+	User = "pool_user"
+	Password = "pool_password"
+	Name = "pool_db"
+	Host = "zkevm-pool-db"
+	Port = "5432"
+	EnableLog = false
+	MaxConns = 200
 
 [Etherman]
 URL = "http://your.L1node.url"

pool/config.go

@@ -0,0 +1,9 @@
+package pool
+
+import 	"github.com/0xPolygonHermez/zkevm-node/db"
+
+type Config struct {
+	// FreeClaimGasLimit is the max gas allowed use to do a free claim
+	FreeClaimGasLimit uint64    `mapstructure:"FreeClaimGasLimit"`
+	DB                db.Config `mapstructure:"DB"`
+}

pool/pool.go

@@ -47,11 +47,13 @@ type Pool struct {
 	state        stateInterface
 	l2BridgeAddr common.Address
 	chainID      uint64
+	cfg          Config
 }
 
 // NewPool creates and initializes an instance of Pool
-func NewPool(s storage, st stateInterface, l2BridgeAddr common.Address, chainID uint64) *Pool {
+func NewPool(cfg Config, s storage, st stateInterface, l2BridgeAddr common.Address, chainID uint64) *Pool {
 	return &Pool{
+		cfg:          cfg,
 		storage:      s,
 		state:        st,
 		l2BridgeAddr: l2BridgeAddr,
@@ -72,7 +74,7 @@ func (p *Pool) AddTx(ctx context.Context, tx types.Transaction) error {
 		ReceivedAt:  time.Now(),
 	}
 
-	poolTx.IsClaims = poolTx.IsClaimTx(p.l2BridgeAddr)
+	poolTx.IsClaims = poolTx.IsClaimTx(p.l2BridgeAddr, p.cfg.FreeClaimGasLimit)
 
 	return p.storage.AddTx(ctx, poolTx)
 }

pool/pool_test.go

@@ -106,7 +106,10 @@ func Test_AddTx(t *testing.T) {
 	}
 
 	const chainID = 2576980377
-	p := pool.NewPool(s, st, common.Address{}, chainID)
+	cfg := pool.Config {
+		FreeClaimGasLimit: 150000,
+	}
+	p := pool.NewPool(cfg, s, st, common.Address{}, chainID)
 
 	txRLPHash := "0xf86e8212658082520894fd8b27a263e19f0e9592180e61f0f8c9dfeb1ff6880de0b6b3a764000080850133333355a01eac4c2defc7ed767ae36bbd02613c581b8fb87d0e4f579c9ee3a7cfdb16faa7a043ce30f43d952b9d034cf8f04fecb631192a5dbc7ee2a47f1f49c0d022a8849d"
 	b, err := hex.DecodeHex(txRLPHash)
@@ -175,7 +178,10 @@ func Test_GetPendingTxs(t *testing.T) {
 		t.Error(err)
 	}
 
-	p := pool.NewPool(s, st, common.Address{}, chainID.Uint64())
+	cfg := pool.Config {
+		FreeClaimGasLimit: 150000,
+	}
+	p := pool.NewPool(cfg, s, st, common.Address{}, chainID.Uint64())
 
 	const txsCount = 10
 	const limit = 5
@@ -236,8 +242,10 @@ func Test_GetPendingTxsZeroPassed(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	}
-
-	p := pool.NewPool(s, st, common.Address{}, chainID.Uint64())
+	cfg := pool.Config {
+		FreeClaimGasLimit: 150000,
+	}
+	p := pool.NewPool(cfg, s, st, common.Address{}, chainID.Uint64())
 
 	const txsCount = 10
 	const limit = 0
@@ -298,8 +306,10 @@ func Test_GetTopPendingTxByProfitabilityAndZkCounters(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	}
-
-	p := pool.NewPool(s, st, common.Address{}, chainID.Uint64())
+	cfg := pool.Config {
+		FreeClaimGasLimit: 150000,
+	}
+	p := pool.NewPool(cfg, s, st, common.Address{}, chainID.Uint64())
 
 	const txsCount = 10
 
@@ -353,8 +363,10 @@ func Test_GetTopFailedTxsByProfitabilityAndZkCounters(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	}
-
-	p := pool.NewPool(s, st, common.Address{}, chainID.Uint64())
+	cfg := pool.Config {
+		FreeClaimGasLimit: 150000,
+	}
+	p := pool.NewPool(cfg, s, st, common.Address{}, chainID.Uint64())
 
 	const txsCount = 10
 
@@ -421,8 +433,10 @@ func Test_UpdateTxsStatus(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	}
-
-	p := pool.NewPool(s, st, common.Address{}, chainID.Uint64())
+	cfg := pool.Config {
+		FreeClaimGasLimit: 150000,
+	}
+	p := pool.NewPool(cfg, s, st, common.Address{}, chainID.Uint64())
 
 	privateKey, err := crypto.HexToECDSA(strings.TrimPrefix(senderPrivateKey, "0x"))
 	require.NoError(t, err)
@@ -492,8 +506,10 @@ func Test_UpdateTxStatus(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	}
-
-	p := pool.NewPool(s, st, common.Address{}, chainID.Uint64())
+	cfg := pool.Config {
+		FreeClaimGasLimit: 150000,
+	}
+	p := pool.NewPool(cfg, s, st, common.Address{}, chainID.Uint64())
 
 	privateKey, err := crypto.HexToECDSA(strings.TrimPrefix(senderPrivateKey, "0x"))
 	require.NoError(t, err)
@@ -535,8 +551,10 @@ func Test_SetAndGetGasPrice(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	}
-
-	p := pool.NewPool(s, nil, common.Address{}, chainID.Uint64())
+	cfg := pool.Config {
+		FreeClaimGasLimit: 150000,
+	}
+	p := pool.NewPool(cfg, s, nil, common.Address{}, chainID.Uint64())
 
 	nBig, err := rand.Int(rand.Reader, big.NewInt(0).SetUint64(math.MaxUint64))
 	if err != nil {
@@ -586,8 +604,10 @@ func TestMarkReorgedTxsAsPending(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	}
-
-	p := pool.NewPool(s, st, common.Address{}, chainID.Uint64())
+	cfg := pool.Config {
+		FreeClaimGasLimit: 150000,
+	}
+	p := pool.NewPool(cfg, s, st, common.Address{}, chainID.Uint64())
 
 	privateKey, err := crypto.HexToECDSA(strings.TrimPrefix(senderPrivateKey, "0x"))
 	require.NoError(t, err)
@@ -650,8 +670,10 @@ func TestGetPendingTxSince(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	}
-
-	p := pool.NewPool(s, st, common.Address{}, chainID.Uint64())
+	cfg := pool.Config {
+		FreeClaimGasLimit: 150000,
+	}
+	p := pool.NewPool(cfg, s, st, common.Address{}, chainID.Uint64())
 
 	const txsCount = 10
 
@@ -753,8 +775,10 @@ func Test_DeleteTxsByHashes(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	}
-
-	p := pool.NewPool(s, st, common.Address{}, chainID.Uint64())
+	cfg := pool.Config {
+		FreeClaimGasLimit: 150000,
+	}
+	p := pool.NewPool(cfg, s, st, common.Address{}, chainID.Uint64())
 
 	privateKey, err := crypto.HexToECDSA(strings.TrimPrefix(senderPrivateKey, "0x"))
 	require.NoError(t, err)
@@ -907,11 +931,13 @@ func Test_TryAddIncompatibleTxs(t *testing.T) {
 			expectedError: fmt.Errorf("chain id higher than allowed, max allowed is %v", uint64(math.MaxUint64)),
 		},
 	}
-
+	cfg := pool.Config {
+		FreeClaimGasLimit: 150000,
+	}
 	for _, testCase := range testCases {
 		t.Run(testCase.name, func(t *testing.T) {
 			incompatibleTx := testCase.createIncompatibleTx()
-			p := pool.NewPool(s, st, common.Address{}, incompatibleTx.ChainId().Uint64())
+			p := pool.NewPool(cfg, s, st, common.Address{}, incompatibleTx.ChainId().Uint64())
 			err = p.AddTx(ctx, incompatibleTx)
 			assert.Equal(t, testCase.expectedError, err)
 		})

pool/transaction.go

@@ -17,9 +17,6 @@ const (
 	TxStatusSelected TxStatus = "selected"
 	// TxStatusFailed represents a tx that has been failed after processing, but can be processed in the future
 	TxStatusFailed TxStatus = "failed"
-
-	// freeClaimGasLimit is the max gas allowed use to do a free claim
-	freeClaimGasLimit uint64 = 150000
 )
 
 // TxStatus represents the state of a tx
@@ -77,7 +74,7 @@ func (zkc *ZkCounters) SumUpZkCounters(txZkCounters ZkCounters) {
 }
 
 // IsClaimTx checks, if tx is a claim tx
-func (tx *Transaction) IsClaimTx(l2BridgeAddr common.Address) bool {
+func (tx *Transaction) IsClaimTx(l2BridgeAddr common.Address, freeClaimGasLimit uint64) bool {
 	if tx.To() == nil {
 		return false
 	}

pool/transaction_test.go

@@ -72,10 +72,10 @@ func Test_IsClaimTx(t *testing.T) {
 			expectedResult: true,
 		},
 	}
-
+	const freeClaimGasLimit uint64 = 150000
 	for _, testCase := range testCases {
 		t.Run(testCase.Name, func(t *testing.T) {
-			result := testCase.Tx.IsClaimTx(l2BridgeAddr)
+			result := testCase.Tx.IsClaimTx(l2BridgeAddr, freeClaimGasLimit)
 			if result != testCase.expectedResult {
 				t.Errorf("Invalid result, expected: %v, found: %v", testCase.expectedResult, result)
 			}

sequencer/pendingtxsqueue_test.go

@@ -79,8 +79,10 @@ func TestQueue_AddAndPopTx(t *testing.T) {
 	if err != nil {
 		panic(err)
 	}
-
-	p := pool.NewPool(s, st, common.Address{}, chainID.Uint64())
+	cfgPool := pool.Config {
+		FreeClaimGasLimit: 150000,
+	}
+	p := pool.NewPool(cfgPool, s, st, common.Address{}, chainID.Uint64())
 
 	const txsCount = 10
 
@@ -156,8 +158,10 @@ func TestQueue_AddOneTx(t *testing.T) {
 	if err != nil {
 		panic(err)
 	}
-
-	p := pool.NewPool(s, st, common.Address{}, chainID.Uint64())
+	cfgPool := pool.Config {
+		FreeClaimGasLimit: 150000,
+	}
+	p := pool.NewPool(cfgPool, s, st, common.Address{}, chainID.Uint64())
 
 	const txsCount = 1
 

test/benchmarks/sequencer/pool_processing_test.go

@@ -185,7 +185,10 @@ func setup(ctx context.Context, b *testing.B) (*operations.Manager, *ethclient.C
 	st := opsman.State()
 	s, err := pgpoolstorage.NewPostgresPoolStorage(poolDbConfig)
 	require.NoError(b, err)
-	pl := pool.NewPool(s, st, common.Address{}, chainID)
+	cfg := pool.Config {
+		FreeClaimGasLimit: 150000,
+	}
+	pl := pool.NewPool(cfg, s, st, common.Address{}, chainID)
 
 	// Print Info before send
 	senderBalance, err := client.BalanceAt(ctx, auth.From, nil)