@lifi/sdk 1.1.2 → 1.1.5

package/dist/cjs/execution/balanceCheck.execute.js

@@ -0,0 +1,48 @@
+"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.balanceCheck = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const balances_1 = __importDefault(require("../balances"));
+const errors_1 = require("../utils/errors");
+const balanceCheck = (signer, step) => __awaiter(void 0, void 0, void 0, function* () {
+    const tokenAmount = yield balances_1.default.getTokenBalance(yield signer.getAddress(), step.action.fromToken);
+    if (tokenAmount) {
+        const currentBalance = new bignumber_js_1.default(tokenAmount.amount).shiftedBy(tokenAmount.decimals);
+        const neededBalance = new bignumber_js_1.default(step.action.fromAmount);
+        if (currentBalance.lt(neededBalance)) {
+            if (neededBalance.multipliedBy(1 - step.action.slippage).lte(currentBalance)) {
+                // adjust amount in slippage limits
+                step.action.fromAmount = currentBalance.toFixed(0);
+            }
+            else {
+                const neeeded = neededBalance.shiftedBy(-tokenAmount.decimals).toFixed();
+                const current = currentBalance
+                    .shiftedBy(-tokenAmount.decimals)
+                    .toFixed();
+                let errorMessage = `Your ${tokenAmount.symbol} balance is too low, ` +
+                    `you try to transfer ${neeeded} ${tokenAmount.symbol}, ` +
+                    `but your wallet only holds ${current} ${tokenAmount.symbol}. ` +
+                    `No funds have been sent. `;
+                if (!currentBalance.isZero()) {
+                    errorMessage +=
+                        `If the problem consists, please delete this transfer and ` +
+                            `start a new one with a maximum of ${current} ${tokenAmount.symbol}.`;
+                }
+                throw new errors_1.ValidationError('The balance is too low.', errorMessage);
+            }
+        }
+    }
+});
+exports.balanceCheck = balanceCheck;

package/dist/cjs/execution/bridges/bridge.execute.d.ts

@@ -0,0 +1,7 @@
+import { Execution } from '@lifi/types';
+import { ExecuteCrossParams } from '../../types';
+export declare class BridgeExecutionManager {
+    shouldContinue: boolean;
+    setShouldContinue: (val: boolean) => void;
+    execute: ({ signer, step, statusManager, settings, }: ExecuteCrossParams) => Promise<Execution>;
+}

package/dist/cjs/execution/bridges/bridge.execute.js

@@ -0,0 +1,154 @@
+"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.BridgeExecutionManager = 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 BridgeExecutionManager {
+    constructor() {
+        this.shouldContinue = true;
+        this.setShouldContinue = (val) => {
+            this.shouldContinue = val;
+        };
+        this.execute = ({ signer, step, statusManager, settings, }) => __awaiter(this, void 0, void 0, function* () {
+            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);
+            const toChain = yield chainsService.getChainById(action.toChainId);
+            // STEP 1: Check Allowance ////////////////////////////////////////////////
+            // approval still needed?
+            const oldCrossProcess = step.execution.process.find((p) => p.type === 'CROSS_CHAIN');
+            if (!(oldCrossProcess === null || oldCrossProcess === void 0 ? void 0 : oldCrossProcess.txHash)) {
+                if (action.fromToken.address !== ethers_1.constants.AddressZero) {
+                    // Check Token Approval only if fromToken is not the native token => no approval needed in that case
+                    yield (0, allowance_execute_1.checkAllowance)(signer, step, fromChain, action.fromToken, action.fromAmount, estimate.approvalAddress, statusManager, settings.infiniteApproval, this.shouldContinue);
+                }
+            }
+            // STEP 2: Get Transaction ////////////////////////////////////////////////
+            let crossChainProcess = statusManager.findOrCreateProcess('CROSS_CHAIN', step);
+            try {
+                let tx;
+                if (crossChainProcess.txHash) {
+                    // load exiting transaction
+                    tx = yield (0, getProvider_1.getProvider)(signer).getTransaction(crossChainProcess.txHash);
+                }
+                else {
+                    // check balance
+                    yield (0, balanceCheck_execute_1.balanceCheck)(signer, step);
+                    // create new transaction
+                    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.');
+                    }
+                    // STEP 3: Send 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;
+                    crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'ACTION_REQUIRED');
+                    if (!this.shouldContinue) {
+                        return step.execution;
+                    }
+                    tx = yield signer.sendTransaction(transactionRequest);
+                    // STEP 4: Wait for Transaction ///////////////////////////////////////////
+                    crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'PENDING', {
+                        txHash: tx.hash,
+                        txLink: fromChain.metamask.blockExplorerUrls[0] + 'tx/' + tx.hash,
+                    });
+                }
+                yield tx.wait();
+            }
+            catch (e) {
+                if (e.code === 'TRANSACTION_REPLACED' && e.replacement) {
+                    crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'PENDING', {
+                        txHash: e.replacement.hash,
+                        txLink: fromChain.metamask.blockExplorerUrls[0] +
+                            'tx/' +
+                            e.replacement.hash,
+                    });
+                }
+                else {
+                    const error = yield (0, parseError_1.parseError)(e, step, crossChainProcess);
+                    crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'FAILED', {
+                        error: {
+                            message: error.message,
+                            htmlMessage: error.htmlMessage,
+                            code: error.code,
+                        },
+                    });
+                    statusManager.updateExecution(step, 'FAILED');
+                    throw error;
+                }
+            }
+            crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'DONE');
+            // STEP 5: Wait for Receiver //////////////////////////////////////
+            let receivingChainProcess = statusManager.findOrCreateProcess('RECEIVING_CHAIN', step, 'PENDING');
+            let statusResponse;
+            try {
+                if (!crossChainProcess.txHash) {
+                    throw new Error('Transaction hash is undefined.');
+                }
+                statusResponse = yield (0, utils_2.waitForReceivingTransaction)(crossChainProcess.txHash, statusManager, receivingChainProcess.type, step);
+            }
+            catch (e) {
+                receivingChainProcess = statusManager.updateProcess(step, receivingChainProcess.type, 'FAILED', {
+                    error: {
+                        code: errors_1.LifiErrorCode.TransactionFailed,
+                        message: 'Failed while waiting for receiving chain.',
+                        htmlMessage: (0, parseError_1.getTransactionFailedMessage)(step, crossChainProcess.txLink),
+                    },
+                });
+                statusManager.updateExecution(step, 'FAILED');
+                throw e;
+            }
+            receivingChainProcess = statusManager.updateProcess(step, receivingChainProcess.type, 'DONE', {
+                substatus: statusResponse.substatus,
+                substatusMessage: statusResponse.substatusMessage ||
+                    (0, utils_2.getSubstatusMessage)(statusResponse.status, statusResponse.substatus),
+                txHash: (_a = statusResponse.receiving) === null || _a === void 0 ? void 0 : _a.txHash,
+                txLink: toChain.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.BridgeExecutionManager = BridgeExecutionManager;

package/dist/cjs/execution/exchanges/swap.execute.d.ts

@@ -0,0 +1,7 @@
+import { Execution } from '@lifi/types';
+import { ExecuteSwapParams } from '../../types';
+export declare class SwapExecutionManager {
+    shouldContinue: boolean;
+    setShouldContinue: (val: boolean) => void;
+    execute: ({ signer, step, statusManager, settings, }: ExecuteSwapParams) => Promise<Execution>;
+}

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;