@lifi/sdk 3.0.0-alpha.2 → 3.0.0-alpha.20

package/dist/cjs/execution/StepExecutionManager.js

@@ -1,267 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StepExecutionManager = void 0;
-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 parseError_1 = require("../utils/parseError");
-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_3 = require("./utils");
-const waitForReceivingTransaction_1 = require("./waitForReceivingTransaction");
-class StepExecutionManager {
-    constructor() {
-        this.allowUserInteraction = true;
-        this.allowInteraction = (value) => {
-            this.allowUserInteraction = value;
-        };
-        this.execute = async ({ walletClient, step, statusManager, settings, }) => {
-            const client = walletClient.extend(viem_1.publicActions);
-            const config = ConfigService_1.default.getInstance().getConfig();
-            const isMultisigWalletClient = !!config.multisig?.isMultisigWalletClient;
-            const multisigBatchTransactions = [];
-            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);
-            const toChain = await chainsService.getChainById(step.action.toChainId);
-            const isBridgeExecution = fromChain.id !== toChain.id;
-            const currentProcessType = isBridgeExecution ? 'CROSS_CHAIN' : 'SWAP';
-            // STEP 1: Check allowance
-            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_2.isZeroAddress)(step.action.fromToken.address) &&
-                (shouldBatchTransactions || !isMultisigWalletClient);
-            if (checkForAllowance) {
-                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
-            let process = statusManager.findOrCreateProcess(step, currentProcessType);
-            if (process.status !== 'DONE') {
-                const multisigProcess = step.execution.process.find((p) => !!p.multisigTxHash);
-                try {
-                    if (isMultisigWalletClient && multisigProcess) {
-                        const multisigTxHash = multisigProcess.multisigTxHash;
-                        if (!multisigTxHash) {
-                            throw new errors_1.ValidationError('Multisig internal transaction hash is undefined.');
-                        }
-                        await (0, multisig_1.updateMultisigRouteProcess)(multisigTxHash, step, statusManager, process.type, fromChain);
-                    }
-                    let txHash;
-                    if (process.txHash) {
-                        // Make sure that the chain is still correct
-                        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;
-                        }
-                        walletClient = updatedWalletClient;
-                        // Load exiting transaction
-                        txHash = process.txHash;
-                    }
-                    else {
-                        process = statusManager.updateProcess(step, process.type, 'STARTED');
-                        // Check balance
-                        await (0, checkBalance_1.checkBalance)(client.account.address, step);
-                        // Create new transaction
-                        if (!step.transactionRequest) {
-                            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,
-                            };
-                        }
-                        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.');
-                        }
-                        // STEP 3: Send the transaction
-                        // Make sure that the chain is still correct
-                        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;
-                        }
-                        walletClient = updatedWalletClient;
-                        process = statusManager.updateProcess(step, process.type, 'ACTION_REQUIRED');
-                        if (!this.allowUserInteraction) {
-                            return step.execution;
-                        }
-                        if (settings.updateTransactionRequestHook) {
-                            const customizedTransactionRequest = await settings.updateTransactionRequestHook(transactionRequest);
-                            transactionRequest = {
-                                ...transactionRequest,
-                                ...customizedTransactionRequest,
-                            };
-                        }
-                        if (shouldBatchTransactions &&
-                            config.multisig?.sendBatchTransaction) {
-                            if (transactionRequest.to && transactionRequest.data) {
-                                const populatedTransaction = {
-                                    value: transactionRequest.value,
-                                    to: transactionRequest.to,
-                                    data: transactionRequest.data,
-                                };
-                                multisigBatchTransactions.push(populatedTransaction);
-                                txHash = await config.multisig?.sendBatchTransaction(multisigBatchTransactions);
-                            }
-                            else {
-                                throw new errors_1.TransactionError(errors_1.LiFiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
-                            }
-                        }
-                        else {
-                            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 (isMultisigWalletClient) {
-                            process = statusManager.updateProcess(step, process.type, 'ACTION_REQUIRED', {
-                                multisigTxHash: txHash,
-                            });
-                        }
-                        else {
-                            process = statusManager.updateProcess(step, process.type, 'PENDING', {
-                                txHash: txHash,
-                                txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${txHash}`,
-                            });
-                        }
-                    }
-                    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 (isMultisigWalletClient && process.status === 'ACTION_REQUIRED') {
-                        await (0, multisig_1.updateMultisigRouteProcess)(transactionReceipt.transactionHash, step, statusManager, process.type, fromChain);
-                    }
-                    if (!isMultisigWalletClient) {
-                        process = statusManager.updateProcess(step, process.type, 'PENDING', {
-                            txHash: transactionReceipt.transactionHash,
-                            txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${transactionReceipt.transactionHash}`,
-                        });
-                    }
-                    if (isBridgeExecution) {
-                        process = statusManager.updateProcess(step, process.type, 'DONE');
-                    }
-                }
-                catch (e) {
-                    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
-            const processTxHash = process.txHash;
-            if (isBridgeExecution) {
-                process = statusManager.findOrCreateProcess(step, 'RECEIVING_CHAIN', 'PENDING');
-            }
-            let statusResponse;
-            try {
-                if (!processTxHash) {
-                    throw new Error('Transaction hash is undefined.');
-                }
-                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_3.getSubstatusMessage)(statusResponse.status, statusResponse.substatus),
-                    txHash: statusReceiving?.txHash,
-                    txLink: `${toChain.metamask.blockExplorerUrls[0]}tx/${statusReceiving?.txHash}`,
-                });
-                statusManager.updateExecution(step, 'DONE', {
-                    fromAmount: statusResponse.sending.amount,
-                    toAmount: statusReceiving?.amount,
-                    toToken: statusReceiving?.token,
-                    gasAmount: statusResponse.sending.gasAmount,
-                    gasAmountUSD: statusResponse.sending.gasAmountUSD,
-                    gasPrice: statusResponse.sending.gasPrice,
-                    gasToken: statusResponse.sending.gasToken,
-                    gasUsed: statusResponse.sending.gasUsed,
-                });
-            }
-            catch (e) {
-                const htmlMessage = await (0, parseError_1.getTransactionFailedMessage)(step, process.txLink);
-                process = statusManager.updateProcess(step, process.type, 'FAILED', {
-                    error: {
-                        code: errors_1.LiFiErrorCode.TransactionFailed,
-                        message: 'Failed while waiting for receiving chain.',
-                        htmlMessage,
-                    },
-                });
-                statusManager.updateExecution(step, 'FAILED');
-                console.warn(e);
-                throw e;
-            }
-            // DONE
-            return step.execution;
-        };
-    }
-}
-exports.StepExecutionManager = StepExecutionManager;

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

@@ -1,15 +0,0 @@
-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;
-    statusManager: StatusManager;
-    settings: InternalExecutionSettings;
-    allowUserInteraction: boolean;
-    executionStopped: boolean;
-    constructor(statusManager: StatusManager, settings: InternalExecutionSettings);
-    setInteraction: (settings?: InteractionSettings) => void;
-    checkChain: () => never;
-    executeStep: (walletClient: WalletClient, step: LifiStep) => Promise<LifiStep>;
-}

package/dist/cjs/execution/StepExecutor.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StepExecutor = void 0;
-const StepExecutionManager_1 = require("./StepExecutionManager");
-const switchChain_1 = require("./switchChain");
-// Please be careful when changing the defaults as it may break the behavior (e.g., background execution)
-const defaultInteractionSettings = {
-    allowInteraction: true,
-    allowUpdates: true,
-    stopExecution: false,
-};
-class StepExecutor {
-    constructor(statusManager, settings) {
-        this.allowUserInteraction = true;
-        this.executionStopped = false;
-        this.setInteraction = (settings) => {
-            const interactionSettings = {
-                ...defaultInteractionSettings,
-                ...settings,
-            };
-            this.allowUserInteraction = interactionSettings.allowInteraction;
-            this.stepExecutionManager.allowInteraction(interactionSettings.allowInteraction);
-            this.statusManager.allowUpdates(interactionSettings.allowUpdates);
-            this.executionStopped = interactionSettings.stopExecution;
-        };
-        // 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 (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');
-            // If the step is waiting for a transaction on the receiving chain, we do not switch the chain
-            // All changes are already done from the source chain
-            // Return the step
-            if (recievingChainProcess?.substatus !== 'WAIT_DESTINATION_TRANSACTION' ||
-                !recievingChainProcess) {
-                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;
-                }
-                walletClient = updatedWalletClient;
-            }
-            const parameters = {
-                walletClient,
-                step,
-                settings: this.settings,
-                statusManager: this.statusManager,
-            };
-            await this.stepExecutionManager.execute(parameters);
-            return step;
-        };
-        this.stepExecutionManager = new StepExecutionManager_1.StepExecutionManager();
-        this.statusManager = statusManager;
-        this.settings = settings;
-    }
-}
-exports.StepExecutor = StepExecutor;

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

@@ -1,4 +0,0 @@
-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/checkBalance.d.ts

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

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

@@ -1 +0,0 @@
-export * from './StatusManager';

package/dist/cjs/execution/index.js

@@ -1,17 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./StatusManager"), exports);

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

@@ -1,4 +0,0 @@
-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/cjs/execution/prepareRestart.d.ts

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

package/dist/cjs/execution/prepareRestart.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepareRestart = void 0;
-const viem_1 = require("viem");
-const errors_1 = require("../utils/errors");
-const prepareRestart = async (route, walletClient) => {
-    for (let index = 0; index < route.steps.length; index++) {
-        const step = route.steps[index];
-        const stepHasFailed = step.execution?.status === 'FAILED';
-        if (stepHasFailed) {
-            await handleErrorType(walletClient, step);
-            deleteFailedProcesses(step);
-            deleteTransactionData(step);
-        }
-    }
-};
-exports.prepareRestart = prepareRestart;
-const handleErrorType = async (walletClient, step) => {
-    const client = walletClient.extend(viem_1.publicActions);
-    const isGasLimitError = step.execution?.process.some((p) => p.error?.code === errors_1.LiFiErrorCode.GasLimitError);
-    const isGasPriceError = step.execution?.process.some((p) => p.error?.code === errors_1.LiFiErrorCode.TransactionUnderpriced);
-    const { transactionRequest } = step;
-    // if (isGasLimitError) {
-    //   if (transactionRequest) {
-    //     let gasLimit = transactionRequest.gasLimit
-    //     try {
-    //       gasLimit = await client.estimateGas(transactionRequest)
-    //     } catch (error) {}
-    //     if (gasLimit) {
-    //       transactionRequest.gasLimit = BigNumber.from(
-    //         `${(BigInt(gasLimit.toString()) * 125n) / 100n}`
-    //       )
-    //     }
-    //   }
-    //   step.estimate.gasCosts?.forEach(
-    //     (gasCost) =>
-    //       (gasCost.limit = `${Math.round(Number(gasCost.limit) * 1.25)}`)
-    //   )
-    // }
-    // if (isGasPriceError) {
-    //   if (transactionRequest) {
-    //     let gasPrice = transactionRequest.gasPrice
-    //     try {
-    //       gasPrice = await client.getGasPrice()
-    //     } catch (error) {}
-    //     if (gasPrice) {
-    //       transactionRequest.gasPrice = BigNumber.from(
-    //         `${(BigInt(gasPrice.toString()) * 125n) / 100n}`
-    //       )
-    //     }
-    //   }
-    //   step.estimate.gasCosts?.forEach(
-    //     (gasCost) =>
-    //       (gasCost.price = `${Math.round(Number(gasCost.price) * 1.25)}`)
-    //   )
-    // }
-};
-const deleteFailedProcesses = (step) => {
-    if (step.execution) {
-        step.execution.process = step.execution.process.filter((process) => process.status === 'DONE');
-    }
-};
-const deleteTransactionData = (step) => {
-    step.transactionRequest = undefined;
-};

package/dist/cjs/execution/stepComparison.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stepComparison = void 0;
-const errors_1 = require("../utils/errors");
-const utils_1 = require("./utils");
-/**
- * This method checks whether the new and updated Step meets the required exchange rate conditions.
- * If yes it returns the updated Step.
- * If no and if user interaction is allowed it triggers the acceptExchangeRateUpdateHook. If no user interaction is allowed it aborts.
- * @param statusManager
- * @param oldStep
- * @param newStep
- * @param settings
- * @param allowUserInteraction
- * @returns Return LifiStep
- */
-const stepComparison = async (statusManager, oldStep, newStep, settings, allowUserInteraction) => {
-    // Check if changed exchange rate is in the range of slippage threshold
-    if ((0, utils_1.checkStepSlippageThreshold)(oldStep, newStep)) {
-        return statusManager.updateStepInRoute(newStep);
-    }
-    let allowStepUpdate;
-    if (allowUserInteraction) {
-        allowStepUpdate = await settings.acceptExchangeRateUpdateHook({
-            oldToAmount: oldStep.estimate.toAmount,
-            newToAmount: newStep.estimate.toAmount,
-            toToken: newStep.action.toToken,
-        });
-    }
-    if (!allowStepUpdate) {
-        // The user declined the new exchange rate, so we are not going to proceed
-        throw new errors_1.TransactionError(errors_1.LiFiErrorCode.ExchangeRateUpdateCanceled, 'Exchange rate has changed!', `Transaction was not sent, your funds are still in your wallet.
-      The exchange rate has changed and the previous estimation can not be fulfilled due to value loss.`);
-    }
-    return statusManager.updateStepInRoute(newStep);
-};
-exports.stepComparison = stepComparison;

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

@@ -1,21 +0,0 @@
-import type { LifiStep } from '@lifi/types';
-import type { WalletClient } from 'viem';
-import type { SwitchChainHook } from '../types';
-import type { StatusManager } from './StatusManager';
-/**
- * This method checks whether the wallet client is configured for the correct chain.
- * If yes it returns the wallet clien.
- * If no and if user interaction is allowed it triggers the switchChainHook. If no user interaction is allowed it aborts.
- *
- * Account Type: local -
- * We need to create and return a new WalletClient from the switchChainHook in order to continue execution on a new chain.
- *
- * Account Type: json-rpc -
- * We can switch chain and return existing WalletClient from the switchChainHook in order to continue execution on a new chain.
- * @param walletClient
- * @param statusManager
- * @param step
- * @param switchChainHook
- * @param allowUserInteraction
- */
-export declare const switchChain: (walletClient: WalletClient, statusManager: StatusManager, step: LifiStep, switchChainHook: SwitchChainHook, allowUserInteraction: boolean) => Promise<WalletClient | undefined>;

package/dist/cjs/execution/switchChain.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.switchChain = void 0;
-const errors_1 = require("../utils/errors");
-/**
- * This method checks whether the wallet client is configured for the correct chain.
- * If yes it returns the wallet clien.
- * If no and if user interaction is allowed it triggers the switchChainHook. If no user interaction is allowed it aborts.
- *
- * Account Type: local -
- * We need to create and return a new WalletClient from the switchChainHook in order to continue execution on a new chain.
- *
- * Account Type: json-rpc -
- * We can switch chain and return existing WalletClient from the switchChainHook in order to continue execution on a new chain.
- * @param walletClient
- * @param statusManager
- * @param step
- * @param switchChainHook
- * @param allowUserInteraction
- */
-const switchChain = async (walletClient, statusManager, step, switchChainHook, allowUserInteraction) => {
-    // if we are already on the correct chain we can proceed directly
-    if ((await walletClient.getChainId()) === step.action.fromChainId) {
-        return walletClient;
-    }
-    // -> set status message
-    step.execution = statusManager.initExecutionObject(step);
-    statusManager.updateExecution(step, 'ACTION_REQUIRED');
-    let switchProcess = statusManager.findOrCreateProcess(step, 'SWITCH_CHAIN', 'ACTION_REQUIRED');
-    if (!allowUserInteraction) {
-        return;
-    }
-    try {
-        const updatedWalletClient = await switchChainHook(step.action.fromChainId);
-        const updatedChainId = await updatedWalletClient?.getChainId();
-        if (updatedChainId !== step.action.fromChainId) {
-            throw new errors_1.ProviderError(errors_1.LiFiErrorCode.ChainSwitchError, 'Chain switch required.');
-        }
-        switchProcess = statusManager.updateProcess(step, switchProcess.type, 'DONE');
-        statusManager.updateExecution(step, 'PENDING');
-        return updatedWalletClient;
-    }
-    catch (error) {
-        statusManager.updateProcess(step, switchProcess.type, 'FAILED', {
-            error: {
-                message: error.message,
-                code: errors_1.LiFiErrorCode.ChainSwitchError,
-            },
-        });
-        statusManager.updateExecution(step, 'FAILED');
-        throw error;
-    }
-};
-exports.switchChain = switchChain;

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

@@ -1,12 +0,0 @@
-import type { LifiStep, ProcessType, Status, StatusMessage, Substatus } from '@lifi/types';
-export declare function getProcessMessage(type: ProcessType, status: Status): string | undefined;
-export declare function getSubstatusMessage(status: StatusMessage, substatus?: Substatus): string | undefined;
-/**
- * Used to check if changed exchange rate is in the range of slippage threshold.
- * We use a slippage value as a threshold to trigger the rate change hook.
- * This can result in almost doubled slippage for the user and need to be revisited.
- * @param oldStep
- * @param newStep
- * @returns Boolean
- */
-export declare function checkStepSlippageThreshold(oldStep: LifiStep, newStep: LifiStep): boolean;

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

@@ -1,3 +0,0 @@
-import type { LifiStep, ProcessType, StatusResponse } from '@lifi/types';
-import type { StatusManager } from '..';
-export declare function waitForReceivingTransaction(txHash: string, statusManager: StatusManager, processType: ProcessType, step: LifiStep): Promise<StatusResponse>;

package/dist/cjs/helpers.d.ts

@@ -1,18 +0,0 @@
-import type { LifiStep, Route } from '@lifi/types';
-import type { TenderlyResponse } from './types';
-/**
- * Returns a random number between min (inclusive) and max (inclusive)
- * @param min - minimum number.
- * @param max - maximum number.
- * @returns - random number.
- */
-export declare const getRandomNumber: (min: number, max: number) => number;
-export declare const checkPackageUpdates: (packageName?: string, packageVersion?: string, disableCheck?: boolean) => Promise<void>;
-/**
- * Converts a quote to Route
- * @param step - Step returned from the quote endpoint.
- * @returns - The route to be executed.
- * @throws {ValidationError} Throws a ValidationError if the step has missing values.
- */
-export declare const convertQuoteToRoute: (step: LifiStep) => Route;
-export declare const fetchTxErrorDetails: (txHash: string, chainId: number) => Promise<TenderlyResponse>;

package/dist/cjs/index.d.ts

@@ -1,5 +0,0 @@
-export * from './execution';
-export * from './helpers';
-export { LiFi } from './LiFi';
-export * from './types';
-export * from './utils/errors';

package/dist/cjs/request.d.ts

@@ -1,9 +0,0 @@
-export declare const requestSettings: {
-    retries: number;
-};
-interface ExtendedRequestInit extends RequestInit {
-    retries?: number;
-    skipTrackingHeaders?: boolean;
-}
-export declare const request: <T = Response>(url: RequestInfo | URL, options?: ExtendedRequestInit) => Promise<T>;
-export {};

package/dist/cjs/services/ApiService.d.ts

@@ -1,17 +0,0 @@
-import type { ConnectionsRequest, ConnectionsResponse, ContractCallQuoteRequest, GasRecommendationRequest, GasRecommendationResponse, GetStatusRequest, LifiStep, QuoteRequest, RequestOptions, TokensRequest, TokensResponse } from '@lifi/types';
-import type { ChainId, ChainKey, ExtendedChain, PossibilitiesRequest, PossibilitiesResponse, RoutesRequest, RoutesResponse, StatusResponse, Token, ToolsRequest, ToolsResponse } from '../types';
-declare const _default: {
-    getChains: (options?: RequestOptions | undefined) => Promise<ExtendedChain[]>;
-    getContractCallQuote: (requestConfig: ContractCallQuoteRequest, options?: RequestOptions | undefined) => Promise<LifiStep>;
-    getGasRecommendation: ({ chainId, fromChain, fromToken }: GasRecommendationRequest, options?: RequestOptions | undefined) => Promise<GasRecommendationResponse>;
-    getPossibilities: (requestConfig?: PossibilitiesRequest | undefined, options?: RequestOptions | undefined) => Promise<PossibilitiesResponse>;
-    getQuote: (requestConfig: QuoteRequest, options?: RequestOptions | undefined) => Promise<LifiStep>;
-    getRoutes: (requestConfig: RoutesRequest, options?: RequestOptions | undefined) => Promise<RoutesResponse>;
-    getStatus: (requestConfig: GetStatusRequest, options?: RequestOptions | undefined) => Promise<StatusResponse>;
-    getStepTransaction: (step: LifiStep, options?: RequestOptions | undefined) => Promise<LifiStep>;
-    getToken: (chain: ChainId | ChainKey, token: string, options?: RequestOptions | undefined) => Promise<Token>;
-    getTokens: (requestConfig?: TokensRequest | undefined, options?: RequestOptions | undefined) => Promise<TokensResponse>;
-    getTools: (requestConfig?: ToolsRequest | undefined, options?: RequestOptions | undefined) => Promise<ToolsResponse>;
-    getAvailableConnections: (connectionRequest: ConnectionsRequest) => Promise<ConnectionsResponse>;
-};
-export default _default;