@lifi/sdk 3.0.0-alpha.6 → 3.0.0-alpha.60

package/src/core/EVM/checkAllowance.ts

@@ -0,0 +1,168 @@
+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'
+import { retryCount, retryDelay } from './utils.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 {
+      allowanceProcess = statusManager.updateProcess(
+        step,
+        allowanceProcess.type,
+        'STARTED'
+      )
+
+      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}`,
+      })
+    },
+    retryCount,
+    retryDelay,
+  })
+
+  if (transactionReceipt.status === 'reverted') {
+    throw new TransactionError(
+      LiFiErrorCode.TransactionFailed,
+      'Transaction was reverted.'
+    )
+  }
+
+  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}`,
+  })
+}

package/src/core/EVM/getAllowance.ts

@@ -0,0 +1,144 @@
+import type { ChainId, Token } from '@lifi/types'
+import type { Address } from 'viem'
+import { getContract } from 'viem'
+import { isNativeTokenAddress } from '../../utils/utils.js'
+import { allowanceAbi } from './abi.js'
+import { getPublicClient } from './publicClient.js'
+import type {
+  TokenAllowance,
+  TokenSpender,
+  TokenSpenderAllowance,
+} from './types.js'
+import { getMulticallAddress } from './utils.js'
+
+export const getAllowance = async (
+  chainId: ChainId,
+  tokenAddress: string,
+  ownerAddress: string,
+  spenderAddress: string
+): Promise<bigint> => {
+  const client = await getPublicClient(chainId)
+  const contract = getContract({
+    address: tokenAddress as Address,
+    abi: allowanceAbi,
+    client: client,
+  })
+
+  try {
+    const approved = (await contract.read.allowance([
+      ownerAddress,
+      spenderAddress,
+    ])) as bigint
+    return approved
+  } catch (e) {
+    return 0n
+  }
+}
+
+export const getAllowanceMulticall = async (
+  chainId: ChainId,
+  tokens: TokenSpender[],
+  ownerAddress: string
+): Promise<TokenSpenderAllowance[]> => {
+  if (!tokens.length) {
+    return []
+  }
+  const multicallAddress = await getMulticallAddress(chainId)
+  if (!multicallAddress) {
+    throw new Error(`No multicall address configured for chainId ${chainId}.`)
+  }
+
+  const client = await getPublicClient(chainId)
+
+  const contracts = tokens.map((token) => ({
+    address: token.token.address as Address,
+    abi: allowanceAbi,
+    functionName: 'allowance',
+    args: [ownerAddress, token.spenderAddress],
+  }))
+
+  const results = await client.multicall({
+    contracts,
+    multicallAddress: multicallAddress as Address,
+  })
+
+  if (!results.length) {
+    throw new Error(
+      `Couldn't load allowance from chainId ${chainId} using multicall.`
+    )
+  }
+
+  return tokens.map(({ token, spenderAddress }, i: number) => ({
+    token,
+    spenderAddress,
+    allowance: results[i].result as bigint,
+  }))
+}
+
+/**
+ * Get the current allowance for a certain token.
+ * @param token - The token that should be checked
+ * @param ownerAddress - The owner of the token
+ * @param spenderAddress - The spender address that has to be approved
+ * @returns Returns allowance
+ */
+export const getTokenAllowance = async (
+  token: Token,
+  ownerAddress: string,
+  spenderAddress: string
+): Promise<bigint | undefined> => {
+  // native token don't need approval
+  if (isNativeTokenAddress(token.address)) {
+    return
+  }
+
+  const approved = await getAllowance(
+    token.chainId,
+    token.address,
+    ownerAddress,
+    spenderAddress
+  )
+  return approved
+}
+
+/**
+ * Get the current allowance for a list of token/spender address pairs.
+ * @param ownerAddress - The owner of the tokens
+ * @param tokens - A list of token and spender address pairs
+ * @returns Returns array of tokens and their allowance
+ */
+export const getTokenAllowanceMulticall = async (
+  ownerAddress: string,
+  tokens: TokenSpender[]
+): Promise<TokenAllowance[]> => {
+  // filter out native tokens
+  const filteredTokens = tokens.filter(
+    ({ token }) => !isNativeTokenAddress(token.address)
+  )
+
+  // group by chain
+  const tokenDataByChain: { [chainId: number]: TokenSpender[] } = {}
+  filteredTokens.forEach((data) => {
+    if (!tokenDataByChain[data.token.chainId]) {
+      tokenDataByChain[data.token.chainId] = []
+    }
+    tokenDataByChain[data.token.chainId].push(data)
+  })
+
+  const chainKeys = Object.keys(tokenDataByChain).map(Number.parseInt)
+
+  const allowances = (
+    await Promise.all(
+      chainKeys.map(async (chainId) => {
+        // get allowances for current chain and token list
+        return getAllowanceMulticall(
+          chainId,
+          tokenDataByChain[chainId],
+          ownerAddress
+        )
+      })
+    )
+  ).flat()
+
+  return allowances
+}

package/src/core/EVM/getENSAddress.ts

@@ -0,0 +1,18 @@
+import { ChainId } from '@lifi/types'
+import { normalize } from 'viem/ens'
+import { getPublicClient } from './publicClient.js'
+
+export const getENSAddress = async (
+  name: string
+): Promise<string | undefined> => {
+  try {
+    const client = await getPublicClient(ChainId.ETH)
+    const address = await client.getEnsAddress({
+      name: normalize(name),
+    })
+    return address as string | undefined
+  } catch (_) {
+    // ignore
+    return
+  }
+}

package/src/core/EVM/getEVMBalance.ts

@@ -0,0 +1,118 @@
+import type { ChainId, Token, TokenAmount } from '@lifi/types'
+import type { Address } from 'viem'
+import { isZeroAddress } from '../../utils/utils.js'
+import { balanceOfAbi, getEthBalanceAbi } from './abi.js'
+import { getPublicClient } from './publicClient.js'
+import { getMulticallAddress } from './utils.js'
+
+export const getEVMBalance = async (
+  walletAddress: string,
+  tokens: Token[]
+): Promise<TokenAmount[]> => {
+  if (tokens.length === 0) {
+    return []
+  }
+  const { chainId } = tokens[0]
+  tokens.forEach((token) => {
+    if (token.chainId !== chainId) {
+      console.warn(`Requested tokens have to be on the same chain.`)
+    }
+  })
+
+  const multicallAddress = await getMulticallAddress(chainId)
+
+  if (multicallAddress && tokens.length > 1) {
+    return getEVMBalanceMulticall(
+      chainId,
+      tokens,
+      walletAddress,
+      multicallAddress
+    )
+  } else {
+    return getEVMBalanceDefault(chainId, tokens, walletAddress)
+  }
+}
+
+const getEVMBalanceMulticall = async (
+  chainId: ChainId,
+  tokens: Token[],
+  walletAddress: string,
+  multicallAddress: string
+): Promise<TokenAmount[]> => {
+  const client = await getPublicClient(chainId)
+
+  const contracts = tokens.map((token) => {
+    if (isZeroAddress(token.address)) {
+      return {
+        address: multicallAddress as Address,
+        abi: getEthBalanceAbi,
+        functionName: 'getEthBalance',
+        args: [walletAddress],
+      }
+    }
+    return {
+      address: token.address as Address,
+      abi: balanceOfAbi,
+      functionName: 'balanceOf',
+      args: [walletAddress],
+    }
+  })
+  const blockNumber = await client.getBlockNumber()
+  const results = await client.multicall({
+    contracts,
+    multicallAddress: multicallAddress as Address,
+    blockNumber,
+  })
+
+  if (!results.length) {
+    return []
+  }
+
+  return tokens.map((token, i: number) => {
+    return {
+      ...token,
+      amount: results[i].result as bigint,
+      blockNumber,
+    }
+  })
+}
+
+const getEVMBalanceDefault = async (
+  chainId: ChainId,
+  tokens: Token[],
+  walletAddress: string
+): Promise<TokenAmount[]> => {
+  const client = await getPublicClient(chainId)
+  const blockNumber = await client.getBlockNumber()
+  const queue: Promise<bigint>[] = tokens.map((token) => {
+    if (isZeroAddress(token.address)) {
+      return client.getBalance({
+        address: walletAddress as Address,
+      })
+    }
+    return client.readContract({
+      address: token.address as Address,
+      abi: balanceOfAbi,
+      functionName: 'balanceOf',
+      args: [walletAddress],
+    }) as Promise<bigint>
+  })
+
+  const results = await Promise.allSettled(queue)
+
+  const tokenAmounts: TokenAmount[] = tokens.map((token, index) => {
+    const result = results[index]
+    if (result.status === 'rejected') {
+      return {
+        ...token,
+        blockNumber,
+      }
+    }
+    return {
+      ...token,
+      amount: result.value,
+      blockNumber,
+    }
+  })
+  return tokenAmounts
+}

package/src/core/EVM/multisig.ts

@@ -0,0 +1,53 @@
+import type { ExtendedChain, LiFiStep, ProcessType } from '@lifi/types'
+import type { Hash } from 'viem'
+import { LiFiErrorCode, TransactionError } from '../../utils/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/publicClient.ts

@@ -0,0 +1,54 @@
+import { ChainId } from '@lifi/types'
+import type { PublicClient } from 'viem'
+import { createPublicClient, fallback, http } from 'viem'
+import { mainnet, type Chain } from 'viem/chains'
+import { config } from '../../config.js'
+import { getRpcUrls } from '../rpc.js'
+
+// cached providers
+const publicClients: Record<number, PublicClient> = {}
+
+/**
+ * Get an instance of a provider for a specific chain
+ * @param chainId - Id of the chain the provider is for
+ * @returns The public client for the given chain
+ */
+export const getPublicClient = async (
+  chainId: number
+): Promise<PublicClient> => {
+  if (!publicClients[chainId]) {
+    const urls = await getRpcUrls(chainId)
+    const fallbackTransports = urls.map((url) =>
+      http(url, {
+        batch: true,
+      })
+    )
+    const _chain = await config.getChainById(chainId)
+    const chain: Chain = {
+      ..._chain,
+      ..._chain.metamask,
+      name: _chain.metamask.chainName,
+      rpcUrls: {
+        default: { http: _chain.metamask.rpcUrls },
+        public: { http: _chain.metamask.rpcUrls },
+      },
+    }
+    // Add ENS contracts
+    if (chain.id === ChainId.ETH) {
+      chain.contracts = {
+        ...mainnet.contracts,
+        ...chain.contracts,
+      }
+    }
+    publicClients[chainId] = createPublicClient({
+      chain: chain,
+      transport: fallback(fallbackTransports),
+    })
+  }
+
+  if (!publicClients[chainId]) {
+    throw new Error(`Unable to configure provider for chain ${chainId}`)
+  }
+
+  return publicClients[chainId]
+}

package/src/core/EVM/setAllowance.ts

@@ -0,0 +1,144 @@
+import type {
+  Address,
+  Hash,
+  PublicClient,
+  SendTransactionParameters,
+  WalletClient,
+} from 'viem'
+import { encodeFunctionData, maxUint256, publicActions } from 'viem'
+import { isNativeTokenAddress } from '../../utils/utils.js'
+import type { ExecutionOptions, TransactionParameters } from '../types.js'
+import { approveAbi } from './abi.js'
+import { getAllowance } from './getAllowance.js'
+import type { ApproveTokenRequest, RevokeApprovalRequest } from './types.js'
+import { getMaxPriorityFeePerGas } from './utils.js'
+
+export const setAllowance = async (
+  walletClient: WalletClient,
+  tokenAddress: string,
+  contractAddress: string,
+  amount: bigint,
+  settings?: ExecutionOptions,
+  returnPopulatedTransaction?: boolean
+): Promise<Hash> => {
+  const data = encodeFunctionData({
+    abi: approveAbi,
+    functionName: 'approve',
+    args: [contractAddress, amount],
+  })
+
+  if (returnPopulatedTransaction) {
+    return data
+  }
+  const client = walletClient.extend(publicActions)
+
+  let transactionRequest: TransactionParameters = {
+    to: tokenAddress,
+    data,
+    maxPriorityFeePerGas:
+      walletClient.account?.type === 'local'
+        ? await getMaxPriorityFeePerGas(client as PublicClient)
+        : undefined,
+  }
+
+  if (settings?.updateTransactionRequestHook) {
+    const customizedTransactionRequest: TransactionParameters =
+      await settings.updateTransactionRequestHook({
+        requestType: 'approve',
+        ...transactionRequest,
+      })
+
+    transactionRequest = {
+      ...transactionRequest,
+      ...customizedTransactionRequest,
+    }
+  }
+
+  return client.sendTransaction({
+    to: transactionRequest.to as Address,
+    account: walletClient.account!,
+    data: transactionRequest.data,
+    gas: transactionRequest.gas,
+    gasPrice: transactionRequest.gasPrice,
+    maxFeePerGas: transactionRequest.maxFeePerGas,
+    maxPriorityFeePerGas: transactionRequest.maxPriorityFeePerGas,
+    chain: null,
+  } as SendTransactionParameters)
+}
+
+/**
+ * Set approval for a certain token and amount.
+ * @param request - The approval request
+ * @param request.walletClient
+ * @param request.token
+ * @param request.spenderAddress
+ * @param request.amount
+ * @param request.infiniteApproval
+ * @returns Returns Hash or nothing
+ */
+export const setTokenAllowance = async ({
+  walletClient,
+  token,
+  spenderAddress,
+  amount,
+  infiniteApproval = false,
+}: ApproveTokenRequest): Promise<Hash | void> => {
+  // native token don't need approval
+  if (isNativeTokenAddress(token.address)) {
+    return
+  }
+  const approvedAmount = await getAllowance(
+    token.chainId,
+    token.address,
+    walletClient.account!.address,
+    spenderAddress
+  )
+
+  if (amount > approvedAmount) {
+    const approvalAmount = infiniteApproval ? maxUint256 : amount
+
+    const approveTx = await setAllowance(
+      walletClient,
+      token.address,
+      spenderAddress,
+      approvalAmount
+    )
+
+    return approveTx
+  }
+}
+
+/**
+ * Revoke approval for a certain token.
+ * @param request - The revoke request
+ * @param request.walletClient
+ * @param request.token
+ * @param request.spenderAddress
+ * @returns Returns Hash or nothing
+ */
+export const revokeTokenApproval = async ({
+  walletClient,
+  token,
+  spenderAddress,
+}: RevokeApprovalRequest): Promise<Hash | void> => {
+  // native token don't need approval
+  if (isNativeTokenAddress(token.address)) {
+    return
+  }
+  const approvedAmount = await getAllowance(
+    token.chainId,
+    token.address,
+    walletClient.account!.address,
+    spenderAddress
+  )
+  if (approvedAmount > 0) {
+    const approveTx = await setAllowance(
+      walletClient,
+      token.address,
+      spenderAddress,
+      0n
+    )
+
+    return approveTx
+  }
+}