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

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/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/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;
-}

package/dist/execution/RouteExecutionManager.js

@@ -1,195 +0,0 @@
-import ConfigService from '../services/ConfigService';
-import { ValidationError } from '../utils/errors';
-import { StatusManager } from './StatusManager';
-import { StepExecutor } from './StepExecutor';
-import { prepareRestart } from './prepareRestart';
-export class RouteExecutionManager {
-    constructor(configUpdate) {
-        this.executionDictionary = {};
-        this.executionPromiseDictionary = {};
-        /**
-         * 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.
-         */
-        this.executeRoute = async (walletClient, route, settings) => {
-            // Deep clone to prevent side effects
-            const clonedRoute = structuredClone(route);
-            let executionPromise = this.executionPromiseDictionary[clonedRoute.id];
-            // Check if route is already running
-            if (executionPromise) {
-                return executionPromise;
-            }
-            executionPromise = this.executeSteps(walletClient, clonedRoute, settings);
-            this.executionPromiseDictionary[clonedRoute.id] = executionPromise;
-            return executionPromise;
-        };
-        /**
-         * 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.
-         */
-        this.resumeRoute = async (walletClient, route, settings) => {
-            // Deep clone to prevent side effects
-            const clonedRoute = structuredClone(route);
-            const execution = this.executionDictionary[clonedRoute.id];
-            if (execution) {
-                const executionHalted = execution.executors.some((executor) => executor.executionStopped);
-                if (!executionHalted) {
-                    // Check if we want to resume route execution in the background
-                    this.updateRouteExecution(route, {
-                        executeInBackground: settings?.executeInBackground,
-                    });
-                    const executionPromise = this.executionPromiseDictionary[clonedRoute.id];
-                    return executionPromise ?? clonedRoute;
-                }
-            }
-            await prepareRestart(clonedRoute, walletClient);
-            const executionPromise = this.executeSteps(walletClient, clonedRoute, settings);
-            this.executionPromiseDictionary[clonedRoute.id] = executionPromise;
-            return executionPromise;
-        };
-        this.executeSteps = async (walletClient, route, settings) => {
-            const config = this.configService.getConfig();
-            const execution = {
-                route,
-                executors: [],
-                settings: { ...config.defaultExecutionSettings, ...settings },
-            };
-            this.executionDictionary[route.id] = execution;
-            const statusManager = new StatusManager(route, execution.settings, (route) => {
-                if (this.executionDictionary[route.id]) {
-                    execution.route = route;
-                }
-            });
-            // Loop over steps and execute them
-            for (let index = 0; index < route.steps.length; index++) {
-                const execution = this.executionDictionary[route.id];
-                // Check if execution has stopped in the meantime
-                if (!execution) {
-                    break;
-                }
-                const step = route.steps[index];
-                const previousStep = route.steps[index - 1];
-                // Check if the step is already done
-                //
-                if (step.execution?.status === 'DONE') {
-                    continue;
-                }
-                // Update amount using output of previous execution. In the future this should be handled by calling `updateRoute`
-                if (previousStep?.execution?.toAmount) {
-                    step.action.fromAmount = previousStep.execution.toAmount;
-                }
-                try {
-                    const stepExecutor = new StepExecutor(statusManager, execution.settings);
-                    execution.executors.push(stepExecutor);
-                    // Check if we want to execute this step in the background
-                    this.updateRouteExecution(route, execution.settings);
-                    const executedStep = await stepExecutor.executeStep(walletClient, step);
-                    // We may reach this point if user interaction isn't allowed. We want to stop execution until we resume it
-                    if (executedStep.execution?.status !== 'DONE') {
-                        this.stopExecution(route);
-                    }
-                    // Execution stopped during the current step, we don't want to continue to the next step so we return already
-                    if (stepExecutor.executionStopped) {
-                        return route;
-                    }
-                }
-                catch (e) {
-                    this.stopExecution(route);
-                    throw e;
-                }
-            }
-            // Clean up after the execution
-            delete this.executionDictionary[route.id];
-            return route;
-        };
-        /**
-         * Updates route execution to background or foreground state.
-         * @param route - A route that is currently in execution.
-         * @param settings - An object with execution settings.
-         */
-        this.updateRouteExecution = (route, settings) => {
-            const execution = this.executionDictionary[route.id];
-            if (!execution) {
-                return;
-            }
-            for (const executor of execution.executors) {
-                executor.setInteraction({
-                    allowInteraction: !settings.executeInBackground,
-                    allowUpdates: true,
-                });
-            }
-            // Update active route settings so we know what the current state of execution is
-            execution.settings = {
-                ...execution.settings,
-                ...settings,
-            };
-        };
-        /**
-         * 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.
-         */
-        this.updateExecutionSettings = (settings, route) => {
-            const execution = this.executionDictionary[route.id];
-            if (!execution) {
-                throw new ValidationError("Can't set ExecutionSettings for the inactive route.");
-            }
-            const config = this.configService.getConfig();
-            execution.settings = {
-                ...config.defaultExecutionSettings,
-                ...settings,
-            };
-        };
-        /**
-         * Stops the execution of an active route.
-         * @param route - A route that is currently in execution.
-         * @returns The stopped route.
-         */
-        this.stopExecution = (route) => {
-            const execution = this.executionDictionary[route.id];
-            if (!execution) {
-                return route;
-            }
-            for (const executor of execution.executors) {
-                executor.setInteraction({
-                    allowInteraction: false,
-                    allowUpdates: false,
-                    stopExecution: true,
-                });
-            }
-            delete this.executionDictionary[route.id];
-            return route;
-        };
-        /**
-         * Get the list of active routes.
-         * @returns A list of routes.
-         */
-        this.getActiveRoutes = () => {
-            return Object.values(this.executionDictionary)
-                .map((dict) => dict?.route)
-                .filter(Boolean);
-        };
-        /**
-         * Return the current route information for given route. The route has to be active.
-         * @param route - A route object.
-         * @returns The updated route.
-         */
-        this.getActiveRoute = (route) => {
-            return this.executionDictionary[route.id]?.route;
-        };
-        this.configService = ConfigService.getInstance();
-        if (configUpdate) {
-            // Update API urls before we request chains
-            this.configService.updateConfig(configUpdate);
-        }
-    }
-}

package/dist/execution/StatusManager.d.ts

@@ -1,67 +0,0 @@
-import type { 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.
- * @returns {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 step  The current step in execution
-     * @returns 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 step  The current step in execution
-     * @param status  The status for the execution
-     * @param receipt Optional. Information about received tokens
-     * @returns       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 step The step that should contain the new process.
-     * @param type Type of the process. Used to identify already existing processes.
-     * @param status By default created procces is set to the STARTED status. We can override new process with the needed status.
-     * @returns Returns process.
-     */
-    findOrCreateProcess: (step: LifiStep, type: ProcessType, status?: Status) => Process;
-    /**
-     * Update a process object.
-     * @param step The step where the process should be updated
-     * @param type  The process type to update
-     * @param status The status the process gets.
-     * @param [params]   Additional parameters to append to the process.
-     * @returns The update process
-     */
-    updateProcess: (step: LifiStep, type: ProcessType, status: Status, params?: OptionalParameters) => Process;
-    /**
-     * Remove a process from the execution
-     * @param step The step where the process should be removed from
-     * @param type  The process type to remove
-     */
-    removeProcess: (step: LifiStep, type: ProcessType) => void;
-    updateStepInRoute: (step: LifiStep) => LifiStep;
-    allowUpdates(value: boolean): void;
-}
-export {};