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

package/dist/cjs/types/internal.types.d.ts

@@ -1,142 +0,0 @@
-import type { ChainId, LifiStep, Route, RouteOptions, Token } from '@lifi/types';
-import type { Hash, Hex, WalletClient } from 'viem';
-import type { StatusManager } from '../execution/StatusManager';
-import type { StepExecutor } from '../execution/StepExecutor';
-export type TransactionParameters = {
-    chainId?: number;
-    to?: string;
-    from?: string;
-    nonce?: number;
-    data?: Hex;
-    value?: bigint;
-    gas?: bigint;
-    gasPrice?: bigint;
-    maxFeePerGas?: bigint;
-    maxPriorityFeePerGas?: bigint;
-};
-export interface ExecutionParams {
-    walletClient: WalletClient;
-    step: LifiStep;
-    statusManager: StatusManager;
-    settings: InternalExecutionSettings;
-}
-export type UpdateRouteHook = (updatedRoute: Route) => void;
-export type TransactionRequestUpdateHook = (updatedTxRequest: TransactionParameters) => Promise<TransactionParameters>;
-export type Config = {
-    apiUrl: string;
-    rpcs: Record<ChainId, string[]>;
-    multicallAddresses: Record<ChainId, string | undefined>;
-    defaultExecutionSettings: InternalExecutionSettings;
-    defaultRouteOptions: RouteOptions;
-    disableVersionCheck?: boolean;
-    userId?: string;
-    integrator: string;
-    widgetVersion?: string;
-    multisig?: MultisigConfig;
-};
-export interface MultisigTxDetails {
-    status: 'DONE' | 'FAILED' | 'PENDING' | 'CANCELLED';
-    txHash?: Hash;
-}
-export interface MultisigTransactionResponse {
-    hash: string;
-}
-export interface BaseTransaction {
-    to: string;
-    value?: bigint;
-    data: string;
-}
-export interface MultisigConfig {
-    isMultisigWalletClient: boolean;
-    getMultisigTransactionDetails: (txHash: Hash, fromChainId: number, updateIntermediateStatus?: () => void) => Promise<MultisigTxDetails>;
-    sendBatchTransaction?: (batchTransactions: BaseTransaction[]) => Promise<Hash>;
-    shouldBatchTransactions?: boolean;
-}
-export type ConfigUpdate = {
-    apiUrl?: string;
-    rpcs?: Record<number, string[]>;
-    multicallAddresses?: Record<number, string | undefined>;
-    defaultExecutionSettings?: ExecutionSettings;
-    defaultRouteOptions?: RouteOptions;
-    disableVersionCheck?: boolean;
-    userId?: string;
-    integrator: string;
-    widgetVersion?: string;
-    multisigConfig?: MultisigConfig;
-};
-export type SwitchChainHook = (requiredChainId: number) => Promise<WalletClient | undefined>;
-export interface AcceptSlippageUpdateHookParams {
-    toToken: Token;
-    oldToAmount: string;
-    newToAmount: string;
-    oldSlippage: number;
-    newSlippage: number;
-}
-export type AcceptSlippageUpdateHook = (params: AcceptSlippageUpdateHookParams) => Promise<boolean | undefined>;
-export interface ExchangeRateUpdateParams {
-    toToken: Token;
-    oldToAmount: string;
-    newToAmount: string;
-}
-export type AcceptExchangeRateUpdateHook = (params: ExchangeRateUpdateParams) => Promise<boolean | undefined>;
-export interface RouteExecutionData {
-    route: Route;
-    executors: StepExecutor[];
-    settings: InternalExecutionSettings;
-}
-export type ExecutionSettings = Partial<InternalExecutionSettings>;
-export interface InternalExecutionSettings {
-    acceptExchangeRateUpdateHook: AcceptExchangeRateUpdateHook;
-    switchChainHook: SwitchChainHook;
-    updateRouteHook: UpdateRouteHook;
-    updateTransactionRequestHook?: TransactionRequestUpdateHook;
-    executeInBackground: boolean;
-    infiniteApproval: boolean;
-}
-export type RouteExecutionDictionary = Partial<Record<string, RouteExecutionData>>;
-export type RouteExecutionPromiseDictionary = Partial<Record<string, Promise<Route>>>;
-export interface InteractionSettings {
-    allowInteraction?: boolean;
-    allowUpdates?: boolean;
-    stopExecution?: boolean;
-}
-export interface TenderlyResponse {
-    hash: string;
-    block_hash: string;
-    block_number: number;
-    from: string;
-    gas: number;
-    gas_price: number;
-    gas_fee_cap: number;
-    gas_tip_cap: number;
-    cumulative_gas_used: number;
-    gas_used: number;
-    effective_gas_price: number;
-    input: string;
-    nonce: number;
-    to: string;
-    index: number;
-    value: string;
-    access_list: any;
-    status: boolean;
-    addresses: string[];
-    contract_ids: string[];
-    network_id: string;
-    timestamp: string;
-    function_selector: string;
-    l1_block_number: number;
-    l1_timestamp: number;
-    deposit_tx: boolean;
-    system_tx: boolean;
-    mint: number;
-    sig: Signature;
-    error_message: string;
-    method: string;
-    decoded_input: any;
-    call_trace: any;
-}
-export interface Signature {
-    v: string;
-    r: string;
-    s: string;
-}

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

@@ -1,107 +0,0 @@
-declare enum ErrorType {
-    RPCError = "RPCError",
-    ProviderError = "ProviderError",
-    ServerError = "ServerError",
-    TransactionError = "TransactionError",
-    ValidationError = "ValidationError",
-    NotFoundError = "NotFoundError",
-    UnknownError = "UnknownError",
-    SlippageError = "SlippageError"
-}
-export declare enum LiFiErrorCode {
-    InternalError = 1000,
-    ValidationError = 1001,
-    TransactionUnderpriced = 1002,
-    TransactionFailed = 1003,
-    Timeout = 1004,
-    ProviderUnavailable = 1005,
-    NotFound = 1006,
-    ChainSwitchError = 1007,
-    TransactionUnprepared = 1008,
-    GasLimitError = 1009,
-    TransactionCanceled = 1010,
-    SlippageError = 1011,
-    SignatureRejected = 1012,
-    BalanceError = 1013,
-    AllowanceRequired = 1014,
-    InsufficientFunds = 1015,
-    ExchangeRateUpdateCanceled = 1016
-}
-export declare enum EthersErrorType {
-    ActionRejected = "ACTION_REJECTED",
-    CallExecption = "CALL_EXCEPTION",
-    InsufficientFunds = "INSUFFICIENT_FUNDS"
-}
-export declare enum EthersErrorMessage {
-    ERC20Allowance = "ERC20: transfer amount exceeds allowance",
-    LowGas = "intrinsic gas too low",
-    OutOfGas = "out of gas",
-    Underpriced = "underpriced",
-    LowReplacementFee = "replacement fee too low"
-}
-export declare enum ErrorMessage {
-    UnknownError = "Unknown error occurred.",
-    SlippageError = "The slippage is larger than the defined threshold. Please request a new route to get a fresh quote.",
-    GasLimitLow = "Gas limit is too low.",
-    TransactionUnderpriced = "Transaction is underpriced.",
-    Default = "Something went wrong."
-}
-export declare enum MetaMaskRPCErrorCode {
-    invalidInput = -32000,
-    resourceNotFound = -32001,
-    resourceUnavailable = -32002,
-    transactionRejected = -32003,
-    methodNotSupported = -32004,
-    limitExceeded = -32005,
-    parse = -32700,
-    invalidRequest = -32600,
-    methodNotFound = -32601,
-    invalidParams = -32602,
-    internal = -32603
-}
-export declare enum MetaMaskProviderErrorCode {
-    userRejectedRequest = 4001,
-    unauthorized = 4100,
-    unsupportedMethod = 4200,
-    disconnected = 4900,
-    chainDisconnected = 4901
-}
-export type ErrorCode = LiFiErrorCode | MetaMaskRPCErrorCode | MetaMaskProviderErrorCode;
-export declare class LiFiError extends Error {
-    code: ErrorCode;
-    htmlMessage?: string;
-    constructor(type: ErrorType, code: number, message: string, htmlMessage?: string, stack?: string);
-}
-export declare class RPCError extends LiFiError {
-    constructor(code: ErrorCode, message: string, htmlMessage?: string, stack?: string);
-}
-export declare class ProviderError extends LiFiError {
-    constructor(code: ErrorCode, message: string, htmlMessage?: string, stack?: string);
-}
-export declare class ServerError extends LiFiError {
-    constructor(message: string, htmlMessage?: string, stack?: string);
-}
-export declare class ValidationError extends LiFiError {
-    constructor(message: string, htmlMessage?: string, stack?: string);
-}
-export declare class TransactionError extends LiFiError {
-    constructor(code: ErrorCode, message: string, htmlMessage?: string, stack?: string);
-}
-export declare class SlippageError extends LiFiError {
-    constructor(message: string, htmlMessage?: string, stack?: string);
-}
-export declare class BalanceError extends LiFiError {
-    constructor(message: string, htmlMessage?: string, stack?: string);
-}
-export declare class NotFoundError extends LiFiError {
-    constructor(message: string, htmlMessage?: string, stack?: string);
-}
-export declare class UnknownError extends LiFiError {
-    constructor(code: ErrorCode, message: string, htmlMessage?: string, stack?: string);
-}
-export declare class HTTPError extends Error {
-    response: Response;
-    status: number;
-    constructor(response: Response);
-}
-export {};

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

@@ -1,2 +0,0 @@
-import type { PublicClient } from 'viem';
-export declare const getMaxPriorityFeePerGas: (client: PublicClient) => Promise<bigint | undefined>;

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

@@ -1,5 +0,0 @@
-export * from './errors';
-export * from './getMaxPriorityFeePerGas';
-export * from './median';
-export * from './parseError';
-export * from './utils';

package/dist/cjs/utils/index.js

@@ -1,21 +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("./errors"), exports);
-__exportStar(require("./getMaxPriorityFeePerGas"), exports);
-__exportStar(require("./median"), exports);
-__exportStar(require("./parseError"), exports);
-__exportStar(require("./utils"), exports);

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

@@ -1,37 +0,0 @@
-import type { LifiStep, Process } from '@lifi/types';
-import { LiFiError } from './errors';
-/**
- * Available MetaMask error codes:
- *
- * export const errorCodes: ErrorCodes = {
-     rpc: {
-      invalidInput: -32000,
-      resourceNotFound: -32001,
-      resourceUnavailable: -32002,
-      transactionRejected: -32003,
-      methodNotSupported: -32004,
-      limitExceeded: -32005,
-      parse: -32700,
-      invalidRequest: -32600,
-      methodNotFound: -32601,
-      invalidParams: -32602,
-      internal: -32603,
-    },
-    provider: {
-      userRejectedRequest: 4001,
-      unauthorized: 4100,
-      unsupportedMethod: 4200,
-      disconnected: 4900,
-      chainDisconnected: 4901,
-    },
-  };
- *
- * For more information about error codes supported by metamask check
- * https://github.com/MetaMask/eth-rpc-errors
- * https://eips.ethereum.org/EIPS/eip-1474#error-codes
- * https://eips.ethereum.org/EIPS/eip-1193#provider-errors
- */
-export declare const getTransactionNotSentMessage: (step?: LifiStep, process?: Process) => Promise<string>;
-export declare const getTransactionFailedMessage: (step: LifiStep, txLink?: string) => Promise<string>;
-export declare const parseError: (e: any, step?: LifiStep, process?: Process) => Promise<LiFiError>;
-export declare const parseBackendError: (e: any) => Promise<LiFiError>;

package/dist/cjs/utils/parseError.js

@@ -1,157 +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.parseBackendError = exports.parseError = exports.getTransactionFailedMessage = exports.getTransactionNotSentMessage = void 0;
-const eth_rpc_errors_1 = require("eth-rpc-errors");
-const viem_1 = require("viem");
-const helpers_1 = require("../helpers");
-const ChainsService_1 = __importDefault(require("../services/ChainsService"));
-const errors_1 = require("./errors");
-/**
- * Available MetaMask error codes:
- *
- * export const errorCodes: ErrorCodes = {
-     rpc: {
-      invalidInput: -32000,
-      resourceNotFound: -32001,
-      resourceUnavailable: -32002,
-      transactionRejected: -32003,
-      methodNotSupported: -32004,
-      limitExceeded: -32005,
-      parse: -32700,
-      invalidRequest: -32600,
-      methodNotFound: -32601,
-      invalidParams: -32602,
-      internal: -32603,
-    },
-    provider: {
-      userRejectedRequest: 4001,
-      unauthorized: 4100,
-      unsupportedMethod: 4200,
-      disconnected: 4900,
-      chainDisconnected: 4901,
-    },
-  };
- *
- * For more information about error codes supported by metamask check
- * https://github.com/MetaMask/eth-rpc-errors
- * https://eips.ethereum.org/EIPS/eip-1474#error-codes
- * https://eips.ethereum.org/EIPS/eip-1193#provider-errors
- */
-const getTransactionNotSentMessage = async (step, process) => {
-    let transactionNotSend = 'Transaction was not sent, your funds are still in your wallet';
-    // add information about funds if available
-    if (step) {
-        const chainService = ChainsService_1.default.getInstance();
-        const chain = await chainService.getChainById(step.action.fromChainId);
-        transactionNotSend += ` (${(0, viem_1.formatUnits)(BigInt(step.action.fromAmount), step.action.fromToken.decimals)} ${step.action.fromToken.symbol} on ${chain.name})`;
-    }
-    transactionNotSend +=
-        ", please retry.<br/>If it still doesn't work, it is safe to delete this transfer and start a new one.";
-    // add transaction explorer link if available
-    transactionNotSend +=
-        process && process.txLink
-            ? `<br>You can check the failed transaction&nbsp;<a href="${process.txLink}" target="_blank" rel="nofollow noreferrer">here</a>.`
-            : '';
-    return transactionNotSend;
-};
-exports.getTransactionNotSentMessage = getTransactionNotSentMessage;
-const getTransactionFailedMessage = async (step, txLink) => {
-    const chainsService = ChainsService_1.default.getInstance();
-    const chain = await chainsService.getChainById(step.action.toChainId);
-    const baseString = `It appears that your transaction may not have been successful.
-  However, to confirm this, please check your ${chain.name} wallet for ${step.action.toToken.symbol}.`;
-    return txLink
-        ? `${baseString}
-    You can also check the&nbsp;<a href="${txLink}" target="_blank" rel="nofollow noreferrer">block explorer</a> for more information.`
-        : baseString;
-};
-exports.getTransactionFailedMessage = getTransactionFailedMessage;
-const parseError = async (e, step, process) => {
-    if (e instanceof errors_1.LiFiError) {
-        return e;
-    }
-    const errorCode = e.code || e.cause?.code;
-    switch (errorCode) {
-        case errors_1.EthersErrorType.CallExecption:
-            const defaultErrorMessage = await (0, exports.getTransactionNotSentMessage)(step, process);
-            try {
-                if (!step?.action.fromChainId) {
-                    throw new Error('fromChainId is not defined.');
-                }
-                const response = await (0, helpers_1.fetchTxErrorDetails)(e.transactionHash, step?.action.fromChainId);
-                const errorMessage = response?.error_message ?? e.reason;
-                const isAllowanceError = response?.error_message?.includes(errors_1.EthersErrorMessage.ERC20Allowance) || e.reason?.includes(errors_1.EthersErrorMessage.ERC20Allowance);
-                if (isAllowanceError) {
-                    return new errors_1.TransactionError(errors_1.LiFiErrorCode.AllowanceRequired, e.reason, errorMessage, e.stack);
-                }
-                // Error messages other than allowance error will be handled in catch block
-                throw new Error(e);
-            }
-            catch (error) {
-                return new errors_1.ProviderError(errors_1.LiFiErrorCode.TransactionFailed, e.reason, defaultErrorMessage, e.stack);
-            }
-        case errors_1.EthersErrorType.InsufficientFunds:
-            return new errors_1.TransactionError(errors_1.LiFiErrorCode.InsufficientFunds, e.message, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
-        case errors_1.EthersErrorType.ActionRejected:
-        case errors_1.MetaMaskProviderErrorCode.userRejectedRequest:
-            return new errors_1.TransactionError(errors_1.LiFiErrorCode.SignatureRejected, e.message, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
-        case errors_1.LiFiErrorCode.TransactionUnprepared:
-            return new errors_1.TransactionError(errors_1.LiFiErrorCode.TransactionUnprepared, e.message, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
-        case errors_1.LiFiErrorCode.ValidationError:
-            return new errors_1.TransactionError(errors_1.LiFiErrorCode.ValidationError, e.message, e.htmlMessage);
-        case errors_1.LiFiErrorCode.TransactionCanceled:
-            return new errors_1.TransactionError(errors_1.LiFiErrorCode.TransactionCanceled, e.message, e.htmlMessage);
-        case errors_1.LiFiErrorCode.ExchangeRateUpdateCanceled:
-            return new errors_1.TransactionError(errors_1.LiFiErrorCode.ExchangeRateUpdateCanceled, e.message, e.htmlMessage);
-        default: {
-            if (errorCode && typeof errorCode === 'number') {
-                if (Object.values(eth_rpc_errors_1.errorCodes.rpc).includes(errorCode)) {
-                    // rpc errors
-                    // underpriced errors are sent as internal errors, so we need to parse the message manually
-                    if (errorCode === eth_rpc_errors_1.errorCodes.rpc.internal &&
-                        (e.message?.includes(errors_1.EthersErrorMessage.Underpriced) ||
-                            e.message?.includes(errors_1.EthersErrorMessage.LowReplacementFee))) {
-                        return new errors_1.RPCError(errors_1.LiFiErrorCode.TransactionUnderpriced, errors_1.ErrorMessage.TransactionUnderpriced, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
-                    }
-                    if (e.message?.includes(errors_1.EthersErrorMessage.LowGas) ||
-                        e.message?.includes(errors_1.EthersErrorMessage.OutOfGas)) {
-                        return new errors_1.TransactionError(errors_1.LiFiErrorCode.GasLimitError, errors_1.ErrorMessage.GasLimitLow, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
-                    }
-                    return new errors_1.RPCError(errorCode, (0, eth_rpc_errors_1.getMessageFromCode)(errorCode), await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
-                }
-                // provider errors
-                if (Object.values(eth_rpc_errors_1.errorCodes.provider).includes(errorCode)) {
-                    return new errors_1.ProviderError(errorCode, (0, eth_rpc_errors_1.getMessageFromCode)(errorCode), await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
-                }
-            }
-            return new errors_1.UnknownError(errors_1.LiFiErrorCode.InternalError, e.message || errors_1.ErrorMessage.UnknownError, undefined, e.stack);
-        }
-    }
-};
-exports.parseError = parseError;
-const parseBackendError = async (e) => {
-    let data;
-    try {
-        data = await e.response?.json();
-    }
-    catch (error) {
-        // ignore
-    }
-    if (e.response?.status === 400) {
-        return new errors_1.ValidationError(data?.message || e.response?.statusText, undefined, e.stack);
-    }
-    if (e.response?.status === 404) {
-        return new errors_1.NotFoundError(data?.message || e.response?.statusText, undefined, e.stack);
-    }
-    if (e.response?.status === 409) {
-        return new errors_1.SlippageError(data?.message || e.response?.statusText, errors_1.ErrorMessage.SlippageError, e.stack);
-    }
-    if (e.response?.status === 500) {
-        return new errors_1.ServerError(data?.message || e.response?.statusText, undefined, e.stack);
-    }
-    return new errors_1.ServerError(errors_1.ErrorMessage.Default, undefined, e.stack);
-};
-exports.parseBackendError = parseBackendError;

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

@@ -1,10 +0,0 @@
-export declare const wait: (ms: number) => Promise<undefined>;
-/**
- * Repeatedly calls a given asynchronous function until it resolves with a value
- * @param toRepeat The function that should be repeated
- * @param timeout The timeout in milliseconds between retries, defaults to 5000
- * @returns The result of the toRepeat function
- */
-export declare const repeatUntilDone: <T>(toRepeat: () => Promise<T | undefined>, timeout?: number) => Promise<T>;
-export declare const isZeroAddress: (address: string) => boolean;
-export declare const isNativeTokenAddress: (address: string) => boolean;

package/dist/cjs/version.d.ts

@@ -1,2 +0,0 @@
-export declare const name = "@lifi/sdk";
-export declare const version = "3.0.0-alpha.2";

package/dist/connectors.d.ts

@@ -1,8 +0,0 @@
-import type { PublicClient } from 'viem';
-import type { Chain } from 'viem/chains';
-import type { ChainId } from './types';
-export declare const getChainById: (chainId: ChainId) => Chain | undefined;
-export declare const getRpcUrl: (chainId: ChainId) => Promise<string>;
-export declare const getRpcUrls: (chainId: ChainId) => Promise<string[]>;
-export declare const getPublicClient: (chainId: number) => Promise<PublicClient>;
-export declare const getMulticallAddress: (chainId: ChainId) => Promise<string | undefined>;

package/dist/connectors.js

@@ -1,41 +0,0 @@
-import { createPublicClient, fallback, http } from 'viem';
-import * as chains from 'viem/chains'; // TODO: optimize using BE chains
-import ConfigService from './services/ConfigService';
-import { ServerError } from './utils/errors';
-// cached providers
-const publicClients = {};
-export const getChainById = (chainId) => {
-    return Object.values(chains).find((chain) => chain.id === chainId);
-};
-// RPC Urls
-export const getRpcUrl = async (chainId) => {
-    const rpcUrls = await getRpcUrls(chainId);
-    return rpcUrls[0];
-};
-export const getRpcUrls = async (chainId) => {
-    const configService = ConfigService.getInstance();
-    const config = await configService.getConfigAsync();
-    return config.rpcs[chainId];
-};
-export const getPublicClient = async (chainId) => {
-    if (!publicClients[chainId]) {
-        const urls = await getRpcUrls(chainId);
-        const fallbackTransports = urls.map((url) => http(url, {
-            batch: true,
-        }));
-        publicClients[chainId] = createPublicClient({
-            chain: getChainById(chainId),
-            transport: fallback(fallbackTransports),
-        });
-    }
-    if (!publicClients[chainId]) {
-        throw new ServerError(`Unable to configure provider for chain ${chainId}`);
-    }
-    return publicClients[chainId];
-};
-// Multicall
-export const getMulticallAddress = async (chainId) => {
-    const configService = ConfigService.getInstance();
-    const config = await configService.getConfigAsync();
-    return config.multicallAddresses[chainId];
-};

package/dist/constants.d.ts

@@ -1,6 +0,0 @@
-export declare const AddressZero = "0x0000000000000000000000000000000000000000";
-export declare const AlternativeAddressZero = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
-/**
- * Cronos require bigger multicall chunks than default 1024 (1 KB)
- */
-export declare const MulticallBatchSize = 16384;

package/dist/execution/RouteExecutionManager.d.ts

@@ -1,59 +0,0 @@
-import type { Route } from '@lifi/types';
-import type { WalletClient } from 'viem';
-import ConfigService from '../services/ConfigService';
-import type { ConfigUpdate, ExecutionSettings } from '../types';
-export declare class RouteExecutionManager {
-    private executionDictionary;
-    private executionPromiseDictionary;
-    protected configService: ConfigService;
-    constructor(configUpdate: ConfigUpdate);
-    /**
-     * Execute a route.
-     * @param walletClient - The walletClient required to send the transactions.
-     * @param route - The route that should be executed. Cannot be an active route.
-     * @param settings - An object containing settings and callbacks.
-     * @returns The executed route.
-     * @throws {LiFiError} Throws a LiFiError if the execution fails.
-     */
-    executeRoute: (walletClient: WalletClient, route: Route, settings?: ExecutionSettings) => Promise<Route>;
-    /**
-     * Resume the execution of a route that has been stopped or had an error while executing.
-     * @param walletClient - The walletClient required to send the transactions.
-     * @param route - The route that is to be executed. Cannot be an active route.
-     * @param settings - An object containing settings and callbacks.
-     * @returns The executed route.
-     * @throws {LiFiError} Throws a LiFiError if the execution fails.
-     */
-    resumeRoute: (walletClient: WalletClient, route: Route, settings?: ExecutionSettings) => Promise<Route>;
-    private executeSteps;
-    /**
-     * Updates route execution to background or foreground state.
-     * @param route - A route that is currently in execution.
-     * @param settings - An object with execution settings.
-     */
-    updateRouteExecution: (route: Route, settings: Pick<ExecutionSettings, 'executeInBackground'>) => void;
-    /**
-     * Update the ExecutionSettings for an active route.
-     * @param settings - An object with execution settings.
-     * @param 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;
-    /**
-     * Stops the execution of an active route.
-     * @param route - A route that is currently in execution.
-     * @returns The stopped route.
-     */
-    stopExecution: (route: Route) => Route;
-    /**
-     * Get the list of active routes.
-     * @returns A list of routes.
-     */
-    getActiveRoutes: () => Route[];
-    /**
-     * Return the current route information for given route. The route has to be active.
-     * @param route - A route object.
-     * @returns The updated route.
-     */
-    getActiveRoute: (route: Route) => Route | undefined;
-}