@lifi/sdk 3.6.0-beta.3 → 3.6.0-beta.4

package/src/_esm/core/EVM/EVMStepExecutor.js

@@ -5,7 +5,6 @@ import { config } from '../../config.js';
 import { LiFiErrorCode } from '../../errors/constants.js';
 import { TransactionError } from '../../errors/errors.js';
 import { getRelayerQuote, getStepTransaction, relayTransaction, } from '../../services/api.js';
-import { isZeroAddress } from '../../utils/isZeroAddress.js';
 import { BaseStepExecutor } from '../BaseStepExecutor.js';
 import { checkBalance } from '../checkBalance.js';
 import { stepComparison } from '../stepComparison.js';
@@ -15,7 +14,7 @@ import { getNativePermit } from './getNativePermit.js';
 import { parseEVMErrors } from './parseEVMErrors.js';
 import { signPermitMessage } from './signPermitMessage.js';
 import { switchChain } from './switchChain.js';
-import { isEVMPermitStep } from './typeguards.js';
+import { isRelayerStep } from './typeguards.js';
 import { getMaxPriorityFeePerGas } from './utils.js';
 import { waitForBatchTransactionReceipt, } from './waitForBatchTransactionReceipt.js';
 import { waitForRelayedTransactionReceipt } from './waitForRelayedTransactionReceipt.js';
@@ -67,6 +66,46 @@ export class EVMStepExecutor extends BaseStepExecutor {
                 return updatedClient;
             }
         });
+        Object.defineProperty(this, "waitForTransaction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async ({ step, process, fromChain, toChain, atomicBatchSupported, isRelayerTransaction, txHash, isBridgeExecution, }) => {
+                let transactionReceipt;
+                if (atomicBatchSupported) {
+                    transactionReceipt = await waitForBatchTransactionReceipt(this.client, txHash);
+                }
+                else if (isRelayerTransaction) {
+                    transactionReceipt = await waitForRelayedTransactionReceipt(txHash);
+                }
+                else {
+                    transactionReceipt = await waitForTransactionReceipt({
+                        client: this.client,
+                        chainId: fromChain.id,
+                        txHash,
+                        onReplaced: (response) => {
+                            this.statusManager.updateProcess(step, process.type, 'PENDING', {
+                                txHash: response.transaction.hash,
+                                txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${response.transaction.hash}`,
+                            });
+                        },
+                    });
+                }
+                // Update pending process if the transaction hash from the receipt is different.
+                // This might happen if the transaction was replaced.
+                if (transactionReceipt?.transactionHash &&
+                    transactionReceipt.transactionHash !== txHash) {
+                    process = this.statusManager.updateProcess(step, process.type, 'PENDING', {
+                        txHash: transactionReceipt.transactionHash,
+                        txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${transactionReceipt.transactionHash}`,
+                    });
+                }
+                if (isBridgeExecution) {
+                    process = this.statusManager.updateProcess(step, process.type, 'DONE');
+                }
+                await waitForDestinationChainTransaction(step, process, fromChain, toChain, this.statusManager);
+            }
+        });
         Object.defineProperty(this, "executeStep", {
             enumerable: true,
             configurable: true,
@@ -87,21 +126,24 @@ export class EVMStepExecutor extends BaseStepExecutor {
                 }
                 const fromChain = await config.getChainById(step.action.fromChainId);
                 const toChain = await config.getChainById(step.action.toChainId);
+                // Check if the wallet supports atomic batch transactions (EIP-5792)
+                const calls = [];
                 let atomicBatchSupported = false;
                 try {
                     const capabilities = (await getAction(this.client, getCapabilities, 'getCapabilities')(undefined));
                     atomicBatchSupported = capabilities[fromChain.id]?.atomicBatch?.supported;
                 }
                 catch {
-                    // If the wallet does not support getCapabilities, we assume that atomic batch is not supported
+                    // If the wallet does not support getCapabilities or the call fails,
+                    // we assume that atomic batch is not supported
                 }
-                const calls = [];
                 const isBridgeExecution = fromChain.id !== toChain.id;
                 const currentProcessType = isBridgeExecution ? 'CROSS_CHAIN' : 'SWAP';
                 // Find existing swap/bridge process
                 const existingProcess = step.execution.process.find((p) => p.type === currentProcessType);
+                const isFromNativeToken = fromChain.nativeToken.address === step.action.fromToken.address;
                 // Check if step requires permit signature and will be used with relayer service
-                const isPermitStep = isEVMPermitStep(step);
+                const isRelayerTransaction = isRelayerStep(step);
                 // Check if token requires approval
                 // Native tokens (like ETH) don't need approval since they're not ERC20 tokens
                 // We should support different permit types:
@@ -110,19 +152,23 @@ export class EVMStepExecutor extends BaseStepExecutor {
                 // 3. Standard ERC20 approval
                 const nativePermit = await getNativePermit(this.client, fromChain, step.action.fromToken.address);
                 // Check if proxy contract is available and token supports native permits, not available for atomic batch
-                const nativePermitSupported = !!fromChain.permit2Proxy &&
-                    nativePermit.supported &&
+                const nativePermitSupported = nativePermit.supported &&
+                    !!fromChain.permit2Proxy &&
                     !atomicBatchSupported &&
-                    !isPermitStep;
+                    !isRelayerTransaction && // TODO: remove once we support ERC-2771
+                    !isFromNativeToken;
                 // Check if chain has Permit2 contract deployed. Permit2 should not be available for atomic batch.
-                const permit2Supported = !!fromChain.permit2 && !!fromChain.permit2Proxy && !atomicBatchSupported;
+                const permit2Supported = !!fromChain.permit2 &&
+                    !!fromChain.permit2Proxy &&
+                    !atomicBatchSupported &&
+                    !isFromNativeToken;
                 // Token supports either native permits or Permit2
                 const permitSupported = permit2Supported || nativePermitSupported;
                 const checkForAllowance = 
                 // No existing swap/bridgetransaction is pending
                 !existingProcess?.txHash &&
                     // Token is not native (address is not zero)
-                    !isZeroAddress(step.action.fromToken.address) &&
+                    !isFromNativeToken &&
                     // Token doesn't support native permits
                     !nativePermitSupported;
                 if (checkForAllowance) {
@@ -149,252 +195,237 @@ export class EVMStepExecutor extends BaseStepExecutor {
                         }
                     }
                 }
-                let process = this.statusManager.findOrCreateProcess({
-                    step,
-                    type: currentProcessType,
-                    chainId: fromChain.id,
-                });
-                if (process.status !== 'DONE') {
-                    try {
-                        let txHash;
-                        if (process.txHash) {
-                            // Make sure that the chain is still correct
-                            const updatedClient = await this.checkClient(step, process);
-                            if (!updatedClient) {
-                                return step;
-                            }
-                            // Wait for exiting transaction
-                            txHash = process.txHash;
+                let process = this.statusManager.findProcess(step, currentProcessType);
+                if (process?.status === 'DONE') {
+                    await waitForDestinationChainTransaction(step, process, fromChain, toChain, this.statusManager);
+                    return step;
+                }
+                try {
+                    if (process?.txHash) {
+                        // Make sure that the chain is still correct
+                        const updatedClient = await this.checkClient(step, process);
+                        if (!updatedClient) {
+                            return step;
                         }
-                        else {
-                            process = this.statusManager.updateProcess(step, process.type, 'STARTED');
-                            // Check balance
-                            await checkBalance(this.client.account.address, step);
-                            // Create new transaction request
-                            if (!step.transactionRequest) {
-                                const { execution, ...stepBase } = step;
-                                let updatedStep;
-                                if (isPermitStep) {
-                                    const updatedRelayedStep = await getRelayerQuote({
-                                        fromChain: stepBase.action.fromChainId,
-                                        fromToken: stepBase.action.fromToken.address,
-                                        fromAddress: stepBase.action.fromAddress,
-                                        fromAmount: stepBase.action.fromAmount,
-                                        toChain: stepBase.action.toChainId,
-                                        toToken: stepBase.action.toToken.address,
-                                        slippage: stepBase.action.slippage,
-                                        toAddress: stepBase.action.toAddress,
-                                        allowBridges: [stepBase.tool],
-                                    });
-                                    updatedStep = {
-                                        ...updatedRelayedStep.data.quote.step,
-                                        ...updatedRelayedStep.data.quote,
-                                        id: stepBase.id,
-                                    };
-                                }
-                                else {
-                                    updatedStep = await getStepTransaction(stepBase);
-                                }
-                                const comparedStep = await stepComparison(this.statusManager, step, updatedStep, this.allowUserInteraction, this.executionOptions);
-                                Object.assign(step, {
-                                    ...comparedStep,
-                                    execution: step.execution,
-                                });
-                            }
-                            if (!step.transactionRequest) {
-                                throw new TransactionError(LiFiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
-                            }
-                            let transactionRequest = {
-                                to: step.transactionRequest.to,
-                                from: step.transactionRequest.from,
-                                data: step.transactionRequest.data,
-                                value: step.transactionRequest.value
-                                    ? BigInt(step.transactionRequest.value)
-                                    : undefined,
-                                gas: step.transactionRequest.gasLimit
-                                    ? BigInt(step.transactionRequest.gasLimit)
-                                    : undefined,
-                                // gasPrice: step.transactionRequest.gasPrice
-                                //   ? BigInt(step.transactionRequest.gasPrice as string)
-                                //   : undefined,
-                                // maxFeePerGas: step.transactionRequest.maxFeePerGas
-                                //   ? BigInt(step.transactionRequest.maxFeePerGas as string)
-                                //   : undefined,
-                                maxPriorityFeePerGas: this.client.account?.type === 'local'
-                                    ? await getMaxPriorityFeePerGas(this.client)
-                                    : step.transactionRequest.maxPriorityFeePerGas
-                                        ? BigInt(step.transactionRequest.maxPriorityFeePerGas)
-                                        : undefined,
+                        // Wait for exiting transaction
+                        const txHash = process.txHash;
+                        await this.waitForTransaction({
+                            step,
+                            process,
+                            fromChain,
+                            toChain,
+                            atomicBatchSupported,
+                            isRelayerTransaction,
+                            txHash,
+                            isBridgeExecution,
+                        });
+                        return step;
+                    }
+                    process = this.statusManager.findOrCreateProcess({
+                        step,
+                        type: permitSupported ? 'PERMIT' : currentProcessType,
+                        status: 'STARTED',
+                    });
+                    // Check balance
+                    await checkBalance(this.client.account.address, step);
+                    // Create new transaction request
+                    if (!step.transactionRequest) {
+                        const { execution, ...stepBase } = step;
+                        let updatedStep;
+                        if (isRelayerTransaction) {
+                            const updatedRelayedStep = await getRelayerQuote({
+                                fromChain: stepBase.action.fromChainId,
+                                fromToken: stepBase.action.fromToken.address,
+                                fromAddress: stepBase.action.fromAddress,
+                                fromAmount: stepBase.action.fromAmount,
+                                toChain: stepBase.action.toChainId,
+                                toToken: stepBase.action.toToken.address,
+                                slippage: stepBase.action.slippage,
+                                toAddress: stepBase.action.toAddress,
+                                allowBridges: [stepBase.tool],
+                            });
+                            updatedStep = {
+                                ...updatedRelayedStep.data.quote.step,
+                                ...updatedRelayedStep.data.quote,
+                                id: stepBase.id,
                             };
-                            if (this.executionOptions?.updateTransactionRequestHook) {
-                                const customizedTransactionRequest = await this.executionOptions.updateTransactionRequestHook({
-                                    requestType: 'transaction',
-                                    ...transactionRequest,
-                                });
-                                transactionRequest = {
-                                    ...transactionRequest,
-                                    ...customizedTransactionRequest,
-                                };
-                            }
-                            // Make sure that the chain is still correct
-                            const updatedClient = await this.checkClient(step, process);
-                            if (!updatedClient) {
-                                return step;
-                            }
-                            process = this.statusManager.updateProcess(step, process.type, permitSupported ? 'PERMIT_REQUIRED' : 'ACTION_REQUIRED');
-                            if (!this.allowUserInteraction) {
-                                return step;
-                            }
-                            let isTransactionRelayed = false;
-                            if (atomicBatchSupported) {
-                                const transferCall = {
-                                    chainId: fromChain.id,
-                                    data: transactionRequest.data,
-                                    to: transactionRequest.to,
-                                    value: transactionRequest.value,
-                                };
-                                calls.push(transferCall);
-                                txHash = (await getAction(this.client, sendCalls, 'sendCalls')({
-                                    account: this.client.account,
-                                    calls,
-                                }));
-                            }
-                            else {
-                                let permitSignature;
-                                if (permitSupported) {
-                                    permitSignature = await signPermitMessage(this.client, {
-                                        transactionRequest,
-                                        chain: fromChain,
-                                        tokenAddress: step.action.fromToken.address,
-                                        amount: BigInt(step.action.fromAmount),
-                                        nativePermit,
-                                        permitData: isPermitStep ? step.permitData : undefined,
-                                        useWitness: isPermitStep,
-                                    });
-                                    transactionRequest.to = fromChain.permit2Proxy;
-                                }
-                                if (isPermitStep && permitSignature) {
-                                    const relayedTransaction = await relayTransaction({
-                                        tokenOwner: this.client.account.address,
-                                        chainId: fromChain.id,
-                                        permit: step.permit,
-                                        witness: step.witness,
-                                        signedPermitData: permitSignature.signature,
-                                        callData: transactionRequest.data,
-                                    });
-                                    txHash = relayedTransaction.data.taskId;
-                                    isTransactionRelayed = true;
-                                }
-                                else {
-                                    if (permitSignature) {
-                                        // If we have a permit signature, we need to use updated data
-                                        transactionRequest.data = permitSignature.data;
-                                        try {
-                                            // Try to re-estimate the gas due to additional Permit data
-                                            const estimatedGas = await estimateGas(this.client, {
-                                                account: this.client.account,
-                                                to: transactionRequest.to,
-                                                data: transactionRequest.data,
-                                                value: transactionRequest.value,
-                                            });
-                                            transactionRequest.gas =
-                                                transactionRequest.gas &&
-                                                    transactionRequest.gas > estimatedGas
-                                                    ? transactionRequest.gas
-                                                    : estimatedGas;
-                                        }
-                                        catch {
-                                            // Let the wallet estimate the gas in case of failure
-                                            transactionRequest.gas = undefined;
-                                        }
-                                    }
-                                    process = this.statusManager.updateProcess(step, process.type, 'ACTION_REQUIRED');
-                                    txHash = await getAction(this.client, sendTransaction, 'sendTransaction')({
-                                        to: transactionRequest.to,
-                                        account: this.client.account,
-                                        data: transactionRequest.data,
-                                        value: transactionRequest.value,
-                                        gas: transactionRequest.gas,
-                                        gasPrice: transactionRequest.gasPrice,
-                                        maxFeePerGas: transactionRequest.maxFeePerGas,
-                                        maxPriorityFeePerGas: transactionRequest.maxPriorityFeePerGas,
-                                    });
-                                }
-                            }
-                            process = this.statusManager.updateProcess(step, process.type, 'PENDING', 
-                            // When atomic batch is supported, txHash represents the batch hash rather than an individual transaction hash at this point
-                            atomicBatchSupported
-                                ? {
-                                    atomicBatchSupported,
-                                }
-                                : isTransactionRelayed
-                                    ? undefined
-                                    : {
-                                        txHash: txHash,
-                                        txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${txHash}`,
-                                    });
                         }
-                        let transactionReceipt;
-                        if (atomicBatchSupported) {
-                            transactionReceipt = await waitForBatchTransactionReceipt(this.client, txHash);
+                        else {
+                            updatedStep = await getStepTransaction(stepBase);
                         }
-                        else if (isPermitStep) {
-                            transactionReceipt = await waitForRelayedTransactionReceipt(txHash);
+                        const comparedStep = await stepComparison(this.statusManager, step, updatedStep, this.allowUserInteraction, this.executionOptions);
+                        Object.assign(step, {
+                            ...comparedStep,
+                            execution: step.execution,
+                        });
+                    }
+                    if (!step.transactionRequest) {
+                        throw new TransactionError(LiFiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
+                    }
+                    let transactionRequest = {
+                        to: step.transactionRequest.to,
+                        from: step.transactionRequest.from,
+                        data: step.transactionRequest.data,
+                        value: step.transactionRequest.value
+                            ? BigInt(step.transactionRequest.value)
+                            : undefined,
+                        gas: step.transactionRequest.gasLimit
+                            ? BigInt(step.transactionRequest.gasLimit)
+                            : undefined,
+                        // gasPrice: step.transactionRequest.gasPrice
+                        //   ? BigInt(step.transactionRequest.gasPrice as string)
+                        //   : undefined,
+                        // maxFeePerGas: step.transactionRequest.maxFeePerGas
+                        //   ? BigInt(step.transactionRequest.maxFeePerGas as string)
+                        //   : undefined,
+                        maxPriorityFeePerGas: this.client.account?.type === 'local'
+                            ? await getMaxPriorityFeePerGas(this.client)
+                            : step.transactionRequest.maxPriorityFeePerGas
+                                ? BigInt(step.transactionRequest.maxPriorityFeePerGas)
+                                : undefined,
+                    };
+                    if (this.executionOptions?.updateTransactionRequestHook) {
+                        const customizedTransactionRequest = await this.executionOptions.updateTransactionRequestHook({
+                            requestType: 'transaction',
+                            ...transactionRequest,
+                        });
+                        transactionRequest = {
+                            ...transactionRequest,
+                            ...customizedTransactionRequest,
+                        };
+                    }
+                    // Make sure that the chain is still correct
+                    const updatedClient = await this.checkClient(step, process);
+                    if (!updatedClient) {
+                        return step;
+                    }
+                    process = this.statusManager.updateProcess(step, process.type, 'ACTION_REQUIRED');
+                    if (!this.allowUserInteraction) {
+                        return step;
+                    }
+                    let txHash;
+                    let isTransactionRelayed = false;
+                    if (atomicBatchSupported) {
+                        const transferCall = {
+                            chainId: fromChain.id,
+                            data: transactionRequest.data,
+                            to: transactionRequest.to,
+                            value: transactionRequest.value,
+                        };
+                        calls.push(transferCall);
+                        txHash = (await getAction(this.client, sendCalls, 'sendCalls')({
+                            account: this.client.account,
+                            calls,
+                        }));
+                    }
+                    else {
+                        let permitSignature;
+                        if (permitSupported) {
+                            permitSignature = await signPermitMessage(this.client, {
+                                transactionRequest,
+                                chain: fromChain,
+                                tokenAddress: step.action.fromToken.address,
+                                amount: BigInt(step.action.fromAmount),
+                                nativePermit,
+                                permitData: isRelayerTransaction ? step.permitData : undefined,
+                                useWitness: isRelayerTransaction,
+                            });
+                            transactionRequest.to = fromChain.permit2Proxy;
+                            this.statusManager.updateProcess(step, process.type, 'DONE');
                         }
-                        else {
-                            transactionReceipt = await waitForTransactionReceipt({
-                                client: this.client,
+                        if (isRelayerTransaction && permitSignature) {
+                            process = this.statusManager.findOrCreateProcess({
+                                step,
+                                type: currentProcessType,
+                                status: 'PENDING',
+                            });
+                            const relayedTransaction = await relayTransaction({
+                                tokenOwner: this.client.account.address,
                                 chainId: fromChain.id,
-                                txHash,
-                                onReplaced: (response) => {
-                                    this.statusManager.updateProcess(step, process.type, 'PENDING', {
-                                        txHash: response.transaction.hash,
-                                        txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${response.transaction.hash}`,
-                                    });
-                                },
+                                permit: step.permit,
+                                witness: step.witness,
+                                signedPermitData: permitSignature.signature,
+                                callData: transactionRequest.data,
                             });
+                            txHash = relayedTransaction.data.taskId;
+                            isTransactionRelayed = true;
                         }
-                        // Update pending process if the transaction hash from the receipt is different.
-                        // This might happen if the transaction was replaced.
-                        if (transactionReceipt?.transactionHash &&
-                            transactionReceipt.transactionHash !== txHash) {
-                            process = this.statusManager.updateProcess(step, process.type, 'PENDING', {
-                                txHash: transactionReceipt.transactionHash,
-                                txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${transactionReceipt.transactionHash}`,
+                        else {
+                            process = this.statusManager.findOrCreateProcess({
+                                step,
+                                type: currentProcessType,
+                                status: 'STARTED',
+                            });
+                            if (permitSignature) {
+                                // If we have a permit signature, we need to use updated data
+                                transactionRequest.data = permitSignature.data;
+                                try {
+                                    // Try to re-estimate the gas due to additional Permit data
+                                    const estimatedGas = await estimateGas(this.client, {
+                                        account: this.client.account,
+                                        to: transactionRequest.to,
+                                        data: transactionRequest.data,
+                                        value: transactionRequest.value,
+                                    });
+                                    transactionRequest.gas =
+                                        transactionRequest.gas && transactionRequest.gas > estimatedGas
+                                            ? transactionRequest.gas
+                                            : estimatedGas;
+                                }
+                                catch {
+                                    // Let the wallet estimate the gas in case of failure
+                                    transactionRequest.gas = undefined;
+                                }
+                            }
+                            process = this.statusManager.updateProcess(step, process.type, 'ACTION_REQUIRED');
+                            txHash = await getAction(this.client, sendTransaction, 'sendTransaction')({
+                                to: transactionRequest.to,
+                                account: this.client.account,
+                                data: transactionRequest.data,
+                                value: transactionRequest.value,
+                                gas: transactionRequest.gas,
+                                gasPrice: transactionRequest.gasPrice,
+                                maxFeePerGas: transactionRequest.maxFeePerGas,
+                                maxPriorityFeePerGas: transactionRequest.maxPriorityFeePerGas,
                             });
-                        }
-                        if (isBridgeExecution) {
-                            process = this.statusManager.updateProcess(step, process.type, 'DONE');
                         }
                     }
-                    catch (e) {
-                        const error = await parseEVMErrors(e, step, process);
-                        process = this.statusManager.updateProcess(step, process.type, 'FAILED', {
-                            error: {
-                                message: error.cause.message,
-                                code: error.code,
-                            },
-                        });
-                        this.statusManager.updateExecution(step, 'FAILED');
-                        throw error;
-                    }
-                }
-                // Wait for the transaction status on the destination chain
-                const transactionHash = process.txHash;
-                if (!transactionHash) {
-                    throw new Error('Transaction hash is undefined.');
-                }
-                if (isBridgeExecution) {
-                    process = this.statusManager.findOrCreateProcess({
+                    process = this.statusManager.updateProcess(step, process.type, 'PENDING', 
+                    // When atomic batch is supported, txHash represents the batch hash rather than an individual transaction hash at this point
+                    atomicBatchSupported
+                        ? {
+                            atomicBatchSupported,
+                        }
+                        : isTransactionRelayed
+                            ? undefined
+                            : {
+                                txHash: txHash,
+                                txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${txHash}`,
+                            });
+                    await this.waitForTransaction({
                         step,
-                        type: 'RECEIVING_CHAIN',
-                        status: 'PENDING',
-                        chainId: toChain.id,
+                        process,
+                        fromChain,
+                        toChain,
+                        atomicBatchSupported,
+                        isRelayerTransaction,
+                        txHash,
+                        isBridgeExecution,
                     });
+                    // DONE
+                    return step;
+                }
+                catch (e) {
+                    const error = await parseEVMErrors(e, step, process);
+                    process = this.statusManager.updateProcess(step, process?.type || currentProcessType, 'FAILED', {
+                        error: {
+                            message: error.cause.message,
+                            code: error.code,
+                        },
+                    });
+                    this.statusManager.updateExecution(step, 'FAILED');
+                    throw error;
                 }
-                await waitForDestinationChainTransaction(step, process.type, transactionHash, toChain, this.statusManager);
-                // DONE
-                return step;
             }
         });
         this.client = options.client;