@lifi/sdk 3.5.0-beta.0 → 3.5.0

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',
+  },
+]

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.