@lifi/sdk 2.0.0-beta.13 → 2.0.0-beta.14

package/dist/cjs/{execution → src/execution}/RouteExecutionManager.js

@@ -56,7 +56,7 @@ class RouteExecutionManager {
                     return executionPromise ?? clonedRoute;
                 }
             }
-            (0, preRestart_1.handlePreRestart)(clonedRoute);
+            await (0, preRestart_1.handlePreRestart)(clonedRoute, signer);
             const executionPromise = this.executeSteps(signer, clonedRoute, settings);
             this.executionPromiseDictionary[clonedRoute.id] = executionPromise;
             return executionPromise;

package/dist/cjs/src/execution/RouteExecutionManager.unit.handlers.d.ts

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

package/dist/cjs/src/execution/RouteExecutionManager.unit.handlers.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lifiHandlers = void 0;
+const msw_1 = require("msw");
+const RouteExecutionManager_unit_mock_1 = require("./RouteExecutionManager.unit.mock");
+const ConfigService_1 = __importDefault(require("../services/ConfigService"));
+const fixtures_1 = require("../../test/fixtures");
+const config = ConfigService_1.default.getInstance().getConfig();
+exports.lifiHandlers = [
+    msw_1.rest.post(`${config.apiUrl}/advanced/stepTransaction`, async (_, response, context) => response(context.status(200), context.json((0, RouteExecutionManager_unit_mock_1.mockStepTransactionWithTxRequest)((0, fixtures_1.buildStepObject)({
+        includingExecution: true,
+    }))))),
+    msw_1.rest.get(`${config.apiUrl}/chains`, async (_, response, context) => response(context.status(200), context.json({
+        chains: RouteExecutionManager_unit_mock_1.mockChainsResponse,
+    }))),
+    msw_1.rest.get(`${config.apiUrl}/status`, async (_, response, context) => response(context.status(200), context.json(RouteExecutionManager_unit_mock_1.mockStatus))),
+];

package/dist/cjs/src/execution/RouteExecutionManager.unit.mock.d.ts

@@ -0,0 +1,80 @@
+import { LifiStep } from '@lifi/types';
+export declare const mockChainsResponse: {
+    key: string;
+    chainType: string;
+    name: string;
+    coin: string;
+    id: number;
+    mainnet: boolean;
+    logoURI: string;
+    tokenlistUrl: string;
+    faucetUrls: string[];
+    multicallAddress: string;
+    metamask: {
+        chainId: string;
+        blockExplorerUrls: string[];
+        chainName: string;
+        nativeCurrency: {
+            name: string;
+            symbol: string;
+            decimals: number;
+        };
+        rpcUrls: string[];
+    };
+    nativeToken: {
+        address: string;
+        chainId: number;
+        symbol: string;
+        decimals: number;
+        name: string;
+        priceUSD: string;
+        logoURI: string;
+        coinKey: string;
+    };
+}[];
+export declare const mockTransactionRequest: {
+    transactionRequest: {
+        data: string;
+        to: string;
+        value: string;
+        from: string;
+        chainId: number;
+        gasPrice: string;
+        gasLimit: string;
+    };
+};
+export declare const mockStatus: {
+    status: string;
+    receiving: boolean;
+    sending: {
+        amount: string;
+        gasAmount: string;
+        gasAmountUSD: string;
+        gasPrice: string;
+        gasToken: string;
+        gasUsed: string;
+    };
+};
+export declare const mockStepTransactionWithTxRequest: (step?: LifiStep) => {
+    transactionRequest: {
+        transactionRequest: {
+            data: string;
+            to: string;
+            value: string;
+            from: string;
+            chainId: number;
+            gasPrice: string;
+            gasLimit: string;
+        };
+    };
+    type: "lifi";
+    includedSteps: import("@lifi/types").Step[];
+    id: string;
+    referrer?: string | undefined;
+    action: import("@lifi/types").Action | import("@lifi/types").CallAction;
+    estimate: import("@lifi/types").Estimate;
+    tool: string;
+    toolDetails: Pick<import("@lifi/types").Bridge | import("@lifi/types").ExchangeAggregator | import("@lifi/types").Exchange, "key" | "name" | "logoURI">;
+    integrator?: string | undefined;
+    execution?: import("@lifi/types").Execution | undefined;
+};

package/dist/cjs/src/execution/RouteExecutionManager.unit.mock.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockStepTransactionWithTxRequest = exports.mockStatus = exports.mockTransactionRequest = exports.mockChainsResponse = void 0;
+const fixtures_1 = require("../../test/fixtures");
+exports.mockChainsResponse = [
+    {
+        key: 'pol',
+        chainType: 'EVM',
+        name: 'Polygon',
+        coin: 'MATIC',
+        id: 137,
+        mainnet: true,
+        logoURI: 'https://raw.githubusercontent.com/lifinance/types/main/src/assets/icons/chains/polygon.svg',
+        tokenlistUrl: 'https://unpkg.com/quickswap-default-token-list@1.0.71/build/quickswap-default.tokenlist.json',
+        faucetUrls: ['https://stakely.io/faucet/polygon-matic'],
+        multicallAddress: '0xcA11bde05977b3631167028862bE2a173976CA11',
+        metamask: {
+            chainId: '0x89',
+            blockExplorerUrls: [
+                'https://polygonscan.com/',
+                'https://explorer-mainnet.maticvigil.com/',
+            ],
+            chainName: 'Matic(Polygon) Mainnet',
+            nativeCurrency: {
+                name: 'MATIC',
+                symbol: 'MATIC',
+                decimals: 18,
+            },
+            rpcUrls: [
+                'https://polygon-rpc.com/',
+                'https://rpc-mainnet.maticvigil.com/',
+            ],
+        },
+        nativeToken: {
+            address: '0x0000000000000000000000000000000000000000',
+            chainId: 137,
+            symbol: 'MATIC',
+            decimals: 18,
+            name: 'MATIC',
+            priceUSD: '0.899628',
+            logoURI: 'https://static.debank.com/image/matic_token/logo_url/matic/6f5a6b6f0732a7a235131bd7804d357c.png',
+            coinKey: 'MATIC',
+        },
+    },
+];
+exports.mockTransactionRequest = {
+    transactionRequest: {
+        // eslint-disable-next-line max-len
+        data: '0xdata',
+        to: '0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE',
+        value: '0x0600830dbc7f5bf7',
+        from: '0x552008c0f6870c2f77e5cC1d2eb9bdff03e30Ea0',
+        chainId: 137,
+        gasPrice: '0x27c01c1727',
+        gasLimit: '682701',
+    },
+};
+exports.mockStatus = {
+    status: 'DONE',
+    receiving: true,
+    sending: {
+        amount: '123',
+        gasAmount: '123',
+        gasAmountUSD: '123',
+        gasPrice: '123',
+        gasToken: '123',
+        gasUsed: '123',
+    },
+};
+const mockStepTransactionWithTxRequest = (step = (0, fixtures_1.buildStepObject)({
+    includingExecution: false,
+})) => ({
+    ...step,
+    transactionRequest: exports.mockTransactionRequest,
+});
+exports.mockStepTransactionWithTxRequest = mockStepTransactionWithTxRequest;

package/dist/cjs/{execution → src/execution}/StepExecutionManager.js

@@ -89,6 +89,12 @@ class StepExecutionManager {
                                 customConfig.maxPriorityFeePerGas;
                             transactionRequest.maxFeePerGas = customConfig.maxFeePerGas;
                         }
+                        else {
+                            const estimatedGasLimit = await signer.estimateGas(transactionRequest);
+                            if (estimatedGasLimit) {
+                                transactionRequest.gasLimit = `${(BigInt(estimatedGasLimit.toString()) * 125n) / 100n}`;
+                            }
+                        }
                         // Submit the transaction
                         transaction = await signer.sendTransaction(transactionRequest);
                         // STEP 4: Wait for the transaction

package/dist/cjs/src/utils/preRestart.d.ts

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

package/dist/cjs/{utils → src/utils}/preRestart.js

@@ -2,21 +2,32 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handlePreRestart = void 0;
 const errors_1 = require("./errors");
-const handlePreRestart = (route) => {
+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);
         }
     }
 };
 exports.handlePreRestart = handlePreRestart;
-const handleErrorType = (route, index) => {
+const handleErrorType = async (route, index, signer) => {
     const isGasLimitError = route.steps[index].execution?.process.some((p) => p.error?.code === errors_1.LifiErrorCode.GasLimitError);
     const isGasPriceError = route.steps[index].execution?.process.some((p) => p.error?.code === errors_1.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) {

package/dist/cjs/src/version.d.ts

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

package/dist/cjs/{version.js → src/version.js}

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = exports.name = void 0;
 exports.name = '@lifi/sdk';
-exports.version = '2.0.0-beta.13';
+exports.version = '2.0.0-beta.14';

package/dist/cjs/test/fixtures.d.ts

@@ -0,0 +1,7 @@
+import { LifiStep, Route } from '@lifi/types';
+export declare const buildStepObject: ({ includingExecution, }: {
+    includingExecution?: boolean | undefined;
+}) => LifiStep;
+export declare const buildRouteObject: ({ step, }: {
+    step?: LifiStep | undefined;
+}) => Route;

package/dist/cjs/test/fixtures.js

@@ -0,0 +1,157 @@
+"use strict";
+// This file holds generator functions to create objects for testing purposes
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRouteObject = exports.buildStepObject = void 0;
+const types_1 = require("@lifi/types");
+const SOME_TOKEN = {
+    ...(0, types_1.findDefaultToken)(types_1.CoinKey.USDC, types_1.ChainId.DAI),
+    priceUSD: '',
+};
+const SOME_OTHER_TOKEN = {
+    ...(0, types_1.findDefaultToken)(types_1.CoinKey.USDT, types_1.ChainId.DAI),
+    priceUSD: '',
+};
+const SOME_DATE = new Date('2021-04-10').getTime();
+const buildStepObject = ({ includingExecution = true, }) => ({
+    id: '8d3a0474-4ee3-4a7a-90c7-2a2264b7f3a9',
+    type: 'lifi',
+    tool: '1inch',
+    toolDetails: {
+        key: '1inch',
+        name: '1inch',
+        logoURI: 'https://raw.githubusercontent.com/lifinance/types/main/src/assets/icons/exchanges/oneinch.png',
+    },
+    action: {
+        fromChainId: 137,
+        toChainId: 137,
+        fromToken: SOME_TOKEN,
+        toToken: SOME_OTHER_TOKEN,
+        fromAmount: '1000000',
+        slippage: 0.03,
+        fromAddress: '0x552008c0f6870c2f77e5cC1d2eb9bdff03e30Ea0',
+        toAddress: '0x552008c0f6870c2f77e5cC1d2eb9bdff03e30Ea0',
+    },
+    estimate: {
+        fromAmount: '1000000',
+        fromAmountUSD: '100',
+        toAmount: '260982615655554',
+        toAmountUSD: '26098',
+        toAmountMin: '253153137185887',
+        approvalAddress: '0x11111112542d85b3ef69ae05771c2dccff4faa26',
+        executionDuration: 300,
+        tool: '1inch',
+    },
+    includedSteps: [
+        {
+            id: 'f8474598-a553-4643-bbd1-bf8c77e679b3',
+            type: 'swap',
+            action: {
+                fromChainId: 137,
+                fromAmount: '5000000000000000000',
+                fromToken: {
+                    address: '0x0000000000000000000000000000000000000000',
+                    chainId: 137,
+                    symbol: 'MATIC',
+                    decimals: 18,
+                    name: 'MATIC',
+                    priceUSD: '1.124763',
+                    logoURI: 'https://static.debank.com/image/matic_token/logo_url/matic/6f5a6b6f0732a7a235131bd7804d357c.png',
+                    coinKey: types_1.CoinKey.MATIC,
+                },
+                toChainId: 137,
+                toToken: {
+                    address: '0xc2132d05d31c914a87c6611c10748aeb04b58e8f',
+                    chainId: 137,
+                    symbol: 'USDT',
+                    decimals: 6,
+                    name: '(PoS) Tether USD',
+                    priceUSD: '1.00081',
+                    logoURI: 'https://static.debank.com/image/coin/logo_url/usdt/23af7472292cb41dc39b3f1146ead0fe.png',
+                    coinKey: types_1.CoinKey.USDT,
+                },
+                slippage: 0.005,
+            },
+            estimate: {
+                tool: '1inch',
+                fromAmount: '5000000000000000000',
+                toAmount: '5617317',
+                toAmountMin: '5589230',
+                approvalAddress: '0x1111111254eeb25477b68fb85ed929f73a960582',
+                executionDuration: 30,
+                feeCosts: [],
+                gasCosts: [
+                    {
+                        type: 'SEND',
+                        price: '149725515512',
+                        estimate: '258059',
+                        limit: '344079',
+                        amount: '51517405651853448',
+                        amountUSD: '0.06',
+                        token: {
+                            address: '0x0000000000000000000000000000000000000000',
+                            chainId: 137,
+                            symbol: 'MATIC',
+                            decimals: 18,
+                            name: 'MATIC',
+                            priceUSD: '1.124763',
+                            logoURI: 'https://static.debank.com/image/matic_token/logo_url/matic/6f5a6b6f0732a7a235131bd7804d357c.png',
+                            coinKey: types_1.CoinKey.MATIC,
+                        },
+                    },
+                ],
+            },
+            tool: '1inch',
+            toolDetails: {
+                key: '1inch',
+                name: '1inch',
+                logoURI: 'https://raw.githubusercontent.com/lifinance/types/main/src/assets/icons/exchanges/oneinch.png',
+            },
+        },
+    ],
+    execution: includingExecution
+        ? {
+            status: 'PENDING',
+            process: [
+                {
+                    type: 'TOKEN_ALLOWANCE',
+                    startedAt: SOME_DATE,
+                    message: 'Somethings done',
+                    status: 'DONE',
+                    doneAt: SOME_DATE + 10,
+                    txHash: '0x11111112542d85b3ef69ae05771c2dccff4faa26',
+                    txLink: 'https://example.com',
+                },
+                {
+                    type: 'SWAP',
+                    startedAt: SOME_DATE + 20,
+                    message: 'Somethings pending',
+                    status: 'PENDING',
+                },
+            ],
+            fromAmount: '1000000',
+            toAmount: '261490494702370',
+        }
+        : undefined,
+});
+exports.buildStepObject = buildStepObject;
+const buildRouteObject = ({ step = (0, exports.buildStepObject)({}), }) => ({
+    id: '0x433df53dbf6dbd7b946fc4f3b501c3ff32957d77d96c9d5ba1805b01eb6461cc',
+    fromChainId: 137,
+    fromAmountUSD: '1.00',
+    fromAmount: '1000000',
+    fromToken: SOME_TOKEN,
+    fromAddress: '0x552008c0f6870c2f77e5cC1d2eb9bdff03e30Ea0',
+    toChainId: 137,
+    toAmountUSD: '1.00',
+    toAmount: '260982615655554',
+    toAmountMin: '253153137185887',
+    toToken: SOME_OTHER_TOKEN,
+    toAddress: '0x552008c0f6870c2f77e5cC1d2eb9bdff03e30Ea0',
+    gasCostUSD: '0.01',
+    steps: [step],
+    insurance: {
+        feeAmountUsd: '0',
+        state: 'NOT_INSURABLE',
+    },
+});
+exports.buildRouteObject = buildRouteObject;

package/dist/{execution → src/execution}/RouteExecutionManager.js

@@ -50,7 +50,7 @@ export class RouteExecutionManager {
                     return executionPromise ?? clonedRoute;
                 }
             }
-            handlePreRestart(clonedRoute);
+            await handlePreRestart(clonedRoute, signer);
             const executionPromise = this.executeSteps(signer, clonedRoute, settings);
             this.executionPromiseDictionary[clonedRoute.id] = executionPromise;
             return executionPromise;

package/dist/src/execution/RouteExecutionManager.unit.handlers.d.ts

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

package/dist/src/execution/RouteExecutionManager.unit.handlers.js

@@ -0,0 +1,14 @@
+import { rest } from 'msw';
+import { mockStepTransactionWithTxRequest, mockChainsResponse, mockStatus, } from './RouteExecutionManager.unit.mock';
+import ConfigService from '../services/ConfigService';
+import { buildStepObject } from '../../test/fixtures';
+const config = ConfigService.getInstance().getConfig();
+export const lifiHandlers = [
+    rest.post(`${config.apiUrl}/advanced/stepTransaction`, async (_, response, context) => response(context.status(200), context.json(mockStepTransactionWithTxRequest(buildStepObject({
+        includingExecution: true,
+    }))))),
+    rest.get(`${config.apiUrl}/chains`, async (_, response, context) => response(context.status(200), context.json({
+        chains: mockChainsResponse,
+    }))),
+    rest.get(`${config.apiUrl}/status`, async (_, response, context) => response(context.status(200), context.json(mockStatus))),
+];

package/dist/src/execution/RouteExecutionManager.unit.mock.d.ts

@@ -0,0 +1,80 @@
+import { LifiStep } from '@lifi/types';
+export declare const mockChainsResponse: {
+    key: string;
+    chainType: string;
+    name: string;
+    coin: string;
+    id: number;
+    mainnet: boolean;
+    logoURI: string;
+    tokenlistUrl: string;
+    faucetUrls: string[];
+    multicallAddress: string;
+    metamask: {
+        chainId: string;
+        blockExplorerUrls: string[];
+        chainName: string;
+        nativeCurrency: {
+            name: string;
+            symbol: string;
+            decimals: number;
+        };
+        rpcUrls: string[];
+    };
+    nativeToken: {
+        address: string;
+        chainId: number;
+        symbol: string;
+        decimals: number;
+        name: string;
+        priceUSD: string;
+        logoURI: string;
+        coinKey: string;
+    };
+}[];
+export declare const mockTransactionRequest: {
+    transactionRequest: {
+        data: string;
+        to: string;
+        value: string;
+        from: string;
+        chainId: number;
+        gasPrice: string;
+        gasLimit: string;
+    };
+};
+export declare const mockStatus: {
+    status: string;
+    receiving: boolean;
+    sending: {
+        amount: string;
+        gasAmount: string;
+        gasAmountUSD: string;
+        gasPrice: string;
+        gasToken: string;
+        gasUsed: string;
+    };
+};
+export declare const mockStepTransactionWithTxRequest: (step?: LifiStep) => {
+    transactionRequest: {
+        transactionRequest: {
+            data: string;
+            to: string;
+            value: string;
+            from: string;
+            chainId: number;
+            gasPrice: string;
+            gasLimit: string;
+        };
+    };
+    type: "lifi";
+    includedSteps: import("@lifi/types").Step[];
+    id: string;
+    referrer?: string | undefined;
+    action: import("@lifi/types").Action | import("@lifi/types").CallAction;
+    estimate: import("@lifi/types").Estimate;
+    tool: string;
+    toolDetails: Pick<import("@lifi/types").Bridge | import("@lifi/types").ExchangeAggregator | import("@lifi/types").Exchange, "key" | "name" | "logoURI">;
+    integrator?: string | undefined;
+    execution?: import("@lifi/types").Execution | undefined;
+};

package/dist/src/execution/RouteExecutionManager.unit.mock.js

@@ -0,0 +1,72 @@
+import { buildStepObject } from '../../test/fixtures';
+export const mockChainsResponse = [
+    {
+        key: 'pol',
+        chainType: 'EVM',
+        name: 'Polygon',
+        coin: 'MATIC',
+        id: 137,
+        mainnet: true,
+        logoURI: 'https://raw.githubusercontent.com/lifinance/types/main/src/assets/icons/chains/polygon.svg',
+        tokenlistUrl: 'https://unpkg.com/quickswap-default-token-list@1.0.71/build/quickswap-default.tokenlist.json',
+        faucetUrls: ['https://stakely.io/faucet/polygon-matic'],
+        multicallAddress: '0xcA11bde05977b3631167028862bE2a173976CA11',
+        metamask: {
+            chainId: '0x89',
+            blockExplorerUrls: [
+                'https://polygonscan.com/',
+                'https://explorer-mainnet.maticvigil.com/',
+            ],
+            chainName: 'Matic(Polygon) Mainnet',
+            nativeCurrency: {
+                name: 'MATIC',
+                symbol: 'MATIC',
+                decimals: 18,
+            },
+            rpcUrls: [
+                'https://polygon-rpc.com/',
+                'https://rpc-mainnet.maticvigil.com/',
+            ],
+        },
+        nativeToken: {
+            address: '0x0000000000000000000000000000000000000000',
+            chainId: 137,
+            symbol: 'MATIC',
+            decimals: 18,
+            name: 'MATIC',
+            priceUSD: '0.899628',
+            logoURI: 'https://static.debank.com/image/matic_token/logo_url/matic/6f5a6b6f0732a7a235131bd7804d357c.png',
+            coinKey: 'MATIC',
+        },
+    },
+];
+export const mockTransactionRequest = {
+    transactionRequest: {
+        // eslint-disable-next-line max-len
+        data: '0xdata',
+        to: '0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE',
+        value: '0x0600830dbc7f5bf7',
+        from: '0x552008c0f6870c2f77e5cC1d2eb9bdff03e30Ea0',
+        chainId: 137,
+        gasPrice: '0x27c01c1727',
+        gasLimit: '682701',
+    },
+};
+export const mockStatus = {
+    status: 'DONE',
+    receiving: true,
+    sending: {
+        amount: '123',
+        gasAmount: '123',
+        gasAmountUSD: '123',
+        gasPrice: '123',
+        gasToken: '123',
+        gasUsed: '123',
+    },
+};
+export const mockStepTransactionWithTxRequest = (step = buildStepObject({
+    includingExecution: false,
+})) => ({
+    ...step,
+    transactionRequest: mockTransactionRequest,
+});

package/dist/{execution → src/execution}/StepExecutionManager.js

@@ -83,6 +83,12 @@ export class StepExecutionManager {
                                 customConfig.maxPriorityFeePerGas;
                             transactionRequest.maxFeePerGas = customConfig.maxFeePerGas;
                         }
+                        else {
+                            const estimatedGasLimit = await signer.estimateGas(transactionRequest);
+                            if (estimatedGasLimit) {
+                                transactionRequest.gasLimit = `${(BigInt(estimatedGasLimit.toString()) * 125n) / 100n}`;
+                            }
+                        }
                         // Submit the transaction
                         transaction = await signer.sendTransaction(transactionRequest);
                         // STEP 4: Wait for the transaction

package/dist/src/utils/preRestart.d.ts

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

package/dist/{utils → src/utils}/preRestart.js

@@ -1,18 +1,29 @@
 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) {

package/dist/src/version.d.ts

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

package/dist/src/version.js

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