@lifi/sdk 2.3.1 → 3.0.0-alpha.10

package/dist/execution/StepExecutionManager.js

@@ -1,267 +0,0 @@
-import { BigNumber } from 'ethers';
-import { checkAllowance } from '../allowance';
-import { checkBalance } from '../balance';
-import ApiService from '../services/ApiService';
-import ChainsService from '../services/ChainsService';
-import { LifiErrorCode, TransactionError, ValidationError, } from '../utils/errors';
-import { getProvider } from '../utils/getProvider';
-import { getTransactionFailedMessage, parseError } from '../utils/parseError';
-import { isZeroAddress, personalizeStep } from '../utils/utils';
-import { stepComparison } from './stepComparison';
-import { switchChain } from './switchChain';
-import { getSubstatusMessage, waitForReceivingTransaction } from './utils';
-import ConfigService from '../services/ConfigService';
-import { updateMultisigRouteProcess } from './multisig';
-export class StepExecutionManager {
-    constructor() {
-        this.allowUserInteraction = true;
-        this.allowInteraction = (value) => {
-            this.allowUserInteraction = value;
-        };
-        this.execute = async ({ signer, step, statusManager, settings, }) => {
-            const config = ConfigService.getInstance().getConfig();
-            const isMultisigSigner = !!config.multisigConfig?.isMultisigSigner;
-            const multisigBatchTransactions = [];
-            const shouldBatchTransactions = config.multisigConfig?.shouldBatchTransactions &&
-                !!config.multisigConfig.sendBatchTransaction;
-            step.execution = statusManager.initExecutionObject(step);
-            const chainsService = ChainsService.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 &&
-                !isZeroAddress(step.action.fromToken.address) &&
-                (shouldBatchTransactions || !isMultisigSigner);
-            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);
-                    }
-                }
-            }
-            // 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 (isMultisigSigner && multisigProcess) {
-                        if (!multisigProcess) {
-                            throw new ValidationError('Multisig process is undefined.');
-                        }
-                        if (!config.multisigConfig?.getMultisigTransactionDetails) {
-                            throw new ValidationError('"getMultisigTransactionDetails()" is missing in Multisig config.');
-                        }
-                        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);
-                    }
-                    let transaction;
-                    if (process.txHash) {
-                        // Make sure that the chain is still correct
-                        const updatedSigner = await switchChain(signer, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
-                        if (!updatedSigner) {
-                            // Chain switch was not successful, stop execution here
-                            return step.execution;
-                        }
-                        signer = updatedSigner;
-                        // Load exiting transaction
-                        transaction = await getProvider(signer).getTransaction(process.txHash);
-                    }
-                    else {
-                        process = statusManager.updateProcess(step, process.type, 'STARTED');
-                        // Check balance
-                        await checkBalance(signer, 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);
-                            step = {
-                                ...comparedStep,
-                                execution: step.execution,
-                            };
-                        }
-                        const { transactionRequest } = step;
-                        if (!transactionRequest) {
-                            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) {
-                            // Chain switch was not successful, stop execution here
-                            return step.execution;
-                        }
-                        signer = updatedSigner;
-                        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) { }
-                        }
-                        // Submit the transaction
-                        if (shouldBatchTransactions &&
-                            config.multisigConfig?.sendBatchTransaction) {
-                            const { to, data, value } = await signer.populateTransaction(transactionRequest);
-                            const isValidTransaction = to && data;
-                            if (isValidTransaction) {
-                                const populatedTransaction = {
-                                    value: value?.toString() ?? BigNumber.from(0).toString(),
-                                    to,
-                                    data: data.toString(),
-                                };
-                                multisigBatchTransactions.push(populatedTransaction);
-                                transaction = await config.multisigConfig?.sendBatchTransaction(multisigBatchTransactions);
-                            }
-                            else {
-                                throw new TransactionError(LifiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
-                            }
-                        }
-                        else {
-                            transaction = await signer.sendTransaction(transactionRequest);
-                        }
-                        // STEP 4: Wait for the transaction
-                        if (isMultisigSigner) {
-                            process = statusManager.updateProcess(step, process.type, 'ACTION_REQUIRED', {
-                                multisigTxHash: transaction.hash,
-                            });
-                        }
-                        else {
-                            process = statusManager.updateProcess(step, process.type, 'PENDING', {
-                                txHash: transaction.hash,
-                                txLink: fromChain.metamask.blockExplorerUrls[0] +
-                                    'tx/' +
-                                    transaction.hash,
-                            });
-                        }
-                    }
-                    await transaction.wait?.();
-                    // if it's multisig signer 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 (!isMultisigSigner) {
-                        process = statusManager.updateProcess(step, process.type, 'PENDING', {
-                            txHash: transaction.hash,
-                            txLink: fromChain.metamask.blockExplorerUrls[0] +
-                                'tx/' +
-                                transaction.hash,
-                        });
-                    }
-                    if (isBridgeExecution) {
-                        process = statusManager.updateProcess(step, process.type, 'DONE');
-                    }
-                }
-                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;
-                    }
-                }
-            }
-            // 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 waitForReceivingTransaction(processTxHash, statusManager, process.type, step));
-                const statusReceiving = statusResponse.receiving;
-                process = statusManager.updateProcess(step, process.type, 'DONE', {
-                    substatus: statusResponse.substatus,
-                    substatusMessage: statusResponse.substatusMessage ||
-                        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 getTransactionFailedMessage(step, process.txLink);
-                process = statusManager.updateProcess(step, process.type, 'FAILED', {
-                    error: {
-                        code: LifiErrorCode.TransactionFailed,
-                        message: 'Failed while waiting for receiving chain.',
-                        htmlMessage,
-                    },
-                });
-                statusManager.updateExecution(step, 'FAILED');
-                console.warn(e);
-                throw e;
-            }
-            // DONE
-            return step.execution;
-        };
-    }
-}

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

@@ -1,58 +0,0 @@
-import { StepExecutionManager } from './StepExecutionManager';
-import { switchChain } from './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,
-};
-export 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 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();
-        this.statusManager = statusManager;
-        this.settings = settings;
-    }
-}

package/dist/execution/index.d.ts

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

package/dist/execution/index.js

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

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

package/dist/execution/multisig.js

@@ -1,27 +0,0 @@
-import ConfigService from '../services/ConfigService';
-import { LifiErrorCode, TransactionError } from '../utils/errors';
-export const updateMultisigRouteProcess = async (internalTxHash, step, statusManager, process, fromChain) => {
-    const config = ConfigService.getInstance().getConfig();
-    if (!config.multisigConfig?.getMultisigTransactionDetails) {
-        throw new Error('"getMultisigTransactionDetails()" is missing in Multisig config.');
-    }
-    const updateIntermediateMultisigStatus = () => {
-        process = statusManager.updateProcess(step, process.type, 'PENDING');
-    };
-    const multisigStatusResponse = await config.multisigConfig?.getMultisigTransactionDetails(internalTxHash, fromChain.id, updateIntermediateMultisigStatus);
-    if (multisigStatusResponse.status === 'DONE') {
-        process = statusManager.updateProcess(step, process.type, 'PENDING', {
-            txHash: multisigStatusResponse.txHash,
-            multisigTxHash: undefined,
-            txLink: fromChain.metamask.blockExplorerUrls[0] +
-                'tx/' +
-                multisigStatusResponse.txHash,
-        });
-    }
-    if (multisigStatusResponse.status === 'FAILED') {
-        throw new TransactionError(LifiErrorCode.TransactionFailed, 'Multisig transaction failed.');
-    }
-    if (multisigStatusResponse.status === 'CANCELLED') {
-        throw new TransactionError(LifiErrorCode.TransactionRejected, 'Transaction was rejected by users.');
-    }
-};

package/dist/execution/switchChain.d.ts

@@ -1,16 +0,0 @@
-import { LifiStep } from '@lifi/types';
-import { Signer } from 'ethers';
-import { SwitchChainHook } from '../types';
-import { StatusManager } from './StatusManager';
-/**
- * This method checks whether the signer is configured for the correct chain.
- * If yes it returns the signer.
- * If no and if user interaction is allowed it triggers the switchChainHook. If no user interaction is allowed it aborts.
- *
- * @param signer
- * @param statusManager
- * @param step
- * @param switchChainHook
- * @param allowUserInteraction
- */
-export declare const switchChain: (signer: Signer, statusManager: StatusManager, step: LifiStep, switchChainHook: SwitchChainHook, allowUserInteraction: boolean) => Promise<Signer | undefined>;

package/dist/execution/utils.d.ts

@@ -1,6 +0,0 @@
-import { LifiStep, ProcessType, Status, StatusMessage, StatusResponse, Substatus } from '@lifi/types';
-import { StatusManager } from '..';
-export declare function waitForReceivingTransaction(txHash: string, statusManager: StatusManager, processType: ProcessType, step: LifiStep): Promise<StatusResponse>;
-export declare function getProcessMessage(type: ProcessType, status: Status): string | undefined;
-export declare function getSubstatusMessage(status: StatusMessage, substatus?: Substatus): string | undefined;
-export declare function checkStepSlippageThreshold(oldStep: LifiStep, newStep: LifiStep): boolean;

package/dist/execution/utils.js

@@ -1,122 +0,0 @@
-import BigNumber from 'bignumber.js';
-import ApiService from '../services/ApiService';
-import { ServerError } from '../utils/errors';
-import { repeatUntilDone } from '../utils/utils';
-const TRANSACTION_HASH_OBSERVERS = {};
-export async function waitForReceivingTransaction(txHash, statusManager, processType, step) {
-    const getStatus = () => new Promise(async (resolve, reject) => {
-        let statusResponse;
-        try {
-            statusResponse = await ApiService.getStatus({
-                bridge: step.tool,
-                fromChain: step.action.fromChainId,
-                toChain: step.action.toChainId,
-                txHash,
-            });
-        }
-        catch (e) {
-            console.debug('Fetching status from backend failed.', e);
-            return resolve(undefined);
-        }
-        switch (statusResponse.status) {
-            case 'DONE':
-                return resolve(statusResponse);
-            case 'PENDING':
-                statusManager?.updateProcess(step, processType, 'PENDING', {
-                    substatus: statusResponse.substatus,
-                    substatusMessage: statusResponse.substatusMessage ||
-                        getSubstatusMessage(statusResponse.status, statusResponse.substatus),
-                    txLink: statusResponse.bridgeExplorerLink,
-                });
-                return resolve(undefined);
-            case 'NOT_FOUND':
-                return resolve(undefined);
-            case 'FAILED':
-            default:
-                return reject();
-        }
-    });
-    let status;
-    if (txHash in TRANSACTION_HASH_OBSERVERS) {
-        status = await TRANSACTION_HASH_OBSERVERS[txHash];
-    }
-    else {
-        TRANSACTION_HASH_OBSERVERS[txHash] = repeatUntilDone(getStatus, 5000);
-        status = await TRANSACTION_HASH_OBSERVERS[txHash];
-    }
-    if (!status.receiving) {
-        throw new ServerError("Status doesn't contain receiving information.");
-    }
-    return status;
-}
-const processMessages = {
-    TOKEN_ALLOWANCE: {
-        STARTED: 'Setting token allowance.',
-        PENDING: 'Waiting for token allowance.',
-        DONE: 'Token allowance set.',
-    },
-    SWITCH_CHAIN: {
-        PENDING: 'Chain switch required.',
-        DONE: 'Chain switched successfully.',
-    },
-    SWAP: {
-        STARTED: 'Preparing swap transaction.',
-        ACTION_REQUIRED: 'Please sign the transaction.',
-        PENDING: 'Waiting for swap transaction.',
-        DONE: 'Swap completed.',
-    },
-    CROSS_CHAIN: {
-        STARTED: 'Preparing bridge transaction.',
-        ACTION_REQUIRED: 'Please sign the transaction.',
-        PENDING: 'Waiting for bridge transaction.',
-        DONE: 'Bridge transaction confirmed.',
-    },
-    RECEIVING_CHAIN: {
-        PENDING: 'Waiting for destination chain.',
-        DONE: 'Bridge completed.',
-    },
-    TRANSACTION: {},
-};
-const substatusMessages = {
-    PENDING: {
-        BRIDGE_NOT_AVAILABLE: 'Bridge communication is temporarily unavailable.',
-        CHAIN_NOT_AVAILABLE: 'RPC communication is temporarily unavailable.',
-        NOT_PROCESSABLE_REFUND_NEEDED: 'The transfer cannot be completed successfully. A refund operation is required.',
-        UNKNOWN_ERROR: 'An unexpected error occurred. Please seek assistance in the LI.FI discord server.',
-        WAIT_SOURCE_CONFIRMATIONS: 'The bridge deposit has been received. The bridge is waiting for more confirmations to start the off-chain logic.',
-        WAIT_DESTINATION_TRANSACTION: 'The bridge off-chain logic is being executed. Wait for the transaction to appear on the destination chain.',
-    },
-    DONE: {
-        PARTIAL: 'Some of the received tokens are not the requested destination tokens.',
-        REFUNDED: 'The tokens were refunded to the sender address.',
-        COMPLETED: 'The transfer is complete.',
-    },
-    FAILED: {},
-    INVALID: {},
-    NOT_FOUND: {},
-};
-export function getProcessMessage(type, status) {
-    const processMessage = processMessages[type][status];
-    return processMessage;
-}
-export function getSubstatusMessage(status, substatus) {
-    if (!substatus) {
-        return;
-    }
-    const message = substatusMessages[status][substatus];
-    return message;
-}
-// Used to check if changed exchange rate is in the range of slippage threshold
-export function checkStepSlippageThreshold(oldStep, newStep) {
-    const setSlippage = new BigNumber(oldStep.action.slippage);
-    const oldEstimatedToAmount = new BigNumber(oldStep.estimate.toAmountMin);
-    const newEstimatedToAmount = new BigNumber(newStep.estimate.toAmountMin);
-    const amountDifference = oldEstimatedToAmount.minus(newEstimatedToAmount);
-    // oldEstimatedToAmount can be 0 when we use conract calls
-    let actualSlippage = new BigNumber(0);
-    if (oldEstimatedToAmount.gt(0)) {
-        actualSlippage = amountDifference.dividedBy(oldEstimatedToAmount);
-    }
-    return (newEstimatedToAmount.gte(oldEstimatedToAmount) &&
-        actualSlippage.lte(setSlippage));
-}

package/dist/helpers.d.ts

@@ -1,28 +0,0 @@
-import { LifiStep, Route, Token } from '@lifi/types';
-import { TenderlyResponse } from './types';
-/**
- * Predefined hook that decrypts calldata using EIP-1193 compliant wallet functions.
- * @param {string} walletAddress - The wallet address of the user that should decrypt the calldata.
- * @return {(encryptedData: string) => Promise<any>} A function that decrypts data using EIP-1193 compliant wallet functions.
- */
-export declare const getEthereumDecryptionHook: (walletAddress: string) => (encryptedData: string) => Promise<string>;
-/**
- * Predefined hook that get the public encryption key of a user using EIP-1193 compliant wallet functions.
- * @param {string} walletAddress - The wallet address of the user.
- * @return {(walletAddress: string) => () => Promise<any>} A function that return the public encryption key using EIP-1193 compliant wallet functions.
- */
-export declare const getEthereumPublicKeyHook: (walletAddress: string) => () => Promise<string>;
-/**
- * Returns a random number between min (inclusive) and max (inclusive)
- */
-export declare const getRandomNumber: (min: number, max: number) => number;
-export declare const isSameToken: (tokenA: Token, tokenB: Token) => boolean;
-export declare const checkPackageUpdates: (packageName?: string, packageVersion?: string, disableCheck?: boolean) => Promise<void>;
-/**
- * Converts a quote to Route
- * @param {LifiStep} step - Step returned from the quote endpoint.
- * @return {Route} - 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/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/index.js

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

package/dist/services/ApiService.d.ts

@@ -1,17 +0,0 @@
-import { ConnectionsRequest, ConnectionsResponse, ContractCallQuoteRequest, GasRecommendationRequest, GasRecommendationResponse, GetStatusRequest, LifiStep, QuoteRequest, RequestOptions, TokensRequest, TokensResponse } from '@lifi/types';
-import { 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;