@lifi/sdk 1.7.1 → 2.0.0-beta.0

package/dist/services/ApiService.js

@@ -1,64 +1,61 @@
-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());
-    });
-};
-import axios from 'axios';
+import { request } from '../helpers';
 import { isRoutesRequest, isStep } from '../typeguards';
 import { ValidationError } from '../utils/errors';
 import { parseBackendError } from '../utils/parseError';
 import ConfigService from './ConfigService';
-const getPossibilities = (request, options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (!request) {
-        request = {};
+const getPossibilities = async (requestConfig, options) => {
+    if (!requestConfig) {
+        requestConfig = {};
     }
-    const configService = ConfigService.getInstance();
-    const config = configService.getConfig();
+    const config = ConfigService.getInstance().getConfig();
     // apply defaults
-    request.bridges = request.bridges || config.defaultRouteOptions.bridges;
-    request.exchanges = request.exchanges || config.defaultRouteOptions.exchanges;
+    if (requestConfig.bridges || config.defaultRouteOptions.bridges) {
+        requestConfig.bridges =
+            requestConfig.bridges || config.defaultRouteOptions.bridges;
+    }
+    if (requestConfig.exchanges || config.defaultRouteOptions.exchanges) {
+        requestConfig.exchanges =
+            requestConfig.exchanges || config.defaultRouteOptions.exchanges;
+    }
     // send request
     try {
-        const result = yield axios.post(config.apiUrl + 'advanced/possibilities', request, {
-            signal: options === null || options === void 0 ? void 0 : options.signal,
+        const response = await request(`${config.apiUrl}/advanced/possibilities`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(requestConfig),
+            signal: options?.signal,
         });
-        return result.data;
+        return response;
     }
     catch (e) {
-        throw parseBackendError(e);
+        throw await parseBackendError(e);
     }
-});
-const getToken = (chain, token, options) => __awaiter(void 0, void 0, void 0, function* () {
+};
+const getToken = async (chain, token, options) => {
     if (!chain) {
         throw new ValidationError('Required parameter "chain" is missing.');
     }
     if (!token) {
         throw new ValidationError('Required parameter "token" is missing.');
     }
-    const configService = ConfigService.getInstance();
-    const config = configService.getConfig();
+    const config = ConfigService.getInstance().getConfig();
     try {
-        const result = yield axios.get(config.apiUrl + 'token', {
-            params: {
-                chain,
-                token,
-            },
-            signal: options === null || options === void 0 ? void 0 : options.signal,
+        const response = await request(`${config.apiUrl}/token?${new URLSearchParams({
+            chain,
+            token,
+        })}`, {
+            signal: options?.signal,
         });
-        return result.data;
+        return response;
     }
     catch (e) {
-        throw parseBackendError(e);
+        throw await parseBackendError(e);
     }
-});
-const getQuote = (request, options) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c, _d, _e, _f;
-    const configService = ConfigService.getInstance();
-    const config = configService.getConfig();
+};
+const getQuote = async (requestConfig, options) => {
+    const config = ConfigService.getInstance().getConfig();
     // validation
     const requiredParameters = [
         'fromChain',
@@ -69,44 +66,46 @@ const getQuote = (request, options) => __awaiter(void 0, void 0, void 0, functio
         'toToken',
     ];
     requiredParameters.forEach((requiredParameter) => {
-        if (!request[requiredParameter]) {
+        if (!requestConfig[requiredParameter]) {
             throw new 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.exchanges) === null || _d === void 0 ? void 0 : _d.allow);
-    request.denyExchanges =
-        request.denyExchanges || ((_e = config.defaultRouteOptions.exchanges) === null || _e === void 0 ? void 0 : _e.deny);
-    request.preferExchanges =
-        request.preferExchanges || ((_f = config.defaultRouteOptions.exchanges) === null || _f === void 0 ? void 0 : _f.prefer);
+    requestConfig.order = requestConfig.order || config.defaultRouteOptions.order;
+    requestConfig.slippage =
+        requestConfig.slippage || config.defaultRouteOptions.slippage;
+    requestConfig.integrator =
+        requestConfig.integrator || config.defaultRouteOptions.integrator;
+    requestConfig.referrer =
+        requestConfig.referrer || config.defaultRouteOptions.referrer;
+    requestConfig.fee = requestConfig.fee || config.defaultRouteOptions.fee;
+    requestConfig.allowBridges =
+        requestConfig.allowBridges || config.defaultRouteOptions.bridges?.allow;
+    requestConfig.denyBridges =
+        requestConfig.denyBridges || config.defaultRouteOptions.bridges?.deny;
+    requestConfig.preferBridges =
+        requestConfig.preferBridges || config.defaultRouteOptions.bridges?.prefer;
+    requestConfig.allowExchanges =
+        requestConfig.allowExchanges || config.defaultRouteOptions.exchanges?.allow;
+    requestConfig.denyExchanges =
+        requestConfig.denyExchanges || config.defaultRouteOptions.exchanges?.deny;
+    requestConfig.preferExchanges =
+        requestConfig.preferExchanges ||
+            config.defaultRouteOptions.exchanges?.prefer;
+    Object.keys(requestConfig).forEach((key) => !requestConfig[key] &&
+        delete requestConfig[key]);
     try {
-        const result = yield axios.get(config.apiUrl + 'quote', {
-            params: request,
-            signal: options === null || options === void 0 ? void 0 : options.signal,
+        const response = await request(`${config.apiUrl}/quote?${new URLSearchParams(requestConfig)}`, {
+            signal: options?.signal,
         });
-        return result.data;
+        return response;
     }
     catch (e) {
-        throw parseBackendError(e);
+        throw await parseBackendError(e);
     }
-});
-const getContractCallQuote = (request, options) => __awaiter(void 0, void 0, void 0, function* () {
-    var _g, _h, _j, _k, _l, _m;
-    const configService = ConfigService.getInstance();
-    const config = configService.getConfig();
+};
+const getContractCallQuote = async (requestConfig, options) => {
+    const config = ConfigService.getInstance().getConfig();
     // validation
     const requiredParameters = [
         'fromChain',
@@ -120,41 +119,49 @@ const getContractCallQuote = (request, options) => __awaiter(void 0, void 0, voi
         'toContractGasLimit',
     ];
     requiredParameters.forEach((requiredParameter) => {
-        if (!request[requiredParameter]) {
+        if (!requestConfig[requiredParameter]) {
             throw new 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.exchanges) === null || _k === void 0 ? void 0 : _k.allow);
-    request.denyExchanges =
-        request.denyExchanges || ((_l = config.defaultRouteOptions.exchanges) === null || _l === void 0 ? void 0 : _l.deny);
-    request.preferExchanges =
-        request.preferExchanges || ((_m = config.defaultRouteOptions.exchanges) === null || _m === void 0 ? void 0 : _m.prefer);
+    requestConfig.slippage =
+        requestConfig.slippage || config.defaultRouteOptions.slippage;
+    requestConfig.integrator =
+        requestConfig.integrator || config.defaultRouteOptions.integrator;
+    requestConfig.referrer =
+        requestConfig.referrer || config.defaultRouteOptions.referrer;
+    requestConfig.fee = requestConfig.fee || config.defaultRouteOptions.fee;
+    requestConfig.allowBridges =
+        requestConfig.allowBridges || config.defaultRouteOptions.bridges?.allow;
+    requestConfig.denyBridges =
+        requestConfig.denyBridges || config.defaultRouteOptions.bridges?.deny;
+    requestConfig.preferBridges =
+        requestConfig.preferBridges || config.defaultRouteOptions.bridges?.prefer;
+    requestConfig.allowExchanges =
+        requestConfig.allowExchanges || config.defaultRouteOptions.exchanges?.allow;
+    requestConfig.denyExchanges =
+        requestConfig.denyExchanges || config.defaultRouteOptions.exchanges?.deny;
+    requestConfig.preferExchanges =
+        requestConfig.preferExchanges ||
+            config.defaultRouteOptions.exchanges?.prefer;
     // send request
     try {
-        const result = yield axios.post(config.apiUrl + 'quote/contractCall', request, {
-            signal: options === null || options === void 0 ? void 0 : options.signal,
+        const response = await request(`${config.apiUrl}/quote/contractCall`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(requestConfig),
+            signal: options?.signal,
         });
-        return result.data;
+        return response;
     }
     catch (e) {
-        throw parseBackendError(e);
+        throw await parseBackendError(e);
     }
-});
-const getStatus = ({ bridge, fromChain, toChain, txHash }, options) => __awaiter(void 0, void 0, void 0, function* () {
+};
+const getStatus = async ({ bridge, fromChain, toChain, txHash }, options) => {
     if (fromChain !== toChain && !bridge) {
         throw new ValidationError('Parameter "bridge" is required for cross chain transfers.');
     }
@@ -167,101 +174,132 @@ const getStatus = ({ bridge, fromChain, toChain, txHash }, options) => __awaiter
     if (!txHash) {
         throw new ValidationError('Required parameter "txHash" is missing.');
     }
-    const configService = ConfigService.getInstance();
-    const config = configService.getConfig();
+    const config = ConfigService.getInstance().getConfig();
     try {
-        const result = yield axios.get(config.apiUrl + 'status', {
-            params: {
-                bridge,
-                fromChain,
-                toChain,
-                txHash,
-            },
-            signal: options === null || options === void 0 ? void 0 : options.signal,
+        const response = await request(`${config.apiUrl}/status?${new URLSearchParams({
+            bridge,
+            fromChain,
+            toChain,
+            txHash,
+        })}`, {
+            signal: options?.signal,
         });
-        return result.data;
+        return response;
     }
     catch (e) {
-        throw parseBackendError(e);
+        throw await parseBackendError(e);
     }
-});
-const getChains = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    const configService = ConfigService.getInstance();
-    const config = configService.getConfig();
+};
+const getChains = async (options) => {
+    const config = ConfigService.getInstance().getConfig();
     try {
-        const result = yield axios.get(config.apiUrl + 'chains', {
-            signal: options === null || options === void 0 ? void 0 : options.signal,
+        const response = await request(`${config.apiUrl}/chains`, {
+            signal: options?.signal,
         });
-        return result.data.chains;
+        return response.chains;
     }
     catch (e) {
-        throw parseBackendError(e);
+        throw await parseBackendError(e);
     }
-});
-const getRoutes = (request, options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (!isRoutesRequest(request)) {
+};
+const getRoutes = async (requestConfig, options) => {
+    if (!isRoutesRequest(requestConfig)) {
         throw new ValidationError('Invalid routes request.');
     }
-    const configService = ConfigService.getInstance();
-    const config = configService.getConfig();
+    const config = ConfigService.getInstance().getConfig();
     // apply defaults
-    request.options = Object.assign(Object.assign({}, config.defaultRouteOptions), request.options);
+    requestConfig.options = {
+        ...config.defaultRouteOptions,
+        ...requestConfig.options,
+    };
     // send request
     try {
-        const result = yield axios.post(config.apiUrl + 'advanced/routes', request, {
-            signal: options === null || options === void 0 ? void 0 : options.signal,
+        const response = await request(`${config.apiUrl}/advanced/routes`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(requestConfig),
+            signal: options?.signal,
         });
-        return result.data;
+        return response;
     }
     catch (e) {
-        throw parseBackendError(e);
+        throw await parseBackendError(e);
     }
-});
-const getStepTransaction = (step, options) => __awaiter(void 0, void 0, void 0, function* () {
+};
+const getStepTransaction = async (step, options) => {
     if (!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.getInstance();
-    const config = configService.getConfig();
+    const config = ConfigService.getInstance().getConfig();
     try {
-        const result = yield axios.post(config.apiUrl + 'advanced/stepTransaction', step, {
-            signal: options === null || options === void 0 ? void 0 : options.signal,
+        const response = await request(`${config.apiUrl}/advanced/stepTransaction`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(step),
+            signal: options?.signal,
         });
-        return result.data;
+        return response;
     }
     catch (e) {
-        throw parseBackendError(e);
-    }
-});
-const getTools = (request, options) => __awaiter(void 0, void 0, void 0, function* () {
-    const configService = ConfigService.getInstance();
-    const config = configService.getConfig();
-    const r = yield axios.get(config.apiUrl + 'tools', {
-        params: request,
-        signal: options === null || options === void 0 ? void 0 : options.signal,
+        throw await parseBackendError(e);
+    }
+};
+const getTools = async (requestConfig, options) => {
+    const config = ConfigService.getInstance().getConfig();
+    if (requestConfig) {
+        Object.keys(requestConfig).forEach((key) => !requestConfig[key] &&
+            delete requestConfig[key]);
+    }
+    const response = await request(`${config.apiUrl}/tools?${new URLSearchParams(requestConfig)}`, {
+        signal: options?.signal,
     });
-    return r.data;
-});
-const getTokens = (request, options) => __awaiter(void 0, void 0, void 0, function* () {
-    const configService = ConfigService.getInstance();
-    const config = configService.getConfig();
-    const r = yield axios.get(config.apiUrl + 'tokens', {
-        params: request,
-        signal: options === null || options === void 0 ? void 0 : options.signal,
+    return response;
+};
+const getTokens = async (requestConfig, options) => {
+    const config = ConfigService.getInstance().getConfig();
+    if (requestConfig) {
+        Object.keys(requestConfig).forEach((key) => !requestConfig[key] &&
+            delete requestConfig[key]);
+    }
+    const response = await request(`${config.apiUrl}/tokens?${new URLSearchParams(requestConfig)}`, {
+        signal: options?.signal,
     });
-    return r.data;
-});
+    return response;
+};
+const getGasRecommendation = async ({ chainId, fromChain, fromToken }, options) => {
+    const config = ConfigService.getInstance().getConfig();
+    if (!chainId) {
+        throw new ValidationError('Required parameter "chainId" is missing.');
+    }
+    try {
+        const response = await request(`${config.apiUrl}/gas/suggestion/${chainId}?${new URLSearchParams({
+            fromChain,
+            fromToken,
+        })}`, {
+            signal: options?.signal,
+        });
+        return response;
+    }
+    catch (e) {
+        throw await parseBackendError(e);
+    }
+};
 export default {
+    getChains,
+    getContractCallQuote,
+    getGasRecommendation,
     getPossibilities,
-    getToken,
     getQuote,
-    getContractCallQuote,
-    getStatus,
-    getChains,
     getRoutes,
+    getStatus,
     getStepTransaction,
-    getTools,
+    getToken,
     getTokens,
+    getTools,
 };

package/dist/services/ApiService.unit.handlers.d.ts

@@ -0,0 +1 @@
+export declare const handlers: import("msw").RestHandler<import("msw/lib/glossary-de6278a9").M<import("msw/lib/glossary-de6278a9").h>>[];

package/dist/services/ApiService.unit.handlers.js

@@ -0,0 +1,44 @@
+import { ChainId, CoinKey, findDefaultToken } from '@lifi/types';
+import { rest } from 'msw';
+import ConfigService from './ConfigService';
+const config = ConfigService.getInstance().getConfig();
+export const handlers = [
+    rest.post(`${config.apiUrl}/advanced/routes`, async (request, response, context) => {
+        const data = await request.json();
+        if (isNaN(parseFloat(data.fromAmount))) {
+            return response(context.status(500), context.json({ message: `Oops` }));
+        }
+        return response(context.json({}));
+    }),
+    rest.post(`${config.apiUrl}/advanced/possibilities`, async (request, response, context) => {
+        return response(context.json({}));
+    }),
+    rest.get(`${config.apiUrl}/token`, async (request, response, context) => {
+        return response(context.json({}));
+    }),
+    rest.get(`${config.apiUrl}/quote`, async (request, response, context) => {
+        return response(context.json({}));
+    }),
+    rest.get(`${config.apiUrl}/status`, async (request, response, context) => {
+        return response(context.json({}));
+    }),
+    rest.get(`${config.apiUrl}/chains`, async (request, response, context) => {
+        return response(context.json({ chains: [{ id: 1 }] }));
+    }),
+    rest.get(`${config.apiUrl}/tools`, async (request, response, context) => {
+        return response(context.json({ bridges: [], exchanges: [] }));
+    }),
+    rest.get(`${config.apiUrl}/tokens`, async (request, response, context) => {
+        return response(context.json({
+            tokens: {
+                [ChainId.ETH]: [findDefaultToken(CoinKey.ETH, ChainId.ETH)],
+            },
+        }));
+    }),
+    rest.post(`${config.apiUrl}/advanced/stepTransaction`, async (request, response, context) => {
+        return response(context.json({}));
+    }),
+    rest.get(`${config.apiUrl}/gas/suggestion/${ChainId.OPT}`, async (request, response, context) => {
+        return response(context.json({}));
+    }),
+];

package/dist/services/ChainsService.js

@@ -1,12 +1,3 @@
-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());
-    });
-};
 import { ValidationError } from '../utils/errors';
 import ApiService from './ApiService';
 export default class ChainsService {
@@ -14,10 +5,8 @@ export default class ChainsService {
         this.chains = [];
         this.loadingPromise = this.loadAvailableChains();
     }
-    loadAvailableChains() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.chains = yield ApiService.getChains();
-        });
+    async loadAvailableChains() {
+        this.chains = await ApiService.getChains();
     }
     static getInstance() {
         if (!this.instance) {
@@ -25,24 +14,20 @@ export default class 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 ValidationError(`Unknown chainId passed: ${chainId}.`);
-            }
-            return chain;
-        });
+    async getChainById(chainId) {
+        if (this.loadingPromise) {
+            await this.loadingPromise;
+        }
+        const chain = this.chains.find((chain) => chain.id === chainId);
+        if (!chain) {
+            throw new 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;
-        });
+    async getChains() {
+        if (this.loadingPromise) {
+            await this.loadingPromise;
+        }
+        return this.chains;
     }
 }

package/dist/services/ConfigService.js

@@ -1,12 +1,3 @@
-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());
-    });
-};
 import { ChainId, } from '../types';
 const DefaultExecutionSettings = {
     /* eslint-disable-next-line @typescript-eslint/no-empty-function */
@@ -31,10 +22,10 @@ export default class ConfigService {
          * 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;
+        this.getConfigAsync = async () => {
+            await this.setupPromise;
             return this.config;
-        });
+        };
         this.updateConfig = (configUpdate) => {
             // API
             this.config.apiUrl = configUpdate.apiUrl || this.config.apiUrl;
@@ -49,11 +40,10 @@ export default class ConfigService {
             return this.config;
         };
         this.updateChains = (chains) => {
-            var _a, _b;
             for (const chain of chains) {
                 const chainId = chain.id;
                 // set RPCs if they were not configured by the user before
-                if (!((_a = this.config.rpcs[chainId]) === null || _a === void 0 ? void 0 : _a.length)) {
+                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
@@ -61,7 +51,7 @@ export default class ConfigService {
                     this.config.multicallAddresses[chainId] = chain.multicallAddress;
                 }
             }
-            (_b = this.resolveSetupPromise) === null || _b === void 0 ? void 0 : _b.call(this);
+            this.resolveSetupPromise?.();
             return this.config;
         };
         this.config = ConfigService.getDefaultConfig();
@@ -88,7 +78,7 @@ export default class ConfigService {
 }
 ConfigService.getDefaultConfig = () => {
     return {
-        apiUrl: 'https://li.quest/v1/',
+        apiUrl: 'https://li.quest/v1',
         rpcs: ConfigService.chainIdToObject([]),
         multicallAddresses: ConfigService.chainIdToObject(undefined),
         defaultExecutionSettings: DefaultExecutionSettings,

package/dist/typeguards.js

@@ -10,7 +10,7 @@ export const isRoutesRequest = (routesRequest) => {
         toTokenAddress !== '' &&
         (!options || isRoutesOptions(options)));
 };
-const isRoutesOptions = (routeOptions) => !(routeOptions === null || routeOptions === void 0 ? void 0 : routeOptions.slippage) || typeof routeOptions.slippage === 'number';
+const isRoutesOptions = (routeOptions) => !routeOptions?.slippage || typeof routeOptions.slippage === 'number';
 export const isStep = (step) => {
     const { id, type, tool, action, estimate } = step;
     return (typeof id === 'string' &&

package/dist/types/internal.types.d.ts

@@ -72,7 +72,10 @@ export type EnforcedObjectProperties<T> = T & {
     [P in keyof T]-?: T[P];
 };
 export interface ActiveRouteDictionary {
-    [k: string]: ExecutionData;
+    [k: string]: {
+        executionData: ExecutionData;
+        executionPromise: Promise<Route>;
+    };
 }
 export type RevokeTokenData = {
     token: Token;

package/dist/utils/errors.d.ts

@@ -77,4 +77,9 @@ export declare class NotFoundError extends LifiError {
 export declare class UnknownError extends LifiError {
     constructor(code: ErrorCode, message: string, htmlMessage?: string, stack?: string);
 }
+export declare class HTTPError extends Error {
+    response: Response;
+    status: number;
+    constructor(response: Response);
+}
 export {};