@lifi/sdk 3.0.0-alpha.20 → 3.0.0-alpha.21

package/dist/core/EVM/getAllowance.ts

@@ -0,0 +1,146 @@
+import type { ChainId, Token } from '@lifi/types'
+import type { Address } from 'viem'
+import { getContract } from 'viem'
+import { MulticallBatchSize } from '../../constants.js'
+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,
+    batchSize: MulticallBatchSize,
+  })
+
+  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/dist/core/EVM/getEVMBalance.ts

@@ -0,0 +1,120 @@
+import type { ChainId, Token, TokenAmount } from '@lifi/types'
+import type { Address } from 'viem'
+import { MulticallBatchSize } from '../../constants.js'
+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,
+    batchSize: MulticallBatchSize,
+  })
+
+  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/dist/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/dist/core/EVM/publicClient.ts

@@ -0,0 +1,46 @@
+import type { PublicClient } from 'viem'
+import { createPublicClient, fallback, http } from 'viem'
+import type { Chain } from 'viem/chains'
+import { config } from '../../config.js'
+import { getRpcUrls } from '../utils.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 },
+      },
+    }
+    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/dist/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
+  }
+}

package/dist/core/EVM/switchChain.ts

@@ -0,0 +1,77 @@
+import type { LiFiStep } from '@lifi/types'
+import type { WalletClient } from 'viem'
+import { LiFiErrorCode, ProviderError } from '../../utils/errors.js'
+import type { StatusManager } from '../StatusManager.js'
+import type { SwitchChainHook } from '../types.js'
+
+/**
+ * This method checks whether the wallet client is configured for the correct chain.
+ * If yes it returns the wallet clien.
+ * If no and if user interaction is allowed it triggers the switchChainHook. If no user interaction is allowed it aborts.
+ *
+ * Account Type: local -
+ * We need to create and return a new WalletClient from the switchChainHook in order to continue execution on a new chain.
+ *
+ * Account Type: json-rpc -
+ * We can switch chain and return existing WalletClient from the switchChainHook in order to continue execution on a new chain.
+ * @param walletClient
+ * @param statusManager
+ * @param step
+ * @param switchChainHook
+ * @param allowUserInteraction
+ * @returns New WalletClient
+ */
+export const switchChain = async (
+  walletClient: WalletClient,
+  statusManager: StatusManager,
+  step: LiFiStep,
+  allowUserInteraction: boolean,
+  switchChainHook?: SwitchChainHook
+): Promise<WalletClient | undefined> => {
+  // if we are already on the correct chain we can proceed directly
+  if ((await walletClient.getChainId()) === step.action.fromChainId) {
+    return walletClient
+  }
+
+  // -> set status message
+  step.execution = statusManager.initExecutionObject(step)
+  statusManager.updateExecution(step, 'ACTION_REQUIRED')
+
+  let switchProcess = statusManager.findOrCreateProcess(
+    step,
+    'SWITCH_CHAIN',
+    'ACTION_REQUIRED'
+  )
+
+  if (!allowUserInteraction) {
+    return
+  }
+
+  try {
+    const updatedWalletClient = await switchChainHook?.(step.action.fromChainId)
+    const updatedChainId = await updatedWalletClient?.getChainId()
+    if (updatedChainId !== step.action.fromChainId) {
+      throw new ProviderError(
+        LiFiErrorCode.ChainSwitchError,
+        'Chain switch required.'
+      )
+    }
+
+    switchProcess = statusManager.updateProcess(
+      step,
+      switchProcess.type,
+      'DONE'
+    )
+    statusManager.updateExecution(step, 'PENDING')
+    return updatedWalletClient
+  } catch (error: any) {
+    statusManager.updateProcess(step, switchProcess.type, 'FAILED', {
+      error: {
+        message: error.message,
+        code: LiFiErrorCode.ChainSwitchError,
+      },
+    })
+    statusManager.updateExecution(step, 'FAILED')
+    throw error
+  }
+}

package/dist/core/EVM/types.ts

@@ -0,0 +1,75 @@
+import { ChainType, type ChainId, type Token } from '@lifi/types'
+import type { Hash, WalletClient } from 'viem'
+import type { SwitchChainHook } from '../types.js'
+import { type SDKProvider } from '../types.js'
+
+export interface EVMProviderOptions {
+  getWalletClient?: () => Promise<WalletClient>
+  switchChain?: SwitchChainHook
+  multicall?: Partial<Record<ChainId, string>>
+  multisig?: MultisigConfig
+}
+
+export interface EVMProvider extends SDKProvider {
+  setOptions(options: EVMProviderOptions): void
+  multicall?: Partial<Record<ChainId, string>>
+  multisig?: MultisigConfig
+}
+
+export function isEVM(provider: SDKProvider): provider is EVMProvider {
+  return provider.type === ChainType.EVM
+}
+
+export type TokenSpender = {
+  token: Token
+  spenderAddress: string
+}
+
+export type TokenAllowance = {
+  token: Token
+  allowance?: bigint
+}
+
+export type TokenSpenderAllowance = {
+  token: Token
+  spenderAddress: string
+  allowance?: bigint
+}
+
+export interface ApproveTokenRequest {
+  walletClient: WalletClient
+  token: Token
+  spenderAddress: string
+  amount: bigint
+  infiniteApproval?: boolean
+}
+
+export interface RevokeApprovalRequest {
+  walletClient: WalletClient
+  token: Token
+  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/dist/core/EVM/utils.ts

@@ -0,0 +1,43 @@
+import { ChainType, type ChainId } from '@lifi/types'
+import type { PublicClient, Transaction } from 'viem'
+import { median } from '../../utils/median.js'
+import { getProvider } from '../provider.js'
+import type { EVMProvider } from './types.js'
+
+export const getMaxPriorityFeePerGas = async (
+  client: PublicClient
+): Promise<bigint | undefined> => {
+  const block = await client.getBlock({
+    includeTransactions: true,
+  })
+
+  const maxPriorityFeePerGasList = (block.transactions as Transaction[])
+    .filter((tx) => tx.maxPriorityFeePerGas)
+    .map((tx) => tx.maxPriorityFeePerGas) as bigint[]
+
+  if (!maxPriorityFeePerGasList.length) {
+    return
+  }
+
+  const maxPriorityFeePerGasSum = maxPriorityFeePerGasList.reduce(
+    (acc, value) => (acc += value),
+    0n
+  )
+
+  const maxPriorityFeePerGasMedian = median(maxPriorityFeePerGasList) ?? 0n
+
+  const maxPriorityFeePerGasAvg =
+    maxPriorityFeePerGasSum / BigInt(maxPriorityFeePerGasList.length)
+
+  return maxPriorityFeePerGasMedian > maxPriorityFeePerGasAvg
+    ? maxPriorityFeePerGasAvg
+    : maxPriorityFeePerGasMedian
+}
+
+// Multicall
+export const getMulticallAddress = async (
+  chainId: ChainId
+): Promise<string | undefined> => {
+  const provider = getProvider<EVMProvider>(ChainType.EVM)
+  return provider.multicall?.[chainId]
+}