@lifi/sdk 1.7.1 → 2.0.0-beta.0

package/dist/execution/StatusManager.js

@@ -1,5 +1,4 @@
 import { emptyExecution, } from '../types';
-import { deepClone } from '../utils/utils';
 import { getProcessMessage } from './utils';
 /**
  * Manages status updates of a route and provides various functions for tracking processes
@@ -17,7 +16,7 @@ export class StatusManager {
          * @return {Execution}       The initialized execution object for this step and a function to update this step
          */
         this.initExecutionObject = (step) => {
-            const currentExecution = step.execution || deepClone(emptyExecution);
+            const currentExecution = step.execution || structuredClone(emptyExecution);
             if (!step.execution) {
                 step.execution = currentExecution;
                 step.execution.status = 'PENDING';
@@ -38,8 +37,7 @@ export class StatusManager {
          * @return {Process}
          */
         this.findOrCreateProcess = (step, type, status) => {
-            var _a;
-            if (!((_a = step.execution) === null || _a === void 0 ? void 0 : _a.process)) {
+            if (!step.execution?.process) {
                 throw new Error("Execution hasn't been initialized.");
             }
             const process = step.execution.process.find((p) => p.type === type);
@@ -53,8 +51,8 @@ export class StatusManager {
             const newProcess = {
                 type: type,
                 startedAt: Date.now(),
-                message: getProcessMessage(type, status !== null && status !== void 0 ? status : 'STARTED'),
-                status: status !== null && status !== void 0 ? status : 'STARTED',
+                message: getProcessMessage(type, status ?? 'STARTED'),
+                status: status ?? 'STARTED',
             };
             step.execution.process.push(newProcess);
             this.updateStepInRoute(step);
@@ -69,11 +67,10 @@ export class StatusManager {
          * @return {Process} The update process
          */
         this.updateProcess = (step, type, status, params) => {
-            var _a, _b, _c;
             if (!step.execution) {
                 throw new Error("Can't update an empty step execution.");
             }
-            const currentProcess = (_a = step === null || step === void 0 ? void 0 : step.execution) === null || _a === void 0 ? void 0 : _a.process.find((p) => p.type === type);
+            const currentProcess = step?.execution?.process.find((p) => p.type === type);
             if (!currentProcess) {
                 throw new Error("Can't find a process for the given type.");
             }
@@ -107,8 +104,8 @@ export class StatusManager {
             }
             // Sort processes, the ones with DONE status go first
             step.execution.process = [
-                ...(_b = step === null || step === void 0 ? void 0 : step.execution) === null || _b === void 0 ? void 0 : _b.process.filter((process) => process.status === 'DONE'),
-                ...(_c = step === null || step === void 0 ? void 0 : step.execution) === null || _c === void 0 ? void 0 : _c.process.filter((process) => process.status !== 'DONE'),
+                ...step?.execution?.process.filter((process) => process.status === 'DONE'),
+                ...step?.execution?.process.filter((process) => process.status !== 'DONE'),
             ];
             this.updateStepInRoute(step); // updates the step in the route
             return currentProcess;
@@ -157,7 +154,10 @@ export class StatusManager {
         }
         step.execution.status = status;
         if (receipt) {
-            step.execution = Object.assign(Object.assign({}, step.execution), receipt);
+            step.execution = {
+                ...step.execution,
+                ...receipt,
+            };
         }
         this.updateStepInRoute(step);
         return step;

package/dist/execution/StepExecutor.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 { ExecutionManager } from './ExecutionManager';
 import { switchChain } from './switchChain';
 // Please be careful when changing the defaults as it may break the behavior (e.g., background execution)
@@ -20,7 +11,10 @@ export class StepExecutor {
         this.allowUserInteraction = true;
         this.executionStopped = false;
         this.setInteraction = (settings) => {
-            const interactionSettings = Object.assign(Object.assign({}, defaultInteractionSettings), settings);
+            const interactionSettings = {
+                ...defaultInteractionSettings,
+                ...settings,
+            };
             this.allowUserInteraction = interactionSettings.allowInteraction;
             this.executionManager.allowInteraction(interactionSettings.allowInteraction);
             this.statusManager.allowUpdates(interactionSettings.allowUpdates);
@@ -32,9 +26,9 @@ export class StepExecutor {
         this.checkChain = () => {
             throw new Error('checkChain is not implemented.');
         };
-        this.executeStep = (signer, step) => __awaiter(this, void 0, void 0, function* () {
+        this.executeStep = async (signer, step) => {
             // Make sure that the chain is still correct
-            const updatedSigner = yield switchChain(signer, this.statusManager, step, this.settings.switchChainHook, this.allowUserInteraction);
+            const updatedSigner = await switchChain(signer, this.statusManager, step, this.settings.switchChainHook, this.allowUserInteraction);
             if (!updatedSigner) {
                 // Chain switch was not successful, stop execution here
                 return step;
@@ -46,9 +40,9 @@ export class StepExecutor {
                 settings: this.settings,
                 statusManager: this.statusManager,
             };
-            yield this.executionManager.execute(parameters);
+            await this.executionManager.execute(parameters);
             return step;
-        });
+        };
         this.executionManager = new ExecutionManager();
         this.statusManager = statusManager;
         this.settings = settings;

package/dist/execution/stepComparison.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 { LifiErrorCode, TransactionError } from '../utils/errors';
 import { checkStepSlippageThreshold } from './utils';
 /**
@@ -20,16 +11,15 @@ import { checkStepSlippageThreshold } from './utils';
  * @param acceptSlippageUpdateHook
  * @param allowUserInteraction
  */
-export const stepComparison = (statusManager, oldStep, newStep, settings, allowUserInteraction) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
+export const stepComparison = async (statusManager, oldStep, newStep, settings, allowUserInteraction) => {
     // Check if changed exchange rate is in the range of slippage threshold
     if (checkStepSlippageThreshold(oldStep, newStep)) {
         return statusManager.updateStepInRoute(newStep);
     }
-    const acceptExchangeRateUpdateHook = (_a = settings.acceptExchangeRateUpdateHook) !== null && _a !== void 0 ? _a : settings.acceptSlippageUpdateHook;
+    const acceptExchangeRateUpdateHook = settings.acceptExchangeRateUpdateHook ?? settings.acceptSlippageUpdateHook;
     let allowStepUpdate;
     if (allowUserInteraction) {
-        allowStepUpdate = yield acceptExchangeRateUpdateHook({
+        allowStepUpdate = await acceptExchangeRateUpdateHook({
             oldToAmount: oldStep.estimate.toAmount,
             newToAmount: newStep.estimate.toAmount,
             toToken: newStep.action.toToken,
@@ -43,4 +33,4 @@ export const stepComparison = (statusManager, oldStep, newStep, settings, allowU
       The exchange rate has changed and the previous estimation can not be fulfilled due to value loss.`);
     }
     return statusManager.updateStepInRoute(newStep);
-});
+};

package/dist/execution/switchChain.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 { LifiErrorCode, ProviderError } from '../utils/errors';
 /**
  * This method checks whether the signer is configured for the correct chain.
@@ -19,9 +10,9 @@ import { LifiErrorCode, ProviderError } from '../utils/errors';
  * @param switchChainHook
  * @param allowUserInteraction
  */
-export const switchChain = (signer, statusManager, step, switchChainHook, allowUserInteraction) => __awaiter(void 0, void 0, void 0, function* () {
+export const switchChain = async (signer, statusManager, step, switchChainHook, allowUserInteraction) => {
     // if we are already on the correct chain we can proceed directly
-    if ((yield signer.getChainId()) === step.action.fromChainId) {
+    if ((await signer.getChainId()) === step.action.fromChainId) {
         return signer;
     }
     // -> set status message
@@ -32,8 +23,8 @@ export const switchChain = (signer, statusManager, step, switchChainHook, allowU
         return;
     }
     try {
-        const updatedSigner = yield switchChainHook(step.action.fromChainId);
-        const updatedChainId = yield (updatedSigner === null || updatedSigner === void 0 ? void 0 : updatedSigner.getChainId());
+        const updatedSigner = await switchChainHook(step.action.fromChainId);
+        const updatedChainId = await updatedSigner?.getChainId();
         if (updatedChainId !== step.action.fromChainId) {
             throw new ProviderError(LifiErrorCode.ChainSwitchError, 'Chain switch required.');
         }
@@ -51,4 +42,4 @@ export const switchChain = (signer, statusManager, step, switchChainHook, allowU
         statusManager.updateExecution(step, 'FAILED');
         throw error;
     }
-});
+};

package/dist/execution/utils.js

@@ -1,62 +1,55 @@
-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 BigNumber from 'bignumber.js';
 import ApiService from '../services/ApiService';
 import { ServerError } from '../utils/errors';
 import { repeatUntilDone } from '../utils/utils';
 const TRANSACTION_HASH_OBSERVERS = {};
-export 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.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', Object.assign({ substatus: statusResponse.substatus, substatusMessage: statusResponse.substatusMessage ||
-                            getSubstatusMessage(statusResponse.status, statusResponse.substatus) }, (statusResponse.bridgeExplorerLink && {
-                        txLink: statusResponse.bridgeExplorerLink,
-                    })));
-                    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];
+export async function waitForReceivingTransaction(txHash, statusManager, processType, step) {
+    const getStatus = () => new Promise(async (resolve, reject) => {
+        let statusResponse;
+        try {
+            statusResponse = await ApiService.getStatus({
+                bridge: step.tool,
+                fromChain: step.action.fromChainId,
+                toChain: step.action.toChainId,
+                txHash,
+            });
         }
-        else {
-            TRANSACTION_HASH_OBSERVERS[txHash] = repeatUntilDone(getStatus, 5000);
-            status = yield TRANSACTION_HASH_OBSERVERS[txHash];
+        catch (e) {
+            console.debug('Fetching status from backend failed.', e);
+            return resolve(undefined);
         }
-        if (!status.receiving) {
-            throw new ServerError("Status doesn't contain receiving information.");
+        switch (statusResponse.status) {
+            case 'DONE':
+                return resolve(statusResponse);
+            case 'PENDING':
+                statusManager?.updateProcess(step, processType, 'PENDING', {
+                    substatus: statusResponse.substatus,
+                    substatusMessage: statusResponse.substatusMessage ||
+                        getSubstatusMessage(statusResponse.status, statusResponse.substatus),
+                    ...(statusResponse.bridgeExplorerLink && {
+                        txLink: statusResponse.bridgeExplorerLink,
+                    }),
+                });
+                return resolve(undefined);
+            case 'NOT_FOUND':
+                return resolve(undefined);
+            case 'FAILED':
+            default:
+                return reject();
         }
-        return status;
     });
+    let status;
+    if (txHash in TRANSACTION_HASH_OBSERVERS) {
+        status = await TRANSACTION_HASH_OBSERVERS[txHash];
+    }
+    else {
+        TRANSACTION_HASH_OBSERVERS[txHash] = repeatUntilDone(getStatus, 5000);
+        status = await TRANSACTION_HASH_OBSERVERS[txHash];
+    }
+    if (!status.receiving) {
+        throw new ServerError("Status doesn't contain receiving information.");
+    }
+    return status;
 }
 const processMessages = {
     TOKEN_ALLOWANCE: {

package/dist/helpers.d.ts

@@ -1,4 +1,4 @@
-import { Token } from '@lifi/types';
+import { Route, Step, 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.
@@ -17,3 +17,14 @@ export declare const getEthereumPublicKeyHook: (walletAddress: string) => () =>
 export declare const getRandomNumber: (min: number, max: number) => number;
 export declare const isSameToken: (tokenA: Token, tokenB: Token) => boolean;
 export declare const checkPackageUpdates: (packageName?: string, packageVersion?: string, disableCheck?: boolean) => Promise<void>;
+/**
+ * Converts a quote to Route
+ * @param {Step} step - Step returned from the quote endpoint.
+ * @return {Route} - The route to be executed.
+ * @throws {ValidationError} Throws a ValidationError if the step has missing values.
+ */
+export declare const convertQuoteToRoute: (step: Step) => Route;
+export declare const requestSettings: {
+    retries: number;
+};
+export declare const request: <T = Response>(url: string, options?: RequestInit, retries?: number) => Promise<T>;

package/dist/helpers.js

@@ -1,23 +1,16 @@
-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 { HTTPError, ValidationError } from './utils/errors';
+import { sleep } from './utils/utils';
 import { name, version } from './version';
-const ethereumRequest = (method, params) => __awaiter(void 0, void 0, void 0, function* () {
+const ethereumRequest = async (method, params) => {
     // If ethereum.request() exists, the provider is probably EIP-1193 compliant.
-    if (!(ethereum === null || ethereum === void 0 ? void 0 : ethereum.request)) {
+    if (!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.
@@ -59,15 +52,16 @@ function semverCompare(a, b) {
         caseFirst: 'upper',
     });
 }
-export const checkPackageUpdates = (packageName, packageVersion, disableCheck) => __awaiter(void 0, void 0, void 0, function* () {
+export const checkPackageUpdates = async (packageName, packageVersion, disableCheck) => {
     if (disableCheck || process.env.NODE_ENV !== 'development') {
         return;
     }
     try {
-        const pkgName = packageName !== null && packageName !== void 0 ? packageName : name;
-        const response = yield (yield fetch(`https://registry.npmjs.org/${pkgName}/latest`)).json();
-        const latestVersion = response.version;
-        const currentVersion = packageVersion !== null && packageVersion !== void 0 ? packageVersion : version;
+        const pkgName = packageName ?? name;
+        const response = await request('https://registry.npmjs.org/${pkgName}/latest');
+        const data = await response.json();
+        const latestVersion = data.version;
+        const currentVersion = packageVersion ?? version;
         if (semverCompare(latestVersion, currentVersion)) {
             console.warn(
             // eslint-disable-next-line max-len
@@ -77,4 +71,57 @@ export const checkPackageUpdates = (packageName, packageVersion, disableCheck) =
     catch (error) {
         // Cannot verify version, might be network error etc. We don't bother showing anything in that case
     }
-});
+};
+/**
+ * Converts a quote to Route
+ * @param {Step} step - Step returned from the quote endpoint.
+ * @return {Route} - The route to be executed.
+ * @throws {ValidationError} Throws a ValidationError if the step has missing values.
+ */
+export const convertQuoteToRoute = (step) => {
+    if (!step.estimate.fromAmountUSD) {
+        throw new ValidationError("Missing 'fromAmountUSD' in step estimate.");
+    }
+    if (!step.estimate.toAmountUSD) {
+        throw new ValidationError("Missing 'toAmountUSD' in step estimate.");
+    }
+    const lifiStep = {
+        ...step,
+        type: 'lifi',
+        includedSteps: [],
+    };
+    const route = {
+        fromToken: step.action.fromToken,
+        toToken: step.action.toToken,
+        fromAmount: step.action.fromAmount,
+        toAmount: step.estimate.toAmount,
+        id: step.id,
+        fromChainId: step.action.fromToken.chainId,
+        toChainId: step.action.toToken.chainId,
+        fromAmountUSD: step.estimate.fromAmountUSD,
+        toAmountUSD: step.estimate.toAmountUSD,
+        steps: [lifiStep],
+        toAmountMin: step.estimate.toAmountMin,
+    };
+    return route;
+};
+export const requestSettings = {
+    retries: 1,
+};
+export const request = async (url, options, retries = requestSettings.retries) => {
+    try {
+        const response = await fetch(url, options);
+        if (!response.ok) {
+            throw new HTTPError(response);
+        }
+        const data = await response.json();
+        return data;
+    }
+    catch (error) {
+        if (retries > 0 && error?.status === 500) {
+            await sleep(500);
+            return request(url, options, retries - 1);
+        }
+        throw error;
+    }
+};

package/dist/services/ApiService.d.ts

@@ -1,15 +1,16 @@
-import { ContractCallQuoteRequest, GetStatusRequest, QuoteRequest, RequestOptions, TokensRequest, TokensResponse } from '@lifi/types';
+import { ContractCallQuoteRequest, GasRecommendationRequest, GasRecommendationResponse, GetStatusRequest, QuoteRequest, RequestOptions, TokensRequest, TokensResponse } from '@lifi/types';
 import { ChainId, ChainKey, ExtendedChain, 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<ExtendedChain[]>;
-    getRoutes: (request: RoutesRequest, options?: RequestOptions | undefined) => Promise<RoutesResponse>;
+    getContractCallQuote: (requestConfig: ContractCallQuoteRequest, options?: RequestOptions | undefined) => Promise<Step>;
+    getGasRecommendation: ({ chainId, fromChain, fromToken }: GasRecommendationRequest, options?: RequestOptions | undefined) => Promise<GasRecommendationResponse>;
+    getPossibilities: (requestConfig?: PossibilitiesRequest | undefined, options?: RequestOptions | undefined) => Promise<PossibilitiesResponse>;
+    getQuote: (requestConfig: QuoteRequest, options?: RequestOptions | undefined) => Promise<Step>;
+    getRoutes: (requestConfig: RoutesRequest, options?: RequestOptions | undefined) => Promise<RoutesResponse>;
+    getStatus: ({ bridge, fromChain, toChain, txHash }: GetStatusRequest, options?: RequestOptions | undefined) => Promise<StatusResponse>;
     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>;
+    getToken: (chain: ChainKey | ChainId, token: string, options?: RequestOptions | undefined) => Promise<Token>;
+    getTokens: (requestConfig?: TokensRequest | undefined, options?: RequestOptions | undefined) => Promise<TokensResponse>;
+    getTools: (requestConfig?: ToolsRequest | undefined, options?: RequestOptions | undefined) => Promise<ToolsResponse>;
 };
 export default _default;