@lifi/sdk 1.0.0

package/dist/typeguards.js

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

package/dist/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/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/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/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/types/internal.types.d.ts

@@ -0,0 +1,75 @@
+import { CrossStep, LifiStep, Route, RouteOptions, Step, SwapStep, 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: SwapStep;
+}
+export interface ExecuteCrossParams extends ExecutionParams {
+    step: CrossStep | LifiStep;
+}
+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 ExecutionData {
+    route: Route;
+    executors: StepExecutor[];
+    settings: InternalExecutionSettings;
+}
+export interface ExecutionSettings {
+    updateCallback?: CallbackFunction;
+    switchChainHook?: SwitchChainHook;
+    infiniteApproval?: boolean;
+}
+export interface InternalExecutionSettings extends ExecutionSettings {
+    updateCallback: CallbackFunction;
+    switchChainHook: SwitchChainHook;
+    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/types/internal.types.js

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

package/dist/utils/errors.d.ts

@@ -0,0 +1,73 @@
+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,
+    SlippageError = 1008
+}
+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/utils/errors.js

@@ -0,0 +1,147 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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["SlippageError"] = 1008] = "SlippageError";
+})(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 = {}));
+var LifiError = /** @class */ (function (_super) {
+    __extends(LifiError, _super);
+    function LifiError(type, code, message, htmlMessage, stack) {
+        var _this = _super.call(this, message) || this;
+        // 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;
+        }
+        return _this;
+    }
+    return LifiError;
+}(Error));
+exports.LifiError = LifiError;
+var RPCError = /** @class */ (function (_super) {
+    __extends(RPCError, _super);
+    function RPCError(code, message, htmlMessage, stack) {
+        return _super.call(this, ErrorType.RPCError, code, message, htmlMessage, stack) || this;
+    }
+    return RPCError;
+}(LifiError));
+exports.RPCError = RPCError;
+var ProviderError = /** @class */ (function (_super) {
+    __extends(ProviderError, _super);
+    function ProviderError(code, message, htmlMessage, stack) {
+        return _super.call(this, ErrorType.ProviderError, code, message, htmlMessage, stack) || this;
+    }
+    return ProviderError;
+}(LifiError));
+exports.ProviderError = ProviderError;
+var ServerError = /** @class */ (function (_super) {
+    __extends(ServerError, _super);
+    function ServerError(message, htmlMessage, stack) {
+        return _super.call(this, ErrorType.ServerError, LifiErrorCode.InternalError, message, htmlMessage, stack) || this;
+    }
+    return ServerError;
+}(LifiError));
+exports.ServerError = ServerError;
+var ValidationError = /** @class */ (function (_super) {
+    __extends(ValidationError, _super);
+    function ValidationError(message, htmlMessage, stack) {
+        return _super.call(this, ErrorType.ValidationError, LifiErrorCode.ValidationError, message, htmlMessage, stack) || this;
+    }
+    return ValidationError;
+}(LifiError));
+exports.ValidationError = ValidationError;
+var TransactionError = /** @class */ (function (_super) {
+    __extends(TransactionError, _super);
+    function TransactionError(code, message, htmlMessage, stack) {
+        return _super.call(this, ErrorType.TransactionError, code, message, htmlMessage, stack) || this;
+    }
+    return TransactionError;
+}(LifiError));
+exports.TransactionError = TransactionError;
+var SlippageError = /** @class */ (function (_super) {
+    __extends(SlippageError, _super);
+    function SlippageError(message, htmlMessage, stack) {
+        return _super.call(this, ErrorType.SlippageError, LifiErrorCode.SlippageError, message, htmlMessage, stack) || this;
+    }
+    return SlippageError;
+}(LifiError));
+exports.SlippageError = SlippageError;
+var NotFoundError = /** @class */ (function (_super) {
+    __extends(NotFoundError, _super);
+    function NotFoundError(message, htmlMessage, stack) {
+        return _super.call(this, ErrorType.NotFoundError, LifiErrorCode.NotFound, message, htmlMessage, stack) || this;
+    }
+    return NotFoundError;
+}(LifiError));
+exports.NotFoundError = NotFoundError;
+var UnknownError = /** @class */ (function (_super) {
+    __extends(UnknownError, _super);
+    function UnknownError(code, message, htmlMessage, stack) {
+        return _super.call(this, ErrorType.UnknownError, code, message, htmlMessage, stack) || this;
+    }
+    return UnknownError;
+}(LifiError));
+exports.UnknownError = UnknownError;

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProvider = void 0;
+var errors_1 = require("./errors");
+var getProvider = function (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/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/utils/multicall.js

@@ -0,0 +1,111 @@
+"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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchDataUsingMulticall = void 0;
+var abi_1 = require("@ethersproject/abi");
+var contracts_1 = require("@ethersproject/contracts");
+var connectors_1 = require("../connectors");
+var utils_1 = require("./utils");
+var multicallAbi_json_1 = __importDefault(require("./multicallAbi.json"));
+var MAX_MULTICALL_SIZE = 100;
+var fetchDataUsingMulticall = function (calls, abi, chainId, multicallAddress, requireSuccess) {
+    if (requireSuccess === void 0) { requireSuccess = false; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var provider, multicallContract, abiInterface, chunkedList, chunkedResults;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, connectors_1.getRpcProvider)(chainId)];
+                case 1:
+                    provider = _a.sent();
+                    multicallContract = new contracts_1.Contract(multicallAddress, multicallAbi_json_1.default, provider);
+                    abiInterface = new abi_1.Interface(abi);
+                    chunkedList = (0, utils_1.splitListIntoChunks)(calls, MAX_MULTICALL_SIZE);
+                    return [4 /*yield*/, Promise.all(chunkedList.map(function (chunkedCalls) { return __awaiter(void 0, void 0, void 0, function () {
+                            var callData, _a, blockNumber_1, returnData, e_1;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        callData = chunkedCalls.map(function (call) { return [
+                                            call.address.toLowerCase(),
+                                            abiInterface.encodeFunctionData(call.name, call.params),
+                                        ]; });
+                                        _b.label = 1;
+                                    case 1:
+                                        _b.trys.push([1, 3, , 4]);
+                                        return [4 /*yield*/, multicallContract.tryBlockAndAggregate(requireSuccess, callData)
+                                            // 4. decode bytes array to useful data array...
+                                        ];
+                                    case 2:
+                                        _a = _b.sent(), blockNumber_1 = _a.blockNumber, returnData = _a.returnData;
+                                        // 4. decode bytes array to useful data array...
+                                        return [2 /*return*/, returnData
+                                                .map(function (_a, i) {
+                                                var success = _a.success, returnData = _a.returnData;
+                                                if (success) {
+                                                    return abiInterface.decodeFunctionResult(chunkedCalls[i].name, returnData);
+                                                }
+                                                else {
+                                                    console.error("Multicall unsuccessful for address \"".concat(chunkedCalls[i].address, "\", function \"").concat(chunkedCalls[i].name, "\", chainId \"").concat(chainId, "\""));
+                                                    return [];
+                                                }
+                                            })
+                                                .map(function (data) {
+                                                return {
+                                                    data: data[0],
+                                                    blockNumber: blockNumber_1.toNumber(),
+                                                };
+                                            })];
+                                    case 3:
+                                        e_1 = _b.sent();
+                                        console.error("Multicall failed on chainId \"".concat(chainId, "\""), chunkedList, e_1);
+                                        return [2 /*return*/, []];
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        }); }))];
+                case 2:
+                    chunkedResults = _a.sent();
+                    return [2 /*return*/, chunkedResults.flat()];
+            }
+        });
+    });
+};
+exports.fetchDataUsingMulticall = fetchDataUsingMulticall;