@lifi/sdk 2.2.3 → 3.0.0-alpha.2

package/dist/execution/StepExecutionManager.d.ts

@@ -1,7 +1,7 @@
-import { Execution } from '@lifi/types';
-import { ExecutionParams } from '../types';
+import type { Execution } from '@lifi/types';
+import type { ExecutionParams } from '../types';
 export declare class StepExecutionManager {
     allowUserInteraction: boolean;
     allowInteraction: (value: boolean) => void;
-    execute: ({ signer, step, statusManager, settings, }: ExecutionParams) => Promise<Execution>;
+    execute: ({ walletClient, step, statusManager, settings, }: ExecutionParams) => Promise<Execution>;
 }

package/dist/execution/StepExecutionManager.js

@@ -1,29 +1,31 @@
-import { BigNumber } from 'ethers';
-import { checkAllowance } from '../allowance';
-import { checkBalance } from '../balance';
+import { publicActions } from 'viem';
 import ApiService from '../services/ApiService';
 import ChainsService from '../services/ChainsService';
-import { LifiErrorCode, TransactionError, ValidationError, } from '../utils/errors';
-import { getProvider } from '../utils/getProvider';
+import ConfigService from '../services/ConfigService';
+import { getMaxPriorityFeePerGas } from '../utils';
+import { LiFiErrorCode, TransactionError, ValidationError, } from '../utils/errors';
 import { getTransactionFailedMessage, parseError } from '../utils/parseError';
-import { isZeroAddress, personalizeStep } from '../utils/utils';
+import { isZeroAddress } from '../utils/utils';
+import { checkAllowance } from './checkAllowance';
+import { checkBalance } from './checkBalance';
+import { updateMultisigRouteProcess } from './multisig';
 import { stepComparison } from './stepComparison';
 import { switchChain } from './switchChain';
-import { getSubstatusMessage, waitForReceivingTransaction } from './utils';
-import ConfigService from '../services/ConfigService';
-import { updateMultisigRouteProcess } from './multisig';
+import { getSubstatusMessage } from './utils';
+import { waitForReceivingTransaction } from './waitForReceivingTransaction';
 export 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(publicActions);
             const config = ConfigService.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.getInstance();
             const fromChain = await chainsService.getChainById(step.action.fromChainId);
@@ -35,20 +37,16 @@ export class StepExecutionManager {
             // Check token approval only if fromToken is not the native token => no approval needed in that case
             const checkForAllowance = !existingProcess?.txHash &&
                 !isZeroAddress(step.action.fromToken.address) &&
-                (shouldBatchTransactions || !isMultisigSigner);
+                (shouldBatchTransactions || !isMultisigWalletClient);
             if (checkForAllowance) {
-                const populatedTransaction = await 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: BigNumber.from(0).toString(),
-                            to,
-                            data,
-                        };
-                        multisigBatchTransactions.push(cleanedPopulatedTransaction);
-                    }
+                const data = await 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
@@ -56,136 +54,143 @@ export class StepExecutionManager {
             if (process.status !== 'DONE') {
                 const multisigProcess = step.execution.process.find((p) => !!p.multisigTxHash);
                 try {
-                    if (isMultisigSigner && multisigProcess) {
-                        if (!multisigProcess) {
-                            throw new ValidationError('Multisig process is undefined.');
-                        }
-                        if (!config.multisigConfig?.getMultisigTransactionDetails) {
-                            throw new 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 ValidationError('Multisig internal transaction hash is undefined.');
                         }
-                        await updateMultisigRouteProcess(multisigTxHash, step, statusManager, process, fromChain);
+                        await 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 switchChain(signer, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
-                        if (!updatedSigner) {
+                        const updatedWalletClient = await 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 getProvider(signer).getTransaction(process.txHash);
+                        txHash = process.txHash;
                     }
                     else {
                         process = statusManager.updateProcess(step, process.type, 'STARTED');
                         // Check balance
-                        await checkBalance(signer, step);
+                        await checkBalance(client.account.address, step);
                         // Create new transaction
                         if (!step.transactionRequest) {
-                            const personalizedStep = await personalizeStep(signer, step);
-                            const updatedStep = await ApiService.getStepTransaction(personalizedStep);
-                            const comparedStep = await stepComparison(statusManager, personalizedStep, updatedStep, settings, this.allowUserInteraction);
+                            const updatedStep = await ApiService.getStepTransaction(step);
+                            const comparedStep = await 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 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 TransactionError(LifiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
+                            throw new TransactionError(LiFiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
                         }
                         // STEP 3: Send the transaction
                         // Make sure that the chain is still correct
-                        const updatedSigner = await switchChain(signer, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
-                        if (!updatedSigner) {
+                        const updatedWalletClient = await 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 = 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() ?? 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 TransactionError(LifiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
+                                throw new TransactionError(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 TransactionError(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 updateMultisigRouteProcess(transaction.hash, step, statusManager, process, fromChain);
+                    if (isMultisigWalletClient && process.status === 'ACTION_REQUIRED') {
+                        await 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) {
@@ -193,26 +198,16 @@ export 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 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 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
@@ -232,9 +227,7 @@ export class StepExecutionManager {
                     substatusMessage: statusResponse.substatusMessage ||
                         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,
@@ -251,7 +244,7 @@ export class StepExecutionManager {
                 const htmlMessage = await getTransactionFailedMessage(step, process.txLink);
                 process = statusManager.updateProcess(step, process.type, 'FAILED', {
                     error: {
-                        code: LifiErrorCode.TransactionFailed,
+                        code: LiFiErrorCode.TransactionFailed,
                         message: 'Failed while waiting for receiving chain.',
                         htmlMessage,
                     },

package/dist/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/execution/StepExecutor.js

@@ -20,13 +20,13 @@ export 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');
@@ -35,15 +35,15 @@ export class StepExecutor {
             // Return the step
             if (recievingChainProcess?.substatus !== 'WAIT_DESTINATION_TRANSACTION' ||
                 !recievingChainProcess) {
-                const updatedSigner = await switchChain(signer, this.statusManager, step, this.settings.switchChainHook, this.allowUserInteraction);
-                if (!updatedSigner) {
+                const updatedWalletClient = await 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/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/execution/checkAllowance.js

@@ -0,0 +1,73 @@
+import { maxUint256, publicActions } from 'viem';
+import { getAllowance, setAllowance } from '../allowance';
+import { LiFiErrorCode, TransactionError } from '../utils';
+import { parseError } from '../utils/parseError';
+export 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 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
+                    ? maxUint256
+                    : fromAmount;
+                if (shouldBatchTransactions) {
+                    const approveTxHash = await setAllowance(walletClient, step.action.fromToken.address, step.estimate.approvalAddress, approvalAmount, true);
+                    allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
+                    return approveTxHash;
+                }
+                const approveTxHash = await 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 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;
+    }
+};
+const waitForApprovalTransaction = async (walletClient, txHash, processType, step, chain, statusManager) => {
+    const client = walletClient.extend(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 TransactionError(LiFiErrorCode.TransactionCanceled, 'User canceled transaction.');
+    }
+    statusManager.updateProcess(step, processType, 'DONE', {
+        txHash: transactionReceipt.transactionHash,
+        txLink: `${chain.metamask.blockExplorerUrls[0]}tx/${transactionReceipt.transactionHash}`,
+    });
+};

package/dist/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/execution/checkBalance.js

@@ -0,0 +1,38 @@
+import { formatUnits } from 'viem';
+import { getTokenBalance } from '../balance';
+import { BalanceError } from '../utils/errors';
+export const checkBalance = async (walletAddress, step, depth = 0) => {
+    const token = await 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 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 = formatUnits(neededBalance, token.decimals);
+                const current = 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 BalanceError('The balance is too low.', errorMessage);
+            }
+        }
+    }
+};

package/dist/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 './StatusManager';
+export declare const updateMultisigRouteProcess: (internalTxHash: Hash, step: LifiStep, statusManager: StatusManager, processType: ProcessType, fromChain: ExtendedChain) => Promise<void>;

package/dist/execution/multisig.js

@@ -1,27 +1,25 @@
 import ConfigService from '../services/ConfigService';
-import { LifiErrorCode, TransactionError } from '../utils/errors';
-export const updateMultisigRouteProcess = async (internalTxHash, step, statusManager, process, fromChain) => {
+import { LiFiErrorCode, TransactionError } from '../utils/errors';
+export const updateMultisigRouteProcess = async (internalTxHash, step, statusManager, processType, fromChain) => {
     const config = ConfigService.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 TransactionError(LifiErrorCode.TransactionFailed, 'Multisig transaction failed.');
+        throw new TransactionError(LiFiErrorCode.TransactionFailed, 'Multisig transaction failed.');
     }
     if (multisigStatusResponse.status === 'CANCELLED') {
-        throw new TransactionError(LifiErrorCode.TransactionRejected, 'Transaction was rejected by users.');
+        throw new TransactionError(LiFiErrorCode.SignatureRejected, 'Transaction was rejected by user.');
     }
 };

package/dist/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>;