@lifi/sdk 1.0.1 → 1.1.1

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

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 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) {
@@ -49,6 +60,7 @@ var parseError_1 = require("../../utils/parseError");
 var utils_1 = require("../../utils/utils");
 var allowance_execute_1 = require("../allowance.execute");
 var balanceCheck_execute_1 = require("../balanceCheck.execute");
+var stepComparison_1 = require("../stepComparison");
 var switchChain_1 = require("../switchChain");
 var utils_2 = require("../utils");
 var SwapExecutionManager = /** @class */ (function () {
@@ -61,10 +73,10 @@ var SwapExecutionManager = /** @class */ (function () {
         this.execute = function (_a) {
             var signer = _a.signer, step = _a.step, statusManager = _a.statusManager, settings = _a.settings;
             return __awaiter(_this, void 0, void 0, function () {
-                var action, estimate, chainsService, fromChain, swapProcess, tx, personalizedStep, transactionRequest, updatedSigner, e_1, error, receipt, e_2, error, statusResponse, e_3;
-                var _b, _c, _d, _e;
-                return __generator(this, function (_f) {
-                    switch (_f.label) {
+                var action, estimate, chainsService, fromChain, swapProcess, tx, personalizedStep, updatedStep, _b, transactionRequest, updatedSigner, e_1, error, receipt, e_2, error, statusResponse, e_3;
+                var _c, _d, _e, _f;
+                return __generator(this, function (_g) {
+                    switch (_g.label) {
                         case 0:
                             action = step.action, estimate = step.estimate;
                             step.execution = statusManager.initExecutionObject(step);
@@ -73,23 +85,23 @@ var SwapExecutionManager = /** @class */ (function () {
                                 // Approval
                             ];
                         case 1:
-                            fromChain = _f.sent();
+                            fromChain = _g.sent();
                             if (!(action.fromToken.address !== ethers_1.constants.AddressZero)) return [3 /*break*/, 3];
                             return [4 /*yield*/, (0, allowance_execute_1.checkAllowance)(signer, step, fromChain, action.fromToken, action.fromAmount, estimate.approvalAddress, statusManager, settings.infiniteApproval, this.shouldContinue)];
                         case 2:
-                            _f.sent();
-                            _f.label = 3;
+                            _g.sent();
+                            _g.label = 3;
                         case 3:
                             swapProcess = statusManager.findOrCreateProcess('SWAP', step);
-                            _f.label = 4;
+                            _g.label = 4;
                         case 4:
-                            _f.trys.push([4, 13, , 15]);
+                            _g.trys.push([4, 14, , 16]);
                             if (!swapProcess.txHash) return [3 /*break*/, 6];
                             return [4 /*yield*/, (0, getProvider_1.getProvider)(signer).getTransaction(swapProcess.txHash)];
                         case 5:
                             // -> restore existing tx
-                            tx = _f.sent();
-                            return [3 /*break*/, 12];
+                            tx = _g.sent();
+                            return [3 /*break*/, 13];
                         case 6: 
                         // -> check balance
                         return [4 /*yield*/, (0, balanceCheck_execute_1.balanceCheck)(signer, step)
@@ -97,41 +109,46 @@ var SwapExecutionManager = /** @class */ (function () {
                         ];
                         case 7:
                             // -> check balance
-                            _f.sent();
+                            _g.sent();
                             return [4 /*yield*/, (0, utils_1.personalizeStep)(signer, step)];
                         case 8:
-                            personalizedStep = _f.sent();
+                            personalizedStep = _g.sent();
                             return [4 /*yield*/, ApiService_1.default.getStepTransaction(personalizedStep)];
                         case 9:
-                            transactionRequest = (_f.sent()).transactionRequest;
+                            updatedStep = _g.sent();
+                            _b = [{}];
+                            return [4 /*yield*/, (0, stepComparison_1.stepComparison)(statusManager, personalizedStep, updatedStep, settings.acceptSlippageUpdateHook, this.shouldContinue)];
+                        case 10:
+                            step = __assign.apply(void 0, [__assign.apply(void 0, _b.concat([(_g.sent())])), { execution: step.execution }]);
+                            transactionRequest = step.transactionRequest;
                             if (!transactionRequest) {
                                 throw new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
                             }
                             return [4 /*yield*/, (0, switchChain_1.switchChain)(signer, statusManager, step, settings.switchChainHook, this.shouldContinue)];
-                        case 10:
-                            updatedSigner = _f.sent();
+                        case 11:
+                            updatedSigner = _g.sent();
                             if (!updatedSigner) {
                                 // chain switch was not successful, stop execution here
                                 return [2 /*return*/, step.execution];
                             }
                             signer = updatedSigner;
                             // -> set step.execution
-                            statusManager.updateProcess(step, swapProcess.type, 'ACTION_REQUIRED');
+                            swapProcess = swapProcess = statusManager.updateProcess(step, swapProcess.type, 'ACTION_REQUIRED');
                             if (!this.shouldContinue) {
                                 return [2 /*return*/, step.execution]; // stop before user interaction is needed
                             }
                             return [4 /*yield*/, signer.sendTransaction(transactionRequest)];
-                        case 11:
+                        case 12:
                             // -> submit tx
-                            tx = _f.sent();
-                            _f.label = 12;
-                        case 12: return [3 /*break*/, 15];
-                        case 13:
-                            e_1 = _f.sent();
-                            return [4 /*yield*/, (0, parseError_1.parseError)(e_1, step, swapProcess)];
+                            tx = _g.sent();
+                            _g.label = 13;
+                        case 13: return [3 /*break*/, 16];
                         case 14:
-                            error = _f.sent();
-                            statusManager.updateProcess(step, swapProcess.type, 'FAILED', {
+                            e_1 = _g.sent();
+                            return [4 /*yield*/, (0, parseError_1.parseError)(e_1, step, swapProcess)];
+                        case 15:
+                            error = _g.sent();
+                            swapProcess = statusManager.updateProcess(step, swapProcess.type, 'FAILED', {
                                 error: {
                                     message: error.message,
                                     htmlMessage: error.htmlMessage,
@@ -140,34 +157,34 @@ var SwapExecutionManager = /** @class */ (function () {
                             });
                             statusManager.updateExecution(step, 'FAILED');
                             throw error;
-                        case 15:
+                        case 16:
                             // Wait for Transaction
-                            statusManager.updateProcess(step, swapProcess.type, 'PENDING', {
+                            swapProcess = statusManager.updateProcess(step, swapProcess.type, 'PENDING', {
                                 txLink: fromChain.metamask.blockExplorerUrls[0] + 'tx/' + tx.hash,
                                 txHash: tx.hash,
                             });
-                            _f.label = 16;
-                        case 16:
-                            _f.trys.push([16, 18, , 22]);
-                            return [4 /*yield*/, tx.wait()];
+                            _g.label = 17;
                         case 17:
-                            receipt = _f.sent();
-                            return [3 /*break*/, 22];
+                            _g.trys.push([17, 19, , 23]);
+                            return [4 /*yield*/, tx.wait()];
                         case 18:
-                            e_2 = _f.sent();
-                            if (!(e_2.code === 'TRANSACTION_REPLACED' && e_2.replacement)) return [3 /*break*/, 19];
+                            receipt = _g.sent();
+                            return [3 /*break*/, 23];
+                        case 19:
+                            e_2 = _g.sent();
+                            if (!(e_2.code === 'TRANSACTION_REPLACED' && e_2.replacement)) return [3 /*break*/, 20];
                             receipt = e_2.replacement;
-                            statusManager.updateProcess(step, swapProcess.type, 'PENDING', {
+                            swapProcess = statusManager.updateProcess(step, swapProcess.type, 'PENDING', {
                                 txHash: e_2.replacement.hash,
                                 txLink: fromChain.metamask.blockExplorerUrls[0] +
                                     'tx/' +
                                     e_2.replacement.hash,
                             });
-                            return [3 /*break*/, 21];
-                        case 19: return [4 /*yield*/, (0, parseError_1.parseError)(e_2)];
-                        case 20:
-                            error = _f.sent();
-                            statusManager.updateProcess(step, swapProcess.type, 'FAILED', {
+                            return [3 /*break*/, 22];
+                        case 20: return [4 /*yield*/, (0, parseError_1.parseError)(e_2)];
+                        case 21:
+                            error = _g.sent();
+                            swapProcess = statusManager.updateProcess(step, swapProcess.type, 'FAILED', {
                                 error: {
                                     message: error.message,
                                     htmlMessage: error.htmlMessage,
@@ -176,19 +193,19 @@ var SwapExecutionManager = /** @class */ (function () {
                             });
                             statusManager.updateExecution(step, 'FAILED');
                             throw error;
-                        case 21: return [3 /*break*/, 22];
-                        case 22:
-                            _f.trys.push([22, 24, , 25]);
+                        case 22: return [3 /*break*/, 23];
+                        case 23:
+                            _g.trys.push([23, 25, , 26]);
                             if (!swapProcess.txHash) {
                                 throw new Error('Transaction hash is undefined.');
                             }
                             return [4 /*yield*/, (0, utils_2.waitForReceivingTransaction)(swapProcess.txHash, statusManager, swapProcess.type, step)];
-                        case 23:
-                            statusResponse = _f.sent();
-                            return [3 /*break*/, 25];
                         case 24:
-                            e_3 = _f.sent();
-                            statusManager.updateProcess(step, swapProcess.type, 'FAILED', {
+                            statusResponse = _g.sent();
+                            return [3 /*break*/, 26];
+                        case 25:
+                            e_3 = _g.sent();
+                            swapProcess = statusManager.updateProcess(step, swapProcess.type, 'FAILED', {
                                 error: {
                                     code: errors_1.LifiErrorCode.TransactionFailed,
                                     message: 'Failed while waiting for receiving chain.',
@@ -197,18 +214,19 @@ var SwapExecutionManager = /** @class */ (function () {
                             });
                             statusManager.updateExecution(step, 'FAILED');
                             throw e_3;
-                        case 25:
-                            statusManager.updateProcess(step, swapProcess.type, 'DONE', {
-                                txHash: (_b = statusResponse.receiving) === null || _b === void 0 ? void 0 : _b.txHash,
+                        case 26:
+                            swapProcess = statusManager.updateProcess(step, swapProcess.type, 'DONE', {
+                                txHash: (_c = statusResponse.receiving) === null || _c === void 0 ? void 0 : _c.txHash,
                                 txLink: fromChain.metamask.blockExplorerUrls[0] +
                                     'tx/' +
-                                    ((_c = statusResponse.receiving) === null || _c === void 0 ? void 0 : _c.txHash),
+                                    ((_d = statusResponse.receiving) === null || _d === void 0 ? void 0 : _d.txHash),
                             });
                             statusManager.updateExecution(step, 'DONE', {
                                 fromAmount: statusResponse.sending.amount,
-                                toAmount: (_d = statusResponse.receiving) === null || _d === void 0 ? void 0 : _d.amount,
-                                toToken: (_e = statusResponse.receiving) === null || _e === void 0 ? void 0 : _e.token,
-                                // gasUsed: statusResponse.gasUsed,
+                                toAmount: (_e = statusResponse.receiving) === null || _e === void 0 ? void 0 : _e.amount,
+                                toToken: (_f = statusResponse.receiving) === null || _f === void 0 ? void 0 : _f.token,
+                                gasUsed: statusResponse.sending.gasUsed,
+                                gasPrice: statusResponse.sending.gasPrice,
                             });
                             // DONE
                             return [2 /*return*/, step.execution];

package/dist/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/execution/stepComparison.js

@@ -0,0 +1,81 @@
+"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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stepComparison = void 0;
+var errors_1 = require("../utils/errors");
+var parseError_1 = require("../utils/parseError");
+var 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
+ */
+var stepComparison = function (statusManager, oldStep, newStep, acceptSlippageUpdateHook, allowUserInteraction) { return __awaiter(void 0, void 0, void 0, function () {
+    var allowStepUpdate;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if ((0, utils_1.updatedStepMeetsSlippageConditions)(oldStep, newStep)) {
+                    return [2 /*return*/, statusManager.updateStepInRoute(newStep)];
+                }
+                if (!allowUserInteraction) return [3 /*break*/, 2];
+                return [4 /*yield*/, acceptSlippageUpdateHook({
+                        oldToAmount: oldStep.estimate.toAmount,
+                        newToAmount: newStep.estimate.toAmount,
+                        toToken: newStep.action.toToken,
+                        oldSlippage: oldStep.action.slippage,
+                        newSlippage: newStep.action.slippage,
+                    })];
+            case 1:
+                allowStepUpdate = _a.sent();
+                _a.label = 2;
+            case 2:
+                if (!allowStepUpdate) {
+                    throw new errors_1.TransactionError(errors_1.LifiErrorCode.SlippageNotMet, 'Slippage conditions not met!', (0, parseError_1.getSlippageNotMetMessage)(oldStep));
+                }
+                return [2 /*return*/, statusManager.updateStepInRoute(newStep)];
+        }
+    });
+}); };
+exports.stepComparison = stepComparison;

package/dist/execution/switchChain.js

@@ -82,12 +82,12 @@ var switchChain = function (signer, statusManager, step, switchChainHook, allowU
                 if (_a) {
                     throw new errors_1.ProviderError(errors_1.LifiErrorCode.ChainSwitchError, 'Chain switch required.');
                 }
-                statusManager.updateProcess(step, switchProcess.type, 'DONE');
+                switchProcess = statusManager.updateProcess(step, switchProcess.type, 'DONE');
                 statusManager.updateExecution(step, 'PENDING');
                 return [2 /*return*/, updatedSigner];
             case 6:
                 error_1 = _b.sent();
-                statusManager.updateProcess(step, switchProcess.type, 'FAILED', {
+                switchProcess = statusManager.updateProcess(step, switchProcess.type, 'FAILED', {
                     error: {
                         message: error_1.message,
                         code: error_1.code,

package/dist/execution/utils.d.ts

@@ -3,3 +3,4 @@ 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/execution/utils.js

@@ -39,7 +39,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSubstatusMessage = exports.getProcessMessage = exports.waitForReceivingTransaction = void 0;
+exports.updatedStepMeetsSlippageConditions = exports.getSubstatusMessage = exports.getProcessMessage = exports.waitForReceivingTransaction = void 0;
+var bignumber_js_1 = __importDefault(require("bignumber.js"));
 var ApiService_1 = __importDefault(require("../services/ApiService"));
 var errors_1 = require("../utils/errors");
 var utils_1 = require("../utils/utils");
@@ -173,3 +174,13 @@ function getSubstatusMessage(status, substatus) {
     return message;
 }
 exports.getSubstatusMessage = getSubstatusMessage;
+function updatedStepMeetsSlippageConditions(oldStep, newStep) {
+    var setSlippage = new bignumber_js_1.default(oldStep.action.slippage);
+    var oldEstimatedToAmount = new bignumber_js_1.default(oldStep.estimate.toAmountMin);
+    var newEstimatedToAmount = new bignumber_js_1.default(newStep.estimate.toAmountMin);
+    var amountDifference = oldEstimatedToAmount.minus(newEstimatedToAmount);
+    var actualSlippage = amountDifference.dividedBy(oldEstimatedToAmount);
+    return (newEstimatedToAmount.gte(oldEstimatedToAmount) &&
+        actualSlippage.lte(setSlippage));
+}
+exports.updatedStepMeetsSlippageConditions = updatedStepMeetsSlippageConditions;

package/dist/services/ApiService.d.ts

@@ -1,9 +1,10 @@
-import { GetStatusRequest, QuoteRequest, RequestOptions, TokensRequest, TokensResponse } from '@lifi/types';
+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: ({ fromChain, fromToken, fromAddress, fromAmount, toChain, toToken, toAddress, order, slippage, integrator, referrer, allowBridges, denyBridges, preferBridges, allowExchanges, denyExchanges, preferExchanges, }: QuoteRequest, options?: RequestOptions | undefined) => Promise<Step>;
+    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>;