@lifi/sdk 1.1.2 → 1.1.5

package/dist/cjs/services/ConfigService.js

@@ -0,0 +1,98 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("../types");
+const DefaultExecutionSettings = {
+    /* eslint-disable-next-line @typescript-eslint/no-empty-function */
+    updateCallback: () => { },
+    switchChainHook: () => Promise.resolve(undefined),
+    acceptSlippageUpdateHook: () => Promise.resolve(undefined),
+    infiniteApproval: 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 = () => __awaiter(this, void 0, void 0, function* () {
+            yield 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);
+            return this.config;
+        };
+        this.updateChains = (chains) => {
+            var _a;
+            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;
+                }
+            }
+            (_a = this.resolveSetupPromise) === null || _a === void 0 ? void 0 : _a.call(this);
+            return this.config;
+        };
+        this.config = ConfigService.getDefaultConfig();
+        this.setupPromise = new Promise((resolve) => {
+            this.resolveSetupPromise = resolve;
+        });
+    }
+    static chainIdToObject(val) {
+        const result = {};
+        const values = Object.values(types_1.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;
+    }
+}
+exports.default = ConfigService;
+ConfigService.getDefaultConfig = () => {
+    return {
+        apiUrl: 'https://li.quest/v1/',
+        rpcs: ConfigService.chainIdToObject([]),
+        multicallAddresses: ConfigService.chainIdToObject(undefined),
+        defaultExecutionSettings: DefaultExecutionSettings,
+        defaultRouteOptions: {},
+    };
+};

package/dist/cjs/typeguards.d.ts

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

package/dist/cjs/typeguards.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isToken = exports.isStep = exports.isRoutesRequest = void 0;
+const isRoutesRequest = (routesRequest) => {
+    const { fromChainId, fromAmount, fromTokenAddress, toChainId, toTokenAddress, options, } = routesRequest;
+    return (typeof fromChainId === 'number' &&
+        typeof fromAmount === 'string' &&
+        fromAmount !== '' &&
+        typeof fromTokenAddress === 'string' &&
+        fromTokenAddress !== '' &&
+        typeof toChainId === 'number' &&
+        typeof toTokenAddress === 'string' &&
+        toTokenAddress !== '' &&
+        (!options || isRoutesOptions(options)));
+};
+exports.isRoutesRequest = isRoutesRequest;
+const isRoutesOptions = (routeOptions) => !(routeOptions === null || routeOptions === void 0 ? void 0 : routeOptions.slippage) || typeof routeOptions.slippage === 'number';
+const isStep = (step) => {
+    const { id, type, tool, action, estimate } = step;
+    return (typeof id === 'string' &&
+        ['swap', 'cross', 'lifi'].includes(type) &&
+        typeof tool === 'string' &&
+        isAction(action) &&
+        isEstimate(estimate));
+};
+exports.isStep = isStep;
+const isAction = (action) => {
+    const { fromChainId, fromAmount, fromToken, toChainId, toToken, slippage } = action;
+    return (typeof fromChainId === 'number' &&
+        typeof fromAmount === 'string' &&
+        fromAmount !== '' &&
+        (0, exports.isToken)(fromToken) &&
+        typeof toChainId === 'number' &&
+        (0, exports.isToken)(toToken) &&
+        typeof slippage === 'number');
+};
+const isEstimate = (estimate) => {
+    const { fromAmount, toAmount, toAmountMin, approvalAddress } = estimate;
+    return (typeof fromAmount === 'string' &&
+        fromAmount !== '' &&
+        typeof toAmount === 'string' &&
+        toAmount !== '' &&
+        typeof toAmountMin === 'string' &&
+        toAmountMin !== '' &&
+        typeof approvalAddress === 'string');
+};
+const isToken = (token) => {
+    const { address, decimals, chainId } = token;
+    return (typeof address === 'string' &&
+        typeof decimals === 'number' &&
+        typeof chainId === 'number');
+};
+exports.isToken = isToken;

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

@@ -0,0 +1,22 @@
+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/cjs/types/ERC20.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERC20_ABI = void 0;
+exports.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/cjs/types/index.d.ts

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

package/dist/cjs/types/index.js

@@ -0,0 +1,22 @@
+"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 });
+exports.LifiError = void 0;
+__exportStar(require("@lifi/types"), exports);
+var errors_1 = require("../utils/errors");
+Object.defineProperty(exports, "LifiError", { enumerable: true, get: function () { return errors_1.LifiError; } });
+__exportStar(require("./ERC20"), exports);
+__exportStar(require("./internal.types"), exports);

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;