@lifi/sdk 2.3.1 → 3.0.0-alpha.10

package/dist/cjs/utils/multicallAbi.json

@@ -1,313 +0,0 @@
-[
-    {
-        "inputs": [
-            {
-                "components": [
-                    {
-                        "internalType": "address",
-                        "name": "target",
-                        "type": "address"
-                    },
-                    {
-                        "internalType": "bytes",
-                        "name": "callData",
-                        "type": "bytes"
-                    }
-                ],
-                "internalType": "struct Multicall2.Call[]",
-                "name": "calls",
-                "type": "tuple[]"
-            }
-        ],
-        "name": "aggregate",
-        "outputs": [
-            {
-                "internalType": "uint256",
-                "name": "blockNumber",
-                "type": "uint256"
-            },
-            {
-                "internalType": "bytes[]",
-                "name": "returnData",
-                "type": "bytes[]"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            {
-                "components": [
-                    {
-                        "internalType": "address",
-                        "name": "target",
-                        "type": "address"
-                    },
-                    {
-                        "internalType": "bytes",
-                        "name": "callData",
-                        "type": "bytes"
-                    }
-                ],
-                "internalType": "struct Multicall2.Call[]",
-                "name": "calls",
-                "type": "tuple[]"
-            }
-        ],
-        "name": "blockAndAggregate",
-        "outputs": [
-            {
-                "internalType": "uint256",
-                "name": "blockNumber",
-                "type": "uint256"
-            },
-            {
-                "internalType": "bytes32",
-                "name": "blockHash",
-                "type": "bytes32"
-            },
-            {
-                "components": [
-                    {
-                        "internalType": "bool",
-                        "name": "success",
-                        "type": "bool"
-                    },
-                    {
-                        "internalType": "bytes",
-                        "name": "returnData",
-                        "type": "bytes"
-                    }
-                ],
-                "internalType": "struct Multicall2.Result[]",
-                "name": "returnData",
-                "type": "tuple[]"
-            }
-        ],
-        "stateMutability": "nonpayable",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            {
-                "internalType": "uint256",
-                "name": "blockNumber",
-                "type": "uint256"
-            }
-        ],
-        "name": "getBlockHash",
-        "outputs": [
-            {
-                "internalType": "bytes32",
-                "name": "blockHash",
-                "type": "bytes32"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "getBlockNumber",
-        "outputs": [
-            {
-                "internalType": "uint256",
-                "name": "blockNumber",
-                "type": "uint256"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "getCurrentBlockCoinbase",
-        "outputs": [
-            {
-                "internalType": "address",
-                "name": "coinbase",
-                "type": "address"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "getCurrentBlockDifficulty",
-        "outputs": [
-            {
-                "internalType": "uint256",
-                "name": "difficulty",
-                "type": "uint256"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "getCurrentBlockGasLimit",
-        "outputs": [
-            {
-                "internalType": "uint256",
-                "name": "gaslimit",
-                "type": "uint256"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "getCurrentBlockTimestamp",
-        "outputs": [
-            {
-                "internalType": "uint256",
-                "name": "timestamp",
-                "type": "uint256"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            {
-                "internalType": "address",
-                "name": "addr",
-                "type": "address"
-            }
-        ],
-        "name": "getEthBalance",
-        "outputs": [
-            {
-                "internalType": "uint256",
-                "name": "balance",
-                "type": "uint256"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "getLastBlockHash",
-        "outputs": [
-            {
-                "internalType": "bytes32",
-                "name": "blockHash",
-                "type": "bytes32"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            {
-                "internalType": "bool",
-                "name": "requireSuccess",
-                "type": "bool"
-            },
-            {
-                "components": [
-                    {
-                        "internalType": "address",
-                        "name": "target",
-                        "type": "address"
-                    },
-                    {
-                        "internalType": "bytes",
-                        "name": "callData",
-                        "type": "bytes"
-                    }
-                ],
-                "internalType": "struct Multicall2.Call[]",
-                "name": "calls",
-                "type": "tuple[]"
-            }
-        ],
-        "name": "tryAggregate",
-        "outputs": [
-            {
-                "components": [
-                    {
-                        "internalType": "bool",
-                        "name": "success",
-                        "type": "bool"
-                    },
-                    {
-                        "internalType": "bytes",
-                        "name": "returnData",
-                        "type": "bytes"
-                    }
-                ],
-                "internalType": "struct Multicall2.Result[]",
-                "name": "returnData",
-                "type": "tuple[]"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            {
-                "internalType": "bool",
-                "name": "requireSuccess",
-                "type": "bool"
-            },
-            {
-                "components": [
-                    {
-                        "internalType": "address",
-                        "name": "target",
-                        "type": "address"
-                    },
-                    {
-                        "internalType": "bytes",
-                        "name": "callData",
-                        "type": "bytes"
-                    }
-                ],
-                "internalType": "struct Multicall2.Call[]",
-                "name": "calls",
-                "type": "tuple[]"
-            }
-        ],
-        "name": "tryBlockAndAggregate",
-        "outputs": [
-            {
-                "internalType": "uint256",
-                "name": "blockNumber",
-                "type": "uint256"
-            },
-            {
-                "internalType": "bytes32",
-                "name": "blockHash",
-                "type": "bytes32"
-            },
-            {
-                "components": [
-                    {
-                        "internalType": "bool",
-                        "name": "success",
-                        "type": "bool"
-                    },
-                    {
-                        "internalType": "bytes",
-                        "name": "returnData",
-                        "type": "bytes"
-                    }
-                ],
-                "internalType": "struct Multicall2.Result[]",
-                "name": "returnData",
-                "type": "tuple[]"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    }
-]

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

@@ -1,37 +0,0 @@
-import { 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/preRestart.d.ts

@@ -1,3 +0,0 @@
-import { Signer } from 'ethers';
-import { Route } from '../types';
-export declare const handlePreRestart: (route: Route, signer: Signer) => Promise<void>;

package/dist/cjs/utils/preRestart.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handlePreRestart = void 0;
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-const ethers_1 = require("ethers");
-const errors_1 = require("./errors");
-const handlePreRestart = async (route, signer) => {
-    for (let index = 0; index < route.steps.length; index++) {
-        const stepHasFailed = route.steps[index].execution?.status === 'FAILED';
-        if (stepHasFailed) {
-            await handleErrorType(route, index, signer);
-            deleteFailedProcesses(route, index);
-            deleteTransactionData(route, index);
-        }
-    }
-};
-exports.handlePreRestart = handlePreRestart;
-const handleErrorType = async (route, index, signer) => {
-    const isGasLimitError = route.steps[index].execution?.process.some((p) => p.error?.code === errors_1.LifiErrorCode.GasLimitError);
-    const isGasPriceError = route.steps[index].execution?.process.some((p) => p.error?.code === errors_1.LifiErrorCode.TransactionUnderpriced);
-    const { transactionRequest } = route.steps[index];
-    if (isGasLimitError) {
-        if (transactionRequest) {
-            let gasLimit = transactionRequest.gasLimit;
-            try {
-                gasLimit = await signer.estimateGas(transactionRequest);
-            }
-            catch (error) { }
-            if (gasLimit) {
-                transactionRequest.gasLimit = ethers_1.BigNumber.from(`${(BigInt(gasLimit.toString()) * 125n) / 100n}`);
-            }
-        }
-        route.steps[index].estimate.gasCosts?.forEach((gasCost) => (gasCost.limit = `${Math.round(Number(gasCost.limit) * 1.25)}`));
-    }
-    if (isGasPriceError) {
-        if (transactionRequest) {
-            let gasPrice = transactionRequest.gasPrice;
-            try {
-                gasPrice = await signer.getGasPrice();
-            }
-            catch (error) { }
-            if (gasPrice) {
-                transactionRequest.gasPrice = ethers_1.BigNumber.from(`${(BigInt(gasPrice.toString()) * 125n) / 100n}`);
-            }
-        }
-        route.steps[index].estimate.gasCosts?.forEach((gasCost) => (gasCost.price = `${Math.round(Number(gasCost.price) * 1.25)}`));
-    }
-};
-const deleteFailedProcesses = (route, index) => {
-    if (route.steps[index].execution) {
-        route.steps[index].execution.process = route.steps[index].execution.process.filter((process) => process.status === 'DONE');
-    }
-};
-const deleteTransactionData = (route, index) => {
-    route.steps[index].transactionRequest = undefined;
-};

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

@@ -1,25 +0,0 @@
-import { TransactionReceipt } from '@ethersproject/providers';
-import { LifiStep, Token } from '@lifi/types';
-import BigNumber from 'bignumber.js';
-import { Signer } from 'ethers';
-import { ChainId } from '../types';
-export declare const sleep: (mills: number) => Promise<undefined>;
-export declare const personalizeStep: (signer: Signer, step: LifiStep) => Promise<LifiStep>;
-export declare const splitListIntoChunks: <T>(list: T[], chunkSize: number) => T[][];
-export declare const formatTokenAmountOnly: (token: Token, amount: string | BigNumber | undefined) => string;
-/**
- * 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>;
-/**
- * Loads a transaction receipt using the rpc for the given chain id
- * @param chainId The chain id where the transaction should be loaded from
- * @param txHash The hash of the transaction
- * @returns TransactionReceipt
- */
-export declare const loadTransactionReceipt: (chainId: ChainId, txHash: string) => Promise<TransactionReceipt>;
-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 = "2.3.1";

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

@@ -1,57 +0,0 @@
-import { FallbackProvider, StaticJsonRpcProvider, } from '@ethersproject/providers';
-import { getRandomNumber } from './helpers';
-import ConfigService from './services/ConfigService';
-import { ChainId } from './types';
-import { ServerError } from './utils/errors';
-// cached providers
-const chainProviders = {};
-// Archive RPC Provider
-const archiveRpcs = {
-    [ChainId.ETH]: 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/eth/mainnet/archive',
-    [ChainId.BSC]: 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/bsc/mainnet/archive',
-    [ChainId.POL]: 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/polygon/mainnet/archive',
-    [ChainId.FTM]: 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/fantom/mainnet',
-};
-// RPC Urls
-export const getRpcUrl = async (chainId, archive = false) => {
-    const rpcUrls = await getRpcUrls(chainId, archive);
-    return rpcUrls[0];
-};
-export const getRpcUrls = async (chainId, archive = false) => {
-    if (archive && archiveRpcs[chainId]) {
-        return [archiveRpcs[chainId]];
-    }
-    const configService = ConfigService.getInstance();
-    const config = await configService.getConfigAsync();
-    return config.rpcs[chainId];
-};
-const getRandomProvider = (providerList) => {
-    const index = getRandomNumber(0, providerList.length - 1);
-    return providerList[index];
-};
-// Provider
-export const getRpcProvider = async (chainId, archive = false) => {
-    if (archive && archiveRpcs[chainId]) {
-        // return archive PRC, but don't cache it
-        return new FallbackProvider([
-            new StaticJsonRpcProvider(await getRpcUrl(chainId, archive), chainId),
-        ]);
-    }
-    if (!chainProviders[chainId]?.length) {
-        chainProviders[chainId] = [];
-        const urls = await getRpcUrls(chainId, archive);
-        urls.forEach((url) => {
-            chainProviders[chainId].push(new FallbackProvider([new StaticJsonRpcProvider(url, chainId)]));
-        });
-    }
-    if (!chainProviders[chainId].length) {
-        throw new ServerError(`Unable to configure provider for chain ${chainId}`);
-    }
-    return getRandomProvider(chainProviders[chainId]);
-};
-// Multicall
-export const getMulticallAddress = async (chainId) => {
-    const configService = ConfigService.getInstance();
-    const config = await configService.getConfigAsync();
-    return config.multicallAddresses[chainId];
-};

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