Merge branch '311-aggregator-wait-for-receipt-for-1-minute-if-not-bump-the-fee-v2' into test-aggregator-bump-fee

Author: MarcosNicolau

core/chainio/avs_writer.go

@@ -21,7 +21,12 @@ import (
 )
 
 const (
-	gasBumpPercentage int = 20
+	// How much to bump every retry (constant)
+	GasBaseBumpPercentage int = 20
+	// An extra percentage to bump every retry i*5 (linear)
+	GasBumpIncrementalBumpPercentage int = 5
+	// Wait as much as 3 blocks time for the receipt
+	SendAggregateResponseReceiptTimeout time.Duration = time.Second * 36
 )
 
 type AvsWriter struct {
@@ -79,7 +84,10 @@ func NewAvsWriterFromConfig(baseConfig *config.BaseConfig, ecdsaConfig *config.E
 // Sends AggregatedResponse and waits for the receipt for three blocks, if not received
 // it will try again bumping the last tx gas price based on `CalculateGasPriceBump`
 // This process happens indefinitely until the transaction is included.
-// Note: If the rpc endpoints fail, the retry will stop, as it will infinitely try
+//
+// Note: If the rpc endpoints fail, the retry mechanism stops, returning a permanent error.
+// This is because retries are infinite and we want to prevent increasing the time between them too much as it is exponential.
+// And, if the rpc is down for a good period of time, we might fall into an infinite waiting.
 func (w *AvsWriter) SendAggregatedResponse(batchIdentifierHash [32]byte, batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature, onRetry func()) (*types.Receipt, error) {
 	txOpts := *w.Signer.GetTxOpts()
 	txOpts.NoSend = true // simulate the transaction
@@ -116,14 +124,13 @@ func (w *AvsWriter) SendAggregatedResponse(batchIdentifierHash [32]byte, batchMe
 			// Retry with fallback
 			gasPrice, err = w.ClientFallback.SuggestGasPrice(context.Background())
 			if err != nil {
-				return nil, fmt.Errorf("transaction simulation failed: %v", err)
+				return nil, connection.PermanentError{Inner: err}
 			}
 		}
-		txOpts.GasPrice = utils.CalculateGasPriceBumpBasedOnRetry(gasPrice, gasBumpPercentage, i)
+		txOpts.GasPrice = utils.CalculateGasPriceBumpBasedOnRetry(gasPrice, GasBaseBumpPercentage, GasBumpIncrementalBumpPercentage, 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, connection.PermanentError{Inner: err}
 		}

core/connection.go

@@ -19,11 +19,13 @@ func (e PermanentError) Is(err error) bool {
 	return ok
 }
 
-// Same as Retry only that the functionToRetry can return a value upon correct execution
+// Retries a given function in an exponential backoff manner and returns a value upon correct execution.
+// It will retry calling the function while it returns a non permanent error, until the max retries.
+// If maxTries == 0 then the retry function will run indefinitely until success or until a `PermanentError` is returned.
 func RetryWithData[T any](functionToRetry func() (*T, error), minDelay uint64, factor float64, maxTries uint64) (*T, error) {
 	f := func() (*T, error) {
 		val, err := functionToRetry()
-		if perm, ok := err.(PermanentError); err != nil && ok {
+		if perm, ok := err.(PermanentError); ok && err != nil {
 			return nil, backoff.Permanent(perm.Inner)
 		}
 		return val, err
@@ -46,15 +48,12 @@ func RetryWithData[T any](functionToRetry func() (*T, error), minDelay uint64, f
 }
 
 // Retries a given function in an exponential backoff manner.
-// It will retry calling the function while it returns an error, until the max retries.
-// If maxTries == 0 then the retry function will run indefinitely until success
-// from the configuration are reached, or until a `PermanentError` is returned.
-// The function to be retried should return `PermanentError` when the condition for stop retrying
-// is met.
+// It will retry calling the function while it returns a non permanent error, until the max retries.
+// If maxTries == 0 then the retry function will run indefinitely.
 func Retry(functionToRetry func() error, minDelay uint64, factor float64, maxTries uint64) error {
 	f := func() error {
 		err := functionToRetry()
-		if perm, ok := err.(PermanentError); err != nil && ok {
+		if perm, ok := err.(PermanentError); ok && err != nil {
 			return backoff.Permanent(perm.Inner)
 		}
 		return err

core/connection_test.go

@@ -17,26 +17,65 @@ func DummyFunction(x uint64) (uint64, error) {
 	return x, nil
 }
 
+// here we run the dummy function with the retry and check:
+// - The number of retries checks based on the `n`
+// - The returned valued matches based on the `n`
+// - The returned err matches based on the `n`
 func TestRetryWithData(t *testing.T) {
-	function := func() (*uint64, error) {
-		x, err := DummyFunction(43)
-		return &x, err
+	retries := -1
+	testFun := func(n uint64) func() (*uint64, error) {
+		return func() (*uint64, error) {
+			retries++
+			x, err := DummyFunction(n)
+			return &x, err
+		}
 	}
-	data, err := connection.RetryWithData(function, 1000, 2, 3)
-	if err != nil {
-		t.Errorf("Retry error!: %s", err)
-	} else {
-		fmt.Printf("DATA: %d\n", data)
+	data, err := connection.RetryWithData(testFun(uint64(41)), 1000, 2, 3)
+	if !(retries == 3 && *data == 0 && err != nil) {
+		t.Error("Incorrect execution when n == 41")
+	}
+	//restart
+	retries = -1
+	data, err = connection.RetryWithData(testFun(42), 1000, 2, 3)
+	if !(retries == 0 && data == nil) {
+		if _, ok := err.(*connection.PermanentError); ok {
+			t.Error("Incorrect execution when n == 42")
+		}
+	}
+	//restart
+	retries = -1
+	data, err = connection.RetryWithData(testFun(43), 1000, 2, 3)
+	if !(retries == 0 && *data == 43 && err == nil) {
+		t.Error("Incorrect execution when n == 43")
 	}
 }
 
+// same as above but without checking returned data
 func TestRetry(t *testing.T) {
-	function := func() error {
-		_, err := DummyFunction(43)
-		return err
+	retries := -1
+	testFun := func(n uint64) func() error {
+		return func() error {
+			retries++
+			_, err := DummyFunction(n)
+			return err
+		}
+	}
+	err := connection.Retry(testFun(uint64(41)), 1000, 2, 3)
+	if !(retries == 3 && err != nil) {
+		t.Error("Incorrect execution when n == 41")
+	}
+	//restart
+	retries = -1
+	err = connection.Retry(testFun(42), 1000, 2, 3)
+	if !(retries == 0) {
+		if _, ok := err.(*connection.PermanentError); ok {
+			t.Error("Incorrect execution when n == 42")
+		}
 	}
-	err := connection.Retry(function, 1000, 2, 3)
-	if err != nil {
-		t.Errorf("Retry error!: %s", err)
+	//restart
+	retries = -1
+	err = connection.Retry(testFun(43), 1000, 2, 3)
+	if !(retries == 0 && err == nil) {
+		t.Error("Incorrect execution when n == 43")
 	}
 }

core/utils/eth_client_utils.go

@@ -25,9 +25,8 @@ func WaitForTransactionReceipt(client eth.InstrumentedClient, ctx context.Contex
 		// if context has timed out, return
 		if ctx.Err() != nil {
 			return nil, ctx.Err()
-		} else {
-			time.Sleep(sleepTime)
 		}
+		time.Sleep(sleepTime)
 	}
 	return nil, fmt.Errorf("transaction receipt not found for txHash: %s", txHash.String())
 }
@@ -48,13 +47,21 @@ func BytesToQuorumThresholdPercentages(quorumThresholdPercentagesBytes []byte) e
 	return quorumThresholdPercentages
 }
 
-// Very basic algorithm to calculate the gasPrice bump based on the currentGasPrice a constant percentage and the retry number.
-// It adds a the percentage to the current gas price and a 5% * i, where i is the iteration number. That is:
-func CalculateGasPriceBumpBasedOnRetry(currentGasPrice *big.Int, percentage int, i int) *big.Int {
-	retryPercentage := new(big.Int).Mul(big.NewInt(5), big.NewInt(int64(i)))
-	percentageBump := new(big.Int).Add(big.NewInt(int64(percentage)), retryPercentage)
-	bumpAmount := new(big.Int).Mul(currentGasPrice, percentageBump)
+// Simple algorithm to calculate the gasPrice bump based on:
+// the currentGasPrice, a base bump percentage, a retry percentage, and the retry count.
+// Formula: currentGasPrice + (currentGasPrice * (baseBumpPercentage + retryCount * incrementalRetryPercentage) / 100)
+func CalculateGasPriceBumpBasedOnRetry(currentGasPrice *big.Int, baseBumpPercentage int, retryAttemptPercentage int, retryCount int) *big.Int {
+	// Incremental percentage increase for each retry attempt (i*5%)
+	incrementalRetryPercentage := new(big.Int).Mul(big.NewInt(int64(retryAttemptPercentage)), big.NewInt(int64(retryCount)))
+
+	// Total bump percentage: base bump + incremental retry percentage
+	totalBumpPercentage := new(big.Int).Add(big.NewInt(int64(baseBumpPercentage)), incrementalRetryPercentage)
+
+	// Calculate the bump amount: currentGasPrice * totalBumpPercentage / 100
+	bumpAmount := new(big.Int).Mul(currentGasPrice, totalBumpPercentage)
 	bumpAmount = new(big.Int).Div(bumpAmount, big.NewInt(100))
+
+	// Final bumped gas price: currentGasPrice + bumpAmount
 	bumpedGasPrice := new(big.Int).Add(currentGasPrice, bumpAmount)
 
 	return bumpedGasPrice

grafana/provisioning/dashboards/aligned/aggregator_batcher.json

@@ -1425,4 +1425,4 @@
   "uid": "aggregator",
   "version": 15,
   "weekStart": ""
-}
+}