@lifi/sdk 1.6.4 → 1.7.1

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

@@ -1,145 +0,0 @@
-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 ApiService from '../../services/ApiService';
-import ChainsService from '../../services/ChainsService';
-import { LifiErrorCode, TransactionError } from '../../utils/errors';
-import { getProvider } from '../../utils/getProvider';
-import { getTransactionFailedMessage, parseError } from '../../utils/parseError';
-import { isZeroAddress, personalizeStep } from '../../utils/utils';
-import { checkAllowance } from '../allowance.execute';
-import { balanceCheck } from '../balanceCheck.execute';
-import { stepComparison } from '../stepComparison';
-import { switchChain } from '../switchChain';
-import { waitForReceivingTransaction } from '../utils';
-export class SwapExecutionManager {
-    constructor() {
-        this.allowUserInteraction = true;
-        this.allowInteraction = (value) => {
-            this.allowUserInteraction = value;
-        };
-        this.execute = ({ signer, step, statusManager, settings, }) => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
-            step.execution = statusManager.initExecutionObject(step);
-            const chainsService = ChainsService.getInstance();
-            const fromChain = yield chainsService.getChainById(step.action.fromChainId);
-            // STEP 1: Check allowance
-            if (!isZeroAddress(step.action.fromToken.address)) {
-                yield checkAllowance(signer, step, statusManager, settings, fromChain, this.allowUserInteraction);
-            }
-            // STEP 2: Get transaction
-            let swapProcess = statusManager.findOrCreateProcess(step, 'SWAP');
-            let transaction;
-            try {
-                if (swapProcess.txHash) {
-                    // Make sure that the chain is still correct
-                    const updatedSigner = yield switchChain(signer, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
-                    if (!updatedSigner) {
-                        // Chain switch was not successful, stop execution here
-                        return step.execution;
-                    }
-                    signer = updatedSigner;
-                    // Load exiting transaction
-                    transaction = yield getProvider(signer).getTransaction(swapProcess.txHash);
-                }
-                else {
-                    swapProcess = statusManager.updateProcess(step, swapProcess.type, 'STARTED');
-                    // Check balance
-                    yield balanceCheck(signer, step);
-                    // Create new transaction
-                    if (!step.transactionRequest) {
-                        const personalizedStep = yield personalizeStep(signer, step);
-                        const updatedStep = yield ApiService.getStepTransaction(personalizedStep);
-                        step = Object.assign(Object.assign({}, (yield stepComparison(statusManager, personalizedStep, updatedStep, settings.acceptSlippageUpdateHook, this.allowUserInteraction))), { execution: step.execution });
-                    }
-                    const { transactionRequest } = step;
-                    if (!transactionRequest) {
-                        throw new TransactionError(LifiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
-                    }
-                    // STEP 3: Send the transaction
-                    // Make sure that the chain is still correct
-                    const updatedSigner = yield switchChain(signer, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
-                    if (!updatedSigner) {
-                        // Chain switch was not successful, stop execution here
-                        return step.execution;
-                    }
-                    signer = updatedSigner;
-                    swapProcess = statusManager.updateProcess(step, swapProcess.type, 'ACTION_REQUIRED');
-                    if (!this.allowUserInteraction) {
-                        return step.execution;
-                    }
-                    // Submit the transaction
-                    transaction = yield signer.sendTransaction(transactionRequest);
-                }
-                // STEP 4: Wait for the transaction
-                swapProcess = statusManager.updateProcess(step, swapProcess.type, 'PENDING', {
-                    txLink: fromChain.metamask.blockExplorerUrls[0] + 'tx/' + transaction.hash,
-                    txHash: transaction.hash,
-                });
-                yield transaction.wait();
-            }
-            catch (e) {
-                if (e.code === 'TRANSACTION_REPLACED' && 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 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;
-                }
-            }
-            // STEP 5: Wait for the receiving chain
-            let statusResponse;
-            try {
-                if (!swapProcess.txHash) {
-                    throw new Error('Transaction hash is undefined.');
-                }
-                statusResponse = yield waitForReceivingTransaction(swapProcess.txHash, statusManager, swapProcess.type, step);
-            }
-            catch (e) {
-                swapProcess = statusManager.updateProcess(step, swapProcess.type, 'FAILED', {
-                    error: {
-                        code: LifiErrorCode.TransactionFailed,
-                        message: 'Failed while waiting for receiving chain.',
-                        htmlMessage: 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;
-        });
-    }
-}