@lifi/sdk 2.3.1 → 3.0.0-alpha.10

package/dist/services/ConfigService.js

@@ -1,101 +0,0 @@
-import { ChainId, } from '../types';
-const DefaultExecutionSettings = {
-    /* eslint-disable-next-line @typescript-eslint/no-empty-function */
-    updateRouteHook: () => { },
-    switchChainHook: () => Promise.resolve(undefined),
-    acceptExchangeRateUpdateHook: () => Promise.resolve(undefined),
-    infiniteApproval: false,
-    executeInBackground: false,
-};
-class ConfigService {
-    constructor() {
-        this.resolveSetupPromise = undefined;
-        /**
-         * This call immediately returns the current config. It does not make sure that all chain data is already loaded
-         * Use this if you need access to basic information like API urls or settings
-         */
-        this.getConfig = () => {
-            return this.config;
-        };
-        /**
-         * This call waits for all setup promises to be done.
-         * Use this if you need access to chain data (RPCs or multicalls)
-         */
-        this.getConfigAsync = async () => {
-            await this.setupPromise;
-            return this.config;
-        };
-        this.updateConfig = (configUpdate) => {
-            // API
-            this.config.apiUrl = configUpdate.apiUrl || this.config.apiUrl;
-            // RPCS
-            this.config.rpcs = Object.assign(this.config.rpcs, configUpdate.rpcs);
-            // MULTICALL
-            this.config.multicallAddresses = Object.assign(this.config.multicallAddresses, configUpdate.multicallAddresses);
-            // SETTINGS
-            this.config.defaultExecutionSettings = Object.assign(this.config.defaultExecutionSettings, configUpdate.defaultExecutionSettings);
-            // OPTIONS
-            this.config.defaultRouteOptions = Object.assign(this.config.defaultRouteOptions, configUpdate.defaultRouteOptions);
-            this.config.apiKey = configUpdate.apiKey || this.config.apiKey;
-            this.config.userId = configUpdate.userId || this.config.userId;
-            this.config.integrator = configUpdate.integrator || this.config.integrator;
-            this.config.defaultRouteOptions.integrator =
-                configUpdate.integrator ||
-                    configUpdate.defaultRouteOptions?.integrator ||
-                    this.config.integrator;
-            this.config.widgetVersion =
-                configUpdate.widgetVersion || this.config.widgetVersion;
-            this.config.multisigConfig =
-                configUpdate.multisigConfig || this.config.multisigConfig;
-            return this.config;
-        };
-        this.updateChains = (chains) => {
-            for (const chain of chains) {
-                const chainId = chain.id;
-                // set RPCs if they were not configured by the user before
-                if (!this.config.rpcs[chainId]?.length) {
-                    this.config.rpcs[chainId] = chain.metamask.rpcUrls;
-                }
-                // set multicall addresses if they exist and were not configured by the user before
-                if (chain.multicallAddress && !this.config.multicallAddresses[chainId]) {
-                    this.config.multicallAddresses[chainId] = chain.multicallAddress;
-                }
-            }
-            this.resolveSetupPromise?.();
-            return this.config;
-        };
-        this.config = ConfigService.getDefaultConfig();
-        this.setupPromise = new Promise((resolve) => {
-            this.resolveSetupPromise = resolve;
-        });
-    }
-    static chainIdToObject(val) {
-        const result = {};
-        const values = Object.values(ChainId);
-        values.forEach((chainId) => {
-            if (typeof chainId !== 'string') {
-                result[chainId] = val ? JSON.parse(JSON.stringify(val)) : val;
-            }
-        });
-        return result;
-    }
-    static getInstance() {
-        if (!this.instance) {
-            this.instance = new ConfigService();
-        }
-        return this.instance;
-    }
-}
-ConfigService.getDefaultConfig = () => {
-    return {
-        apiUrl: 'https://li.quest/v1',
-        rpcs: ConfigService.chainIdToObject([]),
-        multicallAddresses: ConfigService.chainIdToObject(undefined),
-        defaultExecutionSettings: DefaultExecutionSettings,
-        defaultRouteOptions: {
-            integrator: 'lifi-sdk',
-        },
-        integrator: 'lifi-sdk',
-    };
-};
-export default ConfigService;

package/dist/typeguards.d.ts

@@ -1,4 +0,0 @@
-import { LifiStep, RoutesRequest, StaticToken } from './types';
-export declare const isRoutesRequest: (routesRequest: RoutesRequest) => routesRequest is RoutesRequest;
-export declare const isStep: (step: LifiStep) => step is LifiStep;
-export declare const isToken: (token: StaticToken) => token is StaticToken;

package/dist/types/ERC20.d.ts

@@ -1,22 +0,0 @@
-import { BaseContract, BigNumber, BigNumberish, CallOverrides, ContractTransaction, Overrides } from 'ethers';
-export declare const ERC20_ABI: {
-    name: string;
-    inputs: {
-        internalType: string;
-        name: string;
-        type: string;
-    }[];
-    outputs: {
-        internalType: string;
-        name: string;
-        type: string;
-    }[];
-    stateMutability: string;
-    type: string;
-}[];
-export interface ERC20Contract extends BaseContract {
-    allowance(owner: string, spender: string, overrides?: CallOverrides): Promise<BigNumber>;
-    approve(spender: string, amount: BigNumberish, overrides?: Overrides & {
-        from?: string | Promise<string>;
-    }): Promise<ContractTransaction>;
-}

package/dist/types/ERC20.js

@@ -1,50 +0,0 @@
-export const ERC20_ABI = [
-    {
-        name: 'approve',
-        inputs: [
-            {
-                internalType: 'address',
-                name: 'spender',
-                type: 'address',
-            },
-            {
-                internalType: 'uint256',
-                name: 'amount',
-                type: 'uint256',
-            },
-        ],
-        outputs: [
-            {
-                internalType: 'bool',
-                name: '',
-                type: 'bool',
-            },
-        ],
-        stateMutability: 'nonpayable',
-        type: 'function',
-    },
-    {
-        name: 'allowance',
-        inputs: [
-            {
-                internalType: 'address',
-                name: 'owner',
-                type: 'address',
-            },
-            {
-                internalType: 'address',
-                name: 'spender',
-                type: 'address',
-            },
-        ],
-        outputs: [
-            {
-                internalType: 'uint256',
-                name: '',
-                type: 'uint256',
-            },
-        ],
-        stateMutability: 'view',
-        type: 'function',
-    },
-];

package/dist/types/index.js

@@ -1,4 +0,0 @@
-export * from '@lifi/types';
-export { LifiError } from '../utils/errors';
-export * from './ERC20';
-export * from './internal.types';

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

@@ -1,151 +0,0 @@
-import { TransactionRequest } from '@ethersproject/abstract-provider';
-import { LifiStep, Route, RouteOptions, Token } from '@lifi/types';
-import BigNumber from 'bignumber.js';
-import { Signer } from 'ethers';
-import { ChainId } from '.';
-import { StatusManager } from '../execution/StatusManager';
-import { StepExecutor } from '../execution/StepExecutor';
-export interface TokenWithAmounts extends Token {
-    amount?: BigNumber;
-    amountRendered?: string;
-}
-export type ParsedReceipt = {
-    fromAmount?: string;
-    toAmount: string;
-    gasUsed: string;
-    gasPrice: string;
-    gasFee: string;
-    toTokenAddress?: string;
-};
-export interface ExecutionParams {
-    signer: Signer;
-    step: LifiStep;
-    statusManager: StatusManager;
-    settings: InternalExecutionSettings;
-}
-export type UpdateRouteHook = (updatedRoute: Route) => void;
-export type TransactionRequestUpdateHook = (updatedTxRequest: TransactionRequest) => Promise<TransactionRequest>;
-export type Config = {
-    apiUrl: string;
-    apiKey?: string;
-    rpcs: Record<ChainId, string[]>;
-    multicallAddresses: Record<ChainId, string | undefined>;
-    defaultExecutionSettings: InternalExecutionSettings;
-    defaultRouteOptions: RouteOptions;
-    disableVersionCheck?: boolean;
-    userId?: string;
-    integrator: string;
-    widgetVersion?: string;
-    multisigConfig?: MultisigConfig;
-};
-export interface MultisigTxDetails {
-    status: 'DONE' | 'FAILED' | 'PENDING' | 'CANCELLED';
-    txHash?: string;
-}
-export interface MultisigTransactionResponse {
-    hash: string;
-}
-export interface BaseTransaction {
-    to: string;
-    value: string;
-    data: string;
-}
-export interface MultisigConfig {
-    isMultisigSigner?: boolean;
-    getMultisigTransactionDetails?: (txHash: string, fromChainId: number, updateIntermediateStatus?: () => void) => Promise<MultisigTxDetails>;
-    sendBatchTransaction?: (batchTransactions: BaseTransaction[]) => Promise<MultisigTransactionResponse>;
-    shouldBatchTransactions?: boolean;
-}
-export type ConfigUpdate = {
-    apiUrl?: string;
-    apiKey?: 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<Signer | 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 type RevokeTokenData = {
-    token: Token;
-    approvalAddress: string;
-};
-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/types/internal.types.js

@@ -1 +0,0 @@
-export {};

package/dist/utils/errors.d.ts

@@ -1,106 +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,
-    TransactionRejected = 1012,
-    BalanceError = 1013,
-    AllowanceRequired = 1014,
-    InsufficientFunds = 1015
-}
-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/utils/getProvider.d.ts

@@ -1,3 +0,0 @@
-import { Provider } from '@ethersproject/abstract-provider';
-import { Signer } from 'ethers';
-export declare const getProvider: (signer: Signer) => Provider;

package/dist/utils/getProvider.js

@@ -1,7 +0,0 @@
-import { LifiErrorCode, ProviderError } from './errors';
-export const getProvider = (signer) => {
-    if (!signer.provider) {
-        throw new ProviderError(LifiErrorCode.ProviderUnavailable, 'No provider available in signer.');
-    }
-    return signer.provider;
-};

package/dist/utils/multicall.d.ts

@@ -1,10 +0,0 @@
-import { Fragment, JsonFragment } from '@ethersproject/abi';
-export type MultiCallData = {
-    address: string;
-    name: string;
-    params?: any[];
-};
-export declare const fetchDataUsingMulticall: (calls: Array<MultiCallData>, abi: ReadonlyArray<Fragment | JsonFragment | string>, chainId: number, multicallAddress: string, requireSuccess?: boolean) => Promise<{
-    data: unknown;
-    blockNumber: number;
-}[]>;

package/dist/utils/multicall.js

@@ -1,61 +0,0 @@
-import { Interface } from '@ethersproject/abi';
-import { Contract } from '@ethersproject/contracts';
-import { getRpcProvider } from '../connectors';
-import { splitListIntoChunks } from './utils';
-import MULTICALL_ABI from './multicallAbi.json';
-const MAX_MULTICALL_SIZE = 100;
-export const fetchDataUsingMulticall = async (calls, abi, chainId, multicallAddress, requireSuccess = false) => {
-    // 1. create contract using multicall contract address and abi...
-    const provider = await getRpcProvider(chainId);
-    const multicallContract = new Contract(multicallAddress, MULTICALL_ABI, provider);
-    const abiInterface = new Interface(abi);
-    // split up lists into chunks to stay below multicall limit
-    const chunkedList = splitListIntoChunks(calls, MAX_MULTICALL_SIZE);
-    const chunkedResults = await Promise.all(chunkedList.map(async (chunkedCalls) => {
-        const callData = chunkedCalls.map((call) => [
-            call.address.toLowerCase(),
-            abiInterface.encodeFunctionData(call.name, call.params),
-        ]);
-        try {
-            // 3. get bytes array from multicall contract by process aggregate method...
-            const { blockNumber, returnData } = await multicallContract.tryBlockAndAggregate(requireSuccess, callData);
-            // 4. decode bytes array to useful data array...
-            return returnData
-                .map(({ success, returnData }, i) => {
-                if (!success) {
-                    // requested function failed
-                    console.error(`Multicall unsuccessful for address "${chunkedCalls[i].address}", ` +
-                        `function "${chunkedCalls[i].name}", chainId "${chainId}"`);
-                    return [];
-                }
-                if (returnData.toString() === '0x') {
-                    // requested function does probably not exist
-                    console.error(`Multicall no response for address "${chunkedCalls[i].address}", ` +
-                        `function "${chunkedCalls[i].name}", chainId "${chainId}"`);
-                    return [];
-                }
-                try {
-                    return abiInterface.decodeFunctionResult(chunkedCalls[i].name, returnData);
-                }
-                catch (e) {
-                    // requested function returns other data than expected
-                    console.error(`Multicall parsing unsuccessful for address "${chunkedCalls[i].address}", ` +
-                        `function "${chunkedCalls[i].name}", chainId "${chainId}"`);
-                    return [];
-                }
-            })
-                .map((data) => {
-                return {
-                    data: data[0],
-                    blockNumber: blockNumber.toNumber(),
-                };
-            });
-        }
-        catch (e) {
-            // whole rpc call failed, probably an rpc issue
-            console.error(`Multicall failed on chainId "${chainId}"`, chunkedList, e);
-            return [];
-        }
-    }));
-    return chunkedResults.flat();
-};