@lifi/sdk 3.0.0-alpha.3 → 3.0.0-alpha.31

package/dist/execution/StepExecutionManager.js

@@ -1,260 +0,0 @@
-import { publicActions } from 'viem';
-import ApiService from '../services/ApiService';
-import ChainsService from '../services/ChainsService';
-import ConfigService from '../services/ConfigService';
-import { getMaxPriorityFeePerGas } from '../utils';
-import { LiFiErrorCode, TransactionError, ValidationError, } from '../utils/errors';
-import { getTransactionFailedMessage, parseError } from '../utils/parseError';
-import { isZeroAddress } from '../utils/utils';
-import { checkAllowance } from './checkAllowance';
-import { checkBalance } from './checkBalance';
-import { updateMultisigRouteProcess } from './multisig';
-import { stepComparison } from './stepComparison';
-import { switchChain } from './switchChain';
-import { getSubstatusMessage } from './utils';
-import { waitForReceivingTransaction } from './waitForReceivingTransaction';
-export class StepExecutionManager {
-    constructor() {
-        this.allowUserInteraction = true;
-        this.allowInteraction = (value) => {
-            this.allowUserInteraction = value;
-        };
-        this.execute = async ({ walletClient, step, statusManager, settings, }) => {
-            const client = walletClient.extend(publicActions);
-            const config = ConfigService.getInstance().getConfig();
-            const isMultisigWalletClient = !!config.multisig?.isMultisigWalletClient;
-            const multisigBatchTransactions = [];
-            const shouldBatchTransactions = config.multisig?.shouldBatchTransactions &&
-                !!config.multisig.sendBatchTransaction;
-            step.execution = statusManager.initExecutionObject(step);
-            const chainsService = ChainsService.getInstance();
-            const fromChain = await chainsService.getChainById(step.action.fromChainId);
-            const toChain = await chainsService.getChainById(step.action.toChainId);
-            const isBridgeExecution = fromChain.id !== toChain.id;
-            const currentProcessType = isBridgeExecution ? 'CROSS_CHAIN' : 'SWAP';
-            // STEP 1: Check allowance
-            const existingProcess = step.execution.process.find((p) => p.type === currentProcessType);
-            // Check token approval only if fromToken is not the native token => no approval needed in that case
-            const checkForAllowance = !existingProcess?.txHash &&
-                !isZeroAddress(step.action.fromToken.address) &&
-                (shouldBatchTransactions || !isMultisigWalletClient);
-            if (checkForAllowance) {
-                const data = await checkAllowance(client, step, statusManager, settings, fromChain, this.allowUserInteraction, shouldBatchTransactions);
-                if (data) {
-                    // allowance doesn't need value
-                    const baseTransaction = {
-                        to: step.action.fromToken.address,
-                        data,
-                    };
-                    multisigBatchTransactions.push(baseTransaction);
-                }
-            }
-            // STEP 2: Get transaction
-            let process = statusManager.findOrCreateProcess(step, currentProcessType);
-            if (process.status !== 'DONE') {
-                const multisigProcess = step.execution.process.find((p) => !!p.multisigTxHash);
-                try {
-                    if (isMultisigWalletClient && multisigProcess) {
-                        const multisigTxHash = multisigProcess.multisigTxHash;
-                        if (!multisigTxHash) {
-                            throw new ValidationError('Multisig internal transaction hash is undefined.');
-                        }
-                        await updateMultisigRouteProcess(multisigTxHash, step, statusManager, process.type, fromChain);
-                    }
-                    let txHash;
-                    if (process.txHash) {
-                        // Make sure that the chain is still correct
-                        const updatedWalletClient = await switchChain(walletClient, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
-                        if (!updatedWalletClient) {
-                            // Chain switch was not successful, stop execution here
-                            return step.execution;
-                        }
-                        walletClient = updatedWalletClient;
-                        // Load exiting transaction
-                        txHash = process.txHash;
-                    }
-                    else {
-                        process = statusManager.updateProcess(step, process.type, 'STARTED');
-                        // Check balance
-                        await checkBalance(client.account.address, step);
-                        // Create new transaction
-                        if (!step.transactionRequest) {
-                            const updatedStep = await ApiService.getStepTransaction(step);
-                            const comparedStep = await stepComparison(statusManager, step, updatedStep, settings, this.allowUserInteraction);
-                            step = {
-                                ...comparedStep,
-                                execution: step.execution,
-                            };
-                        }
-                        let transactionRequest = {
-                            to: step.transactionRequest?.to,
-                            from: step.transactionRequest?.from,
-                            data: step.transactionRequest?.data,
-                            value: step.transactionRequest?.value
-                                ? BigInt(step.transactionRequest.value)
-                                : undefined,
-                            maxPriorityFeePerGas: walletClient.account?.type === 'local'
-                                ? await getMaxPriorityFeePerGas(client)
-                                : undefined,
-                            // gas: step.transactionRequest?.gasLimit
-                            //   ? BigInt(step.transactionRequest.gasLimit as string)
-                            //   : undefined,
-                            // gasPrice: step.transactionRequest?.gasPrice
-                            //   ? BigInt(step.transactionRequest.gasPrice as string)
-                            //   : undefined,
-                            // maxFeePerGas: step.transactionRequest?.maxFeePerGas
-                            //   ? BigInt(step.transactionRequest.maxFeePerGas as string)
-                            //   : undefined,
-                            // maxPriorityFeePerGas: step.transactionRequest?.maxPriorityFeePerGas
-                            //   ? BigInt(step.transactionRequest.maxPriorityFeePerGas as string)
-                            //   : undefined,
-                        };
-                        if (!transactionRequest) {
-                            throw new TransactionError(LiFiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
-                        }
-                        // STEP 3: Send the transaction
-                        // Make sure that the chain is still correct
-                        const updatedWalletClient = await switchChain(walletClient, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
-                        if (!updatedWalletClient) {
-                            // Chain switch was not successful, stop execution here
-                            return step.execution;
-                        }
-                        walletClient = updatedWalletClient;
-                        process = statusManager.updateProcess(step, process.type, 'ACTION_REQUIRED');
-                        if (!this.allowUserInteraction) {
-                            return step.execution;
-                        }
-                        if (settings.updateTransactionRequestHook) {
-                            const customizedTransactionRequest = await settings.updateTransactionRequestHook(transactionRequest);
-                            transactionRequest = {
-                                ...transactionRequest,
-                                ...customizedTransactionRequest,
-                            };
-                        }
-                        if (shouldBatchTransactions &&
-                            config.multisig?.sendBatchTransaction) {
-                            if (transactionRequest.to && transactionRequest.data) {
-                                const populatedTransaction = {
-                                    value: transactionRequest.value,
-                                    to: transactionRequest.to,
-                                    data: transactionRequest.data,
-                                };
-                                multisigBatchTransactions.push(populatedTransaction);
-                                txHash = await config.multisig?.sendBatchTransaction(multisigBatchTransactions);
-                            }
-                            else {
-                                throw new TransactionError(LiFiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
-                            }
-                        }
-                        else {
-                            txHash = await walletClient.sendTransaction({
-                                to: transactionRequest.to,
-                                account: walletClient.account,
-                                data: transactionRequest.data,
-                                maxPriorityFeePerGas: transactionRequest.maxPriorityFeePerGas,
-                                chain: null,
-                            });
-                        }
-                        // STEP 4: Wait for the transaction
-                        if (isMultisigWalletClient) {
-                            process = statusManager.updateProcess(step, process.type, 'ACTION_REQUIRED', {
-                                multisigTxHash: txHash,
-                            });
-                        }
-                        else {
-                            process = statusManager.updateProcess(step, process.type, 'PENDING', {
-                                txHash: txHash,
-                                txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${txHash}`,
-                            });
-                        }
-                    }
-                    let replacementReason;
-                    const transactionReceipt = await client.waitForTransactionReceipt({
-                        hash: txHash,
-                        onReplaced(response) {
-                            replacementReason = response.reason;
-                            statusManager.updateProcess(step, process.type, 'PENDING', {
-                                txHash: response.transaction.hash,
-                                txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${response.transaction.hash}`,
-                            });
-                        },
-                    });
-                    if (replacementReason === 'cancelled') {
-                        throw new TransactionError(LiFiErrorCode.TransactionCanceled, 'User canceled transaction.');
-                    }
-                    // if it's multisig wallet client and the process is in ACTION_REQUIRED
-                    // then signatures are still needed
-                    if (isMultisigWalletClient && process.status === 'ACTION_REQUIRED') {
-                        await updateMultisigRouteProcess(transactionReceipt.transactionHash, step, statusManager, process.type, fromChain);
-                    }
-                    if (!isMultisigWalletClient) {
-                        process = statusManager.updateProcess(step, process.type, 'PENDING', {
-                            txHash: transactionReceipt.transactionHash,
-                            txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${transactionReceipt.transactionHash}`,
-                        });
-                    }
-                    if (isBridgeExecution) {
-                        process = statusManager.updateProcess(step, process.type, 'DONE');
-                    }
-                }
-                catch (e) {
-                    const error = await parseError(e, step, process);
-                    process = statusManager.updateProcess(step, process.type, 'FAILED', {
-                        error: {
-                            message: error.message,
-                            htmlMessage: error.htmlMessage,
-                            code: error.code,
-                        },
-                    });
-                    statusManager.updateExecution(step, 'FAILED');
-                    throw error;
-                }
-            }
-            // STEP 5: Wait for the receiving chain
-            const processTxHash = process.txHash;
-            if (isBridgeExecution) {
-                process = statusManager.findOrCreateProcess(step, 'RECEIVING_CHAIN', 'PENDING');
-            }
-            let statusResponse;
-            try {
-                if (!processTxHash) {
-                    throw new Error('Transaction hash is undefined.');
-                }
-                statusResponse = (await waitForReceivingTransaction(processTxHash, statusManager, process.type, step));
-                const statusReceiving = statusResponse.receiving;
-                process = statusManager.updateProcess(step, process.type, 'DONE', {
-                    substatus: statusResponse.substatus,
-                    substatusMessage: statusResponse.substatusMessage ||
-                        getSubstatusMessage(statusResponse.status, statusResponse.substatus),
-                    txHash: statusReceiving?.txHash,
-                    txLink: `${toChain.metamask.blockExplorerUrls[0]}tx/${statusReceiving?.txHash}`,
-                });
-                statusManager.updateExecution(step, 'DONE', {
-                    fromAmount: statusResponse.sending.amount,
-                    toAmount: statusReceiving?.amount,
-                    toToken: statusReceiving?.token,
-                    gasAmount: statusResponse.sending.gasAmount,
-                    gasAmountUSD: statusResponse.sending.gasAmountUSD,
-                    gasPrice: statusResponse.sending.gasPrice,
-                    gasToken: statusResponse.sending.gasToken,
-                    gasUsed: statusResponse.sending.gasUsed,
-                });
-            }
-            catch (e) {
-                const htmlMessage = await getTransactionFailedMessage(step, process.txLink);
-                process = statusManager.updateProcess(step, process.type, 'FAILED', {
-                    error: {
-                        code: LiFiErrorCode.TransactionFailed,
-                        message: 'Failed while waiting for receiving chain.',
-                        htmlMessage,
-                    },
-                });
-                statusManager.updateExecution(step, 'FAILED');
-                console.warn(e);
-                throw e;
-            }
-            // DONE
-            return step.execution;
-        };
-    }
-}

package/dist/execution/StepExecutor.d.ts

@@ -1,15 +0,0 @@
-import type { WalletClient } from 'viem';
-import type { InteractionSettings, InternalExecutionSettings, LifiStep } from '../types';
-import type { StatusManager } from './StatusManager';
-import { StepExecutionManager } from './StepExecutionManager';
-export declare class StepExecutor {
-    stepExecutionManager: StepExecutionManager;
-    statusManager: StatusManager;
-    settings: InternalExecutionSettings;
-    allowUserInteraction: boolean;
-    executionStopped: boolean;
-    constructor(statusManager: StatusManager, settings: InternalExecutionSettings);
-    setInteraction: (settings?: InteractionSettings) => void;
-    checkChain: () => never;
-    executeStep: (walletClient: WalletClient, step: LifiStep) => Promise<LifiStep>;
-}

package/dist/execution/StepExecutor.js

@@ -1,58 +0,0 @@
-import { StepExecutionManager } from './StepExecutionManager';
-import { switchChain } from './switchChain';
-// Please be careful when changing the defaults as it may break the behavior (e.g., background execution)
-const defaultInteractionSettings = {
-    allowInteraction: true,
-    allowUpdates: true,
-    stopExecution: false,
-};
-export class StepExecutor {
-    constructor(statusManager, settings) {
-        this.allowUserInteraction = true;
-        this.executionStopped = false;
-        this.setInteraction = (settings) => {
-            const interactionSettings = {
-                ...defaultInteractionSettings,
-                ...settings,
-            };
-            this.allowUserInteraction = interactionSettings.allowInteraction;
-            this.stepExecutionManager.allowInteraction(interactionSettings.allowInteraction);
-            this.statusManager.allowUpdates(interactionSettings.allowUpdates);
-            this.executionStopped = interactionSettings.stopExecution;
-        };
-        // TODO: add checkChain method and update wallet client inside executors
-        // This can come in handy when we execute multiple routes simultaneously and
-        // should be sure that we are on the right chain when waiting for transactions.
-        this.checkChain = () => {
-            throw new Error('checkChain is not implemented.');
-        };
-        this.executeStep = async (walletClient, step) => {
-            // Make sure that the chain is still correct
-            // 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 updatedWalletClient = await switchChain(walletClient, this.statusManager, step, this.settings.switchChainHook, this.allowUserInteraction);
-                if (!updatedWalletClient) {
-                    // Chain switch was not successful, stop execution here
-                    return step;
-                }
-                walletClient = updatedWalletClient;
-            }
-            const parameters = {
-                walletClient,
-                step,
-                settings: this.settings,
-                statusManager: this.statusManager,
-            };
-            await this.stepExecutionManager.execute(parameters);
-            return step;
-        };
-        this.stepExecutionManager = new StepExecutionManager();
-        this.statusManager = statusManager;
-        this.settings = settings;
-    }
-}

package/dist/execution/checkAllowance.d.ts

@@ -1,4 +0,0 @@
-import type { Hash, WalletClient } from 'viem';
-import type { StatusManager } from '../execution/StatusManager';
-import type { Chain, InternalExecutionSettings, LifiStep } from '../types';
-export declare const checkAllowance: (walletClient: WalletClient, step: LifiStep, statusManager: StatusManager, settings: InternalExecutionSettings, chain: Chain, allowUserInteraction?: boolean, shouldBatchTransactions?: boolean) => Promise<Hash | void>;

package/dist/execution/checkBalance.d.ts

@@ -1,2 +0,0 @@
-import type { LifiStep } from '..';
-export declare const checkBalance: (walletAddress: string, step: LifiStep, depth?: number) => Promise<void>;

package/dist/execution/index.d.ts

@@ -1 +0,0 @@
-export * from './StatusManager';

package/dist/execution/index.js

@@ -1 +0,0 @@
-export * from './StatusManager';

package/dist/execution/multisig.d.ts

@@ -1,4 +0,0 @@
-import type { ExtendedChain, LifiStep, ProcessType } from '@lifi/types';
-import type { Hash } from 'viem';
-import type { StatusManager } from './StatusManager';
-export declare const updateMultisigRouteProcess: (internalTxHash: Hash, step: LifiStep, statusManager: StatusManager, processType: ProcessType, fromChain: ExtendedChain) => Promise<void>;

package/dist/execution/prepareRestart.d.ts

@@ -1,3 +0,0 @@
-import { type WalletClient } from 'viem';
-import type { Route } from '../types';
-export declare const prepareRestart: (route: Route, walletClient: WalletClient) => Promise<void>;

package/dist/execution/prepareRestart.js

@@ -1,61 +0,0 @@
-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/switchChain.d.ts

@@ -1,21 +0,0 @@
-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 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.
- *
- * 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: (walletClient: WalletClient, statusManager: StatusManager, step: LifiStep, switchChainHook: SwitchChainHook, allowUserInteraction: boolean) => Promise<WalletClient | undefined>;

package/dist/execution/waitForReceivingTransaction.d.ts

@@ -1,3 +0,0 @@
-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/index.d.ts

@@ -1,5 +0,0 @@
-export * from './execution';
-export * from './helpers';
-export { LiFi } from './LiFi';
-export * from './types';
-export * from './utils/errors';

package/dist/index.js

@@ -1,6 +0,0 @@
-// expose types and helpers
-export * from './execution';
-export * from './helpers';
-export { LiFi } from './LiFi';
-export * from './types';
-export * from './utils/errors';

package/dist/services/ApiService.d.ts

@@ -1,17 +0,0 @@
-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>;
-    getGasRecommendation: ({ chainId, fromChain, fromToken }: GasRecommendationRequest, options?: RequestOptions | undefined) => Promise<GasRecommendationResponse>;
-    getPossibilities: (requestConfig?: PossibilitiesRequest | undefined, options?: RequestOptions | undefined) => Promise<PossibilitiesResponse>;
-    getQuote: (requestConfig: QuoteRequest, options?: RequestOptions | undefined) => Promise<LifiStep>;
-    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: 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>;
-};
-export default _default;