feat: retry function with bumping fee

Author: MarcosNicolau

core/chainio/avs_writer.go

@@ -15,7 +15,6 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	servicemanager "github.com/yetanotherco/aligned_layer/contracts/bindings/AlignedLayerServiceManager"
-	connection "github.com/yetanotherco/aligned_layer/core"
 	"github.com/yetanotherco/aligned_layer/core/config"
 	"github.com/yetanotherco/aligned_layer/core/utils"
 )
@@ -94,49 +93,25 @@ func (w *AvsWriter) SendAggregatedResponse(batchIdentifierHash [32]byte, batchMe
 	txNonce := new(big.Int).SetUint64(tx.Nonce())
 	txOpts.NoSend = false
 	txOpts.Nonce = txNonce
-	i := 0
-	sendTransaction := func() (*types.Receipt, error) {
-		// bump the fee here
-		gasPrice := utils.CalculateGasPriceBumpBasedOnRetry(tx.GasPrice(), i)
+
+	beforeTransaction := func(gasPrice *big.Int) error {
 		txOpts.GasPrice = gasPrice
-		w.logger.Infof("Sending ResponseToTask transaction for %vth with a gas price of %v", i, txOpts.GasPrice)
-		i++
+		w.logger.Infof("Sending ResponseToTask transaction with a gas price of %v", txOpts.GasPrice)
 		err = w.checkRespondToTaskFeeLimit(tx, txOpts, batchIdentifierHash, senderAddress)
-		if err != nil {
-			return nil, err
-		}
+		return err
+	}
 
+	executeTransaction := func(gasPrice *big.Int) (*types.Transaction, error) {
 		tx, err = w.AvsContractBindings.ServiceManager.RespondToTaskV2(&txOpts, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
 		if err != nil {
 			// Retry with fallback
 			tx, err = w.AvsContractBindings.ServiceManagerFallback.RespondToTaskV2(&txOpts, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
-			if err != nil {
-				return nil, err
-			}
+			return tx, err
 		}
-		ctx, cancel := context.WithTimeout(context.Background(), time.Second*36)
-		defer cancel()
-		receipt, err := utils.WaitForTransactionReceipt(w.Client, ctx, tx.Hash())
-
-		if receipt != nil {
-			return receipt, nil
-		}
-
-		// if we are here, this means we have reached the timeout (after three blocks it hasn't been included)
-		// so we try again by bumping the fee to make sure its included
-		if err != nil {
-			return nil, err
-		}
-		return nil, fmt.Errorf("transaction failed")
+		return tx, err
 	}
-	receipt, err := connection.RetryWithData(sendTransaction, 1000, 2, 3)
 
-	if receipt.Status == 0 {
-		return receipt, fmt.Errorf("transaction failed")
-	} else {
-		// transaction was included in block
-		return receipt, nil
-	}
+	return utils.SendTransactionWithInfiniteRetryAndBumpingGasPrice(beforeTransaction, executeTransaction, w.Client, tx.GasPrice())
 }
 
 func (w *AvsWriter) checkRespondToTaskFeeLimit(tx *types.Transaction, txOpts bind.TransactOpts, batchIdentifierHash [32]byte, senderAddress [20]byte) error {

core/utils/eth_client_utils.go

@@ -11,6 +11,7 @@ import (
 	eigentypes "github.com/Layr-Labs/eigensdk-go/types"
 	gethcommon "github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	connection "github.com/yetanotherco/aligned_layer/core"
 )
 
 const maxRetries = 25
@@ -57,3 +58,40 @@ func CalculateGasPriceBumpBasedOnRetry(currentGasPrice *big.Int, iteration int)
 
 	return gasPrice
 }
+
+// Sends a transaction and waits for the receipt for three blocks, if not received
+// it will try again bumping the gas price based on `CalculateGasPriceBumpBasedOnRetry`.
+// This process happens indefinitely until we get the receipt or the receipt status is an err
+func SendTransactionWithInfiniteRetryAndBumpingGasPrice(beforeTransaction func(*big.Int) error, executeTransaction func(*big.Int) (*types.Transaction, error), client eth.InstrumentedClient, baseGasPrice *big.Int) (*types.Receipt, error) {
+	i := 0
+	sendTransaction := func() (*types.Receipt, error) {
+		i++
+		gasPrice := CalculateGasPriceBumpBasedOnRetry(baseGasPrice, i)
+
+		err := beforeTransaction(gasPrice)
+		if err != nil {
+			return nil, err
+		}
+
+		tx, err := executeTransaction(gasPrice)
+		if err != nil {
+			return nil, err
+		}
+
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second*36)
+		defer cancel()
+		receipt, err := WaitForTransactionReceipt(client, ctx, tx.Hash())
+
+		if receipt != nil {
+			return receipt, nil
+		}
+		// if we are here, this means we have reached the timeout (after three blocks it hasn't been included)
+		// so we try again by bumping the fee to make sure its included
+		if err != nil {
+			return nil, err
+		}
+		return nil, fmt.Errorf("transaction failed")
+
+	}
+	return connection.RetryWithData(sendTransaction, 1000, 2, 0)
+}