gas offset

claimtxman/claimtxman.go

@@ -66,7 +66,7 @@ func NewClaimTxManager(ctx context.Context, cfg Config, chExitRootEvent chan *et
 	var monitorTx ctmtypes.TxMonitorer
 	if cfg.GroupingClaims.Enabled {
 		log.Info("ClaimTxManager working in compressor mode to group claim txs")
-		monitorTx = NewMonitorCompressedTxs(ctx, storage.(StorageCompressedInterface), client, cfg, nonceCache, auth, etherMan, utils.NewTimeProviderSystemLocalTime())
+		monitorTx = NewMonitorCompressedTxs(ctx, storage.(StorageCompressedInterface), client, cfg, nonceCache, auth, etherMan, utils.NewTimeProviderSystemLocalTime(), cfg.GroupingClaims.GasOffset)
 	} else {
 		log.Info("ClaimTxManager working in regular mode to send claim txs individually")
 		monitorTx = NewMonitorTxs(ctx, storage.(StorageInterface), client, cfg, nonceCache, auth)

claimtxman/compose_compress_claim.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"math/big"
 	"slices"
-	"strings"
 
 	ctmtypes "github.com/0xPolygonHermez/zkevm-bridge-service/claimtxman/types"
 	"github.com/0xPolygonHermez/zkevm-bridge-service/etherman/smartcontracts/claimcompressor"
@@ -44,13 +43,13 @@ type bridgeClaimXParams struct {
 }
 
 type ComposeCompressClaim struct {
-	smcAbi              abi.ABI
+	bridgeContractABI   *abi.ABI
 	methodClaimAssets   abi.Method
 	methodClaimMessages abi.Method
 }
 
 func NewComposeCompressClaim() (*ComposeCompressClaim, error) {
-	smcAbi, err := abi.JSON(strings.NewReader(polygonzkevmbridge.PolygonzkevmbridgeABI))
+	smcAbi, err := polygonzkevmbridge.PolygonzkevmbridgeMetaData.GetAbi()
 	if err != nil {
 		return nil, errors.New("fails to read abi fom Bridge contract")
 	}
@@ -63,7 +62,7 @@ func NewComposeCompressClaim() (*ComposeCompressClaim, error) {
 		return nil, errors.New("method claimMessages not found")
 	}
 	return &ComposeCompressClaim{
-		smcAbi:              smcAbi,
+		bridgeContractABI:   smcAbi,
 		methodClaimAssets:   methodClaimAssets,
 		methodClaimMessages: methodClaimMessages,
 	}, nil
@@ -129,7 +128,7 @@ func (c *ComposeCompressClaim) extractParams(data []byte) (*bridgeClaimXParams,
 }
 func (c *ComposeCompressClaim) extractParamsClaimX(data []byte) (*bridgeClaimXParams, error) {
 	// do something
-	method, err := c.smcAbi.MethodById(data[:4])
+	method, err := c.bridgeContractABI.MethodById(data[:4])
 	if err != nil {
 		return nil, fmt.Errorf("extracting params, getting method err: %w ", err)
 	}

claimtxman/config.go

@@ -42,4 +42,6 @@ type ConfigGroupingClaims struct {
 	RetryInterval types.Duration `mapstructure:"RetryInterval"`
 	// RetryTimeout is the maximum time to wait for a claim tx to be mined
 	RetryTimeout types.Duration `mapstructure:"RetryTimeout"`
+	// GasOffset is the offset for the gas estimation
+	GasOffset uint64 `mapstructure:"GasOffset"`
 }

claimtxman/monitor_compressed_txs.go

@@ -34,7 +34,7 @@ type StorageCompressedInterface interface {
 
 type EthermanI interface {
 	CompressClaimCall(mainnetExitRoot, rollupExitRoot common.Hash, claimData []claimcompressor.ClaimCompressorCompressClaimCallData) ([]byte, error)
-	SendCompressedClaims(auth *bind.TransactOpts, compressedTxData []byte) (common.Hash, error)
+	SendCompressedClaims(auth *bind.TransactOpts, compressedTxData []byte) (*types.Transaction, error)
 }
 type MonitorCompressedTxs struct {
 	storage StorageCompressedInterface
@@ -48,6 +48,7 @@ type MonitorCompressedTxs struct {
 	compressClaimComposer *ComposeCompressClaim
 	timeProvider          utils.TimeProvider
 	triggerGroups         *GroupsTrigger
+	gasOffset             uint64
 }
 
 func NewMonitorCompressedTxs(ctx context.Context,
@@ -57,7 +58,8 @@ func NewMonitorCompressedTxs(ctx context.Context,
 	nonceCache *NonceCache,
 	auth *bind.TransactOpts,
 	etherMan EthermanI,
-	timeProvider utils.TimeProvider) *MonitorCompressedTxs {
+	timeProvider utils.TimeProvider,
+	gasOffset uint64) *MonitorCompressedTxs {
 	composer, err := NewComposeCompressClaim()
 	if err != nil {
 		log.Fatal("failed to create ComposeCompressClaim: %v", err)
@@ -73,6 +75,7 @@ func NewMonitorCompressedTxs(ctx context.Context,
 		compressClaimComposer: composer,
 		timeProvider:          timeProvider,
 		triggerGroups:         NewGroupsTrigger(cfg.GroupingClaims),
+		gasOffset:             gasOffset,
 	}
 }
 
@@ -317,17 +320,31 @@ func (tm *MonitorCompressedTxs) SendClaims(pendingTx *PendingTxs, onlyFirstOne b
 			continue
 		}
 
+		// Estimating Gas
+		auth := *tm.auth
+		auth.NoSend = true
+		estimatedTx, err := tm.etherMan.SendCompressedClaims(tm.auth, group.DbEntry.CompressedTxData)
+		if err != nil {
+			msg := fmt.Sprintf("failed to call SMC SendCompressedClaims for group %d: %v", group.DbEntry.GroupID, err)
+			log.Warn(msg)
+			group.DbEntry.LastLog = msg
+			continue
+		}
+		auth.NoSend = false
+		log.Debug("GAS: ", estimatedTx.Gas())
+		auth.GasLimit = estimatedTx.Gas() + tm.gasOffset
+		log.Debug("New GAS: ", auth.GasLimit)
 		// Send claim tx
-		txHash, err := tm.etherMan.SendCompressedClaims(tm.auth, group.DbEntry.CompressedTxData)
+		tx, err := tm.etherMan.SendCompressedClaims(tm.auth, group.DbEntry.CompressedTxData)
 		if err != nil {
 			msg := fmt.Sprintf("failed to call SMC SendCompressedClaims for group %d: %v", group.DbEntry.GroupID, err)
 			log.Warn(msg)
 			group.DbEntry.LastLog = msg
 			continue
 		}
-		log.Infof("send claim tx try: %d for group_id:%d  deposits_id:%s txHash:%s", group.DbEntry.NumRetries, group.DbEntry.GroupID, group.GetTxsDepositIDString(), txHash.String())
+		log.Infof("Send claim tx try: %d for group_id:%d  deposits_id:%s txHash:%s", group.DbEntry.NumRetries, group.DbEntry.GroupID, group.GetTxsDepositIDString(), tx.Hash().String())
 		group.DbEntry.Status = ctmtypes.MonitoredTxGroupStatusClaiming
-		group.DbEntry.AddPendingTx(txHash)
+		group.DbEntry.AddPendingTx(tx.Hash())
 		group.DbEntry.NumRetries++
 	}
 	return nil

config/config.debug.toml

@@ -27,6 +27,7 @@ AuthorizedClaimMessageAddresses = ["0x90F79bf6EB2c4f870365E785982E1f101E93b906"]
     RetryInterval = "10s"
     RetryTimeout = "30s"
     FrequencyToProcessCompressedClaims = "1m"
+    GasOffset = 100000
 
 [Etherman]
 L1URL = "http://localhost:8545"

config/config.local.toml

@@ -27,6 +27,7 @@ AuthorizedClaimMessageAddresses = ["0x90F79bf6EB2c4f870365E785982E1f101E93b906"]
     RetryInterval = "10s"
     RetryTimeout = "30s"
     FrequencyToProcessCompressedClaims = "1m"
+    GasOffset = 100000
 
 [Etherman]
 L1URL = "http://zkevm-mock-l1-network:8545"

config/default.go

@@ -38,6 +38,7 @@ AuthorizedClaimMessageAddresses = []
     MaxRetries = 2
     RetryInterval = "10s"
     RetryTimeout = "30s"
+    GasOffset = 0
 
 
 [Etherman]

etherman/etherman.go

@@ -765,13 +765,13 @@ func (etherMan *Client) AddExistingRollupEvent(ctx context.Context, vLog types.L
 	return nil
 }
 
-func (etherMan *Client) SendCompressedClaims(auth *bind.TransactOpts, compressedTxData []byte) (common.Hash, error) {
+func (etherMan *Client) SendCompressedClaims(auth *bind.TransactOpts, compressedTxData []byte) (*types.Transaction, error) {
 	claimTx, err := etherMan.ClaimCompressor.SendCompressedClaims(auth, compressedTxData)
 	if err != nil {
 		log.Error("failed to call SMC SendCompressedClaims: %v", err)
-		return common.Hash{}, err
+		return nil, err
 	}
-	return claimTx.Hash(), err
+	return claimTx, err
 }
 
 func (etherMan *Client) CompressClaimCall(mainnetExitRoot, rollupExitRoot common.Hash, claimData []claimcompressor.ClaimCompressorCompressClaimCallData) ([]byte, error) {

utils/client.go

@@ -168,7 +168,7 @@ func (c *Client) SendBridgeAsset(ctx context.Context, tokenAddr common.Address,
 	}
 	tx, err := c.Bridge.BridgeAsset(auth, destNetwork, *destAddr, amount, tokenAddr, true, metadata)
 	if err != nil {
-		log.Error("Error: ", err)
+		log.Error("error sending deposit. Error: ", err)
 		return err
 	}
 	// wait transfer to be included in a batch