fix gnosis and base errors

Author: Bojan131

src/constants/constants.js

@@ -715,6 +715,15 @@ export const EXPECTED_TRANSACTION_ERRORS = {
     NONCE_TOO_LOW: 'nonce too low',
     REPLACEMENT_UNDERPRICED: 'replacement transaction underpriced',
     ALREADY_KNOWN: 'already known',
+    EXECUTION_FAILED: 'transaction execution fails',
+    FEE_TOO_LOW: 'feetoolow',
+    SOCKET_HANG_UP: 'socket hang up',
+    ECONNRESET: 'econnreset',
+    ECONNREFUSED: 'econnrefused',
+    SERVER_ERROR: 'server error',
+    BAD_GATEWAY: '502',
+    SERVICE_UNAVAILABLE: '503',
+    EXPECT_BLOCK_NUMBER: 'expect block number from id',
 };
 
 /**

src/modules/blockchain/implementation/gnosis/gnosis-service.js

@@ -54,6 +54,21 @@ class GnosisService extends Web3Service {
         return this.defaultGasPrice;
     }
 
+    buildTransactionGasParams(gasPrice) {
+        const maxFeePerGas = gasPrice;
+        const minPriorityFee = ethers.BigNumber.from(2_000_000_000);
+
+        let maxPriorityFeePerGas = minPriorityFee;
+        if (ethers.BigNumber.isBigNumber(gasPrice)) {
+            const derived = gasPrice.div(5);
+            if (derived.gt(minPriorityFee)) {
+                maxPriorityFeePerGas = derived;
+            }
+        }
+
+        return { maxFeePerGas, maxPriorityFeePerGas };
+    }
+
     async healthCheck() {
         try {
             const blockNumber = await this.getBlockNumber();

src/modules/blockchain/implementation/web3-service.js

@@ -522,6 +522,10 @@ class Web3Service {
         }
     }
 
+    buildTransactionGasParams(gasPrice) {
+        return { gasPrice };
+    }
+
     async callContractFunction(contractInstance, functionName, args, contractName = null) {
         const maxNumberOfRetries = 3;
         const retryDelayInSec = 12;
@@ -567,11 +571,35 @@ class Web3Service {
         let retryCount = 0;
         const maxRetries = 3;
 
-        try {
-            /* eslint-disable no-await-in-loop */
-            gasLimit = await contractInstance.estimateGas[functionName](...args);
-        } catch (error) {
-            this._decodeEstimateGasError(contractInstance, functionName, error, args);
+        for (let estimateAttempt = 0; estimateAttempt < 3; estimateAttempt += 1) {
+            try {
+                /* eslint-disable no-await-in-loop */
+                gasLimit = await contractInstance.estimateGas[functionName](...args);
+                break;
+            } catch (error) {
+                const errMsg = error.message?.toLowerCase() ?? '';
+                const isTransient =
+                    errMsg.includes(EXPECTED_TRANSACTION_ERRORS.EXECUTION_FAILED.toLowerCase()) ||
+                    errMsg.includes(EXPECTED_TRANSACTION_ERRORS.FEE_TOO_LOW.toLowerCase()) ||
+                    errMsg.includes(EXPECTED_TRANSACTION_ERRORS.SOCKET_HANG_UP) ||
+                    errMsg.includes(EXPECTED_TRANSACTION_ERRORS.ECONNRESET) ||
+                    errMsg.includes(EXPECTED_TRANSACTION_ERRORS.ECONNREFUSED) ||
+                    errMsg.includes(EXPECTED_TRANSACTION_ERRORS.SERVER_ERROR) ||
+                    errMsg.includes(EXPECTED_TRANSACTION_ERRORS.BAD_GATEWAY) ||
+                    errMsg.includes(EXPECTED_TRANSACTION_ERRORS.SERVICE_UNAVAILABLE) ||
+                    errMsg.includes(EXPECTED_TRANSACTION_ERRORS.EXPECT_BLOCK_NUMBER);
+                if (isTransient && estimateAttempt < 2) {
+                    this.logger.warn(
+                        `Gas estimation for ${functionName} failed with transient error on ${this.getBlockchainId()}, ` +
+                            `retrying (${estimateAttempt + 1}/3): ${error.message}`,
+                    );
+                    await new Promise((r) => {
+                        setTimeout(r, 2000);
+                    });
+                    continue;
+                }
+                this._decodeEstimateGasError(contractInstance, functionName, error, args);
+            }
         }
 
         gasLimit = gasLimit ?? ethers.utils.parseUnits('900', 'kwei');
@@ -590,12 +618,12 @@ class Web3Service {
                         }${retryCount > 0 ? ` (retry ${retryCount})` : ''}`,
                 );
 
+                const txOverrides = this.buildTransactionGasParams(gasPrice);
+                txOverrides.gasLimit = gasLimit;
+
                 const tx = await contractInstance
                     .connect(operationalWallet)
-                    [functionName](...args, {
-                        gasPrice,
-                        gasLimit,
-                    });
+                    [functionName](...args, txOverrides);
 
                 try {
                     result = await this.provider.waitForTransaction(
@@ -644,22 +672,41 @@ class Web3Service {
                     EXPECTED_TRANSACTION_ERRORS.TIMEOUT_EXCEEDED.toLowerCase(),
                 );
 
-                if (isNonceError || isTimeoutError) {
+                const isExecutionError =
+                    errorMessage.includes(
+                        EXPECTED_TRANSACTION_ERRORS.EXECUTION_FAILED.toLowerCase(),
+                    ) ||
+                    errorMessage.includes(EXPECTED_TRANSACTION_ERRORS.FEE_TOO_LOW.toLowerCase());
+
+                const isNetworkError =
+                    errorMessage.includes(EXPECTED_TRANSACTION_ERRORS.SOCKET_HANG_UP) ||
+                    errorMessage.includes(EXPECTED_TRANSACTION_ERRORS.ECONNRESET) ||
+                    errorMessage.includes(EXPECTED_TRANSACTION_ERRORS.ECONNREFUSED) ||
+                    errorMessage.includes(EXPECTED_TRANSACTION_ERRORS.SERVER_ERROR) ||
+                    errorMessage.includes(EXPECTED_TRANSACTION_ERRORS.BAD_GATEWAY) ||
+                    errorMessage.includes(EXPECTED_TRANSACTION_ERRORS.SERVICE_UNAVAILABLE) ||
+                    errorMessage.includes(EXPECTED_TRANSACTION_ERRORS.EXPECT_BLOCK_NUMBER);
+
+                if (isNonceError || isTimeoutError || isExecutionError || isNetworkError) {
                     retryCount += 1;
                     if (retryCount < maxRetries) {
                         gasPrice = Math.ceil(gasPrice * 1.2);
+                        let errorType = 'Nonce';
+                        if (isTimeoutError) errorType = 'Timeout';
+                        else if (isExecutionError) errorType = 'Execution/fee';
+                        else if (isNetworkError) errorType = 'Network';
                         this.logger.warn(
-                            `${
-                                isTimeoutError ? 'Timeout' : 'Nonce'
-                            } error detected for ${functionName} on ${this.getBlockchainId()}. ` +
+                            `${errorType} error detected for ${functionName} on ${this.getBlockchainId()}. ` +
                                 `Retrying with increased gas price: ${gasPrice} (retry ${retryCount}/${maxRetries})`,
                         );
                         continue;
                     }
+                    let errorType = 'nonce';
+                    if (isTimeoutError) errorType = 'timeout';
+                    else if (isExecutionError) errorType = 'execution/fee';
+                    else if (isNetworkError) errorType = 'network';
                     this.logger.error(
-                        `Max retries (${maxRetries}) reached for ${
-                            isTimeoutError ? 'timeout' : 'nonce'
-                        } error in ${functionName} on ${this.getBlockchainId()}. ` +
+                        `Max retries (${maxRetries}) reached for ${errorType} error in ${functionName} on ${this.getBlockchainId()}. ` +
                             `Final gas price: ${gasPrice}`,
                     );
                 }