@lifi/sdk 1.1.4 → 1.1.5

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

@@ -0,0 +1,85 @@
+import { Route, RouteOptions, Step, 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 declare type ParsedReceipt = {
+    fromAmount?: string;
+    toAmount: string;
+    gasUsed: string;
+    gasPrice: string;
+    gasFee: string;
+    toTokenAddress?: string;
+};
+interface ExecutionParams {
+    signer: Signer;
+    step: Step;
+    statusManager: StatusManager;
+    settings: InternalExecutionSettings;
+}
+export interface ExecuteSwapParams extends ExecutionParams {
+    step: Step;
+}
+export interface ExecuteCrossParams extends ExecutionParams {
+    step: Step;
+}
+export declare type CallbackFunction = (updatedRoute: Route) => void;
+export declare type Config = {
+    apiUrl: string;
+    rpcs: Record<ChainId, string[]>;
+    multicallAddresses: Record<ChainId, string | undefined>;
+    defaultExecutionSettings: InternalExecutionSettings;
+    defaultRouteOptions: RouteOptions;
+};
+export declare type ConfigUpdate = {
+    apiUrl?: string;
+    rpcs?: Record<number, string[]>;
+    multicallAddresses?: Record<number, string | undefined>;
+    defaultExecutionSettings?: ExecutionSettings;
+    defaultRouteOptions?: RouteOptions;
+};
+export declare type SwitchChainHook = (requiredChainId: number) => Promise<Signer | undefined>;
+export interface AcceptSlippageUpdateHookParams {
+    toToken: Token;
+    oldToAmount: string;
+    newToAmount: string;
+    oldSlippage: number;
+    newSlippage: number;
+}
+export declare type AcceptSlippageUpdateHook = (params: AcceptSlippageUpdateHookParams) => Promise<boolean | undefined>;
+export interface ExecutionData {
+    route: Route;
+    executors: StepExecutor[];
+    settings: InternalExecutionSettings;
+}
+export interface ExecutionSettings {
+    updateCallback?: CallbackFunction;
+    switchChainHook?: SwitchChainHook;
+    acceptSlippageUpdateHook?: AcceptSlippageUpdateHook;
+    infiniteApproval?: boolean;
+}
+export interface InternalExecutionSettings extends ExecutionSettings {
+    updateCallback: CallbackFunction;
+    switchChainHook: SwitchChainHook;
+    acceptSlippageUpdateHook: AcceptSlippageUpdateHook;
+    infiniteApproval: boolean;
+}
+export declare type EnforcedObjectProperties<T> = T & {
+    [P in keyof T]-?: T[P];
+};
+export interface ActiveRouteDictionary {
+    [k: string]: ExecutionData;
+}
+export declare type RevokeTokenData = {
+    token: Token;
+    approvalAddress: string;
+};
+export interface HaltingSettings {
+    allowUpdates?: boolean;
+}
+export {};

package/dist/cjs/types/internal.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,75 @@
+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,
+    TransactionUnprepared = 1008,
+    Timeout = 1004,
+    ProviderUnavailable = 1005,
+    NotFound = 1006,
+    ChainSwitchError = 1007,
+    SlippageNotMet = 1008,
+    SlippageError = 1008,
+    GasLimitError = 1009
+}
+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 declare 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 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 {};

package/dist/cjs/utils/errors.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownError = exports.NotFoundError = exports.SlippageError = exports.TransactionError = exports.ValidationError = exports.ServerError = exports.ProviderError = exports.RPCError = exports.LifiError = exports.MetaMaskProviderErrorCode = exports.MetaMaskRPCErrorCode = exports.LifiErrorCode = void 0;
+var ErrorType;
+(function (ErrorType) {
+    ErrorType["RPCError"] = "RPCError";
+    ErrorType["ProviderError"] = "ProviderError";
+    ErrorType["ServerError"] = "ServerError";
+    ErrorType["TransactionError"] = "TransactionError";
+    ErrorType["ValidationError"] = "ValidationError";
+    ErrorType["NotFoundError"] = "NotFoundError";
+    ErrorType["UnknownError"] = "UnknownError";
+    ErrorType["SlippageError"] = "SlippageError";
+})(ErrorType || (ErrorType = {}));
+var LifiErrorCode;
+(function (LifiErrorCode) {
+    LifiErrorCode[LifiErrorCode["InternalError"] = 1000] = "InternalError";
+    LifiErrorCode[LifiErrorCode["ValidationError"] = 1001] = "ValidationError";
+    LifiErrorCode[LifiErrorCode["TransactionUnderpriced"] = 1002] = "TransactionUnderpriced";
+    LifiErrorCode[LifiErrorCode["TransactionFailed"] = 1003] = "TransactionFailed";
+    LifiErrorCode[LifiErrorCode["TransactionUnprepared"] = 1008] = "TransactionUnprepared";
+    LifiErrorCode[LifiErrorCode["Timeout"] = 1004] = "Timeout";
+    LifiErrorCode[LifiErrorCode["ProviderUnavailable"] = 1005] = "ProviderUnavailable";
+    LifiErrorCode[LifiErrorCode["NotFound"] = 1006] = "NotFound";
+    LifiErrorCode[LifiErrorCode["ChainSwitchError"] = 1007] = "ChainSwitchError";
+    LifiErrorCode[LifiErrorCode["SlippageNotMet"] = 1008] = "SlippageNotMet";
+    LifiErrorCode[LifiErrorCode["SlippageError"] = 1008] = "SlippageError";
+    LifiErrorCode[LifiErrorCode["GasLimitError"] = 1009] = "GasLimitError";
+})(LifiErrorCode = exports.LifiErrorCode || (exports.LifiErrorCode = {}));
+var MetaMaskRPCErrorCode;
+(function (MetaMaskRPCErrorCode) {
+    MetaMaskRPCErrorCode[MetaMaskRPCErrorCode["invalidInput"] = -32000] = "invalidInput";
+    MetaMaskRPCErrorCode[MetaMaskRPCErrorCode["resourceNotFound"] = -32001] = "resourceNotFound";
+    MetaMaskRPCErrorCode[MetaMaskRPCErrorCode["resourceUnavailable"] = -32002] = "resourceUnavailable";
+    MetaMaskRPCErrorCode[MetaMaskRPCErrorCode["transactionRejected"] = -32003] = "transactionRejected";
+    MetaMaskRPCErrorCode[MetaMaskRPCErrorCode["methodNotSupported"] = -32004] = "methodNotSupported";
+    MetaMaskRPCErrorCode[MetaMaskRPCErrorCode["limitExceeded"] = -32005] = "limitExceeded";
+    MetaMaskRPCErrorCode[MetaMaskRPCErrorCode["parse"] = -32700] = "parse";
+    MetaMaskRPCErrorCode[MetaMaskRPCErrorCode["invalidRequest"] = -32600] = "invalidRequest";
+    MetaMaskRPCErrorCode[MetaMaskRPCErrorCode["methodNotFound"] = -32601] = "methodNotFound";
+    MetaMaskRPCErrorCode[MetaMaskRPCErrorCode["invalidParams"] = -32602] = "invalidParams";
+    MetaMaskRPCErrorCode[MetaMaskRPCErrorCode["internal"] = -32603] = "internal";
+})(MetaMaskRPCErrorCode = exports.MetaMaskRPCErrorCode || (exports.MetaMaskRPCErrorCode = {}));
+var MetaMaskProviderErrorCode;
+(function (MetaMaskProviderErrorCode) {
+    MetaMaskProviderErrorCode[MetaMaskProviderErrorCode["userRejectedRequest"] = 4001] = "userRejectedRequest";
+    MetaMaskProviderErrorCode[MetaMaskProviderErrorCode["unauthorized"] = 4100] = "unauthorized";
+    MetaMaskProviderErrorCode[MetaMaskProviderErrorCode["unsupportedMethod"] = 4200] = "unsupportedMethod";
+    MetaMaskProviderErrorCode[MetaMaskProviderErrorCode["disconnected"] = 4900] = "disconnected";
+    MetaMaskProviderErrorCode[MetaMaskProviderErrorCode["chainDisconnected"] = 4901] = "chainDisconnected";
+})(MetaMaskProviderErrorCode = exports.MetaMaskProviderErrorCode || (exports.MetaMaskProviderErrorCode = {}));
+class LifiError extends Error {
+    constructor(type, code, message, htmlMessage, stack) {
+        super(message);
+        // Set the prototype explicitly: https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#extending-built-ins-like-error-array-and-map-may-no-longer-work
+        Object.setPrototypeOf(this, LifiError.prototype);
+        this.code = code;
+        // the name property is used by toString(). It is a string and we can't use our custom ErrorTypes, that's why we have to cast
+        this.name = type.toString();
+        this.htmlMessage = htmlMessage;
+        // passing a stack allows us to preserve the stack from errors that we caught and just want to transform in one of our custom errors
+        if (stack) {
+            this.stack = stack;
+        }
+    }
+}
+exports.LifiError = LifiError;
+class RPCError extends LifiError {
+    constructor(code, message, htmlMessage, stack) {
+        super(ErrorType.RPCError, code, message, htmlMessage, stack);
+    }
+}
+exports.RPCError = RPCError;
+class ProviderError extends LifiError {
+    constructor(code, message, htmlMessage, stack) {
+        super(ErrorType.ProviderError, code, message, htmlMessage, stack);
+    }
+}
+exports.ProviderError = ProviderError;
+class ServerError extends LifiError {
+    constructor(message, htmlMessage, stack) {
+        super(ErrorType.ServerError, LifiErrorCode.InternalError, message, htmlMessage, stack);
+    }
+}
+exports.ServerError = ServerError;
+class ValidationError extends LifiError {
+    constructor(message, htmlMessage, stack) {
+        super(ErrorType.ValidationError, LifiErrorCode.ValidationError, message, htmlMessage, stack);
+    }
+}
+exports.ValidationError = ValidationError;
+class TransactionError extends LifiError {
+    constructor(code, message, htmlMessage, stack) {
+        super(ErrorType.TransactionError, code, message, htmlMessage, stack);
+    }
+}
+exports.TransactionError = TransactionError;
+class SlippageError extends LifiError {
+    constructor(message, htmlMessage, stack) {
+        super(ErrorType.SlippageError, LifiErrorCode.SlippageError, message, htmlMessage, stack);
+    }
+}
+exports.SlippageError = SlippageError;
+class NotFoundError extends LifiError {
+    constructor(message, htmlMessage, stack) {
+        super(ErrorType.NotFoundError, LifiErrorCode.NotFound, message, htmlMessage, stack);
+    }
+}
+exports.NotFoundError = NotFoundError;
+class UnknownError extends LifiError {
+    constructor(code, message, htmlMessage, stack) {
+        super(ErrorType.UnknownError, code, message, htmlMessage, stack);
+    }
+}
+exports.UnknownError = UnknownError;

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

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

package/dist/cjs/utils/getProvider.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProvider = void 0;
+const errors_1 = require("./errors");
+const getProvider = (signer) => {
+    if (!signer.provider) {
+        throw new errors_1.ProviderError(errors_1.LifiErrorCode.ProviderUnavailable, 'No provider available in signer.');
+    }
+    return signer.provider;
+};
+exports.getProvider = getProvider;

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

@@ -0,0 +1,10 @@
+import { Fragment, JsonFragment } from '@ethersproject/abi';
+export declare 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/cjs/utils/multicall.js

@@ -0,0 +1,77 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchDataUsingMulticall = void 0;
+const abi_1 = require("@ethersproject/abi");
+const contracts_1 = require("@ethersproject/contracts");
+const connectors_1 = require("../connectors");
+const utils_1 = require("./utils");
+const multicallAbi_json_1 = __importDefault(require("./multicallAbi.json"));
+const MAX_MULTICALL_SIZE = 100;
+const fetchDataUsingMulticall = (calls, abi, chainId, multicallAddress, requireSuccess = false) => __awaiter(void 0, void 0, void 0, function* () {
+    // 1. create contract using multicall contract address and abi...
+    const provider = yield (0, connectors_1.getRpcProvider)(chainId);
+    const multicallContract = new contracts_1.Contract(multicallAddress, multicallAbi_json_1.default, provider);
+    const abiInterface = new abi_1.Interface(abi);
+    // split up lists into chunks to stay below multicall limit
+    const chunkedList = (0, utils_1.splitListIntoChunks)(calls, MAX_MULTICALL_SIZE);
+    const chunkedResults = yield Promise.all(chunkedList.map((chunkedCalls) => __awaiter(void 0, void 0, void 0, function* () {
+        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 } = yield 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();
+});
+exports.fetchDataUsingMulticall = fetchDataUsingMulticall;