@lifi/sdk 1.1.4 → 1.2.0

package/dist/cjs/services/ApiService.js

@@ -0,0 +1,272 @@
+"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 });
+const axios_1 = __importDefault(require("axios"));
+const typeguards_1 = require("../typeguards");
+const errors_1 = require("../utils/errors");
+const parseError_1 = require("../utils/parseError");
+const ConfigService_1 = __importDefault(require("./ConfigService"));
+const getPossibilities = (request, options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!request) {
+        request = {};
+    }
+    const configService = ConfigService_1.default.getInstance();
+    const config = configService.getConfig();
+    // apply defaults
+    request.bridges = request.bridges || config.defaultRouteOptions.bridges;
+    request.exchanges = request.exchanges || config.defaultRouteOptions.exchanges;
+    // send request
+    try {
+        const result = yield axios_1.default.post(config.apiUrl + 'advanced/possibilities', request, {
+            signal: options === null || options === void 0 ? void 0 : options.signal,
+        });
+        return result.data;
+    }
+    catch (e) {
+        throw (0, parseError_1.parseBackendError)(e);
+    }
+});
+const getToken = (chain, token, options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!chain) {
+        throw new errors_1.ValidationError('Required parameter "chain" is missing.');
+    }
+    if (!token) {
+        throw new errors_1.ValidationError('Required parameter "token" is missing.');
+    }
+    const configService = ConfigService_1.default.getInstance();
+    const config = configService.getConfig();
+    try {
+        const result = yield axios_1.default.get(config.apiUrl + 'token', {
+            params: {
+                chain,
+                token,
+            },
+            signal: options === null || options === void 0 ? void 0 : options.signal,
+        });
+        return result.data;
+    }
+    catch (e) {
+        throw (0, parseError_1.parseBackendError)(e);
+    }
+});
+const getQuote = (request, options) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c, _d, _e, _f;
+    const configService = ConfigService_1.default.getInstance();
+    const config = configService.getConfig();
+    // validation
+    const requiredParameters = [
+        'fromChain',
+        'fromToken',
+        'fromAddress',
+        'fromAmount',
+        'toChain',
+        'toToken',
+    ];
+    requiredParameters.forEach((requiredParameter) => {
+        if (!request[requiredParameter]) {
+            throw new errors_1.ValidationError(`Required parameter "${requiredParameter}" is missing.`);
+        }
+    });
+    // apply defaults
+    request.order = request.order || config.defaultRouteOptions.order;
+    request.slippage = request.slippage || config.defaultRouteOptions.slippage;
+    request.integrator =
+        request.integrator || config.defaultRouteOptions.integrator;
+    request.referrer = request.referrer || config.defaultRouteOptions.referrer;
+    request.fee = request.fee || config.defaultRouteOptions.fee;
+    request.allowBridges =
+        request.allowBridges || ((_a = config.defaultRouteOptions.bridges) === null || _a === void 0 ? void 0 : _a.allow);
+    request.denyBridges =
+        request.denyBridges || ((_b = config.defaultRouteOptions.bridges) === null || _b === void 0 ? void 0 : _b.deny);
+    request.preferBridges =
+        request.preferBridges || ((_c = config.defaultRouteOptions.bridges) === null || _c === void 0 ? void 0 : _c.prefer);
+    request.allowExchanges =
+        request.allowExchanges || ((_d = config.defaultRouteOptions.bridges) === null || _d === void 0 ? void 0 : _d.allow);
+    request.denyExchanges =
+        request.denyExchanges || ((_e = config.defaultRouteOptions.bridges) === null || _e === void 0 ? void 0 : _e.deny);
+    request.preferExchanges =
+        request.preferExchanges || ((_f = config.defaultRouteOptions.bridges) === null || _f === void 0 ? void 0 : _f.prefer);
+    try {
+        const result = yield axios_1.default.get(config.apiUrl + 'quote', {
+            params: request,
+            signal: options === null || options === void 0 ? void 0 : options.signal,
+        });
+        return result.data;
+    }
+    catch (e) {
+        throw (0, parseError_1.parseBackendError)(e);
+    }
+});
+const getContractCallQuote = (request, options) => __awaiter(void 0, void 0, void 0, function* () {
+    var _g, _h, _j, _k, _l, _m;
+    const configService = ConfigService_1.default.getInstance();
+    const config = configService.getConfig();
+    // validation
+    const requiredParameters = [
+        'fromChain',
+        'fromToken',
+        'fromAddress',
+        'toChain',
+        'toToken',
+        'toAmount',
+        'toContractAddress',
+        'toContractCallData',
+        'toContractGasLimit',
+    ];
+    requiredParameters.forEach((requiredParameter) => {
+        if (!request[requiredParameter]) {
+            throw new errors_1.ValidationError(`Required parameter "${requiredParameter}" is missing.`);
+        }
+    });
+    // apply defaults
+    // option.order is not used in this endpoint
+    request.slippage = request.slippage || config.defaultRouteOptions.slippage;
+    request.integrator =
+        request.integrator || config.defaultRouteOptions.integrator;
+    request.referrer = request.referrer || config.defaultRouteOptions.referrer;
+    request.fee = request.fee || config.defaultRouteOptions.fee;
+    request.allowBridges =
+        request.allowBridges || ((_g = config.defaultRouteOptions.bridges) === null || _g === void 0 ? void 0 : _g.allow);
+    request.denyBridges =
+        request.denyBridges || ((_h = config.defaultRouteOptions.bridges) === null || _h === void 0 ? void 0 : _h.deny);
+    request.preferBridges =
+        request.preferBridges || ((_j = config.defaultRouteOptions.bridges) === null || _j === void 0 ? void 0 : _j.prefer);
+    request.allowExchanges =
+        request.allowExchanges || ((_k = config.defaultRouteOptions.bridges) === null || _k === void 0 ? void 0 : _k.allow);
+    request.denyExchanges =
+        request.denyExchanges || ((_l = config.defaultRouteOptions.bridges) === null || _l === void 0 ? void 0 : _l.deny);
+    request.preferExchanges =
+        request.preferExchanges || ((_m = config.defaultRouteOptions.bridges) === null || _m === void 0 ? void 0 : _m.prefer);
+    // send request
+    try {
+        const result = yield axios_1.default.post(config.apiUrl + 'quote/contractCall', request, {
+            signal: options === null || options === void 0 ? void 0 : options.signal,
+        });
+        return result.data;
+    }
+    catch (e) {
+        throw (0, parseError_1.parseBackendError)(e);
+    }
+});
+const getStatus = ({ bridge, fromChain, toChain, txHash }, options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (fromChain !== toChain && !bridge) {
+        throw new errors_1.ValidationError('Parameter "bridge" is required for cross chain transfers.');
+    }
+    if (!fromChain) {
+        throw new errors_1.ValidationError('Required parameter "fromChain" is missing.');
+    }
+    if (!toChain) {
+        throw new errors_1.ValidationError('Required parameter "toChain" is missing.');
+    }
+    if (!txHash) {
+        throw new errors_1.ValidationError('Required parameter "txHash" is missing.');
+    }
+    const configService = ConfigService_1.default.getInstance();
+    const config = configService.getConfig();
+    try {
+        const result = yield axios_1.default.get(config.apiUrl + 'status', {
+            params: {
+                bridge,
+                fromChain,
+                toChain,
+                txHash,
+            },
+            signal: options === null || options === void 0 ? void 0 : options.signal,
+        });
+        return result.data;
+    }
+    catch (e) {
+        throw (0, parseError_1.parseBackendError)(e);
+    }
+});
+const getChains = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    const configService = ConfigService_1.default.getInstance();
+    const config = configService.getConfig();
+    try {
+        const result = yield axios_1.default.get(config.apiUrl + 'chains', {
+            signal: options === null || options === void 0 ? void 0 : options.signal,
+        });
+        return result.data.chains;
+    }
+    catch (e) {
+        throw (0, parseError_1.parseBackendError)(e);
+    }
+});
+const getRoutes = (request, options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!(0, typeguards_1.isRoutesRequest)(request)) {
+        throw new errors_1.ValidationError('Invalid routes request.');
+    }
+    const configService = ConfigService_1.default.getInstance();
+    const config = configService.getConfig();
+    // apply defaults
+    request.options = Object.assign(Object.assign({}, config.defaultRouteOptions), request.options);
+    // send request
+    try {
+        const result = yield axios_1.default.post(config.apiUrl + 'advanced/routes', request, {
+            signal: options === null || options === void 0 ? void 0 : options.signal,
+        });
+        return result.data;
+    }
+    catch (e) {
+        throw (0, parseError_1.parseBackendError)(e);
+    }
+});
+const getStepTransaction = (step, options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!(0, typeguards_1.isStep)(step)) {
+        // While the validation fails for some users we should not enforce it
+        // eslint-disable-next-line no-console
+        console.warn('SDK Validation: Invalid Step', step);
+    }
+    const configService = ConfigService_1.default.getInstance();
+    const config = configService.getConfig();
+    try {
+        const result = yield axios_1.default.post(config.apiUrl + 'advanced/stepTransaction', step, {
+            signal: options === null || options === void 0 ? void 0 : options.signal,
+        });
+        return result.data;
+    }
+    catch (e) {
+        throw (0, parseError_1.parseBackendError)(e);
+    }
+});
+const getTools = (request, options) => __awaiter(void 0, void 0, void 0, function* () {
+    const configService = ConfigService_1.default.getInstance();
+    const config = configService.getConfig();
+    const r = yield axios_1.default.get(config.apiUrl + 'tools', {
+        params: request,
+        signal: options === null || options === void 0 ? void 0 : options.signal,
+    });
+    return r.data;
+});
+const getTokens = (request, options) => __awaiter(void 0, void 0, void 0, function* () {
+    const configService = ConfigService_1.default.getInstance();
+    const config = configService.getConfig();
+    const r = yield axios_1.default.get(config.apiUrl + 'tokens', {
+        params: request,
+        signal: options === null || options === void 0 ? void 0 : options.signal,
+    });
+    return r.data;
+});
+exports.default = {
+    getPossibilities,
+    getToken,
+    getQuote,
+    getContractCallQuote,
+    getStatus,
+    getChains,
+    getRoutes,
+    getStepTransaction,
+    getTools,
+    getTokens,
+};

package/dist/cjs/services/ChainsService.d.ts

@@ -0,0 +1,11 @@
+import { Chain, ChainId } from '@lifi/types';
+export default class ChainsService {
+    private static instance;
+    private readonly loadingPromise;
+    private chains;
+    constructor();
+    private loadAvailableChains;
+    static getInstance(): ChainsService;
+    getChainById(chainId: ChainId): Promise<Chain>;
+    getChains(): Promise<Chain[]>;
+}

package/dist/cjs/services/ChainsService.js

@@ -0,0 +1,54 @@
+"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 });
+const errors_1 = require("../utils/errors");
+const ApiService_1 = __importDefault(require("./ApiService"));
+class ChainsService {
+    constructor() {
+        this.chains = [];
+        this.loadingPromise = this.loadAvailableChains();
+    }
+    loadAvailableChains() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.chains = yield ApiService_1.default.getChains();
+        });
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new ChainsService();
+        }
+        return this.instance;
+    }
+    getChainById(chainId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.loadingPromise) {
+                yield this.loadingPromise;
+            }
+            const chain = this.chains.find((chain) => chain.id === chainId);
+            if (!chain) {
+                throw new errors_1.ValidationError(`Unknown chainId passed: ${chainId}.`);
+            }
+            return chain;
+        });
+    }
+    getChains() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.loadingPromise) {
+                yield this.loadingPromise;
+            }
+            return this.chains;
+        });
+    }
+}
+exports.default = ChainsService;

package/dist/cjs/services/ConfigService.d.ts

@@ -0,0 +1,23 @@
+import { Chain, Config, ConfigUpdate } from '../types';
+export default class ConfigService {
+    private static instance;
+    private readonly config;
+    private readonly setupPromise;
+    private resolveSetupPromise;
+    constructor();
+    private static chainIdToObject;
+    private static getDefaultConfig;
+    static getInstance(): ConfigService;
+    /**
+     * 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
+     */
+    getConfig: () => Config;
+    /**
+     * This call waits for all setup promises to be done.
+     * Use this if you need access to chain data (RPCs or multicalls)
+     */
+    getConfigAsync: () => Promise<Config>;
+    updateConfig: (configUpdate: ConfigUpdate) => Config;
+    updateChains: (chains: Chain[]) => Config;
+}

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);