+dynamic_gas_unit_add_percentage flag

.gitignore

@@ -133,3 +133,10 @@ main
 
 # golang-ci-lint binary
 contrib/golang-ci-lint/golang-ci-lint
+
+*signer*.txt
+
+# ignore any rfq config files that are not the template
+services/rfq/**/config*.yaml
+services/rfq/**/config*.yml
+!services/rfq/**/config.yml

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

@@ -392,8 +392,23 @@
 	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()))
+
+	performSignature := func(address common.Address, transaction *types.Transaction) (_ *types.Transaction, err error) {
+
+		newNonce, err := t.getNonce(ctx, chainID, address)
+		if err != nil {
+			return nil, fmt.Errorf("could not sign tx: %w", err)
+		}
+
+		txType := t.txTypeForChain(chainID)
+
+		transaction, err = util.CopyTX(transaction, util.WithNonce(newNonce), util.WithTxType(txType))
+		if err != nil {
+			return nil, fmt.Errorf("could not copy tx: %w", err)
+		}
+
+		//nolint: wrapcheck
+		return parentTransactor.Signer(address, transaction)
 	}
 
 	transactor.Signer = func(address common.Address, transaction *types.Transaction) (_ *types.Transaction, err error) {
@@ -406,25 +421,42 @@
 			}
 		}()
 
-		newNonce, err := t.getNonce(ctx, chainID, address)
-		if err != nil {
-			return nil, fmt.Errorf("could not sign tx: %w", err)
-		}
+		return performSignature(address, transaction)
+	}
 
-		txType := t.txTypeForChain(chainID)
+	// 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())) {
+		transactor.GasLimit = t.config.GetGasEstimate(int(chainID.Uint64()))
+	} else {
 
-		transaction, err = util.CopyTX(transaction, util.WithNonce(newNonce), util.WithTxType(txType))
+		// deepcopy the real transactor so we can use it for simulation
+		transactorForGasEstimate := copyTransactOpts(transactor)
+
+		// override the signer func for our simulation/estimation with a version that does not lock the nonce,
+		// which would othewrise cause a deadlock with the following *actual* transactor
+		transactorForGasEstimate.Signer = func(address common.Address, transaction *types.Transaction) (_ *types.Transaction, err error) {
+			return performSignature(address, transaction)
+		}
+
+		txForGasEstimate, err := call(transactorForGasEstimate)
 		if err != nil {
-			return nil, fmt.Errorf("could not copy tx: %w", err)
+			errMsg := util.FormatError(err)
+
+			return 0, fmt.Errorf("err contract call for gas est: %s", errMsg)
 		}
 
-		//nolint: wrapcheck
-		return parentTransactor.Signer(address, transaction)
+		// with our gas limit now obtained from the simulation, apply this limit (plus any configured % modifier) to the
+		// gas limit of the actual transactor that is about to prepare the real transaction
+		gasLimitAddPercentage := t.config.GetDynamicGasUnitAddPercentage(int(chainID.Uint64()))
+		transactor.GasLimit = txForGasEstimate.Gas() + (txForGasEstimate.Gas() * uint64(gasLimitAddPercentage) / 100)
 	}
+
 	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)
 	}
+
 	defer locker.Unlock()
 
 	// now that we've stored the tx
@@ -676,18 +708,23 @@
 
 // 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 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
 	}
 
+	gasUnitAddPercentage := t.config.GetDynamicGasUnitAddPercentage(chainID)
+
 	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))))
 		metrics.EndSpanWithErr(span, err)
 	}()
 
@@ -696,21 +733,21 @@
 	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)
+	gasLimitFromEstimate, 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))
-
-		// fallback to default
+		// if we failed to est gas for any reason, use the default flat gas from config
 		return t.config.GetGasEstimate(chainID), nil
 	}
 
-	return gasEstimate, nil
+	// multiply the freshly simulated gasLimit by the configured gas unit add percentage
+	gasLimitFromEstimate += (gasLimitFromEstimate * uint64(gasUnitAddPercentage) / 100)
+	gasLimit = gasLimitFromEstimate
+
+	return gasLimit, nil
 }
 
 func (t *txSubmitterImpl) Address() common.Address {

ethergo/util/util.go

@@ -0,0 +1,17 @@
+package util
+
+import "strings"
+
+// FormatError applies custom formatting & noise reduction to error messages. Add more as needed.
+func FormatError(err error) string {
+	if err == nil {
+		return ""
+	}
+	errMsg := err.Error()
+
+	//if an error message contains embedded HTML (eg: many RPC errors), strip it out to reduce noise.
+	if strings.Contains(errMsg, "<!DOCTYPE html>") {
+		errMsg = strings.Split(errMsg, "<!DOCTYPE html>")[0] + "<html portion of error removed>"
+	}
+	return errMsg
+}

services/rfq/contracts/fastbridgev2/events.go

@@ -20,6 +20,8 @@ var (
 	BridgeDepositClaimedTopic common.Hash
 	// BridgeProofDisputedTopic is the topic emitted by a bridge dispute.
 	BridgeProofDisputedTopic common.Hash
+	// BridgeQuoteDetailsTopic is a secondary topic emitted by a bridge request.
+	BridgeQuoteDetailsTopic common.Hash
 )
 
 // static checks to make sure topics actually exist.
@@ -36,6 +38,7 @@ func init() {
 	BridgeProofProvidedTopic = parsedABI.Events["BridgeProofProvided"].ID
 	BridgeDepositClaimedTopic = parsedABI.Events["BridgeDepositClaimed"].ID
 	BridgeProofDisputedTopic = parsedABI.Events["BridgeProofDisputed"].ID
+	BridgeQuoteDetailsTopic = parsedABI.Events["BridgeQuoteDetails"].ID
 
 	_, err = parsedABI.EventByID(BridgeRequestedTopic)
 	if err != nil {
@@ -56,6 +59,16 @@ func init() {
 	if err != nil {
 		panic(err)
 	}
+
+	_, err = parsedABI.EventByID(BridgeDepositClaimedTopic)
+	if err != nil {
+		panic(err)
+	}
+
+	_, err = parsedABI.EventByID(BridgeQuoteDetailsTopic)
+	if err != nil {
+		panic(err)
+	}
 }
 
 // topicMap maps events to topics.
@@ -67,6 +80,7 @@ func topicMap() map[EventType]common.Hash {
 		BridgeProofProvidedEvent:  BridgeProofProvidedTopic,
 		BridgeDepositClaimedEvent: BridgeDepositClaimedTopic,
 		BridgeDisputeEvent:        BridgeProofDisputedTopic,
+		BridgeQuoteDetailsEvent:   BridgeQuoteDetailsTopic,
 	}
 }
 

services/rfq/contracts/fastbridgev2/parser.go

@@ -23,6 +23,8 @@
 	BridgeDepositClaimedEvent
 	// BridgeDisputeEvent is the event type for the BridgeDispute event.
 	BridgeDisputeEvent
+	// BridgeQuoteDetailsEvent is emitted along w/ BridgeRequestedEvent as supplemental data
+	BridgeQuoteDetailsEvent
 )
 
 // Parser parses events from the fastbridge contracat.
@@ -91,6 +93,12 @@
 			return noOpEvent, nil, false
 		}
 		return eventType, disputed, true
+	case BridgeQuoteDetailsEvent:
+		quoteDetails, err := p.filterer.ParseBridgeQuoteDetails(log)
+		if err != nil {
+			return noOpEvent, nil, false
+		}
+		return eventType, quoteDetails, true
 	}
 
 	return eventType, nil, true

services/rfq/relayer/chain/chain.go

@@ -86,10 +86,19 @@ func (c Chain) SubmitRelay(ctx context.Context, request reldb.QuoteRequest) (uin
 		}
 	}
 
+	fmt.Printf(
+		"TxID 0x%x %7d.%s > %7d.%s : Submitting \033[32mRelay\033[0m\n",
+		request.TransactionID,
+		request.Transaction.OriginChainId,
+		request.Transaction.OriginToken.Hex()[:6],
+		request.Transaction.DestChainId,
+		request.Transaction.DestToken.Hex()[:6])
+
 	nonce, err := c.SubmitTransaction(ctx, func(transactor *bind.TransactOpts) (tx *types.Transaction, err error) {
 		transactor.Value = core.CopyBigInt(gasAmount)
 
 		tx, err = c.Bridge.RelayV2(transactor, request.RawRequest, c.submitter.Address())
+
 		if err != nil {
 			return nil, fmt.Errorf("could not relay: %w", err)
 		}

services/rfq/relayer/pricer/fee_pricer.go

@@ -14,11 +14,12 @@
 	"github.com/jellydator/ttlcache/v3"
 	"github.com/synapsecns/sanguine/core/metrics"
 	"github.com/synapsecns/sanguine/ethergo/submitter"
+	ethergoUtil "github.com/synapsecns/sanguine/ethergo/util"
 	"github.com/synapsecns/sanguine/services/rfq/contracts/fastbridgev2"
 	"github.com/synapsecns/sanguine/services/rfq/relayer/chain"
 	"github.com/synapsecns/sanguine/services/rfq/relayer/relconfig"
 	"github.com/synapsecns/sanguine/services/rfq/relayer/reldb"
-	"github.com/synapsecns/sanguine/services/rfq/util"
+	rfqUtil "github.com/synapsecns/sanguine/services/rfq/util"
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/trace"
 )
@@ -255,15 +256,19 @@
 		Data: encodedData,
 	}
 	// Tx.value needs to match `DestAmount` for native gas token, or `ZapNative` for ERC20s.
-	if util.IsGasToken(quoteRequest.Transaction.DestToken) {
+	if rfqUtil.IsGasToken(quoteRequest.Transaction.DestToken) {
 		callMsg.Value = quoteRequest.Transaction.DestAmount
 	} else {
 		callMsg.Value = quoteRequest.Transaction.ZapNative
 	}
 
+	// note: this gas amount is intentionally not modified
 	gasEstimate, err = client.EstimateGas(ctx, callMsg)
 	if err != nil {
-		return 0, fmt.Errorf("could not estimate gas: %w", err)
+
+		errMsg := ethergoUtil.FormatError(err)
+
+		return 0, fmt.Errorf("could not estimate gas: %s", errMsg)
 	}
 
 	return gasEstimate, nil