@lifi/sdk 2.2.3 → 3.0.0-alpha.2

package/dist/execution/prepareRestart.js

@@ -0,0 +1,61 @@
+import { publicActions } from 'viem';
+import { LiFiErrorCode } from '../utils/errors';
+export const prepareRestart = async (route, walletClient) => {
+    for (let index = 0; index < route.steps.length; index++) {
+        const step = route.steps[index];
+        const stepHasFailed = step.execution?.status === 'FAILED';
+        if (stepHasFailed) {
+            await handleErrorType(walletClient, step);
+            deleteFailedProcesses(step);
+            deleteTransactionData(step);
+        }
+    }
+};
+const handleErrorType = async (walletClient, step) => {
+    const client = walletClient.extend(publicActions);
+    const isGasLimitError = step.execution?.process.some((p) => p.error?.code === LiFiErrorCode.GasLimitError);
+    const isGasPriceError = step.execution?.process.some((p) => p.error?.code === LiFiErrorCode.TransactionUnderpriced);
+    const { transactionRequest } = step;
+    // if (isGasLimitError) {
+    //   if (transactionRequest) {
+    //     let gasLimit = transactionRequest.gasLimit
+    //     try {
+    //       gasLimit = await client.estimateGas(transactionRequest)
+    //     } catch (error) {}
+    //     if (gasLimit) {
+    //       transactionRequest.gasLimit = BigNumber.from(
+    //         `${(BigInt(gasLimit.toString()) * 125n) / 100n}`
+    //       )
+    //     }
+    //   }
+    //   step.estimate.gasCosts?.forEach(
+    //     (gasCost) =>
+    //       (gasCost.limit = `${Math.round(Number(gasCost.limit) * 1.25)}`)
+    //   )
+    // }
+    // if (isGasPriceError) {
+    //   if (transactionRequest) {
+    //     let gasPrice = transactionRequest.gasPrice
+    //     try {
+    //       gasPrice = await client.getGasPrice()
+    //     } catch (error) {}
+    //     if (gasPrice) {
+    //       transactionRequest.gasPrice = BigNumber.from(
+    //         `${(BigInt(gasPrice.toString()) * 125n) / 100n}`
+    //       )
+    //     }
+    //   }
+    //   step.estimate.gasCosts?.forEach(
+    //     (gasCost) =>
+    //       (gasCost.price = `${Math.round(Number(gasCost.price) * 1.25)}`)
+    //   )
+    // }
+};
+const deleteFailedProcesses = (step) => {
+    if (step.execution) {
+        step.execution.process = step.execution.process.filter((process) => process.status === 'DONE');
+    }
+};
+const deleteTransactionData = (step) => {
+    step.transactionRequest = undefined;
+};

package/dist/execution/stepComparison.d.ts

@@ -1,14 +1,14 @@
-import { StatusManager } from '.';
-import { InternalExecutionSettings, LifiStep } from '../types';
+import type { InternalExecutionSettings, LifiStep } from '../types';
+import type { StatusManager } from './StatusManager';
 /**
  * This method checks whether the new and updated Step meets the required exchange rate conditions.
  * If yes it returns the updated Step.
  * If no and if user interaction is allowed it triggers the acceptExchangeRateUpdateHook. If no user interaction is allowed it aborts.
- *
  * @param statusManager
  * @param oldStep
  * @param newStep
  * @param settings
  * @param allowUserInteraction
+ * @returns Return LifiStep
  */
 export declare const stepComparison: (statusManager: StatusManager, oldStep: LifiStep, newStep: LifiStep, settings: InternalExecutionSettings, allowUserInteraction: boolean) => Promise<LifiStep>;

package/dist/execution/stepComparison.js

@@ -1,15 +1,15 @@
-import { LifiErrorCode, TransactionError } from '../utils/errors';
+import { LiFiErrorCode, TransactionError } from '../utils/errors';
 import { checkStepSlippageThreshold } from './utils';
 /**
  * This method checks whether the new and updated Step meets the required exchange rate conditions.
  * If yes it returns the updated Step.
  * If no and if user interaction is allowed it triggers the acceptExchangeRateUpdateHook. If no user interaction is allowed it aborts.
- *
  * @param statusManager
  * @param oldStep
  * @param newStep
  * @param settings
  * @param allowUserInteraction
+ * @returns Return LifiStep
  */
 export const stepComparison = async (statusManager, oldStep, newStep, settings, allowUserInteraction) => {
     // Check if changed exchange rate is in the range of slippage threshold
@@ -26,7 +26,7 @@ export const stepComparison = async (statusManager, oldStep, newStep, settings,
     }
     if (!allowStepUpdate) {
         // The user declined the new exchange rate, so we are not going to proceed
-        throw new TransactionError(LifiErrorCode.TransactionCanceled, 'Exchange rate has changed!', `Transaction was not sent, your funds are still in your wallet.
+        throw new TransactionError(LiFiErrorCode.ExchangeRateUpdateCanceled, 'Exchange rate has changed!', `Transaction was not sent, your funds are still in your wallet.
       The exchange rate has changed and the previous estimation can not be fulfilled due to value loss.`);
     }
     return statusManager.updateStepInRoute(newStep);

package/dist/execution/switchChain.d.ts

@@ -1,16 +1,21 @@
-import { LifiStep } from '@lifi/types';
-import { Signer } from 'ethers';
-import { SwitchChainHook } from '../types';
-import { StatusManager } from './StatusManager';
+import type { LifiStep } from '@lifi/types';
+import type { WalletClient } from 'viem';
+import type { SwitchChainHook } from '../types';
+import type { StatusManager } from './StatusManager';
 /**
- * This method checks whether the signer is configured for the correct chain.
- * If yes it returns the signer.
+ * This method checks whether the wallet client is configured for the correct chain.
+ * If yes it returns the wallet clien.
  * If no and if user interaction is allowed it triggers the switchChainHook. If no user interaction is allowed it aborts.
  *
- * @param signer
+ * Account Type: local -
+ * We need to create and return a new WalletClient from the switchChainHook in order to continue execution on a new chain.
+ *
+ * Account Type: json-rpc -
+ * We can switch chain and return existing WalletClient from the switchChainHook in order to continue execution on a new chain.
+ * @param walletClient
  * @param statusManager
  * @param step
  * @param switchChainHook
  * @param allowUserInteraction
  */
-export declare const switchChain: (signer: Signer, statusManager: StatusManager, step: LifiStep, switchChainHook: SwitchChainHook, allowUserInteraction: boolean) => Promise<Signer | undefined>;
+export declare const switchChain: (walletClient: WalletClient, statusManager: StatusManager, step: LifiStep, switchChainHook: SwitchChainHook, allowUserInteraction: boolean) => Promise<WalletClient | undefined>;

package/dist/execution/switchChain.js

@@ -1,19 +1,24 @@
-import { LifiErrorCode, ProviderError } from '../utils/errors';
+import { LiFiErrorCode, ProviderError } from '../utils/errors';
 /**
- * This method checks whether the signer is configured for the correct chain.
- * If yes it returns the signer.
+ * This method checks whether the wallet client is configured for the correct chain.
+ * If yes it returns the wallet clien.
  * If no and if user interaction is allowed it triggers the switchChainHook. If no user interaction is allowed it aborts.
  *
- * @param signer
+ * Account Type: local -
+ * We need to create and return a new WalletClient from the switchChainHook in order to continue execution on a new chain.
+ *
+ * Account Type: json-rpc -
+ * We can switch chain and return existing WalletClient from the switchChainHook in order to continue execution on a new chain.
+ * @param walletClient
  * @param statusManager
  * @param step
  * @param switchChainHook
  * @param allowUserInteraction
  */
-export const switchChain = async (signer, statusManager, step, switchChainHook, allowUserInteraction) => {
+export const switchChain = async (walletClient, statusManager, step, switchChainHook, allowUserInteraction) => {
     // if we are already on the correct chain we can proceed directly
-    if ((await signer.getChainId()) === step.action.fromChainId) {
-        return signer;
+    if ((await walletClient.getChainId()) === step.action.fromChainId) {
+        return walletClient;
     }
     // -> set status message
     step.execution = statusManager.initExecutionObject(step);
@@ -23,20 +28,20 @@ export const switchChain = async (signer, statusManager, step, switchChainHook,
         return;
     }
     try {
-        const updatedSigner = await switchChainHook(step.action.fromChainId);
-        const updatedChainId = await updatedSigner?.getChainId();
+        const updatedWalletClient = await switchChainHook(step.action.fromChainId);
+        const updatedChainId = await updatedWalletClient?.getChainId();
         if (updatedChainId !== step.action.fromChainId) {
-            throw new ProviderError(LifiErrorCode.ChainSwitchError, 'Chain switch required.');
+            throw new ProviderError(LiFiErrorCode.ChainSwitchError, 'Chain switch required.');
         }
         switchProcess = statusManager.updateProcess(step, switchProcess.type, 'DONE');
         statusManager.updateExecution(step, 'PENDING');
-        return updatedSigner;
+        return updatedWalletClient;
     }
     catch (error) {
         statusManager.updateProcess(step, switchProcess.type, 'FAILED', {
             error: {
                 message: error.message,
-                code: LifiErrorCode.ChainSwitchError,
+                code: LiFiErrorCode.ChainSwitchError,
             },
         });
         statusManager.updateExecution(step, 'FAILED');

package/dist/execution/utils.d.ts

@@ -1,6 +1,12 @@
-import { LifiStep, ProcessType, Status, StatusMessage, StatusResponse, Substatus } from '@lifi/types';
-import { StatusManager } from '..';
-export declare function waitForReceivingTransaction(txHash: string, statusManager: StatusManager, processType: ProcessType, step: LifiStep): Promise<StatusResponse>;
+import type { LifiStep, ProcessType, Status, StatusMessage, Substatus } from '@lifi/types';
 export declare function getProcessMessage(type: ProcessType, status: Status): string | undefined;
 export declare function getSubstatusMessage(status: StatusMessage, substatus?: Substatus): string | undefined;
+/**
+ * Used to check if changed exchange rate is in the range of slippage threshold.
+ * We use a slippage value as a threshold to trigger the rate change hook.
+ * This can result in almost doubled slippage for the user and need to be revisited.
+ * @param oldStep
+ * @param newStep
+ * @returns Boolean
+ */
 export declare function checkStepSlippageThreshold(oldStep: LifiStep, newStep: LifiStep): boolean;

package/dist/execution/utils.js

@@ -1,54 +1,3 @@
-import BigNumber from 'bignumber.js';
-import ApiService from '../services/ApiService';
-import { ServerError } from '../utils/errors';
-import { repeatUntilDone } from '../utils/utils';
-const TRANSACTION_HASH_OBSERVERS = {};
-export async function waitForReceivingTransaction(txHash, statusManager, processType, step) {
-    const getStatus = () => new Promise(async (resolve, reject) => {
-        let statusResponse;
-        try {
-            statusResponse = await ApiService.getStatus({
-                bridge: step.tool,
-                fromChain: step.action.fromChainId,
-                toChain: step.action.toChainId,
-                txHash,
-            });
-        }
-        catch (e) {
-            console.debug('Fetching status from backend failed.', e);
-            return resolve(undefined);
-        }
-        switch (statusResponse.status) {
-            case 'DONE':
-                return resolve(statusResponse);
-            case 'PENDING':
-                statusManager?.updateProcess(step, processType, 'PENDING', {
-                    substatus: statusResponse.substatus,
-                    substatusMessage: statusResponse.substatusMessage ||
-                        getSubstatusMessage(statusResponse.status, statusResponse.substatus),
-                    txLink: statusResponse.bridgeExplorerLink,
-                });
-                return resolve(undefined);
-            case 'NOT_FOUND':
-                return resolve(undefined);
-            case 'FAILED':
-            default:
-                return reject();
-        }
-    });
-    let status;
-    if (txHash in TRANSACTION_HASH_OBSERVERS) {
-        status = await TRANSACTION_HASH_OBSERVERS[txHash];
-    }
-    else {
-        TRANSACTION_HASH_OBSERVERS[txHash] = repeatUntilDone(getStatus, 5000);
-        status = await TRANSACTION_HASH_OBSERVERS[txHash];
-    }
-    if (!status.receiving) {
-        throw new ServerError("Status doesn't contain receiving information.");
-    }
-    return status;
-}
 const processMessages = {
     TOKEN_ALLOWANCE: {
         STARTED: 'Setting token allowance.',
@@ -106,17 +55,25 @@ export function getSubstatusMessage(status, substatus) {
     const message = substatusMessages[status][substatus];
     return message;
 }
-// Used to check if changed exchange rate is in the range of slippage threshold
+/**
+ * Used to check if changed exchange rate is in the range of slippage threshold.
+ * We use a slippage value as a threshold to trigger the rate change hook.
+ * This can result in almost doubled slippage for the user and need to be revisited.
+ * @param oldStep
+ * @param newStep
+ * @returns Boolean
+ */
 export function checkStepSlippageThreshold(oldStep, newStep) {
-    const setSlippage = new BigNumber(oldStep.action.slippage);
-    const oldEstimatedToAmount = new BigNumber(oldStep.estimate.toAmountMin);
-    const newEstimatedToAmount = new BigNumber(newStep.estimate.toAmountMin);
-    const amountDifference = oldEstimatedToAmount.minus(newEstimatedToAmount);
+    const setSlippage = oldStep.action.slippage;
+    const oldEstimatedToAmount = BigInt(oldStep.estimate.toAmountMin);
+    const newEstimatedToAmount = BigInt(newStep.estimate.toAmountMin);
+    const amountDifference = oldEstimatedToAmount - newEstimatedToAmount;
     // oldEstimatedToAmount can be 0 when we use conract calls
-    let actualSlippage = new BigNumber(0);
-    if (oldEstimatedToAmount.gt(0)) {
-        actualSlippage = amountDifference.dividedBy(oldEstimatedToAmount);
+    let actualSlippage = 0;
+    if (oldEstimatedToAmount > 0) {
+        actualSlippage =
+            Number((amountDifference * 1000000000n) / oldEstimatedToAmount) /
+                1000000000;
     }
-    return (newEstimatedToAmount.gte(oldEstimatedToAmount) &&
-        actualSlippage.lte(setSlippage));
+    return actualSlippage <= setSlippage;
 }

package/dist/execution/waitForReceivingTransaction.d.ts

@@ -0,0 +1,3 @@
+import type { LifiStep, ProcessType, StatusResponse } from '@lifi/types';
+import type { StatusManager } from '..';
+export declare function waitForReceivingTransaction(txHash: string, statusManager: StatusManager, processType: ProcessType, step: LifiStep): Promise<StatusResponse>;

package/dist/execution/waitForReceivingTransaction.js

@@ -0,0 +1,51 @@
+import ApiService from '../services/ApiService';
+import { ServerError } from '../utils/errors';
+import { repeatUntilDone } from '../utils/utils';
+import { getSubstatusMessage } from './utils';
+const TRANSACTION_HASH_OBSERVERS = {};
+export async function waitForReceivingTransaction(txHash, statusManager, processType, step) {
+    const getStatus = () => new Promise(async (resolve, reject) => {
+        let statusResponse;
+        try {
+            statusResponse = await ApiService.getStatus({
+                bridge: step.tool,
+                fromChain: step.action.fromChainId,
+                toChain: step.action.toChainId,
+                txHash,
+            });
+        }
+        catch (e) {
+            console.debug('Fetching status from backend failed.', e);
+            return resolve(undefined);
+        }
+        switch (statusResponse.status) {
+            case 'DONE':
+                return resolve(statusResponse);
+            case 'PENDING':
+                statusManager?.updateProcess(step, processType, 'PENDING', {
+                    substatus: statusResponse.substatus,
+                    substatusMessage: statusResponse.substatusMessage ||
+                        getSubstatusMessage(statusResponse.status, statusResponse.substatus),
+                    txLink: statusResponse.bridgeExplorerLink,
+                });
+                return resolve(undefined);
+            case 'NOT_FOUND':
+                return resolve(undefined);
+            case 'FAILED':
+            default:
+                return reject();
+        }
+    });
+    let status;
+    if (txHash in TRANSACTION_HASH_OBSERVERS) {
+        status = await TRANSACTION_HASH_OBSERVERS[txHash];
+    }
+    else {
+        TRANSACTION_HASH_OBSERVERS[txHash] = repeatUntilDone(getStatus, 5000);
+        status = await TRANSACTION_HASH_OBSERVERS[txHash];
+    }
+    if (!status.receiving) {
+        throw new ServerError("Status doesn't contain receiving information.");
+    }
+    return status;
+}

package/dist/helpers.d.ts

@@ -1,27 +1,17 @@
-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.
- * @return {(encryptedData: string) => Promise<any>} A function that decrypts data using EIP-1193 compliant wallet functions.
- */
-export declare const getEthereumDecryptionHook: (walletAddress: string) => (encryptedData: string) => Promise<string>;
-/**
- * Predefined hook that get the public encryption key of a user using EIP-1193 compliant wallet functions.
- * @param {string} walletAddress - The wallet address of the user.
- * @return {(walletAddress: string) => () => Promise<any>} A function that return the public encryption key using EIP-1193 compliant wallet functions.
- */
-export declare const getEthereumPublicKeyHook: (walletAddress: string) => () => Promise<string>;
+import type { LifiStep, Route } from '@lifi/types';
+import type { TenderlyResponse } from './types';
 /**
  * Returns a random number between min (inclusive) and max (inclusive)
+ * @param min - minimum number.
+ * @param max - maximum number.
+ * @returns - random number.
  */
 export declare const getRandomNumber: (min: number, max: number) => number;
-export declare const isSameToken: (tokenA: Token, tokenB: Token) => boolean;
 export declare const checkPackageUpdates: (packageName?: string, packageVersion?: string, disableCheck?: boolean) => Promise<void>;
 /**
  * Converts a quote to Route
- * @param {LifiStep} step - Step returned from the quote endpoint.
- * @return {Route} - The route to be executed.
+ * @param step - Step returned from the quote endpoint.
+ * @returns - The route to be executed.
  * @throws {ValidationError} Throws a ValidationError if the step has missing values.
  */
 export declare const convertQuoteToRoute: (step: LifiStep) => Route;

package/dist/helpers.js

@@ -1,44 +1,15 @@
 import { request } from './request';
 import { ValidationError } from './utils/errors';
 import { name, version } from './version';
-const ethereumRequest = async (method, params) => {
-    // If ethereum.request() exists, the provider is probably EIP-1193 compliant.
-    if (!ethereum?.request) {
-        throw new Error('Provider not available.');
-    }
-    return ethereum.request({
-        method,
-        params,
-    });
-};
-/**
- * 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.
- * @return {(encryptedData: string) => Promise<any>} A function that decrypts data using EIP-1193 compliant wallet functions.
- */
-export const getEthereumDecryptionHook = (walletAddress) => {
-    return (encryptedData) => {
-        return ethereumRequest('eth_decrypt', [encryptedData, walletAddress]);
-    };
-};
-/**
- * Predefined hook that get the public encryption key of a user using EIP-1193 compliant wallet functions.
- * @param {string} walletAddress - The wallet address of the user.
- * @return {(walletAddress: string) => () => Promise<any>} A function that return the public encryption key using EIP-1193 compliant wallet functions.
- */
-export const getEthereumPublicKeyHook = (walletAddress) => {
-    return () => {
-        return ethereumRequest('eth_getEncryptionPublicKey', [walletAddress]);
-    };
-};
 /**
  * Returns a random number between min (inclusive) and max (inclusive)
+ * @param min - minimum number.
+ * @param max - maximum number.
+ * @returns - random number.
  */
 export const getRandomNumber = (min, max) => {
     return Math.floor(Math.random() * (max - min + 1) + min);
 };
-export const isSameToken = (tokenA, tokenB) => tokenA.chainId === tokenB.chainId &&
-    tokenA.address.toLowerCase() === tokenB.address.toLowerCase();
 function semverCompare(a, b) {
     if (a.startsWith(b + '-')) {
         return -1;
@@ -73,8 +44,8 @@ export const checkPackageUpdates = async (packageName, packageVersion, disableCh
 };
 /**
  * Converts a quote to Route
- * @param {LifiStep} step - Step returned from the quote endpoint.
- * @return {Route} - The route to be executed.
+ * @param step - Step returned from the quote endpoint.
+ * @returns - The route to be executed.
  * @throws {ValidationError} Throws a ValidationError if the step has missing values.
  */
 export const convertQuoteToRoute = (step) => {

package/dist/request.js

@@ -1,6 +1,6 @@
 import ConfigService from './services/ConfigService';
 import { HTTPError } from './utils/errors';
-import { sleep } from './utils/utils';
+import { wait } from './utils/utils';
 import { version } from './version';
 export const requestSettings = {
     retries: 1,
@@ -45,7 +45,7 @@ export const request = async (url, options = {
     }
     catch (error) {
         if (options.retries > 0 && error?.status === 500) {
-            await sleep(500);
+            await wait(500);
             return request(url, { ...options, retries: options.retries - 1 });
         }
         throw error;

package/dist/services/ApiService.d.ts

@@ -1,5 +1,5 @@
-import { ConnectionsRequest, ConnectionsResponse, ContractCallQuoteRequest, GasRecommendationRequest, GasRecommendationResponse, GetStatusRequest, LifiStep, QuoteRequest, RequestOptions, TokensRequest, TokensResponse } from '@lifi/types';
-import { ChainId, ChainKey, ExtendedChain, PossibilitiesRequest, PossibilitiesResponse, RoutesRequest, RoutesResponse, StatusResponse, Token, ToolsRequest, ToolsResponse } from '../types';
+import type { ConnectionsRequest, ConnectionsResponse, ContractCallQuoteRequest, GasRecommendationRequest, GasRecommendationResponse, GetStatusRequest, LifiStep, QuoteRequest, RequestOptions, TokensRequest, TokensResponse } from '@lifi/types';
+import type { ChainId, ChainKey, ExtendedChain, PossibilitiesRequest, PossibilitiesResponse, RoutesRequest, RoutesResponse, StatusResponse, Token, ToolsRequest, ToolsResponse } from '../types';
 declare const _default: {
     getChains: (options?: RequestOptions | undefined) => Promise<ExtendedChain[]>;
     getContractCallQuote: (requestConfig: ContractCallQuoteRequest, options?: RequestOptions | undefined) => Promise<LifiStep>;

package/dist/services/ApiService.js

@@ -4,6 +4,8 @@ import { ValidationError } from '../utils/errors';
 import { parseBackendError } from '../utils/parseError';
 import ConfigService from './ConfigService';
 /**
+ * @param requestConfig
+ * @param options
  * @deprecated We don't want to support this endpoint anymore in the future. /chains, /tools, /connections, and /tokens should be used instead
  */
 const getPossibilities = async (requestConfig, options) => {
@@ -274,10 +276,10 @@ const getAvailableConnections = async (connectionRequest) => {
         url.searchParams.append('fromToken', fromToken);
     }
     if (toChain) {
-        url.searchParams.append('toChain', toChain);
+        url.searchParams.append('fromToken', toChain);
     }
     if (toToken) {
-        url.searchParams.append('toToken', toToken);
+        url.searchParams.append('fromToken', toToken);
     }
     const connectionRequestArrayParams = [
         'allowBridges',

package/dist/services/ChainsService.d.ts

@@ -1,4 +1,4 @@
-import { ChainId, ExtendedChain } from '@lifi/types';
+import type { ChainId, ExtendedChain } from '@lifi/types';
 export default class ChainsService {
     private static instance;
     private readonly loadingPromise;

package/dist/services/ConfigService.d.ts

@@ -1,4 +1,4 @@
-import { Chain, Config, ConfigUpdate } from '../types';
+import type { Chain, Config, ConfigUpdate } from '../types';
 export default class ConfigService {
     private static instance;
     private readonly config;

package/dist/services/ConfigService.js

@@ -1,4 +1,4 @@
-import { ChainId, } from '../types';
+import { ChainId } from '../types';
 const DefaultExecutionSettings = {
     /* eslint-disable-next-line @typescript-eslint/no-empty-function */
     updateRouteHook: () => { },
@@ -44,8 +44,7 @@ class ConfigService {
                     this.config.integrator;
             this.config.widgetVersion =
                 configUpdate.widgetVersion || this.config.widgetVersion;
-            this.config.multisigConfig =
-                configUpdate.multisigConfig || this.config.multisigConfig;
+            this.config.multisig = configUpdate.multisigConfig || this.config.multisig;
             return this.config;
         };
         this.updateChains = (chains) => {

package/dist/typeguards.d.ts

@@ -1,4 +1,4 @@
-import { LifiStep, RoutesRequest, StaticToken } from './types';
+import type { 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: StaticToken) => token is StaticToken;

package/dist/types/abi.d.ts

@@ -0,0 +1,5 @@
+import type { Abi } from 'viem';
+export declare const approveAbi: Abi;
+export declare const allowanceAbi: Abi;
+export declare const getEthBalanceAbi: Abi;
+export declare const balanceOfAbi: Abi;

package/dist/types/abi.js

@@ -0,0 +1,42 @@
+export const approveAbi = [
+    {
+        name: 'approve',
+        inputs: [
+            { internalType: 'address', name: 'spender', type: 'address' },
+            { internalType: 'uint256', name: 'amount', type: 'uint256' },
+        ],
+        outputs: [{ internalType: 'bool', name: 'approved', type: 'bool' }],
+        stateMutability: 'nonpayable',
+        type: 'function',
+    },
+];
+export const allowanceAbi = [
+    {
+        name: 'allowance',
+        inputs: [
+            { internalType: 'address', name: 'owner', type: 'address' },
+            { internalType: 'address', name: 'spender', type: 'address' },
+        ],
+        outputs: [{ internalType: 'uint256', name: 'allowance', type: 'uint256' }],
+        stateMutability: 'view',
+        type: 'function',
+    },
+];
+export const getEthBalanceAbi = [
+    {
+        inputs: [{ name: '_owner', type: 'address' }],
+        name: 'getEthBalance',
+        outputs: [{ name: 'balance', type: 'uint256' }],
+        type: 'function',
+        stateMutability: 'view',
+    },
+];
+export const balanceOfAbi = [
+    {
+        inputs: [{ name: '_owner', type: 'address' }],
+        name: 'balanceOf',
+        outputs: [{ name: 'balance', type: 'uint256' }],
+        type: 'function',
+        stateMutability: 'view',
+    },
+];

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
 export * from '@lifi/types';
-export { ErrorCode, LifiError } from '../utils/errors';
-export * from './ERC20';
+export { ErrorCode, LiFiError } from '../utils/errors';
+export * from './abi';
 export * from './internal.types';

package/dist/types/index.js

@@ -1,4 +1,4 @@
 export * from '@lifi/types';
-export { LifiError } from '../utils/errors';
-export * from './ERC20';
+export { LiFiError } from '../utils/errors';
+export * from './abi';
 export * from './internal.types';