@lifi/sdk 2.2.2 → 3.0.0-alpha.1

package/dist/cjs/execution/StepExecutionManager.js

@@ -4,32 +4,34 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StepExecutionManager = void 0;
-const ethers_1 = require("ethers");
-const allowance_1 = require("../allowance");
-const balance_1 = require("../balance");
+const viem_1 = require("viem");
 const ApiService_1 = __importDefault(require("../services/ApiService"));
 const ChainsService_1 = __importDefault(require("../services/ChainsService"));
+const ConfigService_1 = __importDefault(require("../services/ConfigService"));
+const utils_1 = require("../utils");
 const errors_1 = require("../utils/errors");
-const getProvider_1 = require("../utils/getProvider");
 const parseError_1 = require("../utils/parseError");
-const utils_1 = require("../utils/utils");
+const utils_2 = require("../utils/utils");
+const checkAllowance_1 = require("./checkAllowance");
+const checkBalance_1 = require("./checkBalance");
+const multisig_1 = require("./multisig");
 const stepComparison_1 = require("./stepComparison");
 const switchChain_1 = require("./switchChain");
-const utils_2 = require("./utils");
-const ConfigService_1 = __importDefault(require("../services/ConfigService"));
-const multisig_1 = require("./multisig");
+const utils_3 = require("./utils");
+const waitForReceivingTransaction_1 = require("./waitForReceivingTransaction");
 class StepExecutionManager {
     constructor() {
         this.allowUserInteraction = true;
         this.allowInteraction = (value) => {
             this.allowUserInteraction = value;
         };
-        this.execute = async ({ signer, step, statusManager, settings, }) => {
+        this.execute = async ({ walletClient, step, statusManager, settings, }) => {
+            const client = walletClient.extend(viem_1.publicActions);
             const config = ConfigService_1.default.getInstance().getConfig();
-            const isMultisigSigner = !!config.multisigConfig?.isMultisigSigner;
+            const isMultisigWalletClient = !!config.multisig?.isMultisigWalletClient;
             const multisigBatchTransactions = [];
-            const shouldBatchTransactions = config.multisigConfig?.shouldBatchTransactions &&
-                !!config.multisigConfig.sendBatchTransaction;
+            const shouldBatchTransactions = config.multisig?.shouldBatchTransactions &&
+                !!config.multisig.sendBatchTransaction;
             step.execution = statusManager.initExecutionObject(step);
             const chainsService = ChainsService_1.default.getInstance();
             const fromChain = await chainsService.getChainById(step.action.fromChainId);
@@ -40,21 +42,17 @@ class StepExecutionManager {
             const existingProcess = step.execution.process.find((p) => p.type === currentProcessType);
             // Check token approval only if fromToken is not the native token => no approval needed in that case
             const checkForAllowance = !existingProcess?.txHash &&
-                !(0, utils_1.isZeroAddress)(step.action.fromToken.address) &&
-                (shouldBatchTransactions || !isMultisigSigner);
+                !(0, utils_2.isZeroAddress)(step.action.fromToken.address) &&
+                (shouldBatchTransactions || !isMultisigWalletClient);
             if (checkForAllowance) {
-                const populatedTransaction = await (0, allowance_1.checkAllowance)(signer, step, statusManager, settings, fromChain, this.allowUserInteraction, shouldBatchTransactions);
-                if (populatedTransaction) {
-                    const { to, data } = populatedTransaction;
-                    if (to && data) {
-                        // allowance doesn't need value
-                        const cleanedPopulatedTransaction = {
-                            value: ethers_1.BigNumber.from(0).toString(),
-                            to,
-                            data,
-                        };
-                        multisigBatchTransactions.push(cleanedPopulatedTransaction);
-                    }
+                const data = await (0, checkAllowance_1.checkAllowance)(client, step, statusManager, settings, fromChain, this.allowUserInteraction, shouldBatchTransactions);
+                if (data) {
+                    // allowance doesn't need value
+                    const baseTransaction = {
+                        to: step.action.fromToken.address,
+                        data,
+                    };
+                    multisigBatchTransactions.push(baseTransaction);
                 }
             }
             // STEP 2: Get transaction
@@ -62,136 +60,143 @@ class StepExecutionManager {
             if (process.status !== 'DONE') {
                 const multisigProcess = step.execution.process.find((p) => !!p.multisigTxHash);
                 try {
-                    if (isMultisigSigner && multisigProcess) {
-                        if (!multisigProcess) {
-                            throw new errors_1.ValidationError('Multisig process is undefined.');
-                        }
-                        if (!config.multisigConfig?.getMultisigTransactionDetails) {
-                            throw new errors_1.ValidationError('"getMultisigTransactionDetails()" is missing in Multisig config.');
-                        }
+                    if (isMultisigWalletClient && multisigProcess) {
                         const multisigTxHash = multisigProcess.multisigTxHash;
                         if (!multisigTxHash) {
-                            // need to check what happens in failed tx
                             throw new errors_1.ValidationError('Multisig internal transaction hash is undefined.');
                         }
-                        await (0, multisig_1.updateMultisigRouteProcess)(multisigTxHash, step, statusManager, process, fromChain);
+                        await (0, multisig_1.updateMultisigRouteProcess)(multisigTxHash, step, statusManager, process.type, fromChain);
                     }
-                    let transaction;
+                    let txHash;
                     if (process.txHash) {
                         // Make sure that the chain is still correct
-                        const updatedSigner = await (0, switchChain_1.switchChain)(signer, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
-                        if (!updatedSigner) {
+                        const updatedWalletClient = await (0, switchChain_1.switchChain)(walletClient, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
+                        if (!updatedWalletClient) {
                             // Chain switch was not successful, stop execution here
                             return step.execution;
                         }
-                        signer = updatedSigner;
+                        walletClient = updatedWalletClient;
                         // Load exiting transaction
-                        transaction = await (0, getProvider_1.getProvider)(signer).getTransaction(process.txHash);
+                        txHash = process.txHash;
                     }
                     else {
                         process = statusManager.updateProcess(step, process.type, 'STARTED');
                         // Check balance
-                        await (0, balance_1.checkBalance)(signer, step);
+                        await (0, checkBalance_1.checkBalance)(client.account.address, step);
                         // Create new transaction
                         if (!step.transactionRequest) {
-                            const personalizedStep = await (0, utils_1.personalizeStep)(signer, step);
-                            const updatedStep = await ApiService_1.default.getStepTransaction(personalizedStep);
-                            const comparedStep = await (0, stepComparison_1.stepComparison)(statusManager, personalizedStep, updatedStep, settings, this.allowUserInteraction);
+                            const updatedStep = await ApiService_1.default.getStepTransaction(step);
+                            const comparedStep = await (0, stepComparison_1.stepComparison)(statusManager, step, updatedStep, settings, this.allowUserInteraction);
                             step = {
                                 ...comparedStep,
                                 execution: step.execution,
                             };
                         }
-                        const { transactionRequest } = step;
+                        let transactionRequest = {
+                            to: step.transactionRequest?.to,
+                            from: step.transactionRequest?.from,
+                            data: step.transactionRequest?.data,
+                            value: step.transactionRequest?.value
+                                ? BigInt(step.transactionRequest.value)
+                                : undefined,
+                            maxPriorityFeePerGas: walletClient.account?.type === 'local'
+                                ? await (0, utils_1.getMaxPriorityFeePerGas)(client)
+                                : undefined,
+                            // gas: step.transactionRequest?.gasLimit
+                            //   ? BigInt(step.transactionRequest.gasLimit as string)
+                            //   : undefined,
+                            // gasPrice: step.transactionRequest?.gasPrice
+                            //   ? BigInt(step.transactionRequest.gasPrice as string)
+                            //   : undefined,
+                            // maxFeePerGas: step.transactionRequest?.maxFeePerGas
+                            //   ? BigInt(step.transactionRequest.maxFeePerGas as string)
+                            //   : undefined,
+                            // maxPriorityFeePerGas: step.transactionRequest?.maxPriorityFeePerGas
+                            //   ? BigInt(step.transactionRequest.maxPriorityFeePerGas as string)
+                            //   : undefined,
+                        };
                         if (!transactionRequest) {
-                            throw new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
+                            throw new errors_1.TransactionError(errors_1.LiFiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
                         }
                         // STEP 3: Send the transaction
                         // Make sure that the chain is still correct
-                        const updatedSigner = await (0, switchChain_1.switchChain)(signer, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
-                        if (!updatedSigner) {
+                        const updatedWalletClient = await (0, switchChain_1.switchChain)(walletClient, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
+                        if (!updatedWalletClient) {
                             // Chain switch was not successful, stop execution here
                             return step.execution;
                         }
-                        signer = updatedSigner;
+                        walletClient = updatedWalletClient;
                         process = statusManager.updateProcess(step, process.type, 'ACTION_REQUIRED');
                         if (!this.allowUserInteraction) {
                             return step.execution;
                         }
                         if (settings.updateTransactionRequestHook) {
-                            const customConfig = await settings.updateTransactionRequestHook(transactionRequest);
-                            transactionRequest.gasLimit = customConfig.gasLimit;
-                            transactionRequest.gasPrice = customConfig.gasPrice;
-                            transactionRequest.maxPriorityFeePerGas =
-                                customConfig.maxPriorityFeePerGas;
-                            transactionRequest.maxFeePerGas = customConfig.maxFeePerGas;
-                        }
-                        else {
-                            try {
-                                const estimatedGasLimit = await signer.estimateGas(transactionRequest);
-                                if (estimatedGasLimit) {
-                                    transactionRequest.gasLimit = ethers_1.BigNumber.from(`${(BigInt(estimatedGasLimit.toString()) * 125n) / 100n}`);
-                                }
-                                // Fetch latest gasPrice from provider and use it
-                                const gasPrice = await signer.getGasPrice();
-                                if (gasPrice) {
-                                    transactionRequest.gasPrice = gasPrice;
-                                }
-                            }
-                            catch (error) { }
+                            const customizedTransactionRequest = await settings.updateTransactionRequestHook(transactionRequest);
+                            transactionRequest = {
+                                ...transactionRequest,
+                                ...customizedTransactionRequest,
+                            };
                         }
-                        // Submit the transaction
                         if (shouldBatchTransactions &&
-                            config.multisigConfig?.sendBatchTransaction) {
-                            const { to, data, value } = await signer.populateTransaction(transactionRequest);
-                            const isValidTransaction = to && data;
-                            if (isValidTransaction) {
+                            config.multisig?.sendBatchTransaction) {
+                            if (transactionRequest.to && transactionRequest.data) {
                                 const populatedTransaction = {
-                                    value: value?.toString() ?? ethers_1.BigNumber.from(0).toString(),
-                                    to,
-                                    data: data.toString(),
+                                    value: transactionRequest.value,
+                                    to: transactionRequest.to,
+                                    data: transactionRequest.data,
                                 };
                                 multisigBatchTransactions.push(populatedTransaction);
-                                transaction = await config.multisigConfig?.sendBatchTransaction(multisigBatchTransactions);
+                                txHash = await config.multisig?.sendBatchTransaction(multisigBatchTransactions);
                             }
                             else {
-                                throw new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
+                                throw new errors_1.TransactionError(errors_1.LiFiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
                             }
                         }
                         else {
-                            transaction = await signer.sendTransaction(transactionRequest);
+                            txHash = await walletClient.sendTransaction({
+                                to: transactionRequest.to,
+                                account: walletClient.account,
+                                data: transactionRequest.data,
+                                maxPriorityFeePerGas: transactionRequest.maxPriorityFeePerGas,
+                                chain: null,
+                            });
                         }
                         // STEP 4: Wait for the transaction
-                        if (isMultisigSigner) {
+                        if (isMultisigWalletClient) {
                             process = statusManager.updateProcess(step, process.type, 'ACTION_REQUIRED', {
-                                multisigTxHash: transaction.hash,
+                                multisigTxHash: txHash,
                             });
                         }
                         else {
                             process = statusManager.updateProcess(step, process.type, 'PENDING', {
-                                txHash: transaction.hash,
-                                txLink: fromChain.metamask.blockExplorerUrls[0] +
-                                    'tx/' +
-                                    transaction.hash,
+                                txHash: txHash,
+                                txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${txHash}`,
                             });
                         }
                     }
-                    await transaction.wait?.();
-                    // if it's multisig signer and the process is in ACTION_REQUIRED
+                    let replacementReason;
+                    const transactionReceipt = await client.waitForTransactionReceipt({
+                        hash: txHash,
+                        onReplaced(response) {
+                            replacementReason = response.reason;
+                            statusManager.updateProcess(step, process.type, 'PENDING', {
+                                txHash: response.transaction.hash,
+                                txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${response.transaction.hash}`,
+                            });
+                        },
+                    });
+                    if (replacementReason === 'cancelled') {
+                        throw new errors_1.TransactionError(errors_1.LiFiErrorCode.TransactionCanceled, 'User canceled transaction.');
+                    }
+                    // if it's multisig wallet client and the process is in ACTION_REQUIRED
                     // then signatures are still needed
-                    if (isMultisigSigner &&
-                        process.status === 'ACTION_REQUIRED' &&
-                        transaction.hash) {
-                        // Return the execution object without updating the process
-                        // The execution would progress once all multisigs signer approve
-                        await (0, multisig_1.updateMultisigRouteProcess)(transaction.hash, step, statusManager, process, fromChain);
+                    if (isMultisigWalletClient && process.status === 'ACTION_REQUIRED') {
+                        await (0, multisig_1.updateMultisigRouteProcess)(transactionReceipt.transactionHash, step, statusManager, process.type, fromChain);
                     }
-                    if (!isMultisigSigner) {
+                    if (!isMultisigWalletClient) {
                         process = statusManager.updateProcess(step, process.type, 'PENDING', {
-                            txHash: transaction.hash,
-                            txLink: fromChain.metamask.blockExplorerUrls[0] +
-                                'tx/' +
-                                transaction.hash,
+                            txHash: transactionReceipt.transactionHash,
+                            txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${transactionReceipt.transactionHash}`,
                         });
                     }
                     if (isBridgeExecution) {
@@ -199,26 +204,16 @@ class StepExecutionManager {
                     }
                 }
                 catch (e) {
-                    if (e.code === 'TRANSACTION_REPLACED' && e.replacement) {
-                        process = statusManager.updateProcess(step, process.type, 'DONE', {
-                            txHash: e.replacement.hash,
-                            txLink: fromChain.metamask.blockExplorerUrls[0] +
-                                'tx/' +
-                                e.replacement.hash,
-                        });
-                    }
-                    else {
-                        const error = await (0, parseError_1.parseError)(e, step, process);
-                        process = statusManager.updateProcess(step, process.type, 'FAILED', {
-                            error: {
-                                message: error.message,
-                                htmlMessage: error.htmlMessage,
-                                code: error.code,
-                            },
-                        });
-                        statusManager.updateExecution(step, 'FAILED');
-                        throw error;
-                    }
+                    const error = await (0, parseError_1.parseError)(e, step, process);
+                    process = statusManager.updateProcess(step, process.type, 'FAILED', {
+                        error: {
+                            message: error.message,
+                            htmlMessage: error.htmlMessage,
+                            code: error.code,
+                        },
+                    });
+                    statusManager.updateExecution(step, 'FAILED');
+                    throw error;
                 }
             }
             // STEP 5: Wait for the receiving chain
@@ -231,16 +226,14 @@ class StepExecutionManager {
                 if (!processTxHash) {
                     throw new Error('Transaction hash is undefined.');
                 }
-                statusResponse = (await (0, utils_2.waitForReceivingTransaction)(processTxHash, statusManager, process.type, step));
+                statusResponse = (await (0, waitForReceivingTransaction_1.waitForReceivingTransaction)(processTxHash, statusManager, process.type, step));
                 const statusReceiving = statusResponse.receiving;
                 process = statusManager.updateProcess(step, process.type, 'DONE', {
                     substatus: statusResponse.substatus,
                     substatusMessage: statusResponse.substatusMessage ||
-                        (0, utils_2.getSubstatusMessage)(statusResponse.status, statusResponse.substatus),
+                        (0, utils_3.getSubstatusMessage)(statusResponse.status, statusResponse.substatus),
                     txHash: statusReceiving?.txHash,
-                    txLink: toChain.metamask.blockExplorerUrls[0] +
-                        'tx/' +
-                        statusReceiving?.txHash,
+                    txLink: `${toChain.metamask.blockExplorerUrls[0]}tx/${statusReceiving?.txHash}`,
                 });
                 statusManager.updateExecution(step, 'DONE', {
                     fromAmount: statusResponse.sending.amount,
@@ -257,7 +250,7 @@ class StepExecutionManager {
                 const htmlMessage = await (0, parseError_1.getTransactionFailedMessage)(step, process.txLink);
                 process = statusManager.updateProcess(step, process.type, 'FAILED', {
                     error: {
-                        code: errors_1.LifiErrorCode.TransactionFailed,
+                        code: errors_1.LiFiErrorCode.TransactionFailed,
                         message: 'Failed while waiting for receiving chain.',
                         htmlMessage,
                     },

package/dist/cjs/execution/StepExecutor.d.ts

@@ -1,6 +1,6 @@
-import { Signer } from 'ethers';
-import { InteractionSettings, InternalExecutionSettings, LifiStep } from '../types';
-import { StatusManager } from './StatusManager';
+import type { WalletClient } from 'viem';
+import type { InteractionSettings, InternalExecutionSettings, LifiStep } from '../types';
+import type { StatusManager } from './StatusManager';
 import { StepExecutionManager } from './StepExecutionManager';
 export declare class StepExecutor {
     stepExecutionManager: StepExecutionManager;
@@ -11,5 +11,5 @@ export declare class StepExecutor {
     constructor(statusManager: StatusManager, settings: InternalExecutionSettings);
     setInteraction: (settings?: InteractionSettings) => void;
     checkChain: () => never;
-    executeStep: (signer: Signer, step: LifiStep) => Promise<LifiStep>;
+    executeStep: (walletClient: WalletClient, step: LifiStep) => Promise<LifiStep>;
 }

package/dist/cjs/execution/StepExecutor.js

@@ -23,13 +23,13 @@ class StepExecutor {
             this.statusManager.allowUpdates(interactionSettings.allowUpdates);
             this.executionStopped = interactionSettings.stopExecution;
         };
-        // TODO: add checkChain method and update signer inside executors
+        // TODO: add checkChain method and update wallet client inside executors
         // This can come in handy when we execute multiple routes simultaneously and
         // should be sure that we are on the right chain when waiting for transactions.
         this.checkChain = () => {
             throw new Error('checkChain is not implemented.');
         };
-        this.executeStep = async (signer, step) => {
+        this.executeStep = async (walletClient, step) => {
             // Make sure that the chain is still correct
             // Find if it's bridging and the step is waiting for a transaction on the receiving chain
             const recievingChainProcess = step.execution?.process.find((process) => process.type === 'RECEIVING_CHAIN');
@@ -38,15 +38,15 @@ class StepExecutor {
             // Return the step
             if (recievingChainProcess?.substatus !== 'WAIT_DESTINATION_TRANSACTION' ||
                 !recievingChainProcess) {
-                const updatedSigner = await (0, switchChain_1.switchChain)(signer, this.statusManager, step, this.settings.switchChainHook, this.allowUserInteraction);
-                if (!updatedSigner) {
+                const updatedWalletClient = await (0, switchChain_1.switchChain)(walletClient, this.statusManager, step, this.settings.switchChainHook, this.allowUserInteraction);
+                if (!updatedWalletClient) {
                     // Chain switch was not successful, stop execution here
                     return step;
                 }
-                signer = updatedSigner;
+                walletClient = updatedWalletClient;
             }
             const parameters = {
-                signer,
+                walletClient,
                 step,
                 settings: this.settings,
                 statusManager: this.statusManager,

package/dist/cjs/execution/checkAllowance.d.ts

@@ -0,0 +1,4 @@
+import type { Hash, WalletClient } from 'viem';
+import type { StatusManager } from '../execution/StatusManager';
+import type { Chain, InternalExecutionSettings, LifiStep } from '../types';
+export declare const checkAllowance: (walletClient: WalletClient, step: LifiStep, statusManager: StatusManager, settings: InternalExecutionSettings, chain: Chain, allowUserInteraction?: boolean, shouldBatchTransactions?: boolean) => Promise<Hash | void>;

package/dist/cjs/execution/checkAllowance.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAllowance = void 0;
+const viem_1 = require("viem");
+const allowance_1 = require("../allowance");
+const utils_1 = require("../utils");
+const parseError_1 = require("../utils/parseError");
+const checkAllowance = async (walletClient, step, statusManager, settings, chain, allowUserInteraction = false, shouldBatchTransactions = false) => {
+    // Ask the user to set an allowance
+    let allowanceProcess = statusManager.findOrCreateProcess(step, 'TOKEN_ALLOWANCE');
+    // Check allowance
+    try {
+        if (allowanceProcess.txHash && allowanceProcess.status !== 'DONE') {
+            await waitForApprovalTransaction(walletClient, allowanceProcess.txHash, allowanceProcess.type, step, chain, statusManager);
+        }
+        else {
+            const approved = await (0, allowance_1.getAllowance)(chain.id, step.action.fromToken.address, walletClient.account.address, step.estimate.approvalAddress);
+            const fromAmount = BigInt(step.action.fromAmount);
+            if (fromAmount > approved) {
+                if (!allowUserInteraction) {
+                    return;
+                }
+                const approvalAmount = settings.infiniteApproval
+                    ? viem_1.maxUint256
+                    : fromAmount;
+                if (shouldBatchTransactions) {
+                    const approveTxHash = await (0, allowance_1.setAllowance)(walletClient, step.action.fromToken.address, step.estimate.approvalAddress, approvalAmount, true);
+                    allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
+                    return approveTxHash;
+                }
+                const approveTxHash = await (0, allowance_1.setAllowance)(walletClient, step.action.fromToken.address, step.estimate.approvalAddress, approvalAmount);
+                await waitForApprovalTransaction(walletClient, approveTxHash, allowanceProcess.type, step, chain, statusManager);
+            }
+            else {
+                allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
+            }
+        }
+    }
+    catch (e) {
+        const error = await (0, parseError_1.parseError)(e, step, allowanceProcess);
+        allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'FAILED', {
+            error: {
+                message: error.message,
+                htmlMessage: error.htmlMessage,
+                code: error.code,
+            },
+        });
+        statusManager.updateExecution(step, 'FAILED');
+        throw error;
+    }
+};
+exports.checkAllowance = checkAllowance;
+const waitForApprovalTransaction = async (walletClient, txHash, processType, step, chain, statusManager) => {
+    const client = walletClient.extend(viem_1.publicActions);
+    statusManager.updateProcess(step, processType, 'PENDING', {
+        txHash,
+        txLink: `${chain.metamask.blockExplorerUrls[0]}tx/${txHash}`,
+    });
+    let replacementReason;
+    const transactionReceipt = await client.waitForTransactionReceipt({
+        hash: txHash,
+        onReplaced(response) {
+            replacementReason = response.reason;
+            statusManager.updateProcess(step, processType, 'PENDING', {
+                txHash: response.transaction.hash,
+                txLink: `${chain.metamask.blockExplorerUrls[0]}tx/${response.transaction.hash}`,
+            });
+        },
+    });
+    if (replacementReason === 'cancelled') {
+        throw new utils_1.TransactionError(utils_1.LiFiErrorCode.TransactionCanceled, 'User canceled transaction.');
+    }
+    statusManager.updateProcess(step, processType, 'DONE', {
+        txHash: transactionReceipt.transactionHash,
+        txLink: `${chain.metamask.blockExplorerUrls[0]}tx/${transactionReceipt.transactionHash}`,
+    });
+};

package/dist/cjs/execution/checkBalance.d.ts

@@ -0,0 +1,2 @@
+import type { LifiStep } from '..';
+export declare const checkBalance: (walletAddress: string, step: LifiStep, depth?: number) => Promise<void>;

package/dist/cjs/execution/checkBalance.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkBalance = void 0;
+const viem_1 = require("viem");
+const balance_1 = require("../balance");
+const errors_1 = require("../utils/errors");
+const checkBalance = async (walletAddress, step, depth = 0) => {
+    const token = await (0, balance_1.getTokenBalance)(walletAddress, step.action.fromToken);
+    if (token) {
+        const currentBalance = token.amount ?? 0n;
+        const neededBalance = BigInt(step.action.fromAmount);
+        if (currentBalance < neededBalance) {
+            if (depth <= 3) {
+                await new Promise((resolve) => {
+                    setTimeout(resolve, 200);
+                });
+                await (0, exports.checkBalance)(walletAddress, step, depth + 1);
+            }
+            else if ((neededBalance * BigInt((1 - step.action.slippage) * 1000000000)) /
+                1000000000n <=
+                currentBalance) {
+                // adjust amount in slippage limits
+                step.action.fromAmount = currentBalance.toString();
+            }
+            else {
+                const neeeded = (0, viem_1.formatUnits)(neededBalance, token.decimals);
+                const current = (0, viem_1.formatUnits)(currentBalance, token.decimals);
+                let errorMessage = `Your ${token.symbol} balance is too low, ` +
+                    `you try to transfer ${neeeded} ${token.symbol}, ` +
+                    `but your wallet only holds ${current} ${token.symbol}. ` +
+                    `No funds have been sent.`;
+                if (currentBalance !== 0n) {
+                    errorMessage +=
+                        `If the problem consists, please delete this transfer and ` +
+                            `start a new one with a maximum of ${current} ${token.symbol}.`;
+                }
+                throw new errors_1.BalanceError('The balance is too low.', errorMessage);
+            }
+        }
+    }
+};
+exports.checkBalance = checkBalance;

package/dist/cjs/execution/multisig.d.ts

@@ -1,3 +1,4 @@
-import { ExtendedChain, LifiStep, Process } from '@lifi/types';
-import { StatusManager } from '.';
-export declare const updateMultisigRouteProcess: (internalTxHash: string, step: LifiStep, statusManager: StatusManager, process: Process, fromChain: ExtendedChain) => Promise<void>;
+import type { ExtendedChain, LifiStep, ProcessType } from '@lifi/types';
+import type { Hash } from 'viem';
+import type { StatusManager } from '.';
+export declare const updateMultisigRouteProcess: (internalTxHash: Hash, step: LifiStep, statusManager: StatusManager, processType: ProcessType, fromChain: ExtendedChain) => Promise<void>;

package/dist/cjs/execution/multisig.js

@@ -6,29 +6,27 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateMultisigRouteProcess = void 0;
 const ConfigService_1 = __importDefault(require("../services/ConfigService"));
 const errors_1 = require("../utils/errors");
-const updateMultisigRouteProcess = async (internalTxHash, step, statusManager, process, fromChain) => {
+const updateMultisigRouteProcess = async (internalTxHash, step, statusManager, processType, fromChain) => {
     const config = ConfigService_1.default.getInstance().getConfig();
-    if (!config.multisigConfig?.getMultisigTransactionDetails) {
-        throw new Error('"getMultisigTransactionDetails()" is missing in Multisig config.');
+    if (!config.multisig?.getMultisigTransactionDetails) {
+        throw new Error('getMultisigTransactionDetails is missing in multisig config.');
     }
     const updateIntermediateMultisigStatus = () => {
-        process = statusManager.updateProcess(step, process.type, 'PENDING');
+        statusManager.updateProcess(step, processType, 'PENDING');
     };
-    const multisigStatusResponse = await config.multisigConfig?.getMultisigTransactionDetails(internalTxHash, fromChain.id, updateIntermediateMultisigStatus);
+    const multisigStatusResponse = await config.multisig?.getMultisigTransactionDetails(internalTxHash, fromChain.id, updateIntermediateMultisigStatus);
     if (multisigStatusResponse.status === 'DONE') {
-        process = statusManager.updateProcess(step, process.type, 'PENDING', {
+        statusManager.updateProcess(step, processType, 'PENDING', {
             txHash: multisigStatusResponse.txHash,
             multisigTxHash: undefined,
-            txLink: fromChain.metamask.blockExplorerUrls[0] +
-                'tx/' +
-                multisigStatusResponse.txHash,
+            txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${multisigStatusResponse.txHash}`,
         });
     }
     if (multisigStatusResponse.status === 'FAILED') {
-        throw new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionFailed, 'Multisig transaction failed.');
+        throw new errors_1.TransactionError(errors_1.LiFiErrorCode.TransactionFailed, 'Multisig transaction failed.');
     }
     if (multisigStatusResponse.status === 'CANCELLED') {
-        throw new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionRejected, 'Transaction was rejected by users.');
+        throw new errors_1.TransactionError(errors_1.LiFiErrorCode.SignatureRejected, 'Transaction was rejected by user.');
     }
 };
 exports.updateMultisigRouteProcess = updateMultisigRouteProcess;

package/dist/cjs/execution/prepareRestart.d.ts

@@ -0,0 +1,3 @@
+import { type WalletClient } from 'viem';
+import type { Route } from '../types';
+export declare const prepareRestart: (route: Route, walletClient: WalletClient) => Promise<void>;