@lifi/sdk 1.0.0

package/dist/services/ApiService.js

@@ -0,0 +1,350 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 });
+var axios_1 = __importDefault(require("axios"));
+var typeguards_1 = require("../typeguards");
+var errors_1 = require("../utils/errors");
+var parseError_1 = require("../utils/parseError");
+var ConfigService_1 = __importDefault(require("./ConfigService"));
+var getPossibilities = function (request, options) { return __awaiter(void 0, void 0, void 0, function () {
+    var configService, config, result, e_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!request) {
+                    request = {};
+                }
+                configService = ConfigService_1.default.getInstance();
+                config = configService.getConfig();
+                // apply defaults
+                request.bridges = request.bridges || config.defaultRouteOptions.bridges;
+                request.exchanges = request.exchanges || config.defaultRouteOptions.exchanges;
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, axios_1.default.post(config.apiUrl + 'advanced/possibilities', request, {
+                        signal: options === null || options === void 0 ? void 0 : options.signal,
+                    })];
+            case 2:
+                result = _a.sent();
+                return [2 /*return*/, result.data];
+            case 3:
+                e_1 = _a.sent();
+                throw (0, parseError_1.parseBackendError)(e_1);
+            case 4: return [2 /*return*/];
+        }
+    });
+}); };
+var getToken = function (chain, token, options) { return __awaiter(void 0, void 0, void 0, function () {
+    var configService, config, result, e_2;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!chain) {
+                    throw new errors_1.ValidationError('Required parameter "chain" is missing.');
+                }
+                if (!token) {
+                    throw new errors_1.ValidationError('Required parameter "token" is missing.');
+                }
+                configService = ConfigService_1.default.getInstance();
+                config = configService.getConfig();
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, axios_1.default.get(config.apiUrl + 'token', {
+                        params: {
+                            chain: chain,
+                            token: token,
+                        },
+                        signal: options === null || options === void 0 ? void 0 : options.signal,
+                    })];
+            case 2:
+                result = _a.sent();
+                return [2 /*return*/, result.data];
+            case 3:
+                e_2 = _a.sent();
+                throw (0, parseError_1.parseBackendError)(e_2);
+            case 4: return [2 /*return*/];
+        }
+    });
+}); };
+var getQuote = function (_a, options) {
+    var fromChain = _a.fromChain, fromToken = _a.fromToken, fromAddress = _a.fromAddress, fromAmount = _a.fromAmount, toChain = _a.toChain, toToken = _a.toToken, toAddress = _a.toAddress, order = _a.order, slippage = _a.slippage, integrator = _a.integrator, referrer = _a.referrer, allowBridges = _a.allowBridges, denyBridges = _a.denyBridges, preferBridges = _a.preferBridges, allowExchanges = _a.allowExchanges, denyExchanges = _a.denyExchanges, preferExchanges = _a.preferExchanges;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var configService, config, result, e_3;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!fromChain) {
+                        throw new errors_1.ValidationError('Required parameter "fromChain" is missing.');
+                    }
+                    if (!fromToken) {
+                        throw new errors_1.ValidationError('Required parameter "fromToken" is missing.');
+                    }
+                    if (!fromAddress) {
+                        throw new errors_1.ValidationError('Required parameter "fromAddress" is missing.');
+                    }
+                    if (!fromAmount) {
+                        throw new errors_1.ValidationError('Required parameter "fromAmount" is missing.');
+                    }
+                    if (!toChain) {
+                        throw new errors_1.ValidationError('Required parameter "toChain" is missing.');
+                    }
+                    if (!toToken) {
+                        throw new errors_1.ValidationError('Required parameter "toToken" is missing.');
+                    }
+                    configService = ConfigService_1.default.getInstance();
+                    config = configService.getConfig();
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, axios_1.default.get(config.apiUrl + 'quote', {
+                            params: {
+                                fromChain: fromChain,
+                                toChain: toChain,
+                                fromToken: fromToken,
+                                toToken: toToken,
+                                fromAddress: fromAddress,
+                                toAddress: toAddress,
+                                fromAmount: fromAmount,
+                                order: order,
+                                slippage: slippage,
+                                integrator: integrator,
+                                referrer: referrer,
+                                allowBridges: allowBridges,
+                                denyBridges: denyBridges,
+                                preferBridges: preferBridges,
+                                allowExchanges: allowExchanges,
+                                denyExchanges: denyExchanges,
+                                preferExchanges: preferExchanges,
+                            },
+                            signal: options === null || options === void 0 ? void 0 : options.signal,
+                        })];
+                case 2:
+                    result = _b.sent();
+                    return [2 /*return*/, result.data];
+                case 3:
+                    e_3 = _b.sent();
+                    throw (0, parseError_1.parseBackendError)(e_3);
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+};
+var getStatus = function (_a, options) {
+    var bridge = _a.bridge, fromChain = _a.fromChain, toChain = _a.toChain, txHash = _a.txHash;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var configService, config, result, e_4;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    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.');
+                    }
+                    configService = ConfigService_1.default.getInstance();
+                    config = configService.getConfig();
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, axios_1.default.get(config.apiUrl + 'status', {
+                            params: {
+                                bridge: bridge,
+                                fromChain: fromChain,
+                                toChain: toChain,
+                                txHash: txHash,
+                            },
+                            signal: options === null || options === void 0 ? void 0 : options.signal,
+                        })];
+                case 2:
+                    result = _b.sent();
+                    return [2 /*return*/, result.data];
+                case 3:
+                    e_4 = _b.sent();
+                    throw (0, parseError_1.parseBackendError)(e_4);
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+};
+var getChains = function (options) { return __awaiter(void 0, void 0, void 0, function () {
+    var configService, config, result, e_5;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                configService = ConfigService_1.default.getInstance();
+                config = configService.getConfig();
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, axios_1.default.get(config.apiUrl + 'chains', {
+                        signal: options === null || options === void 0 ? void 0 : options.signal,
+                    })];
+            case 2:
+                result = _a.sent();
+                return [2 /*return*/, result.data.chains];
+            case 3:
+                e_5 = _a.sent();
+                throw (0, parseError_1.parseBackendError)(e_5);
+            case 4: return [2 /*return*/];
+        }
+    });
+}); };
+var getRoutes = function (request, options) { return __awaiter(void 0, void 0, void 0, function () {
+    var configService, config, result, e_6;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!(0, typeguards_1.isRoutesRequest)(request)) {
+                    throw new errors_1.ValidationError('Invalid routes request.');
+                }
+                configService = ConfigService_1.default.getInstance();
+                config = configService.getConfig();
+                // apply defaults
+                request.options = __assign(__assign({}, config.defaultRouteOptions), request.options);
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, axios_1.default.post(config.apiUrl + 'advanced/routes', request, {
+                        signal: options === null || options === void 0 ? void 0 : options.signal,
+                    })];
+            case 2:
+                result = _a.sent();
+                return [2 /*return*/, result.data];
+            case 3:
+                e_6 = _a.sent();
+                throw (0, parseError_1.parseBackendError)(e_6);
+            case 4: return [2 /*return*/];
+        }
+    });
+}); };
+var getStepTransaction = function (step, options) { return __awaiter(void 0, void 0, void 0, function () {
+    var configService, config, result, e_7;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                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);
+                }
+                configService = ConfigService_1.default.getInstance();
+                config = configService.getConfig();
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, axios_1.default.post(config.apiUrl + 'advanced/stepTransaction', step, {
+                        signal: options === null || options === void 0 ? void 0 : options.signal,
+                    })];
+            case 2:
+                result = _a.sent();
+                return [2 /*return*/, result.data];
+            case 3:
+                e_7 = _a.sent();
+                throw (0, parseError_1.parseBackendError)(e_7);
+            case 4: return [2 /*return*/];
+        }
+    });
+}); };
+var getTools = function (request, options) { return __awaiter(void 0, void 0, void 0, function () {
+    var configService, config, r;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                configService = ConfigService_1.default.getInstance();
+                config = configService.getConfig();
+                return [4 /*yield*/, axios_1.default.get(config.apiUrl + 'tools', {
+                        params: request,
+                        signal: options === null || options === void 0 ? void 0 : options.signal,
+                    })];
+            case 1:
+                r = _a.sent();
+                return [2 /*return*/, r.data];
+        }
+    });
+}); };
+var getTokens = function (request, options) { return __awaiter(void 0, void 0, void 0, function () {
+    var configService, config, r;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                configService = ConfigService_1.default.getInstance();
+                config = configService.getConfig();
+                return [4 /*yield*/, axios_1.default.get(config.apiUrl + 'tokens', {
+                        params: request,
+                        signal: options === null || options === void 0 ? void 0 : options.signal,
+                    })];
+            case 1:
+                r = _a.sent();
+                return [2 /*return*/, r.data];
+        }
+    });
+}); };
+exports.default = {
+    getPossibilities: getPossibilities,
+    getToken: getToken,
+    getQuote: getQuote,
+    getStatus: getStatus,
+    getChains: getChains,
+    getRoutes: getRoutes,
+    getStepTransaction: getStepTransaction,
+    getTools: getTools,
+    getTokens: getTokens,
+};

package/dist/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/services/ChainsService.js

@@ -0,0 +1,108 @@
+"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 });
+var errors_1 = require("../utils/errors");
+var ApiService_1 = __importDefault(require("./ApiService"));
+var ChainsService = /** @class */ (function () {
+    function ChainsService() {
+        this.chains = [];
+        this.loadingPromise = this.loadAvailableChains();
+    }
+    ChainsService.prototype.loadAvailableChains = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this;
+                        return [4 /*yield*/, ApiService_1.default.getChains()];
+                    case 1:
+                        _a.chains = _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ChainsService.getInstance = function () {
+        if (!this.instance) {
+            this.instance = new ChainsService();
+        }
+        return this.instance;
+    };
+    ChainsService.prototype.getChainById = function (chainId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var chain;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.loadingPromise) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.loadingPromise];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        chain = this.chains.find(function (chain) { return chain.id === chainId; });
+                        if (!chain) {
+                            throw new errors_1.ValidationError("Unknown chainId passed: ".concat(chainId, "."));
+                        }
+                        return [2 /*return*/, chain];
+                }
+            });
+        });
+    };
+    ChainsService.prototype.getChains = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.loadingPromise) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.loadingPromise];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/, this.chains];
+                }
+            });
+        });
+    };
+    return ChainsService;
+}());
+exports.default = ChainsService;

package/dist/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/services/ConfigService.js

@@ -0,0 +1,133 @@
+"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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var types_1 = require("../types");
+var DefaultExecutionSettings = {
+    /* eslint-disable-next-line @typescript-eslint/no-empty-function */
+    updateCallback: function () { },
+    switchChainHook: function () { return Promise.resolve(undefined); },
+    infiniteApproval: false,
+};
+var ConfigService = /** @class */ (function () {
+    function ConfigService() {
+        var _this = this;
+        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 = function () {
+            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 = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.setupPromise];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, this.config];
+                }
+            });
+        }); };
+        this.updateConfig = function (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 = function (chains) {
+            var _a;
+            for (var _i = 0, chains_1 = chains; _i < chains_1.length; _i++) {
+                var chain = chains_1[_i];
+                var 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(function (resolve) {
+            _this.resolveSetupPromise = resolve;
+        });
+    }
+    ConfigService.chainIdToObject = function (val) {
+        var result = {};
+        var values = Object.values(types_1.ChainId);
+        values.forEach(function (chainId) {
+            if (typeof chainId !== 'string') {
+                result[chainId] = val ? JSON.parse(JSON.stringify(val)) : val;
+            }
+        });
+        return result;
+    };
+    ConfigService.getInstance = function () {
+        if (!this.instance) {
+            this.instance = new ConfigService();
+        }
+        return this.instance;
+    };
+    ConfigService.getDefaultConfig = function () {
+        return {
+            apiUrl: 'https://li.quest/v1/',
+            rpcs: ConfigService.chainIdToObject([]),
+            multicallAddresses: ConfigService.chainIdToObject(undefined),
+            defaultExecutionSettings: DefaultExecutionSettings,
+            defaultRouteOptions: {},
+        };
+    };
+    return ConfigService;
+}());
+exports.default = ConfigService;

package/dist/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;