@lifi/sdk 2.0.0-beta.8 → 2.0.0

package/dist/LiFi.d.ts

@@ -6,7 +6,7 @@ import { RouteExecutionManager } from './execution/RouteExecutionManager';
 import { Config, ConfigUpdate, RevokeTokenData } from './types';
 export declare class LiFi extends RouteExecutionManager {
     private chainsService;
-    constructor(configUpdate?: ConfigUpdate);
+    constructor(configUpdate: ConfigUpdate);
     /**
      * Get the current configuration of the SDK
      * @return {Config} - The config object
@@ -18,7 +18,7 @@ export declare class LiFi extends RouteExecutionManager {
      */
     getConfigAsync: () => Promise<Config>;
     /**
-     * Get an instance of a provider for a specific cahin
+     * Get an instance of a provider for a specific chain
      * @param {number} chainId - Id of the chain the provider is for
      * @param {boolean} archive - Whether to use an archive provider that is based on a default rpc or not. defaults to false
      * @return {FallbackProvider} The provider for the given chain
@@ -29,7 +29,7 @@ export declare class LiFi extends RouteExecutionManager {
      * @param {ConfigUpdate} configUpdate - An object containing the configuration fields that should be updated.
      * @return {Config} The renewed config object
      */
-    setConfig: (configUpdate: ConfigUpdate) => Config;
+    setConfig: (configUpdate: Partial<ConfigUpdate>) => Config;
     /**
      * Get a set of current possibilities based on a request that specifies which chains, exchanges and bridges are preferred or unwanted.
      * @param {PossibilitiesRequest} request - Object defining preferences regarding chain, exchanges and bridges
@@ -154,10 +154,10 @@ export declare class LiFi extends RouteExecutionManager {
      * @param { RevokeApprovalRequest } request - The revoke request
      */
     revokeTokenApproval: (request: RevokeApprovalRequest) => Promise<void>;
+    /**
+     * Get all the available connections for swap/bridging tokens
+     * @param connectionRequest ConnectionsRequest
+     * @returns ConnectionsResponse
+     */
+    getConnections: (connectionRequest: ConnectionsRequest) => Promise<ConnectionsResponse>;
 }
-/**
- * Get all the available connections for swap/bridging tokens
- * @param connectionRequest ConnectionsRequest
- * @returns ConnectionsResponse
- */
-export declare const getConnections: (connectionRequest: ConnectionsRequest) => Promise<ConnectionsResponse>;

package/dist/LiFi.js

@@ -26,7 +26,7 @@ export class LiFi extends RouteExecutionManager {
             return this.configService.getConfigAsync();
         };
         /**
-         * Get an instance of a provider for a specific cahin
+         * Get an instance of a provider for a specific chain
          * @param {number} chainId - Id of the chain the provider is for
          * @param {boolean} archive - Whether to use an archive provider that is based on a default rpc or not. defaults to false
          * @return {FallbackProvider} The provider for the given chain
@@ -216,19 +216,19 @@ export class LiFi extends RouteExecutionManager {
         this.revokeTokenApproval = (request) => {
             return revokeTokenApproval(request);
         };
+        /**
+         * Get all the available connections for swap/bridging tokens
+         * @param connectionRequest ConnectionsRequest
+         * @returns ConnectionsResponse
+         */
+        this.getConnections = async (connectionRequest) => {
+            const connections = await ApiService.getAvailableConnections(connectionRequest);
+            return connections;
+        };
         this.chainsService = ChainsService.getInstance();
         this.chainsService.getChains().then((chains) => {
             this.configService.updateChains(chains);
         });
-        checkPackageUpdates(name, version, configUpdate?.disableVersionCheck);
+        checkPackageUpdates(name, version, configUpdate.disableVersionCheck);
     }
 }
-/**
- * Get all the available connections for swap/bridging tokens
- * @param connectionRequest ConnectionsRequest
- * @returns ConnectionsResponse
- */
-export const getConnections = async (connectionRequest) => {
-    const connections = await ApiService.getAvailableConnections(connectionRequest);
-    return connections;
-};

package/dist/allowance/checkAllowance.js

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
 import BigNumber from 'bignumber.js';
 import { constants } from 'ethers';
 import { getApproved, setApproval } from '../allowance/utils';
@@ -17,7 +16,24 @@ export const checkAllowance = async (signer, step, statusManager, settings, chai
             allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
         }
         else {
-            const approved = await getApproved(signer, step.action.fromToken.address, step.estimate.approvalAddress);
+            const approvalRequest = {
+                from: step.action.fromToken.address,
+                to: step.estimate.approvalAddress,
+            };
+            if (settings.updateTransactionRequestHook) {
+                const config = await settings.updateTransactionRequestHook(approvalRequest);
+                approvalRequest.gasLimit = config.gasLimit;
+                approvalRequest.gasPrice = config.gasPrice;
+                approvalRequest.maxFeePerGas = config.maxFeePerGas;
+                approvalRequest.maxPriorityFeePerGas = config.maxPriorityFeePerGas;
+            }
+            if (!approvalRequest.from) {
+                throw new Error('Missing Signer address');
+            }
+            if (!approvalRequest.to) {
+                throw new Error('Missing ERC20 contract address');
+            }
+            const approved = await getApproved(signer, approvalRequest.from, approvalRequest.to, approvalRequest);
             if (new BigNumber(step.action.fromAmount).gt(approved)) {
                 if (!allowUserInteraction) {
                     return;

package/dist/allowance/utils.d.ts

@@ -1,8 +1,9 @@
+import { TransactionRequest } from '@ethersproject/abstract-provider';
 import { ChainId, Token } from '@lifi/types';
 import BigNumber from 'bignumber.js';
 import { ContractTransaction, Signer } from 'ethers';
 import { RevokeTokenData } from '../types';
-export declare const getApproved: (signer: Signer, tokenAddress: string, contractAddress: string) => Promise<BigNumber>;
+export declare const getApproved: (signer: Signer, tokenAddress: string, contractAddress: string, transactionRequest?: TransactionRequest) => Promise<BigNumber>;
 export declare const setApproval: (signer: Signer, tokenAddress: string, contractAddress: string, amount: string) => Promise<ContractTransaction>;
 export declare const getAllowanceViaMulticall: (signer: Signer, chainId: ChainId, tokenData: RevokeTokenData[]) => Promise<{
     token: Token;

package/dist/allowance/utils.js

@@ -4,11 +4,16 @@ import ChainsService from '../services/ChainsService';
 import { ERC20_ABI } from '../types';
 import { ServerError } from '../utils/errors';
 import { fetchDataUsingMulticall } from '../utils/multicall';
-export const getApproved = async (signer, tokenAddress, contractAddress) => {
+export const getApproved = async (signer, tokenAddress, contractAddress, transactionRequest) => {
     const signerAddress = await signer.getAddress();
     const erc20 = new Contract(tokenAddress, ERC20_ABI, signer);
     try {
-        const approved = await erc20.allowance(signerAddress, contractAddress);
+        const approved = await erc20.allowance(signerAddress, contractAddress, {
+            gasLimit: transactionRequest?.gasLimit,
+            gasPrice: transactionRequest?.gasPrice,
+            maxFeePerGas: transactionRequest?.maxFeePerGas,
+            maxPriorityFeePerGas: transactionRequest?.maxPriorityFeePerGas,
+        });
         return new BigNumber(approved.toString());
     }
     catch (e) {

package/dist/cjs/LiFi.d.ts

@@ -6,7 +6,7 @@ import { RouteExecutionManager } from './execution/RouteExecutionManager';
 import { Config, ConfigUpdate, RevokeTokenData } from './types';
 export declare class LiFi extends RouteExecutionManager {
     private chainsService;
-    constructor(configUpdate?: ConfigUpdate);
+    constructor(configUpdate: ConfigUpdate);
     /**
      * Get the current configuration of the SDK
      * @return {Config} - The config object
@@ -18,7 +18,7 @@ export declare class LiFi extends RouteExecutionManager {
      */
     getConfigAsync: () => Promise<Config>;
     /**
-     * Get an instance of a provider for a specific cahin
+     * Get an instance of a provider for a specific chain
      * @param {number} chainId - Id of the chain the provider is for
      * @param {boolean} archive - Whether to use an archive provider that is based on a default rpc or not. defaults to false
      * @return {FallbackProvider} The provider for the given chain
@@ -29,7 +29,7 @@ export declare class LiFi extends RouteExecutionManager {
      * @param {ConfigUpdate} configUpdate - An object containing the configuration fields that should be updated.
      * @return {Config} The renewed config object
      */
-    setConfig: (configUpdate: ConfigUpdate) => Config;
+    setConfig: (configUpdate: Partial<ConfigUpdate>) => Config;
     /**
      * Get a set of current possibilities based on a request that specifies which chains, exchanges and bridges are preferred or unwanted.
      * @param {PossibilitiesRequest} request - Object defining preferences regarding chain, exchanges and bridges
@@ -154,10 +154,10 @@ export declare class LiFi extends RouteExecutionManager {
      * @param { RevokeApprovalRequest } request - The revoke request
      */
     revokeTokenApproval: (request: RevokeApprovalRequest) => Promise<void>;
+    /**
+     * Get all the available connections for swap/bridging tokens
+     * @param connectionRequest ConnectionsRequest
+     * @returns ConnectionsResponse
+     */
+    getConnections: (connectionRequest: ConnectionsRequest) => Promise<ConnectionsResponse>;
 }
-/**
- * Get all the available connections for swap/bridging tokens
- * @param connectionRequest ConnectionsRequest
- * @returns ConnectionsResponse
- */
-export declare const getConnections: (connectionRequest: ConnectionsRequest) => Promise<ConnectionsResponse>;

package/dist/cjs/LiFi.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConnections = exports.LiFi = void 0;
+exports.LiFi = void 0;
 const allowance_1 = require("./allowance");
 const balance = __importStar(require("./balance"));
 const connectors_1 = require("./connectors");
@@ -55,7 +55,7 @@ class LiFi extends RouteExecutionManager_1.RouteExecutionManager {
             return this.configService.getConfigAsync();
         };
         /**
-         * Get an instance of a provider for a specific cahin
+         * Get an instance of a provider for a specific chain
          * @param {number} chainId - Id of the chain the provider is for
          * @param {boolean} archive - Whether to use an archive provider that is based on a default rpc or not. defaults to false
          * @return {FallbackProvider} The provider for the given chain
@@ -245,21 +245,20 @@ class LiFi extends RouteExecutionManager_1.RouteExecutionManager {
         this.revokeTokenApproval = (request) => {
             return (0, allowance_1.revokeTokenApproval)(request);
         };
+        /**
+         * Get all the available connections for swap/bridging tokens
+         * @param connectionRequest ConnectionsRequest
+         * @returns ConnectionsResponse
+         */
+        this.getConnections = async (connectionRequest) => {
+            const connections = await ApiService_1.default.getAvailableConnections(connectionRequest);
+            return connections;
+        };
         this.chainsService = ChainsService_1.default.getInstance();
         this.chainsService.getChains().then((chains) => {
             this.configService.updateChains(chains);
         });
-        (0, helpers_1.checkPackageUpdates)(version_1.name, version_1.version, configUpdate?.disableVersionCheck);
+        (0, helpers_1.checkPackageUpdates)(version_1.name, version_1.version, configUpdate.disableVersionCheck);
     }
 }
 exports.LiFi = LiFi;
-/**
- * Get all the available connections for swap/bridging tokens
- * @param connectionRequest ConnectionsRequest
- * @returns ConnectionsResponse
- */
-const getConnections = async (connectionRequest) => {
-    const connections = await ApiService_1.default.getAvailableConnections(connectionRequest);
-    return connections;
-};
-exports.getConnections = getConnections;

package/dist/cjs/allowance/checkAllowance.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkAllowance = void 0;
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
 const bignumber_js_1 = __importDefault(require("bignumber.js"));
 const ethers_1 = require("ethers");
 const utils_1 = require("../allowance/utils");
@@ -23,7 +22,24 @@ const checkAllowance = async (signer, step, statusManager, settings, chain, allo
             allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
         }
         else {
-            const approved = await (0, utils_1.getApproved)(signer, step.action.fromToken.address, step.estimate.approvalAddress);
+            const approvalRequest = {
+                from: step.action.fromToken.address,
+                to: step.estimate.approvalAddress,
+            };
+            if (settings.updateTransactionRequestHook) {
+                const config = await settings.updateTransactionRequestHook(approvalRequest);
+                approvalRequest.gasLimit = config.gasLimit;
+                approvalRequest.gasPrice = config.gasPrice;
+                approvalRequest.maxFeePerGas = config.maxFeePerGas;
+                approvalRequest.maxPriorityFeePerGas = config.maxPriorityFeePerGas;
+            }
+            if (!approvalRequest.from) {
+                throw new Error('Missing Signer address');
+            }
+            if (!approvalRequest.to) {
+                throw new Error('Missing ERC20 contract address');
+            }
+            const approved = await (0, utils_1.getApproved)(signer, approvalRequest.from, approvalRequest.to, approvalRequest);
             if (new bignumber_js_1.default(step.action.fromAmount).gt(approved)) {
                 if (!allowUserInteraction) {
                     return;

package/dist/cjs/allowance/utils.d.ts

@@ -1,8 +1,9 @@
+import { TransactionRequest } from '@ethersproject/abstract-provider';
 import { ChainId, Token } from '@lifi/types';
 import BigNumber from 'bignumber.js';
 import { ContractTransaction, Signer } from 'ethers';
 import { RevokeTokenData } from '../types';
-export declare const getApproved: (signer: Signer, tokenAddress: string, contractAddress: string) => Promise<BigNumber>;
+export declare const getApproved: (signer: Signer, tokenAddress: string, contractAddress: string, transactionRequest?: TransactionRequest) => Promise<BigNumber>;
 export declare const setApproval: (signer: Signer, tokenAddress: string, contractAddress: string, amount: string) => Promise<ContractTransaction>;
 export declare const getAllowanceViaMulticall: (signer: Signer, chainId: ChainId, tokenData: RevokeTokenData[]) => Promise<{
     token: Token;

package/dist/cjs/allowance/utils.js

@@ -10,11 +10,16 @@ const ChainsService_1 = __importDefault(require("../services/ChainsService"));
 const types_1 = require("../types");
 const errors_1 = require("../utils/errors");
 const multicall_1 = require("../utils/multicall");
-const getApproved = async (signer, tokenAddress, contractAddress) => {
+const getApproved = async (signer, tokenAddress, contractAddress, transactionRequest) => {
     const signerAddress = await signer.getAddress();
     const erc20 = new ethers_1.Contract(tokenAddress, types_1.ERC20_ABI, signer);
     try {
-        const approved = await erc20.allowance(signerAddress, contractAddress);
+        const approved = await erc20.allowance(signerAddress, contractAddress, {
+            gasLimit: transactionRequest?.gasLimit,
+            gasPrice: transactionRequest?.gasPrice,
+            maxFeePerGas: transactionRequest?.maxFeePerGas,
+            maxPriorityFeePerGas: transactionRequest?.maxPriorityFeePerGas,
+        });
         return new bignumber_js_1.default(approved.toString());
     }
     catch (e) {

package/dist/cjs/connectors.d.ts

@@ -1,5 +1,5 @@
-import { ChainId } from './types';
 import { FallbackProvider } from '@ethersproject/providers';
+import { ChainId } from './types';
 export declare const getRpcUrl: (chainId: ChainId, archive?: boolean) => Promise<string>;
 export declare const getRpcUrls: (chainId: ChainId, archive?: boolean) => Promise<string[]>;
 export declare const getRpcProvider: (chainId: number, archive?: boolean) => Promise<FallbackProvider>;

package/dist/cjs/connectors.js

@@ -4,10 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMulticallAddress = exports.getRpcProvider = exports.getRpcUrls = exports.getRpcUrl = void 0;
-const ethers_1 = require("ethers");
-const types_1 = require("./types");
-const ConfigService_1 = __importDefault(require("./services/ConfigService"));
+const providers_1 = require("@ethersproject/providers");
 const helpers_1 = require("./helpers");
+const ConfigService_1 = __importDefault(require("./services/ConfigService"));
+const types_1 = require("./types");
 const errors_1 = require("./utils/errors");
 // cached providers
 const chainProviders = {};
@@ -41,17 +41,15 @@ const getRandomProvider = (providerList) => {
 const getRpcProvider = async (chainId, archive = false) => {
     if (archive && archiveRpcs[chainId]) {
         // return archive PRC, but don't cache it
-        return new ethers_1.providers.FallbackProvider([
-            new ethers_1.providers.StaticJsonRpcProvider(await (0, exports.getRpcUrl)(chainId, archive), chainId),
+        return new providers_1.FallbackProvider([
+            new providers_1.StaticJsonRpcProvider(await (0, exports.getRpcUrl)(chainId, archive), chainId),
         ]);
     }
-    if (!chainProviders[chainId]) {
+    if (!chainProviders[chainId]?.length) {
         chainProviders[chainId] = [];
         const urls = await (0, exports.getRpcUrls)(chainId, archive);
         urls.forEach((url) => {
-            chainProviders[chainId].push(new ethers_1.providers.FallbackProvider([
-                new ethers_1.providers.StaticJsonRpcProvider(url, chainId),
-            ]));
+            chainProviders[chainId].push(new providers_1.FallbackProvider([new providers_1.StaticJsonRpcProvider(url, chainId)]));
         });
     }
     if (!chainProviders[chainId].length) {

package/dist/cjs/execution/RouteExecutionManager.d.ts

@@ -6,7 +6,7 @@ export declare class RouteExecutionManager {
     private executionDictionary;
     private executionPromiseDictionary;
     protected configService: ConfigService;
-    constructor(configUpdate?: ConfigUpdate);
+    constructor(configUpdate: ConfigUpdate);
     /**
      * Execute a route.
      * @param {Signer} signer - The signer required to send the transactions.

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

@@ -136,7 +136,7 @@ class StatusManager {
                 throw new Error("Couldn't find a step to update.");
             }
             this.route.steps[stepIndex] = Object.assign(this.route.steps[stepIndex], step);
-            this.settings.updateCallback(this.route);
+            this.settings.updateRouteHook(this.route);
             this.internalUpdateRouteCallback(this.route);
             return this.route.steps[stepIndex];
         };

package/dist/cjs/execution/StepExecutionManager.js

@@ -81,6 +81,28 @@ class StepExecutionManager {
                         if (!this.allowUserInteraction) {
                             return step.execution;
                         }
+                        if (settings.updateTransactionRequestHook) {
+                            const customConfig = await settings.updateTransactionRequestHook(transactionRequest);
+                            transactionRequest.gasLimit = customConfig.gasLimit;
+                            transactionRequest.gasPrice = customConfig.gasPrice;
+                            transactionRequest.maxPriorityFeePerGas =
+                                customConfig.maxPriorityFeePerGas;
+                            transactionRequest.maxFeePerGas = customConfig.maxFeePerGas;
+                        }
+                        else {
+                            try {
+                                const estimatedGasLimit = await signer.estimateGas(transactionRequest);
+                                if (estimatedGasLimit) {
+                                    transactionRequest.gasLimit = `${(BigInt(estimatedGasLimit.toString()) * 125n) / 100n}`;
+                                }
+                                // Fetch latest gasPrice from provider and use it
+                                const gasPrice = await signer.getGasPrice();
+                                if (gasPrice) {
+                                    transactionRequest.gasPrice = gasPrice;
+                                }
+                            }
+                            catch (error) { }
+                        }
                         // Submit the transaction
                         transaction = await signer.sendTransaction(transactionRequest);
                         // STEP 4: Wait for the transaction

package/dist/cjs/execution/StepExecutor.js

@@ -31,12 +31,20 @@ class StepExecutor {
         };
         this.executeStep = async (signer, step) => {
             // Make sure that the chain is still correct
-            const updatedSigner = await (0, switchChain_1.switchChain)(signer, this.statusManager, step, this.settings.switchChainHook, this.allowUserInteraction);
-            if (!updatedSigner) {
-                // Chain switch was not successful, stop execution here
-                return step;
+            // Find if it's bridging and the step is waiting for a transaction on the receiving chain
+            const recievingChainProcess = step.execution?.process.find((process) => process.type === 'RECEIVING_CHAIN');
+            // If the step is waiting for a transaction on the receiving chain, we do not switch the chain
+            // All changes are already done from the source chain
+            // Return the step
+            if (recievingChainProcess?.substatus !== 'WAIT_DESTINATION_TRANSACTION' ||
+                !recievingChainProcess) {
+                const updatedSigner = await (0, switchChain_1.switchChain)(signer, this.statusManager, step, this.settings.switchChainHook, this.allowUserInteraction);
+                if (!updatedSigner) {
+                    // Chain switch was not successful, stop execution here
+                    return step;
+                }
+                signer = updatedSigner;
             }
-            signer = updatedSigner;
             const parameters = {
                 signer,
                 step,

package/dist/cjs/execution/stepComparison.d.ts

@@ -8,7 +8,7 @@ import { InternalExecutionSettings, LifiStep } from '../types';
  * @param statusManager
  * @param oldStep
  * @param newStep
- * @param acceptSlippageUpdateHook
+ * @param settings
  * @param allowUserInteraction
  */
 export declare const stepComparison: (statusManager: StatusManager, oldStep: LifiStep, newStep: LifiStep, settings: InternalExecutionSettings, allowUserInteraction: boolean) => Promise<LifiStep>;

package/dist/cjs/execution/stepComparison.js

@@ -11,7 +11,7 @@ const utils_1 = require("./utils");
  * @param statusManager
  * @param oldStep
  * @param newStep
- * @param acceptSlippageUpdateHook
+ * @param settings
  * @param allowUserInteraction
  */
 const stepComparison = async (statusManager, oldStep, newStep, settings, allowUserInteraction) => {
@@ -19,15 +19,12 @@ const stepComparison = async (statusManager, oldStep, newStep, settings, allowUs
     if ((0, utils_1.checkStepSlippageThreshold)(oldStep, newStep)) {
         return statusManager.updateStepInRoute(newStep);
     }
-    const acceptExchangeRateUpdateHook = settings.acceptExchangeRateUpdateHook ?? settings.acceptSlippageUpdateHook;
     let allowStepUpdate;
     if (allowUserInteraction) {
-        allowStepUpdate = await acceptExchangeRateUpdateHook({
+        allowStepUpdate = await settings.acceptExchangeRateUpdateHook({
             oldToAmount: oldStep.estimate.toAmount,
             newToAmount: newStep.estimate.toAmount,
             toToken: newStep.action.toToken,
-            oldSlippage: oldStep.action.slippage,
-            newSlippage: newStep.action.slippage,
         });
     }
     if (!allowStepUpdate) {

package/dist/cjs/helpers.d.ts

@@ -1,4 +1,5 @@
 import { LifiStep, Route, Token } from '@lifi/types';
+import { TenderlyResponse } from './types';
 /**
  * Predefined hook that decrypts calldata using EIP-1193 compliant wallet functions.
  * @param {string} walletAddress - The wallet address of the user that should decrypt the calldata.
@@ -24,3 +25,4 @@ export declare const checkPackageUpdates: (packageName?: string, packageVersion?
  * @throws {ValidationError} Throws a ValidationError if the step has missing values.
  */
 export declare const convertQuoteToRoute: (step: LifiStep) => Route;
+export declare const fetchTxErrorDetails: (txHash: string, chainId: number) => Promise<TenderlyResponse>;

package/dist/cjs/helpers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertQuoteToRoute = exports.checkPackageUpdates = exports.isSameToken = exports.getRandomNumber = exports.getEthereumPublicKeyHook = exports.getEthereumDecryptionHook = void 0;
+exports.fetchTxErrorDetails = exports.convertQuoteToRoute = exports.checkPackageUpdates = exports.isSameToken = exports.getRandomNumber = exports.getEthereumPublicKeyHook = exports.getEthereumDecryptionHook = void 0;
 const request_1 = require("./request");
 const errors_1 = require("./utils/errors");
 const version_1 = require("./version");
@@ -109,3 +109,8 @@ const convertQuoteToRoute = (step) => {
     return route;
 };
 exports.convertQuoteToRoute = convertQuoteToRoute;
+const fetchTxErrorDetails = async (txHash, chainId) => {
+    const response = await (0, request_1.request)(`https://api.tenderly.co/api/v1/public-contract/${chainId}/tx/${txHash}`);
+    return response;
+};
+exports.fetchTxErrorDetails = fetchTxErrorDetails;

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

@@ -9,7 +9,7 @@ declare const _default: {
     getRoutes: (requestConfig: RoutesRequest, options?: RequestOptions | undefined) => Promise<RoutesResponse>;
     getStatus: (requestConfig: GetStatusRequest, options?: RequestOptions | undefined) => Promise<StatusResponse>;
     getStepTransaction: (step: LifiStep, options?: RequestOptions | undefined) => Promise<LifiStep>;
-    getToken: (chain: ChainKey | ChainId, token: string, options?: RequestOptions | undefined) => Promise<Token>;
+    getToken: (chain: ChainId | ChainKey, token: string, options?: RequestOptions | undefined) => Promise<Token>;
     getTokens: (requestConfig?: TokensRequest | undefined, options?: RequestOptions | undefined) => Promise<TokensResponse>;
     getTools: (requestConfig?: ToolsRequest | undefined, options?: RequestOptions | undefined) => Promise<ToolsResponse>;
     getAvailableConnections: (connectionRequest: ConnectionsRequest) => Promise<ConnectionsResponse>;

package/dist/cjs/services/ConfigService.d.ts

@@ -18,6 +18,6 @@ export default class ConfigService {
      * Use this if you need access to chain data (RPCs or multicalls)
      */
     getConfigAsync: () => Promise<Config>;
-    updateConfig: (configUpdate: ConfigUpdate) => Config;
+    updateConfig: (configUpdate: Partial<ConfigUpdate>) => Config;
     updateChains: (chains: Chain[]) => Config;
 }

package/dist/cjs/services/ConfigService.js

@@ -3,9 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("../types");
 const DefaultExecutionSettings = {
     /* eslint-disable-next-line @typescript-eslint/no-empty-function */
-    updateCallback: () => { },
+    updateRouteHook: () => { },
     switchChainHook: () => Promise.resolve(undefined),
-    acceptSlippageUpdateHook: () => Promise.resolve(undefined),
     acceptExchangeRateUpdateHook: () => Promise.resolve(undefined),
     infiniteApproval: false,
     executeInBackground: false,

package/dist/cjs/typeguards.d.ts

@@ -1,4 +1,4 @@
-import { LifiStep, RoutesRequest, Token } from './types';
+import { LifiStep, RoutesRequest, StaticToken } from './types';
 export declare const isRoutesRequest: (routesRequest: RoutesRequest) => routesRequest is RoutesRequest;
 export declare const isStep: (step: LifiStep) => step is LifiStep;
-export declare const isToken: (token: Token) => token is Token;
+export declare const isToken: (token: StaticToken) => token is StaticToken;

package/dist/cjs/types/internal.types.d.ts

@@ -1,3 +1,4 @@
+import { TransactionRequest } from '@ethersproject/abstract-provider';
 import { LifiStep, Route, RouteOptions, Token } from '@lifi/types';
 import BigNumber from 'bignumber.js';
 import { Signer } from 'ethers';
@@ -22,7 +23,8 @@ export interface ExecutionParams {
     statusManager: StatusManager;
     settings: InternalExecutionSettings;
 }
-export type CallbackFunction = (updatedRoute: Route) => void;
+export type UpdateRouteHook = (updatedRoute: Route) => void;
+export type TransactionRequestUpdateHook = (updatedTxRequest: TransactionRequest) => Promise<TransactionRequest>;
 export type Config = {
     apiUrl: string;
     rpcs: Record<ChainId, string[]>;
@@ -67,16 +69,13 @@ export interface RouteExecutionData {
 }
 export type ExecutionSettings = Partial<InternalExecutionSettings>;
 export interface InternalExecutionSettings {
-    updateCallback: CallbackFunction;
-    switchChainHook: SwitchChainHook;
-    acceptSlippageUpdateHook: AcceptSlippageUpdateHook;
     acceptExchangeRateUpdateHook: AcceptExchangeRateUpdateHook;
-    infiniteApproval: boolean;
+    switchChainHook: SwitchChainHook;
+    updateRouteHook: UpdateRouteHook;
+    updateTransactionRequestHook?: TransactionRequestUpdateHook;
     executeInBackground: boolean;
+    infiniteApproval: boolean;
 }
-export type EnforcedObjectProperties<T> = T & {
-    [P in keyof T]-?: T[P];
-};
 export type RouteExecutionDictionary = Partial<Record<string, RouteExecutionData>>;
 export type RouteExecutionPromiseDictionary = Partial<Record<string, Promise<Route>>>;
 export type RevokeTokenData = {
@@ -88,3 +87,43 @@ export interface InteractionSettings {
     allowUpdates?: boolean;
     stopExecution?: boolean;
 }
+export interface TenderlyResponse {
+    hash: string;
+    block_hash: string;
+    block_number: number;
+    from: string;
+    gas: number;
+    gas_price: number;
+    gas_fee_cap: number;
+    gas_tip_cap: number;
+    cumulative_gas_used: number;
+    gas_used: number;
+    effective_gas_price: number;
+    input: string;
+    nonce: number;
+    to: string;
+    index: number;
+    value: string;
+    access_list: any;
+    status: boolean;
+    addresses: string[];
+    contract_ids: string[];
+    network_id: string;
+    timestamp: string;
+    function_selector: string;
+    l1_block_number: number;
+    l1_timestamp: number;
+    deposit_tx: boolean;
+    system_tx: boolean;
+    mint: number;
+    sig: Signature;
+    error_message: string;
+    method: string;
+    decoded_input: any;
+    call_trace: any;
+}
+export interface Signature {
+    v: string;
+    r: string;
+    s: string;
+}