@lifi/sdk 1.1.4 → 1.2.0

package/dist/cjs/execution/exchanges/swap.execute.js

@@ -0,0 +1,164 @@
+"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.SwapExecutionManager = void 0;
+const ethers_1 = require("ethers");
+const ApiService_1 = __importDefault(require("../../services/ApiService"));
+const ChainsService_1 = __importDefault(require("../../services/ChainsService"));
+const errors_1 = require("../../utils/errors");
+const getProvider_1 = require("../../utils/getProvider");
+const parseError_1 = require("../../utils/parseError");
+const utils_1 = require("../../utils/utils");
+const allowance_execute_1 = require("../allowance.execute");
+const balanceCheck_execute_1 = require("../balanceCheck.execute");
+const stepComparison_1 = require("../stepComparison");
+const switchChain_1 = require("../switchChain");
+const utils_2 = require("../utils");
+class SwapExecutionManager {
+    constructor() {
+        this.shouldContinue = true;
+        this.setShouldContinue = (val) => {
+            this.shouldContinue = val;
+        };
+        this.execute = ({ signer, step, statusManager, settings, }) => __awaiter(this, void 0, void 0, function* () {
+            // setup
+            var _a, _b, _c, _d;
+            const { action, estimate } = step;
+            step.execution = statusManager.initExecutionObject(step);
+            const chainsService = ChainsService_1.default.getInstance();
+            const fromChain = yield chainsService.getChainById(action.fromChainId);
+            // Approval
+            if (action.fromToken.address !== ethers_1.constants.AddressZero) {
+                yield (0, allowance_execute_1.checkAllowance)(signer, step, fromChain, action.fromToken, action.fromAmount, estimate.approvalAddress, statusManager, settings.infiniteApproval, this.shouldContinue);
+            }
+            // Start Swap
+            // -> set step.execution
+            let swapProcess = statusManager.findOrCreateProcess('SWAP', step);
+            // -> swapping
+            let tx;
+            try {
+                if (swapProcess.txHash) {
+                    // -> restore existing tx
+                    tx = yield (0, getProvider_1.getProvider)(signer).getTransaction(swapProcess.txHash);
+                }
+                else {
+                    // -> check balance
+                    yield (0, balanceCheck_execute_1.balanceCheck)(signer, step);
+                    // -> get tx from backend
+                    const personalizedStep = yield (0, utils_1.personalizeStep)(signer, step);
+                    const updatedStep = yield ApiService_1.default.getStepTransaction(personalizedStep);
+                    step = Object.assign(Object.assign({}, (yield (0, stepComparison_1.stepComparison)(statusManager, personalizedStep, updatedStep, settings.acceptSlippageUpdateHook, this.shouldContinue))), { execution: step.execution });
+                    const { transactionRequest } = step;
+                    if (!transactionRequest) {
+                        throw new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
+                    }
+                    // make sure that chain is still correct
+                    const updatedSigner = yield (0, switchChain_1.switchChain)(signer, statusManager, step, settings.switchChainHook, this.shouldContinue);
+                    if (!updatedSigner) {
+                        // chain switch was not successful, stop execution here
+                        return step.execution;
+                    }
+                    signer = updatedSigner;
+                    // -> set step.execution
+                    swapProcess = swapProcess = statusManager.updateProcess(step, swapProcess.type, 'ACTION_REQUIRED');
+                    if (!this.shouldContinue) {
+                        return step.execution; // stop before user interaction is needed
+                    }
+                    // -> submit tx
+                    tx = yield signer.sendTransaction(transactionRequest);
+                }
+            }
+            catch (e) {
+                const error = yield (0, parseError_1.parseError)(e, step, swapProcess);
+                swapProcess = statusManager.updateProcess(step, swapProcess.type, 'FAILED', {
+                    error: {
+                        message: error.message,
+                        htmlMessage: error.htmlMessage,
+                        code: error.code,
+                    },
+                });
+                statusManager.updateExecution(step, 'FAILED');
+                throw error;
+            }
+            // Wait for Transaction
+            swapProcess = statusManager.updateProcess(step, swapProcess.type, 'PENDING', {
+                txLink: fromChain.metamask.blockExplorerUrls[0] + 'tx/' + tx.hash,
+                txHash: tx.hash,
+            });
+            // -> waiting
+            let receipt;
+            try {
+                receipt = yield tx.wait();
+            }
+            catch (e) {
+                // -> set status
+                if (e.code === 'TRANSACTION_REPLACED' && e.replacement) {
+                    receipt = e.replacement;
+                    swapProcess = statusManager.updateProcess(step, swapProcess.type, 'PENDING', {
+                        txHash: e.replacement.hash,
+                        txLink: fromChain.metamask.blockExplorerUrls[0] +
+                            'tx/' +
+                            e.replacement.hash,
+                    });
+                }
+                else {
+                    const error = yield (0, parseError_1.parseError)(e);
+                    swapProcess = statusManager.updateProcess(step, swapProcess.type, 'FAILED', {
+                        error: {
+                            message: error.message,
+                            htmlMessage: error.htmlMessage,
+                            code: error.code,
+                        },
+                    });
+                    statusManager.updateExecution(step, 'FAILED');
+                    throw error;
+                }
+            }
+            let statusResponse;
+            try {
+                if (!swapProcess.txHash) {
+                    throw new Error('Transaction hash is undefined.');
+                }
+                statusResponse = yield (0, utils_2.waitForReceivingTransaction)(swapProcess.txHash, statusManager, swapProcess.type, step);
+            }
+            catch (e) {
+                swapProcess = statusManager.updateProcess(step, swapProcess.type, 'FAILED', {
+                    error: {
+                        code: errors_1.LifiErrorCode.TransactionFailed,
+                        message: 'Failed while waiting for receiving chain.',
+                        htmlMessage: (0, parseError_1.getTransactionFailedMessage)(step, swapProcess.txLink),
+                    },
+                });
+                statusManager.updateExecution(step, 'FAILED');
+                throw e;
+            }
+            swapProcess = statusManager.updateProcess(step, swapProcess.type, 'DONE', {
+                txHash: (_a = statusResponse.receiving) === null || _a === void 0 ? void 0 : _a.txHash,
+                txLink: fromChain.metamask.blockExplorerUrls[0] +
+                    'tx/' +
+                    ((_b = statusResponse.receiving) === null || _b === void 0 ? void 0 : _b.txHash),
+            });
+            statusManager.updateExecution(step, 'DONE', {
+                fromAmount: statusResponse.sending.amount,
+                toAmount: (_c = statusResponse.receiving) === null || _c === void 0 ? void 0 : _c.amount,
+                toToken: (_d = statusResponse.receiving) === null || _d === void 0 ? void 0 : _d.token,
+                gasUsed: statusResponse.sending.gasUsed,
+                gasPrice: statusResponse.sending.gasPrice,
+            });
+            // DONE
+            return step.execution;
+        });
+    }
+}
+exports.SwapExecutionManager = SwapExecutionManager;

package/dist/cjs/execution/index.d.ts

@@ -0,0 +1 @@
+export * from './StatusManager';

package/dist/cjs/execution/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./StatusManager"), exports);

package/dist/cjs/execution/stepComparison.d.ts

@@ -0,0 +1,14 @@
+import { StatusManager } from '.';
+import { AcceptSlippageUpdateHook, Step } from '../types';
+/**
+ * This method checks whether the new and updated Step meets the required slippage conditions.
+ * If yes it returns the updated Step.
+ * If no and if user interaction is allowed it triggers the acceptSlippageUpdateHook. If no user interaction is allowed it aborts.
+ *
+ * @param statusManager
+ * @param oldStep
+ * @param newStep
+ * @param acceptSlippageUpdateHook
+ * @param allowUserInteraction
+ */
+export declare const stepComparison: (statusManager: StatusManager, oldStep: Step, newStep: Step, acceptSlippageUpdateHook: AcceptSlippageUpdateHook, allowUserInteraction: boolean) => Promise<Step>;

package/dist/cjs/execution/stepComparison.js

@@ -0,0 +1,46 @@
+"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.stepComparison = void 0;
+const errors_1 = require("../utils/errors");
+const parseError_1 = require("../utils/parseError");
+const utils_1 = require("./utils");
+/**
+ * This method checks whether the new and updated Step meets the required slippage conditions.
+ * If yes it returns the updated Step.
+ * If no and if user interaction is allowed it triggers the acceptSlippageUpdateHook. If no user interaction is allowed it aborts.
+ *
+ * @param statusManager
+ * @param oldStep
+ * @param newStep
+ * @param acceptSlippageUpdateHook
+ * @param allowUserInteraction
+ */
+const stepComparison = (statusManager, oldStep, newStep, acceptSlippageUpdateHook, allowUserInteraction) => __awaiter(void 0, void 0, void 0, function* () {
+    if ((0, utils_1.updatedStepMeetsSlippageConditions)(oldStep, newStep)) {
+        return statusManager.updateStepInRoute(newStep);
+    }
+    let allowStepUpdate;
+    if (allowUserInteraction) {
+        allowStepUpdate = yield acceptSlippageUpdateHook({
+            oldToAmount: oldStep.estimate.toAmount,
+            newToAmount: newStep.estimate.toAmount,
+            toToken: newStep.action.toToken,
+            oldSlippage: oldStep.action.slippage,
+            newSlippage: newStep.action.slippage,
+        });
+    }
+    if (!allowStepUpdate) {
+        throw new errors_1.TransactionError(errors_1.LifiErrorCode.SlippageNotMet, 'Slippage conditions not met!', (0, parseError_1.getSlippageNotMetMessage)(oldStep));
+    }
+    return statusManager.updateStepInRoute(newStep);
+});
+exports.stepComparison = stepComparison;

package/dist/cjs/execution/switchChain.d.ts

@@ -0,0 +1,16 @@
+import { Step } from '@lifi/types';
+import { Signer } from 'ethers';
+import { SwitchChainHook } from '../types';
+import { StatusManager } from './StatusManager';
+/**
+ * This method checks whether the signer is configured for the correct chain.
+ * If yes it returns the signer.
+ * If no and if user interaction is allowed it triggers the switchChainHook. If no user interaction is allowed it aborts.
+ *
+ * @param signer
+ * @param statusManager
+ * @param step
+ * @param switchChainHook
+ * @param allowUserInteraction
+ */
+export declare const switchChain: (signer: Signer, statusManager: StatusManager, step: Step, switchChainHook: SwitchChainHook, allowUserInteraction: boolean) => Promise<Signer | undefined>;

package/dist/cjs/execution/switchChain.js

@@ -0,0 +1,58 @@
+"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.switchChain = void 0;
+const errors_1 = require("../utils/errors");
+/**
+ * This method checks whether the signer is configured for the correct chain.
+ * If yes it returns the signer.
+ * If no and if user interaction is allowed it triggers the switchChainHook. If no user interaction is allowed it aborts.
+ *
+ * @param signer
+ * @param statusManager
+ * @param step
+ * @param switchChainHook
+ * @param allowUserInteraction
+ */
+const switchChain = (signer, statusManager, step, switchChainHook, allowUserInteraction) => __awaiter(void 0, void 0, void 0, function* () {
+    // if we are already on the correct chain we can proceed directly
+    if ((yield signer.getChainId()) === step.action.fromChainId) {
+        return signer;
+    }
+    // -> set status message
+    step.execution = statusManager.initExecutionObject(step);
+    statusManager.updateExecution(step, 'CHAIN_SWITCH_REQUIRED');
+    let switchProcess = statusManager.findOrCreateProcess('SWITCH_CHAIN', step, 'PENDING');
+    if (!allowUserInteraction) {
+        return;
+    }
+    try {
+        const updatedSigner = yield switchChainHook(step.action.fromChainId);
+        const updatedChainId = yield (updatedSigner === null || updatedSigner === void 0 ? void 0 : updatedSigner.getChainId());
+        if (updatedChainId !== step.action.fromChainId) {
+            throw new errors_1.ProviderError(errors_1.LifiErrorCode.ChainSwitchError, 'Chain switch required.');
+        }
+        switchProcess = statusManager.updateProcess(step, switchProcess.type, 'DONE');
+        statusManager.updateExecution(step, 'PENDING');
+        return updatedSigner;
+    }
+    catch (error) {
+        switchProcess = statusManager.updateProcess(step, switchProcess.type, 'FAILED', {
+            error: {
+                message: error.message,
+                code: error.code,
+            },
+        });
+        statusManager.updateExecution(step, 'FAILED');
+        throw error;
+    }
+});
+exports.switchChain = switchChain;

package/dist/cjs/execution/utils.d.ts

@@ -0,0 +1,6 @@
+import { ProcessType, Status, StatusMessage, StatusResponse, Step, Substatus } from '@lifi/types';
+import { StatusManager } from '..';
+export declare function waitForReceivingTransaction(txHash: string, statusManager: StatusManager, processType: ProcessType, step: Step): Promise<StatusResponse>;
+export declare function getProcessMessage(type: ProcessType, status: Status): string | undefined;
+export declare function getSubstatusMessage(status: StatusMessage, substatus?: Substatus): string | undefined;
+export declare function updatedStepMeetsSlippageConditions(oldStep: Step, newStep: Step): boolean;

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,19 @@
+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;
+export declare const checkPackageUpdates: (packageName?: string, packageVersion?: string, disableCheck?: boolean) => Promise<void>;

package/dist/cjs/helpers.js

@@ -0,0 +1,88 @@
+"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.checkPackageUpdates = exports.isSameToken = exports.getRandomNumber = exports.getEthereumPublicKeyHook = exports.getEthereumDecryptionHook = void 0;
+const version_1 = require("./version");
+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;
+function semverCompare(a, b) {
+    if (a.startsWith(b + '-')) {
+        return -1;
+    }
+    if (b.startsWith(a + '-')) {
+        return 1;
+    }
+    return a.localeCompare(b, undefined, {
+        numeric: true,
+        sensitivity: 'case',
+        caseFirst: 'upper',
+    });
+}
+const checkPackageUpdates = (packageName, packageVersion, disableCheck) => __awaiter(void 0, void 0, void 0, function* () {
+    if (disableCheck || process.env.NODE_ENV !== 'development') {
+        return;
+    }
+    try {
+        const pkgName = packageName !== null && packageName !== void 0 ? packageName : version_1.name;
+        const response = yield (yield fetch(`https://unpkg.com/${pkgName}/package.json`)).json();
+        const latestVersion = response.version;
+        const currentVersion = packageVersion !== null && packageVersion !== void 0 ? packageVersion : version_1.version;
+        if (semverCompare(latestVersion, currentVersion)) {
+            console.warn(
+            // eslint-disable-next-line max-len
+            `${pkgName}: new package version is available. Please update as soon as possible to enjoy the newest features. Current version: ${currentVersion}. Latest version: ${latestVersion}.`);
+        }
+    }
+    catch (error) {
+        // Cannot verify version, might be network error etc. We don't bother showing anything in that case
+    }
+});
+exports.checkPackageUpdates = checkPackageUpdates;

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;