@lifi/sdk 2.3.1 → 3.0.0-alpha.10

package/dist/cjs/allowance/tokenApproval.d.ts

@@ -1,22 +0,0 @@
-import { Token } from '@lifi/types';
-import { Signer } from 'ethers';
-import { RevokeTokenData } from '../types';
-export interface ApproveTokenRequest {
-    signer: Signer;
-    token: Token;
-    approvalAddress: string;
-    amount: string;
-    infiniteApproval?: boolean;
-}
-export interface RevokeApprovalRequest {
-    signer: Signer;
-    token: Token;
-    approvalAddress: string;
-}
-export declare const getTokenApproval: (signer: Signer, token: Token, approvalAddress: string) => Promise<string | undefined>;
-export declare const bulkGetTokenApproval: (signer: Signer, tokenData: RevokeTokenData[]) => Promise<{
-    token: Token;
-    approval: string | undefined;
-}[]>;
-export declare const approveToken: ({ signer, token, approvalAddress, amount, infiniteApproval, }: ApproveTokenRequest) => Promise<void>;
-export declare const revokeTokenApproval: ({ signer, token, approvalAddress, }: RevokeApprovalRequest) => Promise<void>;

package/dist/cjs/allowance/tokenApproval.js

@@ -1,69 +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.revokeTokenApproval = exports.approveToken = exports.bulkGetTokenApproval = exports.getTokenApproval = void 0;
-const bignumber_js_1 = __importDefault(require("bignumber.js"));
-const ethers_1 = require("ethers");
-const helpers_1 = require("../helpers");
-const utils_1 = require("../utils/utils");
-const utils_2 = require("./utils");
-const getTokenApproval = async (signer, token, approvalAddress) => {
-    // native token don't need approval
-    if ((0, utils_1.isNativeTokenAddress)(token.address)) {
-        return;
-    }
-    const approved = await (0, utils_2.getApproved)(signer, token.address, approvalAddress);
-    return approved.toFixed(0);
-};
-exports.getTokenApproval = getTokenApproval;
-const bulkGetTokenApproval = async (signer, tokenData) => {
-    // filter out native tokens
-    const filteredTokenData = tokenData.filter(({ token }) => !(0, utils_1.isNativeTokenAddress)(token.address));
-    // group by chain
-    const tokenDataByChain = (0, utils_2.groupByChain)(filteredTokenData);
-    const approvalPromises = Object.keys(tokenDataByChain).map(async (chainId) => {
-        const parsedChainId = Number.parseInt(chainId);
-        // get allowances for current chain and token list
-        return (0, utils_2.getAllowanceViaMulticall)(signer, parsedChainId, tokenDataByChain[parsedChainId]);
-    });
-    const approvalsByChain = await Promise.all(approvalPromises);
-    const approvals = approvalsByChain.flat();
-    return tokenData.map(({ token }) => {
-        // native token don't need approval
-        if ((0, utils_1.isNativeTokenAddress)(token.address)) {
-            return { token, approval: undefined };
-        }
-        const approved = approvals.find((approval) => (0, helpers_1.isSameToken)(approval.token, token));
-        return { token, approval: approved?.approvedAmount.toString() };
-    });
-};
-exports.bulkGetTokenApproval = bulkGetTokenApproval;
-const approveToken = async ({ signer, token, approvalAddress, amount, infiniteApproval = false, }) => {
-    // native token don't need approval
-    if ((0, utils_1.isNativeTokenAddress)(token.address)) {
-        return;
-    }
-    const approvedAmount = await (0, utils_2.getApproved)(signer, token.address, approvalAddress);
-    if (new bignumber_js_1.default(amount).gt(approvedAmount)) {
-        const approvalAmount = infiniteApproval
-            ? ethers_1.constants.MaxUint256.toString()
-            : amount;
-        const approveTx = await (0, utils_2.setApproval)(signer, token.address, approvalAddress, approvalAmount);
-        await approveTx.wait();
-    }
-};
-exports.approveToken = approveToken;
-const revokeTokenApproval = async ({ signer, token, approvalAddress, }) => {
-    // native token don't need approval
-    if ((0, utils_1.isNativeTokenAddress)(token.address)) {
-        return;
-    }
-    const approvedAmount = await (0, utils_2.getApproved)(signer, token.address, approvalAddress);
-    if (!approvedAmount.isZero()) {
-        const approveTx = await (0, utils_2.setApproval)(signer, token.address, approvalAddress, '0');
-        await approveTx.wait();
-    }
-};
-exports.revokeTokenApproval = revokeTokenApproval;

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

@@ -1,14 +0,0 @@
-import { ChainId, Token } from '@lifi/types';
-import BigNumber from 'bignumber.js';
-import { ContractTransaction, PopulatedTransaction, Signer } from 'ethers';
-import { RevokeTokenData } from '../types';
-export declare const getApproved: (signer: Signer, tokenAddress: string, contractAddress: string) => Promise<BigNumber>;
-export declare const setApproval: (signer: Signer, tokenAddress: string, contractAddress: string, amount: string, returnPopulatedTransaction?: boolean) => Promise<ContractTransaction | PopulatedTransaction>;
-export declare const getAllowanceViaMulticall: (signer: Signer, chainId: ChainId, tokenData: RevokeTokenData[]) => Promise<{
-    token: Token;
-    approvalAddress: string;
-    approvedAmount: BigNumber;
-}[]>;
-export declare const groupByChain: (tokenDataList: RevokeTokenData[]) => {
-    [chainId: number]: RevokeTokenData[];
-};

package/dist/cjs/allowance/utils.js

@@ -1,82 +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.groupByChain = exports.getAllowanceViaMulticall = exports.setApproval = exports.getApproved = void 0;
-const bignumber_js_1 = __importDefault(require("bignumber.js"));
-const ethers_1 = require("ethers");
-const ChainsService_1 = __importDefault(require("../services/ChainsService"));
-const types_1 = require("../types");
-const errors_1 = require("../utils/errors");
-const multicall_1 = require("../utils/multicall");
-const getApproved = async (signer, tokenAddress, contractAddress) => {
-    const signerAddress = await signer.getAddress();
-    const erc20 = new ethers_1.Contract(tokenAddress, types_1.ERC20_ABI, signer);
-    try {
-        const approved = await erc20.allowance(signerAddress, contractAddress);
-        return new bignumber_js_1.default(approved.toString());
-    }
-    catch (e) {
-        return new bignumber_js_1.default(0);
-    }
-};
-exports.getApproved = getApproved;
-const setApproval = async (signer, tokenAddress, contractAddress, amount, returnPopulatedTransaction) => {
-    const erc20 = new ethers_1.Contract(tokenAddress, types_1.ERC20_ABI, signer);
-    if (returnPopulatedTransaction) {
-        return erc20.populateTransaction.approve(contractAddress, amount);
-    }
-    const transactionRequest = await erc20.populateTransaction.approve(contractAddress, amount);
-    try {
-        const estimatedGasLimit = await signer.estimateGas(transactionRequest);
-        if (estimatedGasLimit) {
-            const formattedGasLimit = ethers_1.ethers.BigNumber.from(`${(BigInt(estimatedGasLimit.toString()) * 125n) / 100n}`);
-            transactionRequest.gasLimit = formattedGasLimit;
-        }
-    }
-    catch (error) { }
-    return signer.sendTransaction(transactionRequest);
-};
-exports.setApproval = setApproval;
-const getAllowanceViaMulticall = async (signer, chainId, tokenData) => {
-    const chainsService = ChainsService_1.default.getInstance();
-    const chain = await chainsService.getChainById(chainId);
-    if (!chain.multicallAddress) {
-        throw new errors_1.ServerError(`No multicall address configured for chainId ${chainId}.`);
-    }
-    const ownerAddress = await signer.getAddress();
-    const calls = [];
-    tokenData.map(({ token, approvalAddress }) => {
-        calls.push({
-            address: token.address,
-            name: 'allowance',
-            params: [ownerAddress, approvalAddress],
-        });
-    });
-    const result = await (0, multicall_1.fetchDataUsingMulticall)(calls, types_1.ERC20_ABI, chainId, chain.multicallAddress);
-    if (!result.length) {
-        throw new errors_1.ServerError(`Couldn't load allowance from chainId ${chainId} using multicall.`);
-    }
-    const parsedResult = result.map(({ data }) => ({
-        approvalAmount: data ?? new bignumber_js_1.default(0),
-    }));
-    return tokenData.map(({ token, approvalAddress }, i) => ({
-        token,
-        approvalAddress,
-        approvedAmount: parsedResult[i].approvalAmount,
-    }));
-};
-exports.getAllowanceViaMulticall = getAllowanceViaMulticall;
-const groupByChain = (tokenDataList) => {
-    // group by chain
-    const tokenDataByChain = {};
-    tokenDataList.forEach((tokenData) => {
-        if (!tokenDataByChain[tokenData.token.chainId]) {
-            tokenDataByChain[tokenData.token.chainId] = [];
-        }
-        tokenDataByChain[tokenData.token.chainId].push(tokenData);
-    });
-    return tokenDataByChain;
-};
-exports.groupByChain = groupByChain;

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

@@ -1,3 +0,0 @@
-import { ethers } from 'ethers';
-import { LifiStep } from '..';
-export declare const checkBalance: (signer: ethers.Signer, step: LifiStep, depth?: number) => Promise<void>;

package/dist/cjs/balance/checkBalance.js

@@ -1,45 +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.checkBalance = void 0;
-const bignumber_js_1 = __importDefault(require("bignumber.js"));
-const errors_1 = require("../utils/errors");
-const getTokenBalance_1 = require("./getTokenBalance");
-const checkBalance = async (signer, step, depth = 0) => {
-    const tokenAmount = await (0, getTokenBalance_1.getTokenBalance)(await signer.getAddress(), step.action.fromToken);
-    if (tokenAmount) {
-        const currentBalance = new bignumber_js_1.default(tokenAmount.amount).shiftedBy(tokenAmount.decimals);
-        const neededBalance = new bignumber_js_1.default(step.action.fromAmount);
-        if (currentBalance.lt(neededBalance)) {
-            if (depth <= 3) {
-                await new Promise((resolve) => {
-                    setTimeout(resolve, 200);
-                });
-                await (0, exports.checkBalance)(signer, step, depth + 1);
-            }
-            else if (neededBalance.multipliedBy(1 - step.action.slippage).lte(currentBalance)) {
-                // adjust amount in slippage limits
-                step.action.fromAmount = currentBalance.toFixed(0);
-            }
-            else {
-                const neeeded = neededBalance.shiftedBy(-tokenAmount.decimals).toFixed();
-                const current = currentBalance
-                    .shiftedBy(-tokenAmount.decimals)
-                    .toFixed();
-                let errorMessage = `Your ${tokenAmount.symbol} balance is too low, ` +
-                    `you try to transfer ${neeeded} ${tokenAmount.symbol}, ` +
-                    `but your wallet only holds ${current} ${tokenAmount.symbol}. ` +
-                    `No funds have been sent. `;
-                if (!currentBalance.isZero()) {
-                    errorMessage +=
-                        `If the problem consists, please delete this transfer and ` +
-                            `start a new one with a maximum of ${current} ${tokenAmount.symbol}.`;
-                }
-                throw new errors_1.BalanceError('The balance is too low.', errorMessage);
-            }
-        }
-    }
-};
-exports.checkBalance = checkBalance;

package/dist/cjs/balance/getTokenBalance.d.ts

@@ -1,8 +0,0 @@
-import { Token, TokenAmount } from '@lifi/types';
-export declare const getTokenBalance: (walletAddress: string, token: Token) => Promise<TokenAmount | null>;
-export declare const getTokenBalances: (walletAddress: string, tokens: Token[]) => Promise<TokenAmount[]>;
-export declare const getTokenBalancesForChains: (walletAddress: string, tokensByChain: {
-    [chainId: number]: Token[];
-}) => Promise<{
-    [chainId: number]: TokenAmount[];
-}>;

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

@@ -1,13 +0,0 @@
-export * from './checkBalance';
-export * from './getTokenBalance';
-declare const _default: {
-    checkBalance: (signer: import("ethers").Signer, step: import("@lifi/types").LifiStep, depth?: number) => Promise<void>;
-    getTokenBalance: (walletAddress: string, token: import("@lifi/types").Token) => Promise<import("@lifi/types").TokenAmount | null>;
-    getTokenBalances: (walletAddress: string, tokens: import("@lifi/types").Token[]) => Promise<import("@lifi/types").TokenAmount[]>;
-    getTokenBalancesForChains: (walletAddress: string, tokensByChain: {
-        [chainId: number]: import("@lifi/types").Token[];
-    }) => Promise<{
-        [chainId: number]: import("@lifi/types").TokenAmount[];
-    }>;
-};
-export default _default;

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

@@ -1,6 +0,0 @@
-import { Token, TokenAmount } from '@lifi/types';
-export declare const getBalances: (walletAddress: string, tokens: Token[]) => Promise<TokenAmount[]>;
-declare const _default: {
-    getBalances: (walletAddress: string, tokens: Token[]) => Promise<TokenAmount[]>;
-};
-export default _default;

package/dist/cjs/balance/utils.js

@@ -1,150 +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.getBalances = void 0;
-const bignumber_js_1 = __importDefault(require("bignumber.js"));
-const ethers_1 = require("ethers");
-const connectors_1 = require("../connectors");
-const multicall_1 = require("../utils/multicall");
-const utils_1 = require("../utils/utils");
-const balanceAbi = [
-    {
-        constant: true,
-        inputs: [{ name: 'who', type: 'address' }],
-        name: 'balanceOf',
-        outputs: [{ name: '', type: 'uint256' }],
-        payable: false,
-        stateMutability: 'view',
-        type: 'function',
-    },
-    {
-        constant: true,
-        inputs: [{ name: 'addr', type: 'address' }],
-        name: 'getEthBalance',
-        outputs: [{ name: 'balance', type: 'uint256' }],
-        payable: false,
-        stateMutability: 'view',
-        type: 'function',
-    },
-];
-const getBalances = async (walletAddress, tokens) => {
-    if (tokens.length === 0) {
-        return [];
-    }
-    const { chainId } = tokens[0];
-    tokens.forEach((token) => {
-        if (token.chainId !== chainId) {
-            // eslint-disable-next-line no-console
-            console.warn(`Requested tokens have to be on the same chain.`);
-            return [];
-        }
-    });
-    if ((await (0, connectors_1.getMulticallAddress)(chainId)) && tokens.length > 1) {
-        return getBalancesFromProviderUsingMulticall(walletAddress, tokens);
-    }
-    else {
-        return getBalancesFromProvider(walletAddress, tokens);
-    }
-};
-exports.getBalances = getBalances;
-const getBalancesFromProviderUsingMulticall = async (walletAddress, tokens) => {
-    // Configuration
-    const { chainId } = tokens[0];
-    const multicallAddress = await (0, connectors_1.getMulticallAddress)(chainId);
-    if (!multicallAddress) {
-        throw new Error('No multicallAddress found for the given chain.');
-    }
-    return executeMulticall(walletAddress, tokens, multicallAddress, chainId);
-};
-const executeMulticall = async (walletAddress, tokens, multicallAddress, chainId) => {
-    // Collect calls we want to make
-    const calls = [];
-    tokens.map((token) => {
-        if ((0, utils_1.isZeroAddress)(token.address)) {
-            calls.push({
-                address: multicallAddress,
-                name: 'getEthBalance',
-                params: [walletAddress],
-            });
-        }
-        else {
-            calls.push({
-                address: token.address,
-                name: 'balanceOf',
-                params: [walletAddress],
-            });
-        }
-    });
-    const res = await fetchViaMulticall(calls, balanceAbi, chainId, multicallAddress);
-    if (!res.length) {
-        return [];
-    }
-    return tokens.map((token, i) => {
-        const amount = new bignumber_js_1.default(res[i].amount.toString() || '0')
-            .shiftedBy(-token.decimals)
-            .toFixed();
-        return {
-            ...token,
-            amount: amount || '0',
-            blockNumber: res[i].blockNumber,
-        };
-    });
-};
-const fetchViaMulticall = async (calls, abi, chainId, multicallAddress) => {
-    const result = await (0, multicall_1.fetchDataUsingMulticall)(calls, abi, chainId, multicallAddress);
-    return result.map(({ data, blockNumber }) => ({
-        amount: data ? data : new bignumber_js_1.default(0),
-        blockNumber,
-    }));
-};
-const getBalancesFromProvider = async (walletAddress, tokens) => {
-    const chainId = tokens[0].chainId;
-    const rpc = await (0, connectors_1.getRpcProvider)(chainId);
-    const tokenAmountPromises = tokens.map(async (token) => {
-        let amount = '0';
-        let blockNumber;
-        try {
-            const balance = await getBalanceFromProvider(walletAddress, token.address, chainId, rpc);
-            amount = new bignumber_js_1.default(balance.amount.toString())
-                .shiftedBy(-token.decimals)
-                .toString();
-            blockNumber = balance.blockNumber;
-        }
-        catch (e) {
-            // eslint-disable-next-line no-console
-            console.warn(e);
-        }
-        return {
-            ...token,
-            amount,
-            blockNumber,
-        };
-    });
-    return Promise.all(tokenAmountPromises);
-};
-const getBalanceFromProvider = async (walletAddress, assetId, chainId, provider) => {
-    const blockNumber = await getCurrentBlockNumber(chainId);
-    let balance;
-    if ((0, utils_1.isZeroAddress)(assetId)) {
-        balance = await provider.getBalance(walletAddress, blockNumber);
-    }
-    else {
-        const contract = new ethers_1.ethers.Contract(assetId, ['function balanceOf(address owner) view returns (uint256)'], provider);
-        balance = await contract.balanceOf(walletAddress, {
-            blockTag: blockNumber,
-        });
-    }
-    return {
-        amount: balance,
-        blockNumber,
-    };
-};
-const getCurrentBlockNumber = async (chainId) => {
-    const rpc = await (0, connectors_1.getRpcProvider)(chainId);
-    return rpc.getBlockNumber();
-};
-exports.default = {
-    getBalances: exports.getBalances,
-};

package/dist/cjs/connectors.d.ts

@@ -1,6 +0,0 @@
-import { FallbackProvider } from '@ethersproject/providers';
-import { ChainId } from './types';
-export declare const getRpcUrl: (chainId: ChainId, archive?: boolean) => Promise<string>;
-export declare const getRpcUrls: (chainId: ChainId, archive?: boolean) => Promise<string[]>;
-export declare const getRpcProvider: (chainId: number, archive?: boolean) => Promise<FallbackProvider>;
-export declare const getMulticallAddress: (chainId: ChainId) => Promise<string | undefined>;

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

@@ -1,65 +0,0 @@
-import { Route } from '@lifi/types';
-import { Signer } from 'ethers';
-import ConfigService from '../services/ConfigService';
-import { ConfigUpdate, ExecutionSettings } from '../types';
-export declare class RouteExecutionManager {
-    private executionDictionary;
-    private executionPromiseDictionary;
-    protected configService: ConfigService;
-    constructor(configUpdate: ConfigUpdate);
-    /**
-     * Execute a route.
-     * @param {Signer} signer - The signer required to send the transactions.
-     * @param {Route} route - The route that should be executed. Cannot be an active route.
-     * @param {ExecutionSettings} settings - An object containing settings and callbacks.
-     * @return {Promise<Route>} The executed route.
-     * @throws {LifiError} Throws a LifiError if the execution fails.
-     */
-    executeRoute: (signer: Signer, route: Route, settings?: ExecutionSettings) => Promise<Route>;
-    /**
-     * Resume the execution of a route that has been stopped or had an error while executing.
-     * @param {Signer} signer - The signer required to send the transactions.
-     * @param {Route} route - The route that is to be executed. Cannot be an active route.
-     * @param {ExecutionSettings} settings - An object containing settings and callbacks.
-     * @return {Promise<Route>} The executed route.
-     * @throws {LifiError} Throws a LifiError if the execution fails.
-     */
-    resumeRoute: (signer: Signer, route: Route, settings?: ExecutionSettings) => Promise<Route>;
-    private executeSteps;
-    /**
-     * Updates route execution to background or foreground state.
-     * @param {Route} route - A route that is currently in execution.
-     * @param {boolean} settings - An object with execution settings.
-     */
-    updateRouteExecution: (route: Route, settings: Pick<ExecutionSettings, 'executeInBackground'>) => void;
-    /**
-     * Update the ExecutionSettings for an active route.
-     * @param {ExecutionSettings} settings - An object with execution settings.
-     * @param {Route} route - The active route that gets the new execution settings.
-     * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
-     */
-    updateExecutionSettings: (settings: ExecutionSettings, route: Route) => void;
-    /**
-     * Executes a route until a user interaction is necessary (signing transactions, etc.) and then halts until the route is resumed.
-     * @param {Route} route - A route that is currently in execution.
-     * @deprecated use updateRouteExecution instead.
-     */
-    moveExecutionToBackground: (route: Route) => void;
-    /**
-     * Stops the execution of an active route.
-     * @param {Route} route - A route that is currently in execution.
-     * @return {Route} The stopped route.
-     */
-    stopExecution: (route: Route) => Route;
-    /**
-     * Get the list of active routes.
-     * @return {Route[]} A list of routes.
-     */
-    getActiveRoutes: () => Route[];
-    /**
-     * Return the current route information for given route. The route has to be active.
-     * @param {Route} route - A route object.
-     * @return {Route} The updated route.
-     */
-    getActiveRoute: (route: Route) => Route | undefined;
-}

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

@@ -1,68 +0,0 @@
-import { Execution, InternalExecutionSettings, LifiStep, Process, ProcessType, Route, Status, Token } from '../types';
-interface Receipt {
-    fromAmount?: string;
-    toAmount?: string;
-    toToken?: Token;
-    gasPrice?: string;
-    gasUsed?: string;
-    gasToken?: Token;
-    gasAmount?: string;
-    gasAmountUSD?: string;
-}
-type InternalUpdateRouteCallback = (route: Route) => void;
-type OptionalParameters = Partial<Pick<Process, 'doneAt' | 'failedAt' | 'txHash' | 'txLink' | 'error' | 'substatus' | 'substatusMessage' | 'multisigTxHash'>>;
-/**
- * Manages status updates of a route and provides various functions for tracking processes
- * @param  {Route} route  The route this StatusManger belongs to.
- * @param  {InternalExecutionSettings} settings   The ExecutionSettings for this route.
- * @param  {InternalUpdateRouteCallback} internalUpdateRouteCallback  Internal callback to propage route changes.
- * @return {StatusManager}       An instance of StatusManager.
- */
-export declare class StatusManager {
-    private readonly route;
-    private readonly settings;
-    private readonly internalUpdateRouteCallback;
-    private shouldUpdate;
-    constructor(route: Route, settings: InternalExecutionSettings, internalUpdateRouteCallback: InternalUpdateRouteCallback);
-    /**
-     * Initializes the execution object of a Step.
-     * @param  {LifiStep} step  The current step in execution
-     * @return {Execution}       The initialized execution object for this step and a function to update this step
-     */
-    initExecutionObject: (step: LifiStep) => Execution;
-    /**
-     * Updates the execution object of a Step.
-     * @param  {LifiStep} step  The current step in execution
-     * @param  {Status} status  The status for the execution
-     * @param  {Receipt} receipt Optional. Information about received tokens
-     * @return {Step}       The step with the updated execution object
-     */
-    updateExecution(step: LifiStep, status: Status, receipt?: Receipt): LifiStep;
-    /**
-     * Create and push a new process into the execution.
-     * @param  {ProcessType} type Type of the process. Used to identify already existing processes.
-     * @param  {LifiStep} step The step that should contain the new process.
-     * @param  {Status} status By default created procces is set to the STARTED status. We can override new process with the needed status.
-     * @return {Process}
-     */
-    findOrCreateProcess: (step: LifiStep, type: ProcessType, status?: Status) => Process;
-    /**
-     * Update a process object.
-     * @param  {LifiStep} step The step where the process should be updated
-     * @param  {ProcessType} type  The process type to update
-     * @param  {Status} status The status the process gets.
-     * @param  {object} [params]   Additional parameters to append to the process.
-     * @return {Process} The update process
-     */
-    updateProcess: (step: LifiStep, type: ProcessType, status: Status, params?: OptionalParameters) => Process;
-    /**
-     * Remove a process from the execution
-     * @param  {LifiStep} step The step where the process should be removed from
-     * @param  {ProcessType} type  The process type to remove
-     * @return {void}
-     */
-    removeProcess: (step: LifiStep, type: ProcessType) => void;
-    updateStepInRoute: (step: LifiStep) => LifiStep;
-    allowUpdates(value: boolean): void;
-}
-export {};

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

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

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

@@ -1,15 +0,0 @@
-import { Signer } from 'ethers';
-import { InteractionSettings, InternalExecutionSettings, LifiStep } from '../types';
-import { 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: (signer: Signer, 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 signer 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) => {
-            // 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 updatedSigner = await (0, switchChain_1.switchChain)(signer, this.statusManager, step, this.settings.switchChainHook, this.allowUserInteraction);
-                if (!updatedSigner) {
-                    // Chain switch was not successful, stop execution here
-                    return step;
-                }
-                signer = updatedSigner;
-            }
-            const parameters = {
-                signer,
-                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/index.d.ts

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

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

@@ -1,3 +0,0 @@
-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>;