@axelar-network/axelarjs-sdk 0.12.8 → 0.13.1-alpha

package/dist/src/libs/TransactionRecoveryApi/AxelarGMPRecoveryAPI.js

@@ -12,7 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AxelarGMPRecoveryAPI = exports.GMPErrorResponse = exports.GMPErrorMap = void 0;
+exports.AxelarGMPRecoveryAPI = exports.RouteDir = exports.GMPErrorMap = void 0;
 const types_1 = require("../types");
 const AxelarRecoveryApi_1 = require("./AxelarRecoveryApi");
 const EVMClient_1 = __importDefault(require("./client/EVMClient"));
@@ -35,11 +35,12 @@ exports.GMPErrorMap = {
     [AxelarRecoveryApi_1.GMPStatus.DEST_EXECUTED]: types_1.ApproveGatewayError.ALREADY_EXECUTED,
     [AxelarRecoveryApi_1.GMPStatus.DEST_GATEWAY_APPROVED]: types_1.ApproveGatewayError.ALREADY_APPROVED,
 };
-const GMPErrorResponse = (error, errorDetails) => ({
-    success: false,
-    error: errorDetails || error,
-});
-exports.GMPErrorResponse = GMPErrorResponse;
+var RouteDir;
+(function (RouteDir) {
+    RouteDir["COSMOS_TO_EVM"] = "cosmos_to_evm";
+    RouteDir["EVM_TO_COSMOS"] = "evm_to_cosmos";
+    RouteDir["EVM_TO_EVM"] = "evm_to_evm";
+})(RouteDir = exports.RouteDir || (exports.RouteDir = {}));
 class AxelarGMPRecoveryAPI extends AxelarRecoveryApi_1.AxelarRecoveryApi {
     constructor(config) {
         super(config);
@@ -66,11 +67,14 @@ class AxelarGMPRecoveryAPI extends AxelarRecoveryApi_1.AxelarRecoveryApi {
     getCidFromSrcTxHash(destChainId, txHash, eventIndex) {
         return (0, helpers_1.getCommandId)(destChainId, txHash, eventIndex, this.environment, chain_1.default);
     }
-    doesTxMeetConfirmHt(chain, currHeight) {
+    doesTxMeetConfirmHt(chain, txHash) {
         return __awaiter(this, void 0, void 0, function* () {
+            const confirmations = yield this.getSigner(chain)
+                .provider.getTransactionReceipt(txHash)
+                .then((receipt) => receipt.confirmations);
             return this.axelarQueryApi
                 .getConfirmationHeight(chain)
-                .then((res) => res.height.greaterThan(currHeight))
+                .then((minConfirmHeight) => minConfirmHeight <= confirmations)
                 .catch(() => undefined);
         });
     }
@@ -94,265 +98,375 @@ class AxelarGMPRecoveryAPI extends AxelarRecoveryApi_1.AxelarRecoveryApi {
     }
     getEvmEvent(srcChainId, destChainId, srcTxHash, evmWalletDetails) {
         return __awaiter(this, void 0, void 0, function* () {
-            let eventIndex = -1, success = false, errorMessage = "", infoLog = "";
-            try {
-                eventIndex = (yield this.getEventIndex(srcChainId, srcTxHash, evmWalletDetails));
-            }
-            catch (e) {
+            const eventIndex = yield this.getEventIndex(srcChainId, srcTxHash, evmWalletDetails)
+                .then((index) => index)
+                .catch(() => -1);
+            if (eventIndex === -1) {
                 return {
-                    success,
+                    success: false,
                     errorMessage: `getEvmEvent(): could not find event index for ${srcTxHash}`,
                     commandId: "",
                     eventResponse: {},
-                    infoLog,
+                    infoLog: "",
                 };
             }
             const commandId = this.getCidFromSrcTxHash(destChainId, srcTxHash, eventIndex);
-            infoLog = `srcTxHash: ${srcTxHash}, generated commandId: ${commandId}`;
-            const eventResponse = yield this.axelarQueryApi.getEVMEvent(srcChainId, srcTxHash, eventIndex);
+            const eventResponse = yield (0, utils_1.retry)(() => this.axelarQueryApi.getEVMEvent(srcChainId, srcTxHash, eventIndex), 12, 10000);
             if (!eventResponse || this.isEVMEventFailed(eventResponse)) {
-                errorMessage = this.isEVMEventFailed(eventResponse)
+                const errorMessage = this.isEVMEventFailed(eventResponse)
                     ? `getEvmEvent(): event on source chain is not successful for: ${srcTxHash}`
                     : `getEvmEvent(): could not determine status of event: ${srcTxHash}`;
                 return {
-                    success,
+                    success: false,
                     errorMessage,
                     commandId,
                     eventResponse: {},
-                    infoLog,
+                    infoLog: `srcTxHash: ${srcTxHash}, generated commandId: ${commandId}`,
                 };
             }
-            success = true;
-            infoLog = `${srcTxHash} correspondes to command ID: ${commandId}`;
             return {
+                success: true,
                 commandId,
                 eventResponse,
-                success,
-                errorMessage,
-                infoLog,
+                errorMessage: "",
+                infoLog: `${srcTxHash} correspondes to command ID: ${commandId}`,
             };
         });
     }
-    findEventAndConfirmIfNeeded(srcChain, destChain, txHash, evmWalletDetails, sleepSeconds = 60) {
+    findEventAndConfirmIfNeeded(srcChain, destChain, txHash, evmWalletDetails) {
         return __awaiter(this, void 0, void 0, function* () {
-            const res = {
-                confirmTx: null,
-                success: true,
-                errorMessage: "",
-                infoLogs: [],
-                commandId: "",
-                eventResponse: null,
-            };
-            let confirmLog = "";
             if (this.debugMode)
                 console.debug(`confirmation: checking whether ${txHash} needs to be confirmed on Axelar`);
-            const evmEventResponse = yield this.getEvmEvent(srcChain, destChain, txHash, evmWalletDetails);
-            res.commandId = evmEventResponse.commandId;
-            res.eventResponse = evmEventResponse.eventResponse;
-            const { infoLog: getEvmEventInfoLog } = evmEventResponse;
+            const evmEvent = yield this.getEvmEvent(srcChain, destChain, txHash, evmWalletDetails);
+            const { infoLog: getEvmEventInfoLog } = evmEvent;
             if (this.debugMode)
                 console.debug(`confirmation: ${getEvmEventInfoLog}`);
-            if (this.isEVMEventCompleted(res.eventResponse) ||
-                this.isEVMEventConfirmed(res.eventResponse)) {
-                confirmLog = `confirmation: event for ${txHash} was already detected on the network and did not need to be confirmed`;
+            if (this.isEVMEventCompleted(evmEvent.eventResponse) ||
+                this.isEVMEventConfirmed(evmEvent.eventResponse)) {
+                return {
+                    success: true,
+                    commandId: evmEvent.commandId,
+                    eventResponse: evmEvent.eventResponse,
+                    infoLogs: [
+                        `confirmation: event for ${txHash} was already detected on the network and did not need to be confirmed`,
+                    ],
+                };
             }
             else {
-                /**todo, need to check whether tx is finalized */
-                // const confirmationHeight = await this.axelarQueryApi.getConfirmationHeight(srcChain);
-                res.confirmTx = yield this.confirmGatewayTx(txHash, srcChain).catch((e) => {
-                    console.error(e);
-                    return null;
-                });
-                if (!res.confirmTx) {
-                    res.success = false;
-                    res.errorMessage = "findEventAndConfirmIfNeeded(): unable to confirm transaction on Axelar";
-                    return res;
+                const isConfirmFinalized = yield this.doesTxMeetConfirmHt(srcChain, txHash);
+                if (!isConfirmFinalized) {
+                    const minConfirmLevel = yield this.axelarQueryApi.getConfirmationHeight(srcChain);
+                    return {
+                        success: false,
+                        commandId: evmEvent.commandId,
+                        eventResponse: evmEvent.eventResponse,
+                        infoLogs: [],
+                        errorMessage: `findEventAndConfirmIfNeeded(): ${txHash} is not confirmed on ${srcChain}. The minimum confirmation height is ${minConfirmLevel}`,
+                    };
+                }
+                const confirmTx = yield this.confirmGatewayTx(txHash, srcChain).catch(() => undefined);
+                if (!confirmTx) {
+                    return {
+                        success: false,
+                        commandId: evmEvent.commandId,
+                        eventResponse: evmEvent.eventResponse,
+                        infoLogs: [],
+                        errorMessage: `findEventAndConfirmIfNeeded(): could not confirm transaction on Axelar`,
+                    };
                 }
-                confirmLog = `confirmation: successfully confirmed ${txHash} on Axelar; waiting ${sleepSeconds} seconds for network confirmation`;
-                if (this.debugMode)
-                    console.debug(confirmLog);
-                yield (0, utils_1.sleep)(sleepSeconds);
                 const updatedEvent = yield this.getEvmEvent(srcChain, destChain, txHash, evmWalletDetails);
                 if (this.isEVMEventCompleted(updatedEvent === null || updatedEvent === void 0 ? void 0 : updatedEvent.eventResponse)) {
-                    res.eventResponse = updatedEvent.eventResponse;
-                    confirmLog += `; confirmed event was finalized`;
+                    return {
+                        success: true,
+                        commandId: updatedEvent.commandId,
+                        eventResponse: updatedEvent.eventResponse,
+                        infoLogs: [
+                            `confirmation: successfully confirmed ${txHash} on Axelar; confirmed event was finalized`,
+                            getEvmEventInfoLog,
+                        ],
+                    };
                 }
                 else {
-                    res.success = false;
-                    res.errorMessage = `findEventAndConfirmIfNeeded(): could not confirm and finalize event successfully: ${txHash}`;
-                    confirmLog += `; confirmed event was unable to be finalized`;
+                    return {
+                        success: false,
+                        eventResponse: evmEvent.eventResponse,
+                        commandId: updatedEvent.commandId,
+                        errorMessage: `findEventAndConfirmIfNeeded(): could not confirm and finalize event successfully: ${txHash};. Your transaction may not have enough confirmations yet.`,
+                        infoLogs: [
+                            `confirmation: successfully confirmed ${txHash} on Axelar; confirmed event was unable to be finalized`,
+                            getEvmEventInfoLog,
+                        ],
+                    };
                 }
             }
-            if (this.debugMode)
-                console.debug(confirmLog);
-            getEvmEventInfoLog && res.infoLogs.push(getEvmEventInfoLog);
-            res.infoLogs.push(confirmLog);
-            return res;
         });
     }
-    findBatchAndSignIfNeeded(commandId, destChainId, sleepSeconds = 60) {
+    findBatchAndSignIfNeeded(commandId, destChainId) {
         return __awaiter(this, void 0, void 0, function* () {
             let signTxLog = "";
-            const res = {
-                success: true,
-                errorMessage: "",
-                signCommandTx: null,
-                infoLogs: [],
-            };
-            if (this.debugMode)
-                console.debug(`signing: checking whether command ID: ${commandId} needs to be signed`);
             try {
                 const batchData = yield this.fetchBatchData(destChainId, commandId);
                 if (batchData) {
-                    signTxLog = `signing: batch data exists so do not need to sign. commandId: ${commandId}, batchId: ${batchData.batch_id}; waiting ${sleepSeconds} seconds to attempt broadcast`;
+                    signTxLog = `signing: batch data exists so do not need to sign. commandId: ${commandId}, batchId: ${batchData.batch_id}`;
+                    if (this.debugMode)
+                        console.debug(signTxLog);
+                    return {
+                        success: true,
+                        infoLogs: [signTxLog],
+                    };
                 }
                 else {
-                    res.signCommandTx = yield this.signCommands(destChainId);
-                    signTxLog = `signing: signed batch for commandId (${commandId}) in tx: ${res.signCommandTx.transactionHash}; waiting ${sleepSeconds} seconds to attempt broadcast`;
+                    const signCommandTx = yield this.signCommands(destChainId);
+                    signTxLog = `signing: signed batch for commandId (${commandId}) in tx: ${signCommandTx.transactionHash}`;
+                    if (this.debugMode)
+                        console.debug(signTxLog);
+                    return {
+                        success: true,
+                        signCommandTx,
+                        infoLogs: [signTxLog],
+                    };
                 }
-                if (this.debugMode)
-                    console.debug(signTxLog);
-                yield (0, utils_1.sleep)(sleepSeconds);
             }
             catch (e) {
-                console.error(e);
-                res.errorMessage = `findBatchAndSignIfNeeded(): issue retrieving and signing command data: ${commandId}`;
-                res.success = false;
+                return {
+                    success: false,
+                    errorMessage: `findBatchAndSignIfNeeded(): issue retrieving and signing command data: ${commandId}`,
+                    infoLogs: [signTxLog],
+                };
             }
-            res.infoLogs.push(signTxLog);
-            return res;
         });
     }
-    findBatchAndBroadcast(commandId, destChainId, wallet, iter = 0, maxTries = 2) {
+    findBatchAndApproveGateway(commandId, destChainId, wallet) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (iter > maxTries)
-                return {
-                    success: false,
-                    errorMessage: `findBatchAndBroadcast(): this recovery stalled out on waiting for signing. please try again later. `,
-                    approveTx: null,
-                    infoLogs: [],
-                };
             if (this.debugMode)
                 console.debug(`broadcasting: checking for command ID: ${commandId} to broadcast`);
-            let broadcastTxLog = "";
-            const res = {
-                success: true,
-                errorMessage: "",
-                approveTx: null,
-                infoLogs: [],
-            };
-            try {
+            return (0, utils_1.retry)(() => __awaiter(this, void 0, void 0, function* () {
                 const batchData = yield this.fetchBatchData(destChainId, commandId);
                 if (!batchData) {
-                    res.success = false;
-                    res.errorMessage = `findBatchAndBroadcast(): unable to retrieve batch data for ${commandId}`;
-                    return res;
+                    return Promise.reject(`findBatchAndApproveGateway(): unable to retrieve batch data for ${commandId}`);
                 }
                 const commandData = batchData.command_ids.find((t) => t === commandId);
                 if (!commandData) {
-                    res.success = false;
-                    res.errorMessage = `findBatchAndBroadcast(): unable to retrieve command ID (${commandId}) in batch data`;
-                    return res;
+                    return Promise.reject(`findBatchAndApproveGateway(): unable to retrieve command ID (${commandId}) in batch data`);
                 }
-                switch (batchData.status) {
-                    case "BATCHED_COMMANDS_STATUS_SIGNED":
-                        res.approveTx = yield this.sendApproveTx(destChainId, batchData.execute_data, wallet);
-                        broadcastTxLog = `broadcasting: batch ID ${batchData.batch_id} broadcasted to ${destChainId}`;
-                        res.infoLogs.push(broadcastTxLog);
-                        break;
-                    case "BATCHED_COMMANDS_STATUS_SIGNING": {
-                        broadcastTxLog = `broadcasting: batch ID ${batchData.batch_id} signing in process, checking again in 15 seconds`;
-                        if (this.debugMode)
-                            console.debug(broadcastTxLog);
-                        res.infoLogs.push(broadcastTxLog);
-                        (0, utils_1.sleep)(15);
-                        const retry = yield this.findBatchAndBroadcast(commandId, destChainId, wallet, iter + 1, maxTries);
-                        if (retry.infoLogs)
-                            res.infoLogs = [...res.infoLogs, ...retry.infoLogs];
-                        break;
-                    }
-                    default:
-                        res.errorMessage = `findBatchAndBroadcastIfNeeded(): status unsuccessful for command data: ${commandId}`;
-                        res.success = false;
+                if (batchData.status === "BATCHED_COMMANDS_STATUS_SIGNING") {
+                    return Promise.reject(`findBatchAndApproveGateway(): batch ID ${batchData.batch_id} signing in process`);
                 }
-            }
-            catch (e) {
-                res.errorMessage = `findBatchAndBroadcastIfNeeded(): issue retrieving and broadcasting command data: ${commandId}`;
-                res.success = false;
-            }
-            return res;
+                else if (batchData.status === "BATCHED_COMMANDS_STATUS_SIGNED") {
+                    const approveTx = yield this.sendApproveTx(destChainId, batchData.execute_data, wallet);
+                    return {
+                        success: true,
+                        approveTx,
+                        infoLogs: [
+                            `broadcasting: batch ID ${batchData.batch_id} broadcasted to ${destChainId}`,
+                        ],
+                    };
+                }
+                else {
+                    return Promise.reject(`findBatchAndApproveGateway(): batch ID ${batchData.batch_id} is in an unknown state for command data: ${commandId}`);
+                }
+            }), 3, 10).catch((error) => {
+                return {
+                    success: false,
+                    errorMessage: error.message || // error can be both a string or an object with a message property
+                        error ||
+                        `findBatchAndApproveGatewayIfNeeded(): issue retrieving and broadcasting command data: ${commandId}`,
+                    infoLogs: [],
+                };
+            });
         });
     }
     manualRelayToDestChain(txHash, evmWalletDetails, escapeAfterConfirm = true) {
         return __awaiter(this, void 0, void 0, function* () {
-            let confirmTx = null;
-            let signCommandTx = null;
-            let approveTx = null;
-            const success = true;
-            let infoLogs = [];
-            const _evmWalletDetails = evmWalletDetails || { useWindowEthereum: true };
             const { callTx, status } = yield this.queryTransactionStatus(txHash);
             /**first check if transaction is already executed */
             if (exports.GMPErrorMap[status])
-                return (0, exports.GMPErrorResponse)(exports.GMPErrorMap[status]);
+                return {
+                    success: false,
+                    error: exports.GMPErrorMap[status],
+                };
             const srcChain = callTx.chain;
             const destChain = callTx.returnValues.destinationChain;
-            let commandId = "";
-            /**find event and confirm if needed */
-            let confirmTxRequest;
-            try {
-                confirmTxRequest = yield this.findEventAndConfirmIfNeeded(srcChain, destChain, txHash, _evmWalletDetails);
-                confirmTx = confirmTxRequest.confirmTx;
-                commandId = confirmTxRequest.commandId;
-                // eventResponse = confirmTxRequest.eventResponse;
-                if (confirmTxRequest.infoLogs)
-                    infoLogs = [...infoLogs, ...confirmTxRequest.infoLogs];
+            const srcChainInfo = yield this.getChainInfo(srcChain);
+            const destChainInfo = yield this.getChainInfo(destChain);
+            const routeDir = this.getRouteDir(srcChainInfo, destChainInfo);
+            const _evmWalletDetails = evmWalletDetails || { useWindowEthereum: true };
+            if (routeDir === RouteDir.COSMOS_TO_EVM) {
+                return this.recoverCosmosToEvmTx(txHash, _evmWalletDetails);
             }
-            catch (e) {
-                return (0, exports.GMPErrorResponse)(types_1.ApproveGatewayError.CONFIRM_COMMAND_FAILED, e.errorMessage);
+            else if (routeDir === RouteDir.EVM_TO_COSMOS) {
+                return this.recoverEvmToCosmosTx(srcChain, txHash);
+            }
+            else {
+                return this.recoverEvmToEvmTx(srcChain, destChain, txHash, _evmWalletDetails, escapeAfterConfirm);
             }
-            if (!(confirmTxRequest === null || confirmTxRequest === void 0 ? void 0 : confirmTxRequest.success))
-                return (0, exports.GMPErrorResponse)(types_1.ApproveGatewayError.ERROR_BATCHED_COMMAND, confirmTxRequest.errorMessage);
-            else if (confirmTx && escapeAfterConfirm) {
+        });
+    }
+    getRouteDir(srcChain, destChain) {
+        if (srcChain.module === "axelarnet" && destChain.module === "evm") {
+            return RouteDir.COSMOS_TO_EVM;
+        }
+        else if (srcChain.module === "evm" && destChain.module === "axelarnet") {
+            return RouteDir.EVM_TO_COSMOS;
+        }
+        else {
+            return RouteDir.EVM_TO_EVM;
+        }
+    }
+    recoverEvmToCosmosTx(srcChain, txHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Check if the tx is confirmed on the source chain
+            const isConfirmed = yield this.doesTxMeetConfirmHt(srcChain, txHash);
+            if (!isConfirmed) {
+                const minConfirmLevel = yield this.axelarQueryApi.getConfirmationHeight(srcChain);
                 return {
-                    success,
-                    confirmTx,
-                    infoLogs,
+                    success: false,
+                    error: `${txHash} is not confirmed on ${srcChain}. The minimum confirmation height is ${minConfirmLevel}`,
                 };
             }
-            /**find batch and sign if needed */
-            let signTxRequest;
+            // ConfirmGatewayTx and check if it is successfully executed
+            const confirmTx = yield this.confirmGatewayTx(txHash, srcChain).catch(() => undefined);
+            if (!confirmTx) {
+                return {
+                    success: false,
+                    error: "Failed to send ConfirmGatewayTx to Axelar",
+                };
+            }
+            // Fetch all necessary data to send the route message tx
+            const payload = yield this.fetchGMPTransaction(txHash).then((data) => data.call.returnValues.payload);
+            const logIndex = yield this.getEventIndex(srcChain, txHash);
+            // Send the route message tx
+            const routeMessageTx = yield this.routeMessageRequest(txHash, payload, logIndex).catch(() => undefined);
+            // If the `success` flag is false, return the error response
+            if (!routeMessageTx) {
+                return {
+                    success: false,
+                    error: "Failed to send RouteMessage to Axelar",
+                };
+            }
+            // Return the success response
+            return {
+                success: true,
+                confirmTx,
+                routeMessageTx,
+                infoLogs: [
+                    `Successfully sent ConfirmGatewayTx tx for given tx hash ${txHash}`,
+                    `Successfully sent RouteMessage tx for given tx hash ${txHash}`,
+                ],
+            };
+        });
+    }
+    recoverCosmosToEvmTx(txHash, evmWalletDetails) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const txDetails = yield this.fetchGMPTransaction(txHash);
+            const { messageId, payload, destinationChain } = txDetails.call.returnValues;
+            const { command_id: commandId } = txDetails;
+            // Send RouteMessageTx
+            const routeMessageTx = yield this.routeMessageRequest(messageId, payload, -1).catch(() => undefined);
+            if (!routeMessageTx) {
+                return {
+                    success: false,
+                    error: "Failed to send RouteMessage to Axelar",
+                };
+            }
+            // Dispatch a SignCommand transaction and an Approve transaction to the Gateway contract.
+            const response = yield this.signAndApproveGateway(commandId, destinationChain, evmWalletDetails);
+            // If the response.success is false, we will return the error response
+            if (!response.success) {
+                return {
+                    success: false,
+                    error: response.error,
+                };
+            }
+            // Otherwise, we will return the success response
+            const { signCommandTx, infoLogs: signTxLogs } = response;
+            return {
+                success: true,
+                routeMessageTx,
+                signCommandTx,
+                infoLogs: [`Successfully sent RouteMessage tx for given ${txHash}`, ...signTxLogs],
+            };
+        });
+    }
+    recoverEvmToEvmTx(srcChain, destChain, txHash, evmWalletDetails, escapeAfterConfirm = true) {
+        return __awaiter(this, void 0, void 0, function* () {
             try {
-                signTxRequest = yield this.findBatchAndSignIfNeeded(commandId, destChain);
-                signCommandTx = signTxRequest.signCommandTx;
-                if (signTxRequest.infoLogs)
-                    infoLogs = [...infoLogs, ...signTxRequest.infoLogs];
+                // ConfirmGatewayTx and check if it is successfully executed
+                const confirmTxRequest = yield this.findEventAndConfirmIfNeeded(srcChain, destChain, txHash, evmWalletDetails);
+                // If the `success` flag is false, we will return the error response
+                if (!(confirmTxRequest === null || confirmTxRequest === void 0 ? void 0 : confirmTxRequest.success)) {
+                    return {
+                        success: false,
+                        error: confirmTxRequest.errorMessage || types_1.ApproveGatewayError.ERROR_BATCHED_COMMAND,
+                    };
+                }
+                const { infoLogs: confirmTxLogs, commandId, confirmTx } = confirmTxRequest;
+                // If the `escapeAfterConfirm` flag is set to true, we will return the `confirmTx` and `infoLogs` immediately without signing the batch.
+                if (confirmTx && escapeAfterConfirm) {
+                    return {
+                        success: true,
+                        confirmTx,
+                        infoLogs: confirmTxLogs,
+                    };
+                }
+                // Find the batch and sign it
+                const response = yield this.signAndApproveGateway(commandId, destChain, evmWalletDetails);
+                // If the response.success is false, we will return the error response
+                if (!response.success) {
+                    return {
+                        success: false,
+                        error: response.error,
+                    };
+                }
+                // Otherwise, we will return the success response
+                const { signCommandTx, approveTx, infoLogs: signTxLogs } = response;
+                return {
+                    success: true,
+                    confirmTx,
+                    signCommandTx,
+                    approveTx,
+                    infoLogs: [...confirmTxLogs, ...signTxLogs],
+                };
+                // If more code is required here, you can add it below.
             }
             catch (e) {
-                throw `error finding batch to sign, ${e}`;
+                return {
+                    success: false,
+                    error: e.message || types_1.ApproveGatewayError.CONFIRM_COMMAND_FAILED,
+                };
             }
-            if (!(signTxRequest === null || signTxRequest === void 0 ? void 0 : signTxRequest.success))
-                return (0, exports.GMPErrorResponse)(types_1.ApproveGatewayError.SIGN_COMMAND_FAILED, signTxRequest.errorMessage);
-            /**find batch and manually execute if needed */
-            let broadcastTxRequest;
+        });
+    }
+    signAndApproveGateway(commandId, destChain, evmWalletDetails) {
+        return __awaiter(this, void 0, void 0, function* () {
             try {
-                broadcastTxRequest = yield this.findBatchAndBroadcast(commandId, destChain, _evmWalletDetails);
-                approveTx = broadcastTxRequest.approveTx;
-                if (broadcastTxRequest.infoLogs)
-                    infoLogs = [...infoLogs, ...broadcastTxRequest.infoLogs];
+                const signTxRequest = yield this.findBatchAndSignIfNeeded(commandId, destChain);
+                if (!(signTxRequest === null || signTxRequest === void 0 ? void 0 : signTxRequest.success)) {
+                    return {
+                        success: false,
+                        error: signTxRequest.errorMessage || types_1.ApproveGatewayError.SIGN_COMMAND_FAILED,
+                    };
+                }
+                const broadcastTxRequest = yield this.findBatchAndApproveGateway(commandId, destChain, evmWalletDetails);
+                if (!(broadcastTxRequest === null || broadcastTxRequest === void 0 ? void 0 : broadcastTxRequest.success)) {
+                    return {
+                        success: false,
+                        error: broadcastTxRequest.errorMessage || types_1.ApproveGatewayError.ERROR_BROADCAST_EVENT,
+                    };
+                }
+                return {
+                    success: true,
+                    signCommandTx: signTxRequest.signCommandTx,
+                    approveTx: broadcastTxRequest.approveTx,
+                    infoLogs: [...(signTxRequest.infoLogs || []), ...(broadcastTxRequest.infoLogs || [])],
+                };
             }
             catch (e) {
-                throw `error finding batch to broadcast, ${e}`;
+                return {
+                    success: false,
+                    error: e.message || `Error signing and approving gateway for commandId: ${commandId}`,
+                };
             }
-            if (!(broadcastTxRequest === null || broadcastTxRequest === void 0 ? void 0 : broadcastTxRequest.success))
-                return (0, exports.GMPErrorResponse)(types_1.ApproveGatewayError.ERROR_BROADCAST_EVENT, broadcastTxRequest.errorMessage);
-            return {
-                success,
-                confirmTx,
-                signCommandTx,
-                approveTx,
-                infoLogs,
-            };
         });
     }
     /**
@@ -503,7 +617,7 @@ class AxelarGMPRecoveryAPI extends AxelarRecoveryApi_1.AxelarRecoveryApi {
             // Check if given `gasTokenAddress` exists
             if (!gasTokenSymbol)
                 return (0, error_1.InvalidGasTokenError)();
-            const axelarGateway = AxelarGateway_1.AxelarGateway.create(this.environment, chain, signer.provider);
+            const axelarGateway = yield AxelarGateway_1.AxelarGateway.create(this.environment, chain, signer.provider);
             const gatewayGasTokenAddress = yield axelarGateway.getTokenAddress(gasTokenSymbol);
             // Check if given `gasTokenAddress` is supported by Axelar.
             if (gatewayGasTokenAddress === ethers_1.ethers.constants.AddressZero)