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

package/src/core/EVM/switchChain.ts

@@ -0,0 +1,77 @@
+import type { WalletClient } from 'viem'
+import { LiFiErrorCode, ProviderError } from '../../utils/errors.js'
+import type { StatusManager } from '../StatusManager.js'
+import type { LiFiStepExtended, 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: LiFiStepExtended,
+  allowUserInteraction: boolean,
+  switchChainHook?: SwitchChainHook
+): Promise<WalletClient | undefined> => {
+  // if we are already on the correct chain we can proceed directly
+  const currentChainId = await walletClient.getChainId()
+  if (currentChainId === 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/src/core/EVM/types.ts

@@ -0,0 +1,73 @@
+import { ChainType, 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
+  multisig?: MultisigConfig
+}
+
+export interface EVMProvider extends SDKProvider {
+  setOptions(options: EVMProviderOptions): void
+  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/src/core/EVM/utils.ts

@@ -0,0 +1,48 @@
+import { type ChainId } from '@lifi/types'
+import type { PublicClient, Transaction } from 'viem'
+import { config } from '../../config.js'
+import { median } from '../../utils/median.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 chains = await config.getChains()
+  return chains.find((chain) => chain.id === chainId)?.multicallAddress
+}
+
+// Modified viem retryDelay exponential backoff function.
+export const retryDelay = ({ count }: { count: number; error: Error }) =>
+  Math.min(~~(1 << count) * 200, 3000)
+
+export const retryCount = 20

package/src/core/Solana/Solana.ts

@@ -0,0 +1,41 @@
+import { ChainType } from '@lifi/types'
+import type { StepExecutorOptions } from '../types.js'
+import { SolanaStepExecutor } from './SolanaStepExecutor.js'
+import { getSNSAddress } from './getSNSAddress.js'
+import { getSolanaBalance } from './getSolanaBalance.js'
+import { isAddress } from './isAddress.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,
+    resolveAddress: getSNSAddress,
+    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/src/core/Solana/SolanaStepExecutor.ts

@@ -0,0 +1,272 @@
+import type { ExtendedTransactionInfo, FullStatusData } from '@lifi/types'
+import type { Adapter } 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 {
+  LiFiStepExtended,
+  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: Adapter
+}
+
+export class SolanaStepExecutor extends BaseStepExecutor {
+  private walletAdapter: Adapter
+
+  constructor(options: SolanaStepExecutorOptions) {
+    super(options)
+    this.walletAdapter = options.walletAdapter
+  }
+
+  checkWalletAdapter = (step: LiFiStepExtended) => {
+    // Prevent execution of the quote by wallet different from the one which requested the quote
+    if (this.walletAdapter.publicKey!.toString() !== step.action.fromAddress) {
+      throw new TransactionError(
+        LiFiErrorCode.WalletChangedDuringExecution,
+        'The wallet address that requested the quote does not match the wallet address attempting to sign the transaction.'
+      )
+    }
+  }
+
+  executeStep = async (step: LiFiStepExtended): Promise<LiFiStepExtended> => {
+    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)
+            )
+          )
+
+          this.checkWalletAdapter(step)
+
+          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,
+        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
+    }
+
+    // DONE
+    return step
+  }
+}

package/src/core/Solana/connection.ts

@@ -0,0 +1,20 @@
+import { ChainId } from '@lifi/types'
+import { Connection } from '@solana/web3.js'
+import { getRpcUrl } from '../rpc.js'
+
+let connection: 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 (!connection) {
+    const rpcUrl = await getRpcUrl(ChainId.SOL)
+    connection = new Connection(rpcUrl)
+    return connection
+  } else {
+    return connection
+  }
+}

package/src/core/Solana/getSNSAddress.ts

@@ -0,0 +1,33 @@
+import { isAddress } from './isAddress.js'
+
+interface SNSResult {
+  s: 'ok' | 'error'
+  result: string
+}
+
+// Subject to change
+// https://github.com/Bonfida/sns-sdk?tab=readme-ov-file#sdk-proxy
+export const getSNSAddress = async (name: string) => {
+  try {
+    if (!name.endsWith('.sol')) {
+      return
+    }
+    // const rpcUrl = await getRpcUrl(ChainId.SOL)
+    const snsWorkerUrl = `https://sns-sdk-proxy.bonfida.workers.dev/resolve/${name}`
+    const response: Response = await fetch(snsWorkerUrl)
+    if (!response.ok) {
+      return
+    }
+
+    const data: SNSResult = await response.json()
+
+    if (!isAddress(data.result)) {
+      return
+    }
+
+    return data.result
+  } catch (_) {
+    // ignore
+    return
+  }
+}

package/src/core/Solana/getSolanaBalance.ts

@@ -0,0 +1,72 @@
+import type { ChainId, Token, TokenAmount } from '@lifi/types'
+import { PublicKey } from '@solana/web3.js'
+import { wrappedSolAddress } from '../../constants.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 accountPublicKey = new PublicKey(walletAddress)
+  const tokenProgramPublicKey = new PublicKey(TokenProgramAddress)
+  const [slot, balance, tokenAccountsByOwner] = await Promise.allSettled([
+    connection.getSlot(),
+    connection.getBalance(accountPublicKey),
+    connection.getParsedTokenAccountsByOwner(accountPublicKey, {
+      programId: tokenProgramPublicKey,
+    }),
+  ])
+  const blockNumber = slot.status === 'fulfilled' ? BigInt(slot.value) : 0n
+  const solBalance = balance.status === 'fulfilled' ? BigInt(balance.value) : 0n
+  const walletTokenAmounts =
+    tokenAccountsByOwner.status === 'fulfilled'
+      ? tokenAccountsByOwner.value.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>
+        )
+      : {}
+  walletTokenAmounts[wrappedSolAddress] ??= 0n
+  walletTokenAmounts[wrappedSolAddress] += solBalance
+  const tokenAmounts: TokenAmount[] = tokens.map((token) => {
+    if (walletTokenAmounts[token.address]) {
+      return {
+        ...token,
+        amount: walletTokenAmounts[token.address],
+        blockNumber,
+      }
+    }
+    return {
+      ...token,
+      blockNumber,
+    }
+  })
+  return tokenAmounts
+}

package/src/core/Solana/isAddress.ts

@@ -0,0 +1,10 @@
+import { PublicKey } from '@solana/web3.js'
+
+export function isAddress(address: string): boolean {
+  try {
+    new PublicKey(address)
+    return true
+  } catch (error) {
+    return false
+  }
+}

package/src/core/Solana/types.ts

@@ -0,0 +1,18 @@
+import { ChainType, type ChainId } from '@lifi/types'
+import type { Adapter } from '@solana/wallet-adapter-base'
+import { type SDKProvider } from '../types.js'
+
+export interface SolanaProviderOptions {
+  getWalletAdapter?: () => Promise<Adapter>
+}
+
+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'