@lifi/sdk 3.0.0-alpha.4 → 3.0.0-alpha.41

package/src/core/EVM/EVMStepExecutor.ts

@@ -0,0 +1,461 @@
+import type { ExtendedTransactionInfo, FullStatusData } from '@lifi/types'
+import type {
+  Address,
+  Hash,
+  PublicClient,
+  ReplacementReason,
+  SendTransactionParameters,
+  WalletClient,
+} from 'viem'
+import { publicActions } from 'viem'
+import { config } from '../../config.js'
+import { getStepTransaction } from '../../services/api.js'
+import {
+  LiFiErrorCode,
+  TransactionError,
+  ValidationError,
+  getTransactionFailedMessage,
+  isZeroAddress,
+  parseError,
+} from '../../utils/index.js'
+import { BaseStepExecutor } from '../BaseStepExecutor.js'
+import { checkBalance } from '../checkBalance.js'
+import { stepComparison } from '../stepComparison.js'
+import type {
+  LiFiStepExtended,
+  StepExecutorOptions,
+  TransactionParameters,
+} from '../types.js'
+import { getSubstatusMessage } from '../utils.js'
+import { waitForReceivingTransaction } from '../waitForReceivingTransaction.js'
+import { checkAllowance } from './checkAllowance.js'
+import { updateMultisigRouteProcess } from './multisig.js'
+import { switchChain } from './switchChain.js'
+import type { MultisigConfig, MultisigTransaction } from './types.js'
+import { getMaxPriorityFeePerGas } from './utils.js'
+
+export interface EVMStepExecutorOptions extends StepExecutorOptions {
+  walletClient: WalletClient
+  multisig?: MultisigConfig
+}
+
+export class EVMStepExecutor extends BaseStepExecutor {
+  private walletClient: WalletClient
+  private multisig?: MultisigConfig
+
+  constructor(options: EVMStepExecutorOptions) {
+    super(options)
+    this.walletClient = options.walletClient
+    this.multisig = options.multisig
+  }
+
+  // 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.
+  checkChain = async (
+    step: LiFiStepExtended
+  ): Promise<WalletClient | undefined> => {
+    const updatedWalletClient = await switchChain(
+      this.walletClient,
+      this.statusManager,
+      step,
+      this.allowUserInteraction,
+      this.executionOptions?.switchChainHook
+    )
+    if (updatedWalletClient) {
+      this.walletClient = updatedWalletClient
+    }
+    return updatedWalletClient
+  }
+
+  executeStep = async (step: LiFiStepExtended): Promise<LiFiStepExtended> => {
+    // 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') {
+      const updatedWalletClient = await this.checkChain(step)
+      if (!updatedWalletClient) {
+        return step
+      }
+    }
+
+    const isMultisigWalletClient = !!this.multisig?.isMultisigWalletClient
+    const multisigBatchTransactions: MultisigTransaction[] = []
+
+    const shouldBatchTransactions =
+      this.multisig?.shouldBatchTransactions &&
+      !!this.multisig.sendBatchTransaction
+
+    step.execution = this.statusManager.initExecutionObject(step)
+
+    const fromChain = await config.getChainById(step.action.fromChainId)
+    const toChain = await config.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(
+        fromChain,
+        step,
+        this.walletClient,
+        this.statusManager,
+        this.executionOptions,
+        this.allowUserInteraction,
+        shouldBatchTransactions
+      )
+
+      if (data) {
+        // allowance doesn't need value
+        const baseTransaction: MultisigTransaction = {
+          to: step.action.fromToken.address,
+          data,
+        }
+
+        multisigBatchTransactions.push(baseTransaction)
+      }
+    }
+
+    // STEP 2: Get transaction
+    let process = this.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 as Hash
+          if (!multisigTxHash) {
+            throw new ValidationError(
+              'Multisig internal transaction hash is undefined.'
+            )
+          }
+          await updateMultisigRouteProcess(
+            multisigTxHash,
+            step,
+            process.type,
+            fromChain,
+            this.statusManager,
+            this.multisig
+          )
+        }
+
+        let txHash: Hash
+        if (process.txHash) {
+          // Make sure that the chain is still correct
+          const updatedWalletClient = await this.checkChain(step)
+          if (!updatedWalletClient) {
+            return step
+          }
+
+          // Wait for exiting transaction
+          txHash = process.txHash as Hash
+        } else {
+          process = this.statusManager.updateProcess(
+            step,
+            process.type,
+            'STARTED'
+          )
+
+          // Check balance
+          await checkBalance(this.walletClient.account!.address, step)
+
+          // Create new transaction
+          if (!step.transactionRequest) {
+            const { execution, ...stepBase } = step
+            const updatedStep = await getStepTransaction(stepBase)
+            const comparedStep = await stepComparison(
+              this.statusManager,
+              step,
+              updatedStep,
+              this.allowUserInteraction,
+              this.executionOptions
+            )
+            step = {
+              ...comparedStep,
+              execution: step.execution,
+            }
+          }
+
+          if (!step.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 this.checkChain(step)
+          if (!updatedWalletClient) {
+            return step
+          }
+
+          process = this.statusManager.updateProcess(
+            step,
+            process.type,
+            'ACTION_REQUIRED'
+          )
+
+          if (!this.allowUserInteraction) {
+            return step
+          }
+
+          let transactionRequest: TransactionParameters = {
+            to: step.transactionRequest.to as Hash,
+            from: step.transactionRequest.from as Hash,
+            data: step.transactionRequest.data as Hash,
+            value: step.transactionRequest.value
+              ? BigInt(step.transactionRequest.value as string)
+              : 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:
+              this.walletClient.account?.type === 'local'
+                ? await getMaxPriorityFeePerGas(
+                    this.walletClient.extend(publicActions) as PublicClient
+                  )
+                : step.transactionRequest.maxPriorityFeePerGas
+                  ? BigInt(
+                      step.transactionRequest.maxPriorityFeePerGas as string
+                    )
+                  : undefined,
+          }
+
+          if (this.executionOptions?.updateTransactionRequestHook) {
+            const customizedTransactionRequest: TransactionParameters =
+              await this.executionOptions.updateTransactionRequestHook({
+                requestType: 'transaction',
+                ...transactionRequest,
+              })
+
+            transactionRequest = {
+              ...transactionRequest,
+              ...customizedTransactionRequest,
+            }
+          }
+
+          if (shouldBatchTransactions && this.multisig?.sendBatchTransaction) {
+            if (transactionRequest.to && transactionRequest.data) {
+              const populatedTransaction: MultisigTransaction = {
+                value: transactionRequest.value,
+                to: transactionRequest.to,
+                data: transactionRequest.data,
+              }
+              multisigBatchTransactions.push(populatedTransaction)
+
+              txHash = await this.multisig?.sendBatchTransaction(
+                multisigBatchTransactions
+              )
+            } else {
+              throw new TransactionError(
+                LiFiErrorCode.TransactionUnprepared,
+                'Unable to prepare transaction.'
+              )
+            }
+          } else {
+            txHash = await this.walletClient.sendTransaction({
+              to: transactionRequest.to as Address,
+              account: this.walletClient.account!,
+              data: transactionRequest.data,
+              value: transactionRequest.value,
+              gas: transactionRequest.gas,
+              gasPrice: transactionRequest.gasPrice,
+              maxFeePerGas: transactionRequest.maxFeePerGas,
+              maxPriorityFeePerGas: transactionRequest.maxPriorityFeePerGas,
+              chain: null,
+            } as SendTransactionParameters)
+          }
+
+          // STEP 4: Wait for the transaction
+          if (isMultisigWalletClient) {
+            process = this.statusManager.updateProcess(
+              step,
+              process.type,
+              'ACTION_REQUIRED',
+              {
+                multisigTxHash: txHash,
+              }
+            )
+          } else {
+            process = this.statusManager.updateProcess(
+              step,
+              process.type,
+              'PENDING',
+              {
+                txHash: txHash,
+                txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${txHash}`,
+              }
+            )
+          }
+        }
+
+        let replacementReason: ReplacementReason | undefined
+        const transactionReceipt = await this.walletClient
+          .extend(publicActions)
+          .waitForTransactionReceipt({
+            hash: txHash,
+            onReplaced: (response) => {
+              replacementReason = response.reason
+              this.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,
+            process.type,
+            fromChain,
+            this.statusManager,
+            this.multisig
+          )
+        }
+
+        if (!isMultisigWalletClient) {
+          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')
+        }
+      } catch (e: any) {
+        const error = await parseError(e, step, process)
+        process = this.statusManager.updateProcess(
+          step,
+          process.type,
+          'FAILED',
+          {
+            error: {
+              message: error.message,
+              htmlMessage: error.htmlMessage,
+              code: error.code,
+            },
+          }
+        )
+        this.statusManager.updateExecution(step, 'FAILED')
+        throw error
+      }
+    }
+
+    // STEP 5: Wait for the receiving chain
+    const processTxHash = process.txHash
+    if (isBridgeExecution) {
+      process = this.statusManager.findOrCreateProcess(
+        step,
+        'RECEIVING_CHAIN',
+        'PENDING'
+      )
+    }
+    let statusResponse: FullStatusData
+    try {
+      if (!processTxHash) {
+        throw new Error('Transaction hash is undefined.')
+      }
+      statusResponse = (await waitForReceivingTransaction(
+        processTxHash,
+        this.statusManager,
+        process.type,
+        step
+      )) as FullStatusData
+
+      const statusReceiving =
+        statusResponse.receiving as ExtendedTransactionInfo
+
+      process = this.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}`,
+      })
+
+      this.statusManager.updateExecution(step, 'DONE', {
+        fromAmount: statusResponse.sending.amount,
+        toAmount: statusReceiving?.amount,
+        toToken: statusReceiving?.token,
+        gasCosts: [
+          {
+            amount: statusResponse.sending.gasAmount,
+            amountUSD: statusResponse.sending.gasAmountUSD,
+            token: statusResponse.sending.gasToken,
+            estimate: statusResponse.sending.gasUsed,
+            limit: statusResponse.sending.gasUsed,
+            price: statusResponse.sending.gasPrice,
+            type: 'SEND',
+          },
+        ],
+      })
+    } catch (e: unknown) {
+      const htmlMessage = await getTransactionFailedMessage(
+        step,
+        process.txLink
+      )
+
+      process = this.statusManager.updateProcess(step, process.type, 'FAILED', {
+        error: {
+          code: LiFiErrorCode.TransactionFailed,
+          message: 'Failed while waiting for receiving chain.',
+          htmlMessage,
+        },
+      })
+      this.statusManager.updateExecution(step, 'FAILED')
+      console.warn(e)
+      throw e
+    }
+
+    // DONE
+    return step
+  }
+}

package/src/core/EVM/abi.ts

@@ -0,0 +1,47 @@
+import type { Abi } from 'viem'
+
+export const approveAbi: Abi = [
+  {
+    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: Abi = [
+  {
+    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: Abi = [
+  {
+    inputs: [{ name: '_owner', type: 'address' }],
+    name: 'getEthBalance',
+    outputs: [{ name: 'balance', type: 'uint256' }],
+    type: 'function',
+    stateMutability: 'view',
+  },
+]
+
+export const balanceOfAbi: Abi = [
+  {
+    inputs: [{ name: '_owner', type: 'address' }],
+    name: 'balanceOf',
+    outputs: [{ name: 'balance', type: 'uint256' }],
+    type: 'function',
+    stateMutability: 'view',
+  },
+]

package/src/core/EVM/checkAllowance.ts

@@ -0,0 +1,152 @@
+import type { Chain, LiFiStep, Process, ProcessType } from '@lifi/types'
+import type { Address, Hash, ReplacementReason, WalletClient } from 'viem'
+import { maxUint256, publicActions } from 'viem'
+import { LiFiErrorCode, TransactionError } from '../../utils/index.js'
+import { parseError } from '../../utils/parseError.js'
+import type { StatusManager } from '../StatusManager.js'
+import type { ExecutionOptions } from '../types.js'
+import { getAllowance } from './getAllowance.js'
+import { setAllowance } from './setAllowance.js'
+
+export const checkAllowance = async (
+  chain: Chain,
+  step: LiFiStep,
+  walletClient: WalletClient,
+  statusManager: StatusManager,
+  settings?: ExecutionOptions,
+  allowUserInteraction = false,
+  shouldBatchTransactions = false
+): Promise<Hash | void> => {
+  // Ask the user to set an allowance
+  let allowanceProcess: Process = statusManager.findOrCreateProcess(
+    step,
+    'TOKEN_ALLOWANCE'
+  )
+
+  // Check allowance
+  try {
+    if (allowanceProcess.txHash && allowanceProcess.status !== 'DONE') {
+      await waitForApprovalTransaction(
+        walletClient,
+        allowanceProcess.txHash! as Address,
+        allowanceProcess.type,
+        step,
+        chain,
+        statusManager
+      )
+    } else {
+      const approved = await getAllowance(
+        chain.id,
+        step.action.fromToken.address,
+        walletClient.account!.address,
+        step.estimate.approvalAddress
+      )
+
+      const fromAmount = BigInt(step.action.fromAmount)
+
+      if (fromAmount > approved) {
+        if (!allowUserInteraction) {
+          return
+        }
+        const approvalAmount = settings?.infiniteApproval
+          ? maxUint256
+          : fromAmount
+
+        if (shouldBatchTransactions) {
+          const approveTxHash = await setAllowance(
+            walletClient,
+            step.action.fromToken.address,
+            step.estimate.approvalAddress,
+            approvalAmount,
+            settings,
+            true
+          )
+
+          allowanceProcess = statusManager.updateProcess(
+            step,
+            allowanceProcess.type,
+            'DONE'
+          )
+
+          return approveTxHash
+        }
+
+        const approveTxHash = await setAllowance(
+          walletClient,
+          step.action.fromToken.address,
+          step.estimate.approvalAddress,
+          approvalAmount
+        )
+        await waitForApprovalTransaction(
+          walletClient,
+          approveTxHash,
+          allowanceProcess.type,
+          step,
+          chain,
+          statusManager
+        )
+      } else {
+        allowanceProcess = statusManager.updateProcess(
+          step,
+          allowanceProcess.type,
+          'DONE'
+        )
+      }
+    }
+  } catch (e: any) {
+    const error = await parseError(e, step, allowanceProcess)
+    allowanceProcess = statusManager.updateProcess(
+      step,
+      allowanceProcess.type,
+      'FAILED',
+      {
+        error: {
+          message: error.message,
+          htmlMessage: error.htmlMessage,
+          code: error.code,
+        },
+      }
+    )
+    statusManager.updateExecution(step, 'FAILED')
+    throw error
+  }
+}
+
+const waitForApprovalTransaction = async (
+  walletClient: WalletClient,
+  txHash: Hash,
+  processType: ProcessType,
+  step: LiFiStep,
+  chain: Chain,
+  statusManager: StatusManager
+) => {
+  const client = walletClient.extend(publicActions)
+  statusManager.updateProcess(step, processType, 'PENDING', {
+    txHash,
+    txLink: `${chain.metamask.blockExplorerUrls[0]}tx/${txHash}`,
+  })
+
+  let replacementReason: ReplacementReason | undefined
+  const transactionReceipt = await client.waitForTransactionReceipt({
+    hash: txHash,
+    onReplaced(response) {
+      replacementReason = response.reason
+      statusManager.updateProcess(step, processType, 'PENDING', {
+        txHash: response.transaction.hash,
+        txLink: `${chain.metamask.blockExplorerUrls[0]}tx/${response.transaction.hash}`,
+      })
+    },
+  })
+
+  if (replacementReason === 'cancelled') {
+    throw new TransactionError(
+      LiFiErrorCode.TransactionCanceled,
+      'User canceled transaction.'
+    )
+  }
+
+  statusManager.updateProcess(step, processType, 'DONE', {
+    txHash: transactionReceipt.transactionHash,
+    txLink: `${chain.metamask.blockExplorerUrls[0]}tx/${transactionReceipt.transactionHash}`,
+  })
+}