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

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

package/dist/core/Solana/Solana.ts

@@ -0,0 +1,46 @@
+import { ChainType } from '@lifi/types'
+import { PublicKey } from '@solana/web3.js'
+import type { StepExecutorOptions } from '../types.js'
+import { SolanaStepExecutor } from './SolanaStepExecutor.js'
+import { getSolanaBalance } from './getSolanaBalance.js'
+import type { SolanaProvider, SolanaProviderOptions } from './types.js'
+
+export function Solana(options?: SolanaProviderOptions): SolanaProvider {
+  const _options: SolanaProviderOptions = options ?? {}
+  return {
+    get type() {
+      return ChainType.SVM
+    },
+    isAddress(address: string): boolean {
+      try {
+        new PublicKey(address)
+        return true
+      } catch (error) {
+        return false
+      }
+    },
+    getBalance: getSolanaBalance,
+    async getStepExecutor(
+      options: StepExecutorOptions
+    ): Promise<SolanaStepExecutor> {
+      if (!_options.getWalletAdapter) {
+        throw new Error(`getWalletAdapter is not provided.`)
+      }
+
+      const walletAdapter = await _options.getWalletAdapter()
+
+      const executor = new SolanaStepExecutor({
+        walletAdapter,
+        routeId: options.routeId,
+        executionOptions: {
+          ...options.executionOptions,
+        },
+      })
+
+      return executor
+    },
+    setOptions(options: SolanaProviderOptions) {
+      Object.assign(_options, options)
+    },
+  }
+}

package/dist/core/Solana/SolanaStepExecutor.ts

@@ -0,0 +1,253 @@
+import type {
+  ExtendedTransactionInfo,
+  FullStatusData,
+  LiFiStep,
+} from '@lifi/types'
+import type { WalletAdapter } from '@solana/wallet-adapter-base'
+import {
+  VersionedTransaction,
+  type TransactionConfirmationStrategy,
+  type TransactionSignature,
+} from '@solana/web3.js'
+import { config } from '../../config.js'
+import { getStepTransaction } from '../../services/api.js'
+import {
+  LiFiErrorCode,
+  TransactionError,
+  getTransactionFailedMessage,
+  parseError,
+} from '../../utils/index.js'
+import { BaseStepExecutor } from '../BaseStepExecutor.js'
+import { checkBalance } from '../checkBalance.js'
+import { stepComparison } from '../stepComparison.js'
+import type { StepExecutorOptions, TransactionParameters } from '../types.js'
+import { getSubstatusMessage } from '../utils.js'
+import { waitForReceivingTransaction } from '../waitForReceivingTransaction.js'
+import { getSolanaConnection } from './connection.js'
+
+export interface SolanaStepExecutorOptions extends StepExecutorOptions {
+  walletAdapter: WalletAdapter
+}
+
+export class SolanaStepExecutor extends BaseStepExecutor {
+  private walletAdapter: WalletAdapter
+
+  constructor(options: SolanaStepExecutorOptions) {
+    super(options)
+    this.walletAdapter = options.walletAdapter
+  }
+
+  executeStep = async (step: LiFiStep): Promise<LiFiStep> => {
+    step.execution = this.statusManager.initExecutionObject(step)
+
+    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 2: Get transaction
+    let process = this.statusManager.findOrCreateProcess(
+      step,
+      currentProcessType
+    )
+
+    if (process.status !== 'DONE') {
+      try {
+        const connection = await getSolanaConnection()
+        let txHash: TransactionSignature
+        if (process.txHash) {
+          txHash = process.txHash as TransactionSignature
+        } else {
+          process = this.statusManager.updateProcess(
+            step,
+            process.type,
+            'STARTED'
+          )
+
+          // Check balance
+          await checkBalance(this.walletAdapter.publicKey!.toString(), step)
+
+          // Create new transaction
+          if (!step.transactionRequest) {
+            const updatedStep = await getStepTransaction(step)
+            const comparedStep = await stepComparison(
+              this.statusManager,
+              step,
+              updatedStep,
+              this.allowUserInteraction,
+              this.executionOptions
+            )
+            step = {
+              ...comparedStep,
+              execution: step.execution,
+            }
+          }
+
+          if (!step.transactionRequest?.data) {
+            throw new TransactionError(
+              LiFiErrorCode.TransactionUnprepared,
+              'Unable to prepare transaction.'
+            )
+          }
+
+          process = this.statusManager.updateProcess(
+            step,
+            process.type,
+            'ACTION_REQUIRED'
+          )
+
+          if (!this.allowUserInteraction) {
+            return step
+          }
+
+          let transactionRequest: TransactionParameters = {
+            data: step.transactionRequest.data,
+          }
+
+          if (this.executionOptions?.updateTransactionRequestHook) {
+            const customizedTransactionRequest: TransactionParameters =
+              await this.executionOptions.updateTransactionRequestHook({
+                requestType: 'transaction',
+                ...transactionRequest,
+              })
+
+            transactionRequest = {
+              ...transactionRequest,
+              ...customizedTransactionRequest,
+            }
+          }
+
+          if (!transactionRequest.data) {
+            throw new TransactionError(
+              LiFiErrorCode.TransactionUnprepared,
+              'Unable to prepare transaction.'
+            )
+          }
+
+          const versionedTransaction = VersionedTransaction.deserialize(
+            Uint8Array.from(atob(transactionRequest.data), (c) =>
+              c.charCodeAt(0)
+            )
+          )
+          txHash = await this.walletAdapter.sendTransaction(
+            versionedTransaction,
+            connection,
+            {
+              maxRetries: 5,
+              skipPreflight: true,
+            }
+          )
+
+          process = this.statusManager.updateProcess(
+            step,
+            process.type,
+            'PENDING',
+            {
+              txHash: txHash,
+              txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${txHash}`,
+            }
+          )
+        }
+
+        const signatureResult = await connection.confirmTransaction(
+          {
+            signature: txHash,
+          } as TransactionConfirmationStrategy,
+          'confirmed'
+        )
+
+        if (signatureResult.value.err) {
+          throw new TransactionError(
+            LiFiErrorCode.TransactionFailed,
+            `Transaction failed: ${signatureResult.value.err}`
+          )
+        }
+
+        if (isBridgeExecution) {
+          process = this.statusManager.updateProcess(step, process.type, 'DONE')
+        }
+      } catch (e: any) {
+        const error = await parseError(e, step, process)
+        process = this.statusManager.updateProcess(
+          step,
+          process.type,
+          'FAILED',
+          {
+            error: {
+              message: error.message,
+              htmlMessage: error.htmlMessage,
+              code: error.code,
+            },
+          }
+        )
+        this.statusManager.updateExecution(step, 'FAILED')
+        throw error
+      }
+    }
+
+    // STEP 5: Wait for the receiving chain
+    const processTxHash = process.txHash
+    if (isBridgeExecution) {
+      process = this.statusManager.findOrCreateProcess(
+        step,
+        'RECEIVING_CHAIN',
+        'PENDING'
+      )
+    }
+    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,
+        gasAmount: statusResponse.sending.gasAmount,
+        gasAmountUSD: statusResponse.sending.gasAmountUSD,
+        gasPrice: statusResponse.sending.gasPrice,
+        gasToken: statusResponse.sending.gasToken,
+        gasUsed: statusResponse.sending.gasUsed,
+      })
+    } 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
+    }
+
+    // DONE
+    return step
+  }
+}

package/dist/core/Solana/connection.ts

@@ -0,0 +1,19 @@
+import { ChainId } from '@lifi/types'
+import { Connection } from '@solana/web3.js'
+import { getRpcUrl } from '../utils.js'
+
+const solanaChainProvider: Connection | undefined = undefined
+
+/**
+ * getSolanaConnection is just a thin wrapper around getting the
+ * connection (rpc provider) for Solana
+ * @returns - Solana rpc connection
+ */
+export const getSolanaConnection = async (): Promise<Connection> => {
+  if (!solanaChainProvider) {
+    const rpcUrl = await getRpcUrl(ChainId.SOL)
+    return new Connection(rpcUrl)
+  } else {
+    return solanaChainProvider
+  }
+}

package/dist/core/Solana/getSolanaBalance.ts

@@ -0,0 +1,62 @@
+import type { ChainId, Token, TokenAmount } from '@lifi/types'
+import { PublicKey } from '@solana/web3.js'
+import { getSolanaConnection } from './connection.js'
+import { TokenProgramAddress } from './types.js'
+
+export const getSolanaBalance = 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.`)
+    }
+  })
+
+  return getSolanaBalanceDefault(chainId, tokens, walletAddress)
+}
+
+const getSolanaBalanceDefault = async (
+  _chainId: ChainId,
+  tokens: Token[],
+  walletAddress: string
+): Promise<TokenAmount[]> => {
+  const connection = await getSolanaConnection()
+  const blockNumber = await connection.getSlot()
+  const accountPublicKey = new PublicKey(walletAddress)
+  const tokenProgramPublicKey = new PublicKey(TokenProgramAddress)
+  const response = await connection.getParsedTokenAccountsByOwner(
+    accountPublicKey,
+    {
+      programId: tokenProgramPublicKey,
+    }
+  )
+  const walletTokenAmounts = response.value.reduce(
+    (tokenAmounts, value) => {
+      const amount = BigInt(value.account.data.parsed.info.tokenAmount.amount)
+      if (amount > 0n) {
+        tokenAmounts[value.account.data.parsed.info.mint] = amount
+      }
+      return tokenAmounts
+    },
+    {} as Record<string, bigint>
+  )
+  const tokenAmounts: TokenAmount[] = tokens.map((token) => {
+    if (walletTokenAmounts[token.address]) {
+      return {
+        ...token,
+        amount: walletTokenAmounts[token.address],
+        blockNumber: BigInt(blockNumber),
+      }
+    }
+    return {
+      ...token,
+      blockNumber: BigInt(blockNumber),
+    }
+  })
+  return tokenAmounts
+}

package/dist/core/Solana/types.ts

@@ -0,0 +1,18 @@
+import { ChainType, type ChainId } from '@lifi/types'
+import type { WalletAdapter } from '@solana/wallet-adapter-base'
+import { type SDKProvider } from '../types.js'
+
+export interface SolanaProviderOptions {
+  getWalletAdapter?: () => Promise<WalletAdapter>
+}
+
+export interface SolanaProvider extends SDKProvider {
+  rpcUrls?: Record<ChainId, string[]>
+  setOptions(options: SolanaProviderOptions): void
+}
+
+export function isSolana(provider: SDKProvider): provider is SolanaProvider {
+  return provider.type === ChainType.SVM
+}
+
+export const TokenProgramAddress = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'