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

package/src/core/EVM/checkAllowance.ts

@@ -1,6 +1,5 @@
-import type { ExtendedChain, LiFiStep, Process, ProcessType } from '@lifi/types'
+import type { Chain, LiFiStep, Process, ProcessType } from '@lifi/types'
 import type { Address, Client, Hash } from 'viem'
-import { MaxUint256 } from '../../constants.js'
 import type { StatusManager } from '../StatusManager.js'
 import type { ExecutionOptions } from '../types.js'
 import { getAllowance } from './getAllowance.js'
@@ -8,107 +7,108 @@ import { parseEVMErrors } from './parseEVMErrors.js'
 import { setAllowance } from './setAllowance.js'
 import { waitForTransactionReceipt } from './waitForTransactionReceipt.js'
 
-export type CheckAllowanceParams = {
-  client: Client
-  chain: ExtendedChain
-  step: LiFiStep
-  statusManager: StatusManager
-  executionOptions?: ExecutionOptions
-  allowUserInteraction?: boolean
-  atomicBatchSupported?: boolean
-  permit2Supported?: boolean
-}
-
-export const checkAllowance = async ({
-  client,
-  chain,
-  step,
-  statusManager,
-  executionOptions,
+export const checkAllowance = async (
+  client: Client,
+  chain: Chain,
+  step: LiFiStep,
+  statusManager: StatusManager,
+  settings?: ExecutionOptions,
   allowUserInteraction = false,
-  atomicBatchSupported = false,
-  permit2Supported = false,
-}: CheckAllowanceParams): Promise<Hash | void> => {
-  // Find existing or create new allowance process
-  const allowanceProcess: Process = statusManager.findOrCreateProcess({
+  shouldBatchTransactions = false
+): Promise<Hash | void> => {
+  // Ask the user to set an allowance
+  let allowanceProcess: Process = statusManager.findOrCreateProcess({
     step,
     type: 'TOKEN_ALLOWANCE',
     chainId: step.action.fromChainId,
   })
 
+  // Check allowance
   try {
-    // Handle existing pending transaction
     if (allowanceProcess.txHash && allowanceProcess.status !== 'DONE') {
       await waitForApprovalTransaction(
         client,
-        allowanceProcess.txHash as Address,
+        allowanceProcess.txHash! as Address,
         allowanceProcess.type,
         step,
         chain,
         statusManager
       )
-      return
-    }
-
-    // Start new allowance check
-    statusManager.updateProcess(step, allowanceProcess.type, 'STARTED')
-
-    const spenderAddress = permit2Supported
-      ? chain.permit2
-      : step.estimate.approvalAddress
-    const fromAmount = BigInt(step.action.fromAmount)
-
-    const approved = await getAllowance(
-      chain.id,
-      step.action.fromToken.address as Address,
-      client.account!.address,
-      spenderAddress as Address
-    )
-
-    // Return early if already approved
-    if (fromAmount <= approved) {
-      statusManager.updateProcess(step, allowanceProcess.type, 'DONE')
-      return
-    }
-
-    if (!allowUserInteraction) {
-      return
-    }
-
-    statusManager.updateProcess(step, allowanceProcess.type, 'ACTION_REQUIRED')
+    } else {
+      allowanceProcess = statusManager.updateProcess(
+        step,
+        allowanceProcess.type,
+        'STARTED'
+      )
 
-    // Set new allowance
-    const approveAmount = permit2Supported ? MaxUint256 : fromAmount
-    const approveTxHash = await setAllowance(
-      client,
-      step.action.fromToken.address as Address,
-      spenderAddress as Address,
-      approveAmount,
-      executionOptions,
-      atomicBatchSupported
-    )
+      const approved = await getAllowance(
+        chain.id,
+        step.action.fromToken.address,
+        client.account!.address,
+        step.estimate.approvalAddress
+      )
 
-    if (atomicBatchSupported) {
-      statusManager.updateProcess(step, allowanceProcess.type, 'DONE')
-      return approveTxHash
+      const fromAmount = BigInt(step.action.fromAmount)
+
+      if (fromAmount > approved) {
+        if (!allowUserInteraction) {
+          return
+        }
+
+        if (shouldBatchTransactions) {
+          const approveTxHash = await setAllowance(
+            client,
+            step.action.fromToken.address,
+            step.estimate.approvalAddress,
+            fromAmount,
+            settings,
+            true
+          )
+
+          allowanceProcess = statusManager.updateProcess(
+            step,
+            allowanceProcess.type,
+            'DONE'
+          )
+
+          return approveTxHash
+        }
+
+        const approveTxHash = await setAllowance(
+          client,
+          step.action.fromToken.address,
+          step.estimate.approvalAddress,
+          fromAmount
+        )
+        await waitForApprovalTransaction(
+          client,
+          approveTxHash,
+          allowanceProcess.type,
+          step,
+          chain,
+          statusManager
+        )
+      } else {
+        allowanceProcess = statusManager.updateProcess(
+          step,
+          allowanceProcess.type,
+          'DONE'
+        )
+      }
     }
-
-    await waitForApprovalTransaction(
-      client,
-      approveTxHash,
-      allowanceProcess.type,
-      step,
-      chain,
-      statusManager
-    )
   } catch (e: any) {
     const error = await parseEVMErrors(e, step, allowanceProcess)
-    statusManager.updateProcess(step, allowanceProcess.type, 'FAILED', {
-      error: {
-        message: error.cause.message,
-        code: error.code,
-      },
-    })
+    allowanceProcess = statusManager.updateProcess(
+      step,
+      allowanceProcess.type,
+      'FAILED',
+      {
+        error: {
+          message: error.cause.message,
+          code: error.code,
+        },
+      }
+    )
     statusManager.updateExecution(step, 'FAILED')
     throw error
   }
@@ -119,33 +119,29 @@ const waitForApprovalTransaction = async (
   txHash: Hash,
   processType: ProcessType,
   step: LiFiStep,
-  chain: ExtendedChain,
+  chain: Chain,
   statusManager: StatusManager
 ) => {
-  const baseExplorerUrl = chain.metamask.blockExplorerUrls[0]
-  const getTxLink = (hash: Hash) => `${baseExplorerUrl}tx/${hash}`
-
   statusManager.updateProcess(step, processType, 'PENDING', {
     txHash,
-    txLink: getTxLink(txHash),
+    txLink: `${chain.metamask.blockExplorerUrls[0]}tx/${txHash}`,
   })
 
   const transactionReceipt = await waitForTransactionReceipt({
-    client,
+    client: client,
     chainId: chain.id,
-    txHash,
+    txHash: txHash,
     onReplaced(response) {
-      const newHash = response.transaction.hash
       statusManager.updateProcess(step, processType, 'PENDING', {
-        txHash: newHash,
-        txLink: getTxLink(newHash),
+        txHash: response.transaction.hash,
+        txLink: `${chain.metamask.blockExplorerUrls[0]}tx/${response.transaction.hash}`,
       })
     },
   })
 
-  const finalHash = transactionReceipt?.transactionHash || txHash
+  const transactionHash = transactionReceipt?.transactionHash || txHash
   statusManager.updateProcess(step, processType, 'DONE', {
-    txHash: finalHash,
-    txLink: getTxLink(finalHash),
+    txHash: transactionHash,
+    txLink: `${chain.metamask.blockExplorerUrls[0]}tx/${transactionHash}`,
   })
 }

package/src/core/EVM/getAllowance.ts

@@ -13,9 +13,9 @@ import { getMulticallAddress } from './utils.js'
 
 export const getAllowance = async (
   chainId: ChainId,
-  tokenAddress: Address,
-  ownerAddress: Address,
-  spenderAddress: Address
+  tokenAddress: string,
+  ownerAddress: string,
+  spenderAddress: string
 ): Promise<bigint> => {
   const client = await getPublicClient(chainId)
   try {
@@ -34,7 +34,7 @@ export const getAllowance = async (
 export const getAllowanceMulticall = async (
   chainId: ChainId,
   tokens: TokenSpender[],
-  ownerAddress: Address
+  ownerAddress: string
 ): Promise<TokenSpenderAllowance[]> => {
   if (!tokens.length) {
     return []
@@ -80,8 +80,8 @@ export const getAllowanceMulticall = async (
  */
 export const getTokenAllowance = async (
   token: BaseToken,
-  ownerAddress: Address,
-  spenderAddress: Address
+  ownerAddress: string,
+  spenderAddress: string
 ): Promise<bigint | undefined> => {
   // native token don't need approval
   if (isNativeTokenAddress(token.address)) {
@@ -90,7 +90,7 @@ export const getTokenAllowance = async (
 
   const approved = await getAllowance(
     token.chainId,
-    token.address as Address,
+    token.address,
     ownerAddress,
     spenderAddress
   )
@@ -104,7 +104,7 @@ export const getTokenAllowance = async (
  * @returns Returns array of tokens and their allowance
  */
 export const getTokenAllowanceMulticall = async (
-  ownerAddress: Address,
+  ownerAddress: string,
   tokens: TokenSpender[]
 ): Promise<TokenAllowance[]> => {
   // filter out native tokens

package/src/core/EVM/getEVMBalance.ts

@@ -12,7 +12,7 @@ import { getPublicClient } from './publicClient.js'
 import { getMulticallAddress } from './utils.js'
 
 export const getEVMBalance = async (
-  walletAddress: Address,
+  walletAddress: string,
   tokens: Token[]
 ): Promise<TokenAmount[]> => {
   if (tokens.length === 0) {
@@ -85,7 +85,7 @@ const getEVMBalanceMulticall = async (
 const getEVMBalanceDefault = async (
   chainId: ChainId,
   tokens: Token[],
-  walletAddress: Address
+  walletAddress: string
 ): Promise<TokenAmount[]> => {
   const client = await getPublicClient(chainId)
   const blockNumber = await getBlockNumber(client)

package/src/core/EVM/multisig.ts

@@ -0,0 +1,54 @@
+import type { ExtendedChain, LiFiStep, ProcessType } from '@lifi/types'
+import type { Hash } from 'viem'
+import { LiFiErrorCode } from '../../errors/constants.js'
+import { TransactionError } from '../../errors/errors.js'
+import type { StatusManager } from '../StatusManager.js'
+import type { MultisigConfig, MultisigTxDetails } from './types.js'
+
+export const updateMultisigRouteProcess = async (
+  internalTxHash: Hash,
+  step: LiFiStep,
+  processType: ProcessType,
+  fromChain: ExtendedChain,
+  statusManager: StatusManager,
+  multisig?: MultisigConfig
+) => {
+  if (!multisig?.getMultisigTransactionDetails) {
+    throw new Error(
+      'getMultisigTransactionDetails is missing in multisig config.'
+    )
+  }
+
+  const updateIntermediateMultisigStatus = () => {
+    statusManager.updateProcess(step, processType, 'PENDING')
+  }
+
+  const multisigStatusResponse: MultisigTxDetails =
+    await multisig?.getMultisigTransactionDetails(
+      internalTxHash,
+      fromChain.id,
+      updateIntermediateMultisigStatus
+    )
+
+  if (multisigStatusResponse.status === 'DONE') {
+    statusManager.updateProcess(step, processType, 'PENDING', {
+      txHash: multisigStatusResponse.txHash,
+      multisigTxHash: undefined,
+      txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${multisigStatusResponse.txHash}`,
+    })
+  }
+
+  if (multisigStatusResponse.status === 'FAILED') {
+    throw new TransactionError(
+      LiFiErrorCode.TransactionFailed,
+      'Multisig transaction failed.'
+    )
+  }
+
+  if (multisigStatusResponse.status === 'CANCELLED') {
+    throw new TransactionError(
+      LiFiErrorCode.SignatureRejected,
+      'Transaction was rejected by user.'
+    )
+  }
+}

package/src/core/EVM/parseEVMErrors.ts

@@ -29,14 +29,6 @@ const handleSpecificErrors = async (
   if (e.cause?.name === 'UserRejectedRequestError') {
     return new TransactionError(LiFiErrorCode.SignatureRejected, e.message, e)
   }
-  // Safe Wallet via WalletConnect returns -32000 code when user rejects the signature
-  // {
-  //   code: -32000,
-  //   message: 'User rejected transaction',
-  // }
-  if (e.cause?.code === -32000) {
-    return new TransactionError(LiFiErrorCode.SignatureRejected, e.message, e)
-  }
 
   if (
     step &&

package/src/core/EVM/setAllowance.ts

@@ -1,6 +1,7 @@
-import type { Address, Client, Hash, SendTransactionParameters } from 'viem'
+import type { Client, Hash, SendTransactionParameters } from 'viem'
 import { encodeFunctionData } from 'viem'
 import { sendTransaction } from 'viem/actions'
+import { getAction } from 'viem/utils'
 import { isNativeTokenAddress } from '../../utils/isZeroAddress.js'
 import type { ExecutionOptions, TransactionParameters } from '../types.js'
 import { approveAbi } from './abi.js'
@@ -10,10 +11,10 @@ import { getMaxPriorityFeePerGas } from './utils.js'
 
 export const setAllowance = async (
   client: Client,
-  tokenAddress: Address,
-  contractAddress: Address,
+  tokenAddress: string,
+  contractAddress: string,
   amount: bigint,
-  executionOptions?: ExecutionOptions,
+  settings?: ExecutionOptions,
   returnPopulatedTransaction?: boolean
 ): Promise<Hash> => {
   const data = encodeFunctionData({
@@ -35,9 +36,9 @@ export const setAllowance = async (
         : undefined,
   }
 
-  if (executionOptions?.updateTransactionRequestHook) {
+  if (settings?.updateTransactionRequestHook) {
     const customizedTransactionRequest: TransactionParameters =
-      await executionOptions.updateTransactionRequestHook({
+      await settings.updateTransactionRequestHook({
         requestType: 'approve',
         ...transactionRequest,
       })
@@ -48,7 +49,11 @@ export const setAllowance = async (
     }
   }
 
-  return sendTransaction(client, {
+  return getAction(
+    client,
+    sendTransaction,
+    'sendTransaction'
+  )({
     to: transactionRequest.to,
     account: client.account!,
     data: transactionRequest.data,
@@ -56,6 +61,7 @@ export const setAllowance = async (
     gasPrice: transactionRequest.gasPrice,
     maxFeePerGas: transactionRequest.maxFeePerGas,
     maxPriorityFeePerGas: transactionRequest.maxPriorityFeePerGas,
+    chain: null,
   } as SendTransactionParameters)
 }
 
@@ -80,16 +86,16 @@ export const setTokenAllowance = async ({
   }
   const approvedAmount = await getAllowance(
     token.chainId,
-    token.address as Address,
+    token.address,
     walletClient.account!.address,
-    spenderAddress as Address
+    spenderAddress
   )
 
   if (amount > approvedAmount) {
     const approveTx = await setAllowance(
       walletClient,
-      token.address as Address,
-      spenderAddress as Address,
+      token.address,
+      spenderAddress,
       amount
     )
 
@@ -116,15 +122,15 @@ export const revokeTokenApproval = async ({
   }
   const approvedAmount = await getAllowance(
     token.chainId,
-    token.address as Address,
+    token.address,
     walletClient.account!.address,
-    spenderAddress as Address
+    spenderAddress
   )
   if (approvedAmount > 0) {
     const approveTx = await setAllowance(
       walletClient,
-      token.address as Address,
-      spenderAddress as Address,
+      token.address,
+      spenderAddress,
       0n
     )
 

package/src/core/EVM/switchChain.ts

@@ -1,5 +1,6 @@
-import type { Client } from 'viem'
+import type { Client, GetChainIdReturnType } from 'viem'
 import { getChainId } from 'viem/actions'
+import { getAction } from 'viem/utils'
 import { LiFiErrorCode } from '../../errors/constants.js'
 import { ProviderError } from '../../errors/errors.js'
 import type { StatusManager } from '../StatusManager.js'
@@ -30,7 +31,11 @@ export const switchChain = async (
   switchChainHook?: SwitchChainHook
 ): Promise<Client | undefined> => {
   // if we are already on the correct chain we can proceed directly
-  const currentChainId = await getChainId(client)
+  const currentChainId = (await getAction(
+    client,
+    getChainId,
+    'getChainId'
+  )(undefined)) as GetChainIdReturnType
   if (currentChainId === step.action.fromChainId) {
     return client
   }
@@ -53,7 +58,11 @@ export const switchChain = async (
     const updatedClient = await switchChainHook?.(step.action.fromChainId)
     let updatedChainId: number | undefined
     if (updatedClient) {
-      updatedChainId = await getChainId(updatedClient)
+      updatedChainId = (await getAction(
+        updatedClient,
+        getChainId,
+        'getChainId'
+      )(undefined)) as GetChainIdReturnType
     }
     if (updatedChainId !== step.action.fromChainId) {
       throw new ProviderError(

package/src/core/EVM/types.ts

@@ -1,15 +1,17 @@
 import { type BaseToken, ChainType } from '@lifi/types'
-import type { Client } from 'viem'
+import type { Client, Hash } from 'viem'
 import type { SwitchChainHook } from '../types.js'
 import type { SDKProvider } from '../types.js'
 
 export interface EVMProviderOptions {
   getWalletClient?: () => Promise<Client>
   switchChain?: SwitchChainHook
+  multisig?: MultisigConfig
 }
 
 export interface EVMProvider extends SDKProvider {
   setOptions(options: EVMProviderOptions): void
+  multisig?: MultisigConfig
 }
 
 export function isEVM(provider: SDKProvider): provider is EVMProvider {
@@ -48,3 +50,27 @@ export interface RevokeApprovalRequest {
   token: BaseToken
   spenderAddress: string
 }
+
+export interface MultisigTxDetails {
+  status: 'DONE' | 'FAILED' | 'PENDING' | 'CANCELLED'
+  txHash?: Hash
+}
+
+export interface MultisigTransaction {
+  to: string
+  value?: bigint
+  data: string
+}
+
+export interface MultisigConfig {
+  isMultisigWalletClient: boolean
+  getMultisigTransactionDetails: (
+    txHash: Hash,
+    fromChainId: number,
+    updateIntermediateStatus?: () => void
+  ) => Promise<MultisigTxDetails>
+  sendBatchTransaction?: (
+    batchTransactions: MultisigTransaction[]
+  ) => Promise<Hash>
+  shouldBatchTransactions?: boolean
+}

package/src/core/EVM/utils.ts

@@ -1,5 +1,5 @@
 import type { ChainId } from '@lifi/types'
-import type { Address, Client, Transaction } from 'viem'
+import type { Client, Transaction } from 'viem'
 import { getBlock } from 'viem/actions'
 import { config } from '../../config.js'
 import { median } from '../../utils/median.js'
@@ -37,10 +37,9 @@ export const getMaxPriorityFeePerGas = async (
 // Multicall
 export const getMulticallAddress = async (
   chainId: ChainId
-): Promise<Address | undefined> => {
+): Promise<string | undefined> => {
   const chains = await config.getChains()
-  return chains.find((chain) => chain.id === chainId)
-    ?.multicallAddress as Address
+  return chains.find((chain) => chain.id === chainId)?.multicallAddress
 }
 
 // Modified viem retryDelay exponential backoff function.

package/src/core/Solana/SolanaStepExecutor.ts

@@ -1,4 +1,4 @@
-import type { ExtendedTransactionInfo, FullStatusData } from '@lifi/types'
+import type {} from '@lifi/types'
 import type { SignerWalletAdapter } from '@solana/wallet-adapter-base'
 import { VersionedTransaction } from '@solana/web3.js'
 import { withTimeout } from 'viem'
@@ -7,17 +7,15 @@ import { LiFiErrorCode } from '../../errors/constants.js'
 import { TransactionError } from '../../errors/errors.js'
 import { getStepTransaction } from '../../services/api.js'
 import { base64ToUint8Array } from '../../utils/base64ToUint8Array.js'
-import { getTransactionFailedMessage } from '../../utils/getTransactionMessage.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 { callSolanaWithRetry } from './connection.js'
 import { parseSolanaErrors } from './parseSolanaErrors.js'
 import { sendAndConfirmTransaction } from './sendAndConfirmTransaction.js'
@@ -53,7 +51,6 @@ export class SolanaStepExecutor extends BaseStepExecutor {
     const isBridgeExecution = fromChain.id !== toChain.id
     const currentProcessType = isBridgeExecution ? 'CROSS_CHAIN' : 'SWAP'
 
-    // STEP 2: Get transaction
     let process = this.statusManager.findOrCreateProcess({
       step,
       type: currentProcessType,
@@ -220,8 +217,7 @@ export class SolanaStepExecutor 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,
@@ -230,63 +226,13 @@ export class SolanaStepExecutor extends BaseStepExecutor {
         chainId: toChain.id,
       })
     }
-    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
-    }
+    await waitForDestinationChainTransaction(
+      step,
+      process,
+      this.statusManager,
+      toChain
+    )
 
     // DONE
     return step