+dynamic_gas_unit_add_percentage flag

docs/bridge/docs/06-Services/04-Submitter.md

@@ -59,6 +59,9 @@ submitter_config:
       dynamic_gas_estimate: true
       # SupportsEIP1559 is whether or not this chain supports EIP1559.
       supports_eip_1559: true
+      # DynamicGasUnitAddPercentage - increase gas unit limit (ie: "gas" field on a typical tx) by X% from what dynamic gas estimate returns
+      # Has no effect if dynamic gas estimation is not also enabled.
+      dynamic_gas_unit_add_percentage: 5
     43114:
       max_gas_price: 100000000000 # 100 Gwei
     10:

ethergo/submitter/config/config.go

@@ -49,6 +49,9 @@
 	DynamicGasEstimate bool `yaml:"dynamic_gas_estimate"`
 	// SupportsEIP1559 is whether or not this chain supports EIP1559
 	SupportsEIP1559 bool `yaml:"supports_eip_1559"`
+	// DynamicGasUnitAddPercentage - increase gas unit limit (ie: "gas" field on a typical tx) by X% from what dynamic gas estimate returns
+	// Has no effect if dynamic gas estimation is not also enabled.
+	DynamicGasUnitAddPercentage int `yaml:"dynamic_gas_unit_add_percentage"`
 }
 
 const (
@@ -64,6 +67,9 @@
 
 	// DefaultGasEstimate is the default gas estimate to use for transactions.
 	DefaultGasEstimate = uint64(1200000)
+
+	// DefaultDynamicGasUnitAddPercentage is the default percentage to bump the gas limit by.
+	DefaultDynamicGasUnitAddPercentage = 5
 )
 
 // DefaultMaxPrice is the default max price of a tx.
@@ -188,19 +194,37 @@
 	return gasBumpPercentage
 }
 
+// GetDynamicGasUnitAddPercentage returns the percentage to bump the gas limit by
+func (c *Config) GetDynamicGasUnitAddPercentage(chainID int) (dynamicGasUnitAddPercentage int) {
+	chainConfig, ok := c.Chains[chainID]
+	if ok {
+		dynamicGasUnitAddPercentage = chainConfig.DynamicGasUnitAddPercentage
+	}
+	// if dynamicGasUnitAddPercentage is not set for the chain, use the global config
+	if dynamicGasUnitAddPercentage == 0 {
+		dynamicGasUnitAddPercentage = c.DynamicGasUnitAddPercentage
+	}
+
+	// if the dynamicGasUnitAddPercentage isn't set at all, use the default
+	if dynamicGasUnitAddPercentage == 0 {
+		dynamicGasUnitAddPercentage = DefaultDynamicGasUnitAddPercentage
+	}
+	return dynamicGasUnitAddPercentage
+}
+
 // GetGasEstimate returns the gas estimate to use for transactions
 // TODO: test this method.
 func (c *Config) GetGasEstimate(chainID int) (gasEstimate uint64) {
 	chainConfig, ok := c.Chains[chainID]
 	if ok {
 		gasEstimate = chainConfig.GasEstimate
 	}
-	// if gasBumpPercentage is not set for the chain, use the global config
+	// if gasEstimate is not set for the chain, use the global config
 	if gasEstimate == 0 {
 		gasEstimate = c.GasEstimate
 	}
 
-	// if the gasBumpPercentage isn't set at all, use the default
+	// if the gasEstimate isn't set at all, use the default
 	if gasEstimate == 0 {
 		gasEstimate = DefaultGasEstimate
 	}

ethergo/submitter/config/config_test.go

@@ -77,13 +77,15 @@ gas_bump_percentage: 10
 gas_estimate: 1000
 is_l2: true
 dynamic_gas_estimate: true
+dynamic_gas_unit_add_percentage: 20
 supports_eip_1559: true`
 	var cfg config.Config
 	err := yaml.Unmarshal([]byte(cfgStr), &cfg)
 	assert.NoError(t, err)
 	assert.Equal(t, big.NewInt(250000000000), cfg.MaxGasPrice)
 	assert.Equal(t, 60, cfg.BumpIntervalSeconds)
 	assert.Equal(t, 10, cfg.GasBumpPercentage)
+	assert.Equal(t, 20, cfg.DynamicGasUnitAddPercentage)
 	assert.Equal(t, uint64(1000), cfg.GasEstimate)
 	assert.Equal(t, true, cfg.DynamicGasEstimate)
 	assert.Equal(t, true, cfg.SupportsEIP1559(0))

ethergo/submitter/submitter.go

@@ -388,13 +388,13 @@
 	// this also prevents a bug in the caller from breaking our lock
 	transactor.Nonce = new(big.Int).Add(new(big.Int).SetUint64(math.MaxUint64), big.NewInt(1))
 
+	//tmpdebug
+	fmt.Printf("SubmitTransaction>setGasPrice\n")
+
 	err = t.setGasPrice(ctx, chainClient, transactor, chainID, nil)
 	if err != nil {
 		span.AddEvent("could not set gas price", trace.WithAttributes(attribute.String("error", err.Error())))
 	}
-	if !t.config.GetDynamicGasEstimate(int(chainID.Uint64())) {
-		transactor.GasLimit = t.config.GetGasEstimate(int(chainID.Uint64()))
-	}
 
 	transactor.Signer = func(address common.Address, transaction *types.Transaction) (_ *types.Transaction, err error) {
 		locker = t.nonceMux.Lock(chainID)
@@ -421,12 +421,60 @@
 		//nolint: wrapcheck
 		return parentTransactor.Signer(address, transaction)
 	}
+
+	//tmpdebug
+	fmt.Printf("test ver 7\n")
+
+	// if dynamic gas estimation is not enabled, use cfg var gas_estimate as a gas limit default and do not run a pre-flight simulation
+	// since we do not need it to determine proper gas units
+	if !t.config.GetDynamicGasEstimate(int(chainID.Uint64())) {
+
+		//tmpdebug
+		fmt.Printf("Using Default \n")
+
+		transactor.GasLimit = t.config.GetGasEstimate(int(chainID.Uint64()))
+	} else {
+
+		// //tmpdebug
+		// fmt.Printf("SubmitTransaction>forGasEst call \n")
+
+		// transactor_forGasEstimate := copyTransactOpts(transactor)
+
+		// transactor_forGasEstimate.Nonce.Add(transactor_forGasEstimate.Nonce, big.NewInt(1))
+
+		// tx_forGasEstimate, err := call(transactor_forGasEstimate)
+		// if err != nil {
+		// 	return 0, fmt.Errorf("err contract call for gas est: %w", err)
+		// }
+
+		// fmt.Printf("tx_forGasEstimate: %v\n", tx_forGasEstimate.Gas())
+
+		//transactor.GasLimit = tx_forGasEstimate.Gas() + 555
+
+		// if arbitrum, spoof some low gas units to induce bump tests
+		if chainID.Uint64() == 10 {
+			transactor.GasLimit = 0
+		} else if chainID.Uint64() == 42161 {
+			transactor.GasLimit = 200000
+		}
+	}
+
+	//tmpdebug
+	fmt.Printf("transactor.GasLimit: %d\n", transactor.GasLimit)
+
 	tx, err := call(transactor)
 	if err != nil {
-		return 0, fmt.Errorf("could not call contract: %w", err)
+		return 0, fmt.Errorf("err contract call for tx: %w", err)
 	}
+
+	//tmpdebug
+	fmt.Printf("tx.Gas: %d\n", tx.Gas())
+
 	defer locker.Unlock()
 
+	//tmpdebug
+	fmt.Printf("SubmitTransaction>storeTX\n")
+
 	// now that we've stored the tx
 	err = t.storeTX(ctx, tx, db.Stored, uuid.New().String())
 	if err != nil {
@@ -436,6 +484,9 @@
 	span.AddEvent("trigger reprocess")
 	t.triggerProcessQueue(ctx)
 
+	//tmpdebug
+	fmt.Printf("SubmitTransaction>tx.Nonce: %d\n", tx.Nonce())
+
 	return tx.Nonce(), nil
 }
 
@@ -676,18 +727,31 @@
 
 // getGasEstimate gets the gas estimate for the given transaction.
 // TODO: handle l2s w/ custom gas pricing through contracts.
-func (t *txSubmitterImpl) getGasEstimate(ctx context.Context, chainClient client.EVM, chainID int, tx *types.Transaction) (gasEstimate uint64, err error) {
+func (t *txSubmitterImpl) getGasEstimate(ctx context.Context, chainClient client.EVM, chainID int, tx *types.Transaction) (gasLimit_new uint64, err error) {
+
+	// if dynamic gas estimation is not enabled, use cfg var gas_estimate as a default
 	if !t.config.GetDynamicGasEstimate(chainID) {
 		return t.config.GetGasEstimate(chainID), nil
 	}
 
+	//tmpdebug
+	fmt.Println("getGasEstimate>start")
+
+	gasUnitAddPercentage := t.config.GetDynamicGasUnitAddPercentage(chainID)
+
+	//tmpdebug
+	fmt.Println("getGasEstimate>gasUnitAddPercentage", gasUnitAddPercentage)
+
 	ctx, span := t.metrics.Tracer().Start(ctx, "submitter.getGasEstimate", trace.WithAttributes(
 		attribute.Int(metrics.ChainID, chainID),
+
 		attribute.String(metrics.TxHash, tx.Hash().String()),
+
+		attribute.Int("gasUnitAddPercentage", gasUnitAddPercentage),
 	))
 
 	defer func() {
-		span.AddEvent("estimated_gas", trace.WithAttributes(attribute.Int64("gas", int64(gasEstimate))))
+		span.AddEvent("estimated_gas", trace.WithAttributes(attribute.Int64("gas", int64(gasLimit_new))))
 		metrics.EndSpanWithErr(span, err)
 	}()
 
@@ -696,21 +760,35 @@
 	if err != nil {
 		return 0, fmt.Errorf("could not convert tx to call: %w", err)
 	}
-	// tmpdebug
-	fmt.Printf("Debug Calling EstimateGas")
 
-	gasEstimate, err = chainClient.EstimateGas(ctx, *call)
+	// bump gas limit from prior by X%
+	gasLimit_fromPrior := tx.Gas()
+
+	gasLimit_fromEstimate, err := chainClient.EstimateGas(ctx, *call)
+
 	if err != nil {
-		span.AddEvent("could not estimate gas", trace.WithAttributes(attribute.String("error", err.Error())))
 
-		// tmpdebug
-		fmt.Printf("Debug Default Gas Estimate: %d\n", t.config.GetGasEstimate(chainID))
+		//tmpdebug
+		fmt.Printf("getGasEstimate> Error estimating gas: %v\n", err)
 
-		// fallback to default
-		return t.config.GetGasEstimate(chainID), nil
+		span.AddEvent("could not estimate gas", trace.WithAttributes(attribute.String("error", err.Error())))
+
+		// if we failed to est gas for any reason, use *at least* the default flat gas on the next bump
+		gasLimit_fromEstimate = max(t.config.GetGasEstimate(chainID), gasLimit_fromEstimate)
 	}
 
-	return gasEstimate, nil
+	// use whichever is higher, gas from the prior attempt, or gas from our latest simulation estimate
+	gasLimit_new = max(gasLimit_fromPrior, gasLimit_fromEstimate)
+
+	// whichever source is used as the base, multiply it by the configured gas unit add percentage
+	gasLimit_new = gasLimit_new + (gasLimit_new * uint64(gasUnitAddPercentage) / 100)
+	span.AddEvent("new gas limit", trace.WithAttributes(
+		attribute.Int64("gas_limit", int64(gasLimit_new)),
+		attribute.Int64("gas_limit_from_prior", int64(gasLimit_fromPrior)),
+		attribute.Int64("gas_limit_from_estimate", int64(gasLimit_fromEstimate)),
+	))
+
+	return gasLimit_new, nil
 }
 
 func (t *txSubmitterImpl) Address() common.Address {

ethergo/submitter/util_test.go

@@ -198,6 +198,21 @@ func (s *SubmitterSuite) TestGroupTxesByNonce() {
 	}
 }
 
+func (s *SubmitterSuite) TestOpStackGas() {
+
+	mockTx := mocks.GetMockTxes(s.GetTestContext(), s.T(), 1, types.LegacyTxType)[0]
+
+	fmt.Printf("Original Transaction Gas Limit: %d\n", mockTx.Gas())
+
+}
+
+func TestBox(t *testing.T) {
+	const testTxCount = 10
+	mockTx := mocks.GetMockTxes(context.Background(), t, testTxCount, 0)
+
+	fmt.Printf("Original Transaction Gas Limit: %d\n", mockTx[0].Gas())
+}
+
 // Test for the outersection function.
 func TestOutersection(t *testing.T) {
 	set := []*big.Int{

services/rfq/relayer/chain/chain.go

@@ -74,6 +74,9 @@
 	gasAmount := big.NewInt(0)
 	var err error
 
+	//tmpdebug
+	fmt.Println("SubmitRelay>start: ", request.OriginTxHash)
+
 	// Check to see if ETH should be sent to destination
 	if util.IsGasToken(request.Transaction.DestToken) {
 		gasAmount = request.Transaction.DestAmount
@@ -86,19 +89,37 @@
 		}
 	}
 
+	//tmpdebug
+	fmt.Println("SubmitRelay>SubmitTransaction: ", request.OriginTxHash)
+
 	nonce, err := c.SubmitTransaction(ctx, func(transactor *bind.TransactOpts) (tx *types.Transaction, err error) {
 		transactor.Value = core.CopyBigInt(gasAmount)
 
+		//tmpdebug
+		callType := "exec"
+		if transactor.GasLimit == 0 {
+			callType = "sim"
+		}
+
+		//tmpdebug
+		fmt.Println(callType, "SubmitTransaction>RelayV2: ", request.OriginTxHash)
+
 		tx, err = c.Bridge.RelayV2(transactor, request.RawRequest, c.submitter.Address())
+
 		if err != nil {
 			return nil, fmt.Errorf("could not relay: %w", err)
 		}
 
+		//tmpdebug
+		fmt.Println(callType, "RelayV2 Return tx hash:", request.OriginTxHash, tx.Hash())
+
 		return tx, nil
 	})
 	if err != nil {
 		return 0, nil, fmt.Errorf("could not submit transaction: %w", err)
 	}
+	//tmpdebug
+	fmt.Println("SubmitRelay nonce:", nonce, "gas amount:", gasAmount)
 
 	return nonce, gasAmount, nil
 }

services/rfq/relayer/quoter/quoter.go

@@ -693,28 +693,19 @@ func (m *Manager) generateQuote(ctx context.Context, input QuoteInput) (quote *m
 		return nil, fmt.Errorf("error getting total fee: %w", err)
 	}
 
-	// tmpdebug
-	fmt.Printf("Debug Total Fee Amt: %s\n", fee.String())
-
 	originRFQAddr, err := m.config.GetRFQAddress(input.OriginChainID)
 	if err != nil {
 		logger.Error("Error getting RFQ address", "error", err)
 		return nil, fmt.Errorf("error getting RFQ address: %w", err)
 	}
 
-	// tmpdebug
-	fmt.Printf("Debug originRFQAddr: %s\n", originRFQAddr.String())
-
 	// Build the quote
 	destAmount, err := m.getDestAmount(ctx, originAmount, destToken, input)
 	if err != nil {
 		logger.Error("Error getting dest amount", "error", err)
 		return nil, fmt.Errorf("error getting dest amount: %w", err)
 	}
 
-	// tmpdebug
-	fmt.Printf("Debug destAmount: %s\n", destAmount.String())
-
 	quote = &model.PutRelayerQuoteRequest{
 		OriginChainID:           input.OriginChainID,
 		OriginTokenAddr:         input.OriginTokenAddr.Hex(),