@lifi/sdk 1.1.2 → 1.1.5

package/dist/cjs/execution/utils.js

@@ -0,0 +1,137 @@
+"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.updatedStepMeetsSlippageConditions = exports.getSubstatusMessage = exports.getProcessMessage = exports.waitForReceivingTransaction = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const ApiService_1 = __importDefault(require("../services/ApiService"));
+const errors_1 = require("../utils/errors");
+const utils_1 = require("../utils/utils");
+const TRANSACTION_HASH_OBSERVERS = {};
+function waitForReceivingTransaction(txHash, statusManager, processType, step) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const getStatus = () => new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            let statusResponse;
+            try {
+                statusResponse = yield ApiService_1.default.getStatus({
+                    bridge: step.tool,
+                    fromChain: step.action.fromChainId,
+                    toChain: step.action.toChainId,
+                    txHash,
+                });
+            }
+            catch (e) {
+                console.debug('Fetching status from backend failed.', e);
+                return resolve(undefined);
+            }
+            switch (statusResponse.status) {
+                case 'DONE':
+                    return resolve(statusResponse);
+                case 'PENDING':
+                    statusManager === null || statusManager === void 0 ? void 0 : statusManager.updateProcess(step, processType, 'PENDING', {
+                        substatus: statusResponse.substatus,
+                        substatusMessage: statusResponse.substatusMessage ||
+                            getSubstatusMessage(statusResponse.status, statusResponse.substatus),
+                    });
+                    return resolve(undefined);
+                case 'NOT_FOUND':
+                    return resolve(undefined);
+                case 'FAILED':
+                default:
+                    return reject();
+            }
+        }));
+        let status;
+        if (txHash in TRANSACTION_HASH_OBSERVERS) {
+            status = yield TRANSACTION_HASH_OBSERVERS[txHash];
+        }
+        else {
+            TRANSACTION_HASH_OBSERVERS[txHash] = (0, utils_1.repeatUntilDone)(getStatus, 5000);
+            status = yield TRANSACTION_HASH_OBSERVERS[txHash];
+        }
+        if (!status.receiving) {
+            throw new errors_1.ServerError("Status doesn't contain receiving information.");
+        }
+        return status;
+    });
+}
+exports.waitForReceivingTransaction = waitForReceivingTransaction;
+const processMessages = {
+    TOKEN_ALLOWANCE: {
+        STARTED: 'Setting token allowance.',
+        PENDING: 'Waiting for token allowance.',
+        DONE: 'Token allowance set.',
+    },
+    SWITCH_CHAIN: {
+        PENDING: 'Chain switch required.',
+        DONE: 'Chain switched successfully.',
+    },
+    SWAP: {
+        STARTED: 'Preparing swap.',
+        ACTION_REQUIRED: 'Please sign the transaction.',
+        PENDING: 'Swapping.',
+        DONE: 'Swap completed.',
+    },
+    CROSS_CHAIN: {
+        STARTED: 'Preparing transaction.',
+        ACTION_REQUIRED: 'Please sign the transaction.',
+        PENDING: 'Waiting for transaction.',
+        DONE: 'Transaction approved.',
+    },
+    RECEIVING_CHAIN: {
+        PENDING: 'Waiting for receiving chain.',
+        DONE: 'Funds received.',
+    },
+    TRANSACTION: {},
+};
+const substatusMessages = {
+    PENDING: {
+        BRIDGE_NOT_AVAILABLE: 'Bridge communication is temporarily unavailable.',
+        CHAIN_NOT_AVAILABLE: 'RPC communication is temporarily unavailable.',
+        NOT_PROCESSABLE_REFUND_NEEDED: 'The transfer cannot be completed successfully. A refund operation is required.',
+        UNKNOWN_ERROR: 'An unexpected error occurred. Please seek assistance in the LI.FI discord server.',
+        WAIT_SOURCE_CONFIRMATIONS: 'The bridge deposit has been received. The bridge is waiting for more confirmations to start the off-chain logic.',
+        WAIT_DESTINATION_TRANSACTION: 'The bridge off-chain logic is being executed. Wait for the transaction to appear on the destination chain.',
+    },
+    DONE: {
+        PARTIAL: 'Some of the received tokens are not the requested destination tokens.',
+        REFUNDED: 'The tokens were refunded to the sender address.',
+        COMPLETED: 'The transfer is complete.',
+    },
+    FAILED: {},
+    INVALID: {},
+    NOT_FOUND: {},
+};
+function getProcessMessage(type, status) {
+    const processMessage = processMessages[type][status];
+    return processMessage;
+}
+exports.getProcessMessage = getProcessMessage;
+function getSubstatusMessage(status, substatus) {
+    if (!substatus) {
+        return;
+    }
+    const message = substatusMessages[status][substatus];
+    return message;
+}
+exports.getSubstatusMessage = getSubstatusMessage;
+function updatedStepMeetsSlippageConditions(oldStep, newStep) {
+    const setSlippage = new bignumber_js_1.default(oldStep.action.slippage);
+    const oldEstimatedToAmount = new bignumber_js_1.default(oldStep.estimate.toAmountMin);
+    const newEstimatedToAmount = new bignumber_js_1.default(newStep.estimate.toAmountMin);
+    const amountDifference = oldEstimatedToAmount.minus(newEstimatedToAmount);
+    const actualSlippage = amountDifference.dividedBy(oldEstimatedToAmount);
+    return (newEstimatedToAmount.gte(oldEstimatedToAmount) &&
+        actualSlippage.lte(setSlippage));
+}
+exports.updatedStepMeetsSlippageConditions = updatedStepMeetsSlippageConditions;

package/dist/cjs/helpers.d.ts

@@ -0,0 +1,18 @@
+import { Token } from '@lifi/types';
+/**
+ * Predefined hook that decrypts calldata using EIP-1193 compliant wallet functions.
+ * @param {string} walletAddress - The wallet address of the user that should decrypt the calldata.
+ * @return {(encryptedData: string) => Promise<any>} A function that decrypts data using EIP-1193 compliant wallet functions.
+ */
+export declare const getEthereumDecryptionHook: (walletAddress: string) => (encryptedData: string) => Promise<string>;
+/**
+ * Predefined hook that get the public encryption key of a user using EIP-1193 compliant wallet functions.
+ * @param {string} walletAddress - The wallet address of the user.
+ * @return {(walletAddress: string) => () => Promise<any>} A function that return the public encryption key using EIP-1193 compliant wallet functions.
+ */
+export declare const getEthereumPublicKeyHook: (walletAddress: string) => () => Promise<string>;
+/**
+ * Returns a random number between min (inclusive) and max (inclusive)
+ */
+export declare const getRandomNumber: (min: number, max: number) => number;
+export declare const isSameToken: (tokenA: Token, tokenB: Token) => boolean;

package/dist/cjs/helpers.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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSameToken = exports.getRandomNumber = exports.getEthereumPublicKeyHook = exports.getEthereumDecryptionHook = void 0;
+const ethereumRequest = (method, params) => __awaiter(void 0, void 0, void 0, function* () {
+    // If ethereum.request() exists, the provider is probably EIP-1193 compliant.
+    if (!ethereum || !ethereum.request) {
+        throw new Error('Provider not available.');
+    }
+    return ethereum.request({
+        method,
+        params,
+    });
+});
+/**
+ * Predefined hook that decrypts calldata using EIP-1193 compliant wallet functions.
+ * @param {string} walletAddress - The wallet address of the user that should decrypt the calldata.
+ * @return {(encryptedData: string) => Promise<any>} A function that decrypts data using EIP-1193 compliant wallet functions.
+ */
+const getEthereumDecryptionHook = (walletAddress) => {
+    return (encryptedData) => {
+        return ethereumRequest('eth_decrypt', [encryptedData, walletAddress]);
+    };
+};
+exports.getEthereumDecryptionHook = getEthereumDecryptionHook;
+/**
+ * Predefined hook that get the public encryption key of a user using EIP-1193 compliant wallet functions.
+ * @param {string} walletAddress - The wallet address of the user.
+ * @return {(walletAddress: string) => () => Promise<any>} A function that return the public encryption key using EIP-1193 compliant wallet functions.
+ */
+const getEthereumPublicKeyHook = (walletAddress) => {
+    return () => {
+        return ethereumRequest('eth_getEncryptionPublicKey', [walletAddress]);
+    };
+};
+exports.getEthereumPublicKeyHook = getEthereumPublicKeyHook;
+/**
+ * Returns a random number between min (inclusive) and max (inclusive)
+ */
+const getRandomNumber = (min, max) => {
+    return Math.floor(Math.random() * (max - min + 1) + min);
+};
+exports.getRandomNumber = getRandomNumber;
+const isSameToken = (tokenA, tokenB) => tokenA.chainId === tokenB.chainId &&
+    tokenA.address.toLowerCase() === tokenB.address.toLowerCase();
+exports.isSameToken = isSameToken;

package/dist/cjs/index.d.ts

@@ -0,0 +1,6 @@
+import LIFI from './Lifi';
+export * from './execution';
+export * from './helpers';
+export * from './types';
+export * from './utils/errors';
+export default LIFI;

package/dist/cjs/index.js

@@ -0,0 +1,27 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// expose types and helpers
+const Lifi_1 = __importDefault(require("./Lifi"));
+__exportStar(require("./execution"), exports);
+__exportStar(require("./helpers"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils/errors"), exports);
+// expose sdk
+exports.default = Lifi_1.default;

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

@@ -0,0 +1,15 @@
+import { ContractCallQuoteRequest, GetStatusRequest, QuoteRequest, RequestOptions, TokensRequest, TokensResponse } from '@lifi/types';
+import { ChainId, ChainKey, PossibilitiesRequest, PossibilitiesResponse, RoutesRequest, RoutesResponse, StatusResponse, Step, Token, ToolsRequest, ToolsResponse } from '../types';
+declare const _default: {
+    getPossibilities: (request?: PossibilitiesRequest | undefined, options?: RequestOptions | undefined) => Promise<PossibilitiesResponse>;
+    getToken: (chain: ChainKey | ChainId, token: string, options?: RequestOptions | undefined) => Promise<Token>;
+    getQuote: (request: QuoteRequest, options?: RequestOptions | undefined) => Promise<Step>;
+    getContractCallQuote: (request: ContractCallQuoteRequest, options?: RequestOptions | undefined) => Promise<Step>;
+    getStatus: ({ bridge, fromChain, toChain, txHash }: GetStatusRequest, options?: RequestOptions | undefined) => Promise<StatusResponse>;
+    getChains: (options?: RequestOptions | undefined) => Promise<import("@lifi/types").EVMChain[]>;
+    getRoutes: (request: RoutesRequest, options?: RequestOptions | undefined) => Promise<RoutesResponse>;
+    getStepTransaction: (step: Step, options?: RequestOptions | undefined) => Promise<Step>;
+    getTools: (request?: ToolsRequest | undefined, options?: RequestOptions | undefined) => Promise<ToolsResponse>;
+    getTokens: (request?: TokensRequest | undefined, options?: RequestOptions | undefined) => Promise<TokensResponse>;
+};
+export default _default;

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;
+}