@lifi/sdk 3.5.0-beta.0 → 3.5.1-beta.0

package/src/core/EVM/EVMStepExecutor.ts

@@ -1,67 +1,54 @@
+import type { Process } from '@lifi/types'
 import type {
-  ExtendedTransactionInfo,
-  FullStatusData,
-  Process,
-} from '@lifi/types'
-import type {
-  Address,
   Client,
+  GetAddressesReturnType,
   Hash,
-  Hex,
   SendTransactionParameters,
-  TransactionReceipt,
 } from 'viem'
-import { estimateGas, getAddresses, sendTransaction } from 'viem/actions'
-import { getCapabilities, sendCalls } from 'viem/experimental'
+import { getAddresses, sendTransaction } from 'viem/actions'
+import { getAction } from 'viem/utils'
 import { config } from '../../config.js'
 import { LiFiErrorCode } from '../../errors/constants.js'
-import { TransactionError } from '../../errors/errors.js'
+import { TransactionError, ValidationError } from '../../errors/errors.js'
 import { getStepTransaction } from '../../services/api.js'
-import { getTransactionFailedMessage } from '../../utils/getTransactionMessage.js'
 import { isZeroAddress } from '../../utils/isZeroAddress.js'
 import { BaseStepExecutor } from '../BaseStepExecutor.js'
 import { checkBalance } from '../checkBalance.js'
-import { getSubstatusMessage } from '../processMessages.js'
 import { stepComparison } from '../stepComparison.js'
 import type {
   LiFiStepExtended,
   StepExecutorOptions,
   TransactionParameters,
 } from '../types.js'
-import { waitForReceivingTransaction } from '../waitForReceivingTransaction.js'
+import { waitForDestinationChainTransaction } from '../waitForDestinationChainTransaction.js'
 import { checkAllowance } from './checkAllowance.js'
-import { getNativePermit } from './getNativePermit.js'
+import { updateMultisigRouteProcess } from './multisig.js'
 import { parseEVMErrors } from './parseEVMErrors.js'
-import { signPermitMessage } from './signPermitMessage.js'
 import { switchChain } from './switchChain.js'
+import type { MultisigConfig, MultisigTransaction } from './types.js'
 import { getMaxPriorityFeePerGas } from './utils.js'
-import {
-  type WalletCallReceipt,
-  waitForBatchTransactionReceipt,
-} from './waitForBatchTransactionReceipt.js'
 import { waitForTransactionReceipt } from './waitForTransactionReceipt.js'
 
-export type Call = {
-  data?: Hex
-  to?: Address
-  value?: bigint
-  chainId?: number
-}
-
 export interface EVMStepExecutorOptions extends StepExecutorOptions {
   client: Client
+  multisig?: MultisigConfig
 }
 
 export class EVMStepExecutor extends BaseStepExecutor {
   private client: Client
+  private multisig?: MultisigConfig
 
   constructor(options: EVMStepExecutorOptions) {
     super(options)
     this.client = options.client
+    this.multisig = options.multisig
   }
 
   // Ensure that we are using the right chain and wallet when executing transactions.
-  checkClient = async (step: LiFiStepExtended, process?: Process) => {
+  checkClient = async (
+    step: LiFiStepExtended,
+    process?: Process
+  ): Promise<Client | undefined> => {
     const updatedClient = await switchChain(
       this.client,
       this.statusManager,
@@ -76,7 +63,11 @@ export class EVMStepExecutor extends BaseStepExecutor {
     // Prevent execution of the quote by wallet different from the one which requested the quote
     let accountAddress = this.client.account?.address
     if (!accountAddress) {
-      const accountAddresses = await getAddresses(this.client)
+      const accountAddresses = (await getAction(
+        this.client,
+        getAddresses,
+        'getAddresses'
+      )(undefined)) as GetAddressesReturnType
       accountAddress = accountAddresses?.[0]
     }
     if (accountAddress !== step.action.fromAddress) {
@@ -112,101 +103,68 @@ export class EVMStepExecutor extends BaseStepExecutor {
   executeStep = async (step: LiFiStepExtended): Promise<LiFiStepExtended> => {
     step.execution = this.statusManager.initExecutionObject(step)
 
-    // Find if it's bridging and the step is waiting for a transaction on the receiving chain
-    const recievingChainProcess = step.execution?.process.find(
+    // Find if it's bridging and the step is waiting for a transaction on the destination chain
+    const destinationChainProcess = step.execution?.process.find(
       (process) => process.type === 'RECEIVING_CHAIN'
     )
 
     // Make sure that the chain is still correct
-    // If the step is waiting for a transaction on the receiving chain, we do not switch the chain
+    // If the step is waiting for a transaction on the destination 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') {
+    if (destinationChainProcess?.substatus !== 'WAIT_DESTINATION_TRANSACTION') {
       const updatedClient = await this.checkClient(step)
       if (!updatedClient) {
         return step
       }
     }
 
-    const fromChain = await config.getChainById(step.action.fromChainId)
-    const toChain = await config.getChainById(step.action.toChainId)
+    const isMultisigClient = !!this.multisig?.isMultisigWalletClient
+    const multisigBatchTransactions: MultisigTransaction[] = []
 
-    let atomicBatchSupported = false
-    try {
-      const capabilities = await getCapabilities(this.client)
-      atomicBatchSupported = capabilities[fromChain.id]?.atomicBatch?.supported
-    } catch {
-      // If the wallet does not support getCapabilities, we assume that atomic batch is not supported
-    }
+    const shouldBatchTransactions =
+      this.multisig?.shouldBatchTransactions &&
+      !!this.multisig.sendBatchTransaction
 
-    const calls: Call[] = []
+    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
-    // Find existing swap/bridge process
+    // Check allowance
     const existingProcess = step.execution.process.find(
       (p) => p.type === currentProcessType
     )
 
-    // 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:
-    // 1. Native permits (EIP-2612)
-    // 2. Permit2 - Universal permit implementation by Uniswap (limited to certain chains)
-    // 3. Standard ERC20 approval
-    const nativePermit = await getNativePermit(
-      this.client,
-      fromChain,
-      step.action.fromToken.address as Address
-    )
-    // Check if proxy contract is available and token supports native permits, not available for atomic batch
-    const nativePermitSupported =
-      !!fromChain.permit2Proxy &&
-      nativePermit.supported &&
-      !atomicBatchSupported
-    // Check if chain has Permit2 contract deployed. Permit2 should not be available for atomic batch.
-    const permit2Supported =
-      !!fromChain.permit2 && !!fromChain.permit2Proxy && !atomicBatchSupported
-    // Token supports either native permits or Permit2
-    const permitSupported = permit2Supported || nativePermitSupported
-
+    // Check token approval only if fromToken is not the native token => no approval needed in that case
     const checkForAllowance =
-      // No existing swap/bridgetransaction is pending
       !existingProcess?.txHash &&
-      // Token is not native (address is not zero)
       !isZeroAddress(step.action.fromToken.address) &&
-      // Token doesn't support native permits
-      !nativePermitSupported
+      (shouldBatchTransactions || !isMultisigClient)
 
     if (checkForAllowance) {
-      // Check if token needs approval and get approval transaction or message data when available
-      const data = await checkAllowance({
-        client: this.client,
-        chain: fromChain,
+      const data = await checkAllowance(
+        this.client,
+        fromChain,
         step,
-        statusManager: this.statusManager,
-        executionOptions: this.executionOptions,
-        allowUserInteraction: this.allowUserInteraction,
-        atomicBatchSupported,
-        permit2Supported,
-      })
+        this.statusManager,
+        this.executionOptions,
+        this.allowUserInteraction,
+        shouldBatchTransactions
+      )
 
       if (data) {
-        // Create approval transaction call
-        // No value needed since we're only approving ERC20 tokens
-        if (atomicBatchSupported) {
-          calls.push({
-            chainId: step.action.fromToken.chainId,
-            to: step.action.fromToken.address as Address,
-            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,
       type: currentProcessType,
@@ -214,7 +172,28 @@ export class EVMStepExecutor extends BaseStepExecutor {
     })
 
     if (process.status !== 'DONE') {
+      const multisigProcess = step.execution.process.find(
+        (p) => !!p.multisigTxHash
+      )
+
       try {
+        if (isMultisigClient && 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
@@ -235,7 +214,7 @@ export class EVMStepExecutor extends BaseStepExecutor {
           // Check balance
           await checkBalance(this.client.account!.address, step)
 
-          // Create new transaction request
+          // Create new transaction
           if (!step.transactionRequest) {
             const { execution, ...stepBase } = step
             const updatedStep = await getStepTransaction(stepBase)
@@ -259,6 +238,22 @@ export class EVMStepExecutor extends BaseStepExecutor {
             )
           }
 
+          // 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 transactionRequest: TransactionParameters = {
             to: step.transactionRequest.to,
             from: step.transactionRequest.from,
@@ -296,72 +291,30 @@ export class EVMStepExecutor extends BaseStepExecutor {
             }
           }
 
-          // STEP 3: Send the transaction
-          // 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
-          }
-
-          if (atomicBatchSupported) {
-            const transferCall: Call = {
-              chainId: fromChain.id,
-              data: transactionRequest.data as Hex,
-              to: transactionRequest.to as Address,
-              value: transactionRequest.value,
-            }
-
-            calls.push(transferCall)
-
-            txHash = (await sendCalls(this.client, {
-              account: this.client.account!,
-              calls,
-            })) as Address
-          } else {
-            if (permitSupported) {
-              const { data } = await signPermitMessage(
-                this.client,
-                transactionRequest,
-                fromChain,
-                step.action.fromToken.address as Address,
-                BigInt(step.action.fromAmount),
-                nativePermit
-              )
-
-              transactionRequest.to = fromChain.permit2Proxy
-              transactionRequest.data = data
-
-              try {
-                // Try to re-estimate the gas due to additional Permit data
-                transactionRequest.gas = await estimateGas(this.client, {
-                  account: this.client.account!,
-                  to: transactionRequest.to as Address,
-                  data: transactionRequest.data as Hex,
-                  value: transactionRequest.value,
-                })
-              } catch {
-                // Let the wallet estimate the gas in case of failure
-                transactionRequest.gas = undefined
+          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)
 
-              process = this.statusManager.updateProcess(
-                step,
-                process.type,
-                'ACTION_REQUIRED'
+              txHash = await this.multisig?.sendBatchTransaction(
+                multisigBatchTransactions
+              )
+            } else {
+              throw new TransactionError(
+                LiFiErrorCode.TransactionUnprepared,
+                'Unable to prepare transaction.'
               )
             }
-
-            txHash = await sendTransaction(this.client, {
+          } else {
+            txHash = await getAction(
+              this.client,
+              sendTransaction,
+              'sendTransaction'
+            )({
               to: transactionRequest.to,
               account: this.client.account!,
               data: transactionRequest.data,
@@ -370,53 +323,61 @@ export class EVMStepExecutor extends BaseStepExecutor {
               gasPrice: transactionRequest.gasPrice,
               maxFeePerGas: transactionRequest.maxFeePerGas,
               maxPriorityFeePerGas: transactionRequest.maxPriorityFeePerGas,
+              chain: null,
             } as SendTransactionParameters)
           }
 
-          // STEP 4: Wait for the transaction
-          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,
-                }
-              : {
-                  txHash: txHash,
-                  txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${txHash}`,
-                }
-          )
+          if (isMultisigClient) {
+            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 transactionReceipt:
-          | TransactionReceipt
-          | WalletCallReceipt
-          | undefined
+        const 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}`,
+            })
+          },
+        })
 
-        if (atomicBatchSupported) {
-          transactionReceipt = await waitForBatchTransactionReceipt(
-            this.client,
-            txHash
+        // if it's multisig wallet client and the process is in ACTION_REQUIRED
+        // then signatures are still needed
+        if (isMultisigClient && process.status === 'ACTION_REQUIRED') {
+          await updateMultisigRouteProcess(
+            transactionReceipt?.transactionHash || txHash,
+            step,
+            process.type,
+            fromChain,
+            this.statusManager,
+            this.multisig
           )
-        } 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 (
+          !isMultisigClient &&
           transactionReceipt?.transactionHash &&
           transactionReceipt.transactionHash !== txHash
         ) {
@@ -453,8 +414,7 @@ export class EVMStepExecutor extends BaseStepExecutor {
       }
     }
 
-    // STEP 5: Wait for the receiving chain
-    const processTxHash = process.txHash
+    // Wait for the transaction status on the destination chain
     if (isBridgeExecution) {
       process = this.statusManager.findOrCreateProcess({
         step,
@@ -464,61 +424,12 @@ export class EVMStepExecutor extends BaseStepExecutor {
       })
     }
 
-    try {
-      if (!processTxHash) {
-        throw new Error('Transaction hash is undefined.')
-      }
-      const 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')
-      throw await parseEVMErrors(e as Error, step, process)
-    }
+    await waitForDestinationChainTransaction(
+      step,
+      process,
+      this.statusManager,
+      toChain
+    )
 
     // DONE
     return step

package/src/core/EVM/abi.ts

@@ -1,44 +1,47 @@
-import { parseAbi } from 'viem'
+import type { Abi } from 'viem'
 
-export const permit2ProxyAbi = parseAbi([
-  'function callDiamondWithPermit2(bytes, ((address, uint256), uint256, uint256), bytes) external',
-  'function callDiamondWithEIP2612Signature(address, uint256, uint256, uint8, bytes32, bytes32, bytes) external payable',
-  'function nextNonce(address) external view returns (uint256)',
-  'function callDiamondWithPermit2Witness(bytes, address, ((address, uint256), uint256, uint256), bytes) external payable',
-])
+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 eip2612Abi = parseAbi([
-  'function permit(address, address, uint256, uint256, uint8, bytes32, bytes32) external',
-  'function DOMAIN_SEPARATOR() external view returns (bytes32)',
-  'function nonces(address) external view returns (uint256)',
-  'function name() external view returns (string)',
-  'function version() external view returns (string)',
-])
+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 approveAbi = parseAbi([
-  'function approve(address, uint256) external returns (bool)',
-])
+export const getEthBalanceAbi: Abi = [
+  {
+    inputs: [{ name: '_owner', type: 'address' }],
+    name: 'getEthBalance',
+    outputs: [{ name: 'balance', type: 'uint256' }],
+    type: 'function',
+    stateMutability: 'view',
+  },
+]
 
-export const allowanceAbi = parseAbi([
-  'function allowance(address, address) external view returns (uint256)',
-])
-
-export const getEthBalanceAbi = parseAbi([
-  'function getEthBalance(address) external view returns (uint256)',
-])
-
-export const balanceOfAbi = parseAbi([
-  'function balanceOf(address) external view returns (uint256)',
-])
-
-// EIP-2612 types
-// https://eips.ethereum.org/EIPS/eip-2612
-export const eip2612Types = {
-  Permit: [
-    { name: 'owner', type: 'address' },
-    { name: 'spender', type: 'address' },
-    { name: 'value', type: 'uint256' },
-    { name: 'nonce', type: 'uint256' },
-    { name: 'deadline', type: 'uint256' },
-  ],
-} as const
+export const balanceOfAbi: Abi = [
+  {
+    inputs: [{ name: '_owner', type: 'address' }],
+    name: 'balanceOf',
+    outputs: [{ name: 'balance', type: 'uint256' }],
+    type: 'function',
+    stateMutability: 'view',
+  },
+]