@lifi/sdk 2.0.0-beta.8 → 2.0.0

package/dist/utils/parseError.js

@@ -1,6 +1,7 @@
 import { errorCodes as MetaMaskErrorCodes, getMessageFromCode, } from 'eth-rpc-errors';
+import { fetchTxErrorDetails } from '../helpers';
 import ChainsService from '../services/ChainsService';
-import { LifiError, LifiErrorCode, MetaMaskProviderErrorCode, NotFoundError, ProviderError, RPCError, ServerError, SlippageError, TransactionError, UnknownError, ValidationError, } from './errors';
+import { ErrorMessage, EthersErrorMessage, EthersErrorType, LifiError, LifiErrorCode, MetaMaskProviderErrorCode, NotFoundError, ProviderError, RPCError, ServerError, SlippageError, TransactionError, UnknownError, ValidationError, } from './errors';
 import { formatTokenAmountOnly } from './utils';
 /**
  * Available MetaMask error codes:
@@ -71,13 +72,13 @@ export const parseError = async (e, step, process) => {
                 // rpc errors
                 // underpriced errors are sent as internal errors, so we need to parse the message manually
                 if (e.code === MetaMaskErrorCodes.rpc.internal &&
-                    (e.message?.includes('underpriced') ||
-                        e.message?.includes('replacement fee too low'))) {
-                    return new RPCError(LifiErrorCode.TransactionUnderpriced, 'Transaction is underpriced.', await getTransactionNotSentMessage(step, process), e.stack);
+                    (e.message?.includes(EthersErrorMessage.Underpriced) ||
+                        e.message?.includes(EthersErrorMessage.LowReplacementFee))) {
+                    return new RPCError(LifiErrorCode.TransactionUnderpriced, ErrorMessage.TransactionUnderpriced, await getTransactionNotSentMessage(step, process), e.stack);
                 }
-                if (e.message?.includes('intrinsic gas too low') ||
-                    e.message?.includes('out of gas')) {
-                    return new TransactionError(LifiErrorCode.GasLimitError, 'Gas limit is too low.', await getTransactionNotSentMessage(step, process), e.stack);
+                if (e.message?.includes(EthersErrorMessage.LowGas) ||
+                    e.message?.includes(EthersErrorMessage.OutOfGas)) {
+                    return new TransactionError(LifiErrorCode.GasLimitError, ErrorMessage.GasLimitLow, await getTransactionNotSentMessage(step, process), e.stack);
                 }
                 return new RPCError(e.code, getMessageFromCode(e.code), await getTransactionNotSentMessage(step, process), e.stack);
             }
@@ -88,9 +89,27 @@ export const parseError = async (e, step, process) => {
         }
     }
     switch (e.code) {
-        case 'CALL_EXCEPTION':
-            return new ProviderError(LifiErrorCode.TransactionFailed, e.reason, await getTransactionNotSentMessage(step, process), e.stack);
-        case 'ACTION_REJECTED':
+        case EthersErrorType.CallExecption:
+            const defaultErrorMessage = await getTransactionNotSentMessage(step, process);
+            try {
+                if (!step?.action.fromChainId) {
+                    throw new Error('Signer is not defined.');
+                }
+                const response = await fetchTxErrorDetails(e.transactionHash, step?.action.fromChainId);
+                const errorMessage = response?.error_message ?? e.reason;
+                const isAllowanceError = response?.error_message?.includes(EthersErrorMessage.ERC20Allowance) || e.reason?.includes(EthersErrorMessage.ERC20Allowance);
+                if (isAllowanceError) {
+                    return new TransactionError(LifiErrorCode.AllowanceRequired, e.reason, errorMessage, e.stack);
+                }
+                // Error messages other than allowance error will be handled in catch block
+                throw new Error(e);
+            }
+            catch (error) {
+                return new ProviderError(LifiErrorCode.TransactionFailed, e.reason, defaultErrorMessage, e.stack);
+            }
+        case EthersErrorType.InsufficientFunds:
+            return new TransactionError(LifiErrorCode.InsufficientFunds, e.message, await getTransactionNotSentMessage(step, process), e.stack);
+        case EthersErrorType.ActionRejected:
         case MetaMaskProviderErrorCode.userRejectedRequest:
             return new TransactionError(LifiErrorCode.TransactionRejected, e.message, await getTransactionNotSentMessage(step, process), e.stack);
         case LifiErrorCode.TransactionUnprepared:
@@ -98,7 +117,7 @@ export const parseError = async (e, step, process) => {
         case LifiErrorCode.ValidationError:
             return new TransactionError(LifiErrorCode.ValidationError, e.message, e.htmlMessage);
         default:
-            return new UnknownError(LifiErrorCode.InternalError, e.message || 'Unknown error occurred.', undefined, e.stack);
+            return new UnknownError(LifiErrorCode.InternalError, e.message || ErrorMessage.UnknownError, undefined, e.stack);
     }
 };
 export const parseBackendError = async (e) => {
@@ -116,10 +135,10 @@ export const parseBackendError = async (e) => {
         return new NotFoundError(data?.message || e.response?.statusText, undefined, e.stack);
     }
     if (e.response?.status === 409) {
-        return new SlippageError(data?.message || e.response?.statusText, 'The slippage is larger than the defined threshold. Please request a new route to get a fresh quote.', e.stack);
+        return new SlippageError(data?.message || e.response?.statusText, ErrorMessage.SlippageError, e.stack);
     }
     if (e.response?.status === 500) {
         return new ServerError(data?.message || e.response?.statusText, undefined, e.stack);
     }
-    return new ServerError('Something went wrong.', undefined, e.stack);
+    return new ServerError(ErrorMessage.Default, undefined, e.stack);
 };

package/dist/utils/preRestart.d.ts

@@ -1,2 +1,3 @@
+import { Signer } from 'ethers';
 import { Route } from '../types';
-export declare const handlePreRestart: (route: Route) => void;
+export declare const handlePreRestart: (route: Route, signer: Signer) => Promise<void>;

package/dist/utils/preRestart.js

@@ -1,21 +1,42 @@
 import { LifiErrorCode } from './errors';
-export const handlePreRestart = (route) => {
+export const handlePreRestart = async (route, signer) => {
     for (let index = 0; index < route.steps.length; index++) {
         const stepHasFailed = route.steps[index].execution?.status === 'FAILED';
         if (stepHasFailed) {
-            handleErrorType(route, index);
+            await handleErrorType(route, index, signer);
             deleteFailedProcesses(route, index);
             deleteTransactionData(route, index);
         }
     }
 };
-const handleErrorType = (route, index) => {
+const handleErrorType = async (route, index, signer) => {
     const isGasLimitError = route.steps[index].execution?.process.some((p) => p.error?.code === LifiErrorCode.GasLimitError);
     const isGasPriceError = route.steps[index].execution?.process.some((p) => p.error?.code === LifiErrorCode.TransactionUnderpriced);
+    const { transactionRequest } = route.steps[index];
     if (isGasLimitError) {
+        if (transactionRequest) {
+            let gasLimit = transactionRequest.gasLimit;
+            try {
+                gasLimit = await signer.estimateGas(transactionRequest);
+            }
+            catch (error) { }
+            if (gasLimit) {
+                transactionRequest.gasLimit = `${(BigInt(gasLimit.toString()) * 125n) / 100n}`;
+            }
+        }
         route.steps[index].estimate.gasCosts?.forEach((gasCost) => (gasCost.limit = `${Math.round(Number(gasCost.limit) * 1.25)}`));
     }
     if (isGasPriceError) {
+        if (transactionRequest) {
+            let gasPrice = transactionRequest.gasPrice;
+            try {
+                gasPrice = await signer.getGasPrice();
+            }
+            catch (error) { }
+            if (gasPrice) {
+                transactionRequest.gasPrice = `${(BigInt(gasPrice.toString()) * 125n) / 100n}`;
+            }
+        }
         route.steps[index].estimate.gasCosts?.forEach((gasCost) => (gasCost.price = `${Math.round(Number(gasCost.price) * 1.25)}`));
     }
 };

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 export declare const name = "@lifi/sdk";
-export declare const version = "2.0.0-beta.8";
+export declare const version = "2.0.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 export const name = '@lifi/sdk';
-export const version = '2.0.0-beta.8';
+export const version = '2.0.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifi/sdk",
-  "version": "2.0.0-beta.8",
+  "version": "2.0.0",
   "description": "LI.FI Any-to-Any Cross-Chain-Swap SDK",
   "main": "./dist/cjs/index.js",
   "module": "./dist/index.js",
@@ -76,34 +76,34 @@
   "dependencies": {
     "@ethersproject/abi": "^5.7.0",
     "@ethersproject/contracts": "^5.7.0",
-    "@lifi/types": "^3.2.1",
+    "@lifi/types": "^6.0.0",
     "bignumber.js": "^9.1.1",
     "eth-rpc-errors": "^4.0.3",
     "ethers": "^5.7.2"
   },
   "devDependencies": {
-    "@commitlint/cli": "^17.5.1",
-    "@commitlint/config-conventional": "^17.4.4",
-    "@typescript-eslint/eslint-plugin": "^5.58.0",
-    "@typescript-eslint/parser": "^5.58.0",
-    "@vitest/coverage-c8": "^0.30.0",
-    "cross-fetch": "^3.1.5",
-    "eslint": "^8.38.0",
+    "@commitlint/cli": "^17.6.5",
+    "@commitlint/config-conventional": "^17.6.5",
+    "@mswjs/interceptors": "^0.22.15",
+    "@typescript-eslint/eslint-plugin": "^5.59.9",
+    "@typescript-eslint/parser": "^5.59.9",
+    "@vitest/coverage-c8": "^0.32.0",
+    "cross-fetch": "^3.1.6",
+    "eslint": "^8.42.0",
     "eslint-config-prettier": "^8.8.0",
     "eslint-plugin-prettier": "^4.2.1",
     "husky": "^8.0.3",
-    "lint-staged": "^13.2.1",
+    "lint-staged": "^13.2.2",
     "msw": "1.0.1",
     "npm-run-all": "^4.1.5",
     "pinst": "^3.0.0",
-    "prettier": "^2.8.7",
+    "prettier": "^2.8.8",
     "standard-version": "^9.5.0",
-    "ts-loader": "^9.4.2",
-    "typescript": "^5.0.4",
-    "vitest": "^0.30.0"
+    "typescript": "^5.1.3",
+    "vitest": "^0.32.0"
   },
   "directories": {
     "test": "test"
   },
-  "packageManager": "yarn@3.5.0"
+  "packageManager": "yarn@3.5.1"
 }

package/dist/cjs/services/ApiService.unit.handlers.d.ts

@@ -1 +0,0 @@
-export declare const handlers: import("msw").RestHandler<import("msw/lib/glossary-de6278a9").M<import("msw/lib/glossary-de6278a9").h>>[];

package/dist/cjs/services/ApiService.unit.handlers.js

@@ -1,50 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handlers = void 0;
-const types_1 = require("@lifi/types");
-const msw_1 = require("msw");
-const ConfigService_1 = __importDefault(require("./ConfigService"));
-const config = ConfigService_1.default.getInstance().getConfig();
-exports.handlers = [
-    msw_1.rest.post(`${config.apiUrl}/advanced/routes`, async (request, response, context) => {
-        const data = await request.json();
-        if (isNaN(parseFloat(data.fromAmount))) {
-            return response(context.status(500), context.json({ message: `Oops` }));
-        }
-        return response(context.json({}));
-    }),
-    msw_1.rest.post(`${config.apiUrl}/advanced/possibilities`, async (request, response, context) => {
-        return response(context.json({}));
-    }),
-    msw_1.rest.get(`${config.apiUrl}/token`, async (request, response, context) => {
-        return response(context.json({}));
-    }),
-    msw_1.rest.get(`${config.apiUrl}/quote`, async (request, response, context) => {
-        return response(context.json({}));
-    }),
-    msw_1.rest.get(`${config.apiUrl}/status`, async (request, response, context) => {
-        return response(context.json({}));
-    }),
-    msw_1.rest.get(`${config.apiUrl}/chains`, async (request, response, context) => {
-        return response(context.json({ chains: [{ id: 1 }] }));
-    }),
-    msw_1.rest.get(`${config.apiUrl}/tools`, async (request, response, context) => {
-        return response(context.json({ bridges: [], exchanges: [] }));
-    }),
-    msw_1.rest.get(`${config.apiUrl}/tokens`, async (request, response, context) => {
-        return response(context.json({
-            tokens: {
-                [types_1.ChainId.ETH]: [(0, types_1.findDefaultToken)(types_1.CoinKey.ETH, types_1.ChainId.ETH)],
-            },
-        }));
-    }),
-    msw_1.rest.post(`${config.apiUrl}/advanced/stepTransaction`, async (request, response, context) => {
-        return response(context.json({}));
-    }),
-    msw_1.rest.get(`${config.apiUrl}/gas/suggestion/${types_1.ChainId.OPT}`, async (request, response, context) => {
-        return response(context.json({}));
-    }),
-];

package/dist/services/ApiService.unit.handlers.d.ts

@@ -1 +0,0 @@
-export declare const handlers: import("msw").RestHandler<import("msw/lib/glossary-de6278a9").M<import("msw/lib/glossary-de6278a9").h>>[];

package/dist/services/ApiService.unit.handlers.js

@@ -1,44 +0,0 @@
-import { ChainId, CoinKey, findDefaultToken } from '@lifi/types';
-import { rest } from 'msw';
-import ConfigService from './ConfigService';
-const config = ConfigService.getInstance().getConfig();
-export const handlers = [
-    rest.post(`${config.apiUrl}/advanced/routes`, async (request, response, context) => {
-        const data = await request.json();
-        if (isNaN(parseFloat(data.fromAmount))) {
-            return response(context.status(500), context.json({ message: `Oops` }));
-        }
-        return response(context.json({}));
-    }),
-    rest.post(`${config.apiUrl}/advanced/possibilities`, async (request, response, context) => {
-        return response(context.json({}));
-    }),
-    rest.get(`${config.apiUrl}/token`, async (request, response, context) => {
-        return response(context.json({}));
-    }),
-    rest.get(`${config.apiUrl}/quote`, async (request, response, context) => {
-        return response(context.json({}));
-    }),
-    rest.get(`${config.apiUrl}/status`, async (request, response, context) => {
-        return response(context.json({}));
-    }),
-    rest.get(`${config.apiUrl}/chains`, async (request, response, context) => {
-        return response(context.json({ chains: [{ id: 1 }] }));
-    }),
-    rest.get(`${config.apiUrl}/tools`, async (request, response, context) => {
-        return response(context.json({ bridges: [], exchanges: [] }));
-    }),
-    rest.get(`${config.apiUrl}/tokens`, async (request, response, context) => {
-        return response(context.json({
-            tokens: {
-                [ChainId.ETH]: [findDefaultToken(CoinKey.ETH, ChainId.ETH)],
-            },
-        }));
-    }),
-    rest.post(`${config.apiUrl}/advanced/stepTransaction`, async (request, response, context) => {
-        return response(context.json({}));
-    }),
-    rest.get(`${config.apiUrl}/gas/suggestion/${ChainId.OPT}`, async (request, response, context) => {
-        return response(context.json({}));
-    }),
-];