@lifi/sdk 3.0.0-alpha.3 → 3.0.0-alpha.30

package/src/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/src/core/Solana/SolanaStepExecutor.ts

@@ -0,0 +1,253 @@
+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
+  }
+
+  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)
+            )
+          )
+          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/src/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/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/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'

package/src/core/StatusManager.ts

@@ -0,0 +1,243 @@
+import type {
+  Execution,
+  LiFiStep,
+  Process,
+  ProcessType,
+  Status,
+  Token,
+} from '@lifi/types'
+import { emptyExecution } from '@lifi/types'
+import { executionState } from './executionState.js'
+import type { LiFiStepExtended } from './types.js'
+import { getProcessMessage } from './utils.js'
+
+interface Receipt {
+  fromAmount?: string
+  toAmount?: string
+  toToken?: Token
+  gasPrice?: string
+  gasUsed?: string
+  gasToken?: Token
+  gasAmount?: string
+  gasAmountUSD?: string
+}
+
+type OptionalParameters = Partial<
+  Pick<
+    Process,
+    | 'doneAt'
+    | 'failedAt'
+    | 'txHash'
+    | 'txLink'
+    | 'error'
+    | 'substatus'
+    | 'substatusMessage'
+    | 'multisigTxHash'
+  >
+>
+
+/**
+ * Manages status updates of a route and provides various functions for tracking processes
+ * @param {string} routeId The route dd this StatusManger belongs to.
+ * @returns {StatusManager} An instance of StatusManager.
+ */
+export class StatusManager {
+  private readonly routeId: string
+  private shouldUpdate = true
+
+  constructor(routeId: string) {
+    this.routeId = routeId
+  }
+
+  /**
+   * Initializes the execution object of a Step.
+   * @param step  The current step in execution
+   * @returns The initialized execution object for this step and a function to update this step
+   */
+  initExecutionObject = (step: LiFiStepExtended): Execution => {
+    if (!step.execution) {
+      step.execution = structuredClone<Execution>(emptyExecution)
+      step.execution.status = 'PENDING'
+      this.updateStepInRoute(step)
+    }
+
+    // Change status to PENDING after resuming from FAILED
+    if (step.execution.status === 'FAILED') {
+      step.execution.status = 'PENDING'
+      this.updateStepInRoute(step)
+    }
+
+    return step.execution
+  }
+
+  /**
+   * Updates the execution object of a Step.
+   * @param step  The current step in execution
+   * @param status  The status for the execution
+   * @param receipt Optional. Information about received tokens
+   * @returns The step with the updated execution object
+   */
+  updateExecution(
+    step: LiFiStepExtended,
+    status: Status,
+    receipt?: Receipt
+  ): LiFiStep {
+    if (!step.execution) {
+      throw Error("Can't update empty execution.")
+    }
+    step.execution.status = status
+    if (receipt) {
+      step.execution = {
+        ...step.execution,
+        ...receipt,
+      }
+    }
+    this.updateStepInRoute(step)
+    return step
+  }
+
+  /**
+   * Create and push a new process into the execution.
+   * @param step The step that should contain the new process.
+   * @param type Type of the process. Used to identify already existing processes.
+   * @param status By default created procces is set to the STARTED status. We can override new process with the needed status.
+   * @returns Returns process.
+   */
+  findOrCreateProcess = (
+    step: LiFiStepExtended,
+    type: ProcessType,
+    status?: Status
+  ): Process => {
+    if (!step.execution?.process) {
+      throw new Error("Execution hasn't been initialized.")
+    }
+
+    const process = step.execution.process.find((p) => p.type === type)
+
+    if (process) {
+      if (status && process.status !== status) {
+        process.status = status
+        this.updateStepInRoute(step)
+      }
+      return process
+    }
+
+    const newProcess: Process = {
+      type: type,
+      startedAt: Date.now(),
+      message: getProcessMessage(type, status ?? 'STARTED'),
+      status: status ?? 'STARTED',
+    }
+
+    step.execution.process.push(newProcess)
+    this.updateStepInRoute(step)
+    return newProcess
+  }
+
+  /**
+   * Update a process object.
+   * @param step The step where the process should be updated
+   * @param type  The process type to update
+   * @param status The status the process gets.
+   * @param [params]   Additional parameters to append to the process.
+   * @returns The update process
+   */
+  updateProcess = (
+    step: LiFiStepExtended,
+    type: ProcessType,
+    status: Status,
+    params?: OptionalParameters
+  ): Process => {
+    if (!step.execution) {
+      throw new Error("Can't update an empty step execution.")
+    }
+    const currentProcess = step?.execution?.process.find((p) => p.type === type)
+
+    if (!currentProcess) {
+      throw new Error("Can't find a process for the given type.")
+    }
+
+    switch (status) {
+      case 'CANCELLED':
+        currentProcess.doneAt = Date.now()
+        break
+      case 'FAILED':
+        currentProcess.doneAt = Date.now()
+        step.execution.status = 'FAILED'
+        break
+      case 'DONE':
+        currentProcess.doneAt = Date.now()
+        break
+      case 'PENDING':
+        step.execution.status = 'PENDING'
+        break
+      case 'ACTION_REQUIRED':
+        step.execution.status = 'ACTION_REQUIRED'
+        break
+      default:
+        break
+    }
+
+    currentProcess.status = status
+    currentProcess.message = getProcessMessage(type, status)
+    // set extra parameters or overwritte the standard params set in the switch statement
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        currentProcess[key] = value
+      }
+    }
+    // Sort processes, the ones with DONE status go first
+    step.execution.process = [
+      ...step?.execution?.process.filter(
+        (process) => process.status === 'DONE'
+      ),
+      ...step?.execution?.process.filter(
+        (process) => process.status !== 'DONE'
+      ),
+    ]
+    this.updateStepInRoute(step) // updates the step in the route
+    return currentProcess
+  }
+
+  /**
+   * Remove a process from the execution
+   * @param step The step where the process should be removed from
+   * @param type  The process type to remove
+   */
+  removeProcess = (step: LiFiStepExtended, type: ProcessType): void => {
+    if (!step.execution) {
+      throw new Error("Execution hasn't been initialized.")
+    }
+    const index = step.execution.process.findIndex((p) => p.type === type)
+    step.execution.process.splice(index, 1)
+    this.updateStepInRoute(step)
+  }
+
+  updateStepInRoute = (step: LiFiStep): LiFiStep => {
+    if (!this.shouldUpdate) {
+      return step
+    }
+    const data = executionState.get(this.routeId)
+
+    if (!data) {
+      throw new Error('Execution data not found.')
+    }
+
+    const stepIndex = data.route.steps.findIndex(
+      (routeStep) => routeStep.id === step.id
+    )
+
+    if (stepIndex === -1) {
+      throw new Error("Couldn't find a step to update.")
+    }
+
+    data.route.steps[stepIndex] = { ...data.route.steps[stepIndex], ...step }
+
+    data.executionOptions?.updateRouteHook?.(data.route)
+    return data.route.steps[stepIndex]
+  }
+
+  allowUpdates(value: boolean): void {
+    this.shouldUpdate = value
+  }
+}

package/src/core/checkBalance.ts

@@ -0,0 +1,48 @@
+import type { LiFiStep } from '@lifi/types'
+import { formatUnits } from 'viem'
+import { getTokenBalance } from '../services/balance.js'
+import { BalanceError } from '../utils/errors.js'
+
+export const checkBalance = async (
+  walletAddress: string,
+  step: LiFiStep,
+  depth = 0
+): Promise<void> => {
+  const token = await getTokenBalance(walletAddress, step.action.fromToken)
+  if (token) {
+    const currentBalance = token.amount ?? 0n
+    const neededBalance = BigInt(step.action.fromAmount)
+
+    if (currentBalance < neededBalance) {
+      if (depth <= 3) {
+        await new Promise((resolve) => {
+          setTimeout(resolve, 200)
+        })
+        await checkBalance(walletAddress, step, depth + 1)
+      } else if (
+        (neededBalance * BigInt((1 - step.action.slippage) * 1_000_000_000)) /
+          1_000_000_000n <=
+        currentBalance
+      ) {
+        // adjust amount in slippage limits
+        step.action.fromAmount = currentBalance.toString()
+      } else {
+        const neeeded = formatUnits(neededBalance, token.decimals)
+        const current = formatUnits(currentBalance, token.decimals)
+        let errorMessage =
+          `Your ${token.symbol} balance is too low, ` +
+          `you try to transfer ${neeeded} ${token.symbol}, ` +
+          `but your wallet only holds ${current} ${token.symbol}. ` +
+          `No funds have been sent.`
+
+        if (currentBalance !== 0n) {
+          errorMessage +=
+            `If the problem consists, please delete this transfer and ` +
+            `start a new one with a maximum of ${current} ${token.symbol}.`
+        }
+
+        throw new BalanceError('The balance is too low.', errorMessage)
+      }
+    }
+  }
+}