@lifi/sdk 3.13.5 → 4.0.0-alpha.1

package/src/core/Solana/KeypairWalletAdapter.ts

@@ -1,100 +0,0 @@
-import { ed25519 } from '@noble/curves/ed25519'
-import type {
-  SignerWalletAdapter,
-  WalletName,
-} from '@solana/wallet-adapter-base'
-import {
-  BaseSignerWalletAdapter,
-  isVersionedTransaction,
-  WalletConfigError,
-  WalletNotConnectedError,
-  WalletReadyState,
-} from '@solana/wallet-adapter-base'
-import type {
-  Transaction,
-  TransactionVersion,
-  VersionedTransaction,
-} from '@solana/web3.js'
-import { Keypair } from '@solana/web3.js'
-import bs58 from 'bs58'
-
-export const KeypairWalletName =
-  'Keypair Wallet' as WalletName<'Keypair Wallet'>
-
-/**
- * This keypair wallet adapter is unsafe to use on the frontend and is only included to provide an easy way for applications to test
- * Wallet Adapter without using a third-party wallet.
- */
-export class KeypairWalletAdapter
-  extends BaseSignerWalletAdapter
-  implements SignerWalletAdapter
-{
-  name = KeypairWalletName
-  url = 'https://github.com/anza-xyz/wallet-adapter'
-  icon = ''
-  supportedTransactionVersions: ReadonlySet<TransactionVersion> = new Set([
-    'legacy',
-    0,
-  ])
-
-  /**
-   * Storing a keypair locally like this is not safe because any application using this adapter could retrieve the
-   * secret key, and because the keypair will be lost any time the wallet is disconnected or the window is refreshed.
-   */
-  private _keypair: Keypair | undefined
-
-  constructor(privateKey: string) {
-    if (!privateKey) {
-      throw new WalletConfigError()
-    }
-    super()
-    this._keypair = Keypair.fromSecretKey(bs58.decode(privateKey))
-  }
-
-  get connecting() {
-    return false
-  }
-
-  get publicKey() {
-    return this._keypair?.publicKey || null
-  }
-
-  get readyState() {
-    return WalletReadyState.Loadable
-  }
-
-  async connect(privateKey?: string): Promise<void> {
-    if (!privateKey) {
-      throw new WalletConfigError()
-    }
-    this._keypair = Keypair.fromSecretKey(bs58.decode(privateKey))
-  }
-
-  async disconnect(): Promise<void> {
-    this._keypair = undefined
-  }
-
-  async signTransaction<T extends Transaction | VersionedTransaction>(
-    transaction: T
-  ): Promise<T> {
-    if (!this._keypair) {
-      throw new WalletNotConnectedError()
-    }
-
-    if (isVersionedTransaction(transaction)) {
-      transaction.sign([this._keypair])
-    } else {
-      transaction.partialSign(this._keypair)
-    }
-
-    return transaction
-  }
-
-  async signMessage(message: Uint8Array): Promise<Uint8Array> {
-    if (!this._keypair) {
-      throw new WalletNotConnectedError()
-    }
-
-    return ed25519.sign(message, this._keypair.secretKey.slice(0, 32))
-  }
-}

package/src/core/Solana/Solana.ts

@@ -1,41 +0,0 @@
-import { ChainType } from '@lifi/types'
-import type { StepExecutorOptions } from '../types.js'
-import { getSolanaBalance } from './getSolanaBalance.js'
-import { isSVMAddress } from './isSVMAddress.js'
-import { resolveSolanaAddress } from './resolveSolanaAddress.js'
-import { SolanaStepExecutor } from './SolanaStepExecutor.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: isSVMAddress,
-    resolveAddress: resolveSolanaAddress,
-    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

@@ -1,225 +0,0 @@
-import type { SignerWalletAdapter } from '@solana/wallet-adapter-base'
-import { VersionedTransaction } from '@solana/web3.js'
-import { withTimeout } from 'viem'
-import { config } from '../../config.js'
-import { LiFiErrorCode } from '../../errors/constants.js'
-import { TransactionError } from '../../errors/errors.js'
-import { getStepTransaction } from '../../services/api.js'
-import { base64ToUint8Array } from '../../utils/base64ToUint8Array.js'
-import { BaseStepExecutor } from '../BaseStepExecutor.js'
-import { checkBalance } from '../checkBalance.js'
-import { stepComparison } from '../stepComparison.js'
-import type { LiFiStepExtended, TransactionParameters } from '../types.js'
-import { waitForDestinationChainTransaction } from '../waitForDestinationChainTransaction.js'
-import { callSolanaWithRetry } from './connection.js'
-import { parseSolanaErrors } from './parseSolanaErrors.js'
-import { sendAndConfirmTransaction } from './sendAndConfirmTransaction.js'
-import type { SolanaStepExecutorOptions } from './types.js'
-
-export class SolanaStepExecutor extends BaseStepExecutor {
-  private walletAdapter: SignerWalletAdapter
-
-  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'
-
-    let process = this.statusManager.findOrCreateProcess({
-      step,
-      type: currentProcessType,
-      chainId: fromChain.id,
-    })
-
-    if (process.status !== 'DONE') {
-      try {
-        process = this.statusManager.updateProcess(
-          step,
-          process.type,
-          'STARTED'
-        )
-
-        // Check balance
-        await checkBalance(this.walletAdapter.publicKey!.toString(), step)
-
-        // Create new transaction
-        if (!step.transactionRequest) {
-          // biome-ignore lint/correctness/noUnusedVariables: destructuring
-          const { execution, ...stepBase } = step
-          const updatedStep = await getStepTransaction(stepBase)
-          const comparedStep = await stepComparison(
-            this.statusManager,
-            step,
-            updatedStep,
-            this.allowUserInteraction,
-            this.executionOptions
-          )
-          Object.assign(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(
-          base64ToUint8Array(transactionRequest.data)
-        )
-
-        this.checkWalletAdapter(step)
-
-        // We give users 2 minutes to sign the transaction or it should be considered expired
-        const signedTx = await withTimeout<VersionedTransaction>(
-          () => this.walletAdapter.signTransaction(versionedTransaction),
-          {
-            // https://solana.com/docs/advanced/confirmation#transaction-expiration
-            // Use 2 minutes to account for fluctuations
-            timeout: 120_000,
-            errorInstance: new TransactionError(
-              LiFiErrorCode.TransactionExpired,
-              'Transaction has expired: blockhash is no longer recent enough.'
-            ),
-          }
-        )
-
-        process = this.statusManager.updateProcess(
-          step,
-          process.type,
-          'PENDING'
-        )
-
-        const simulationResult = await callSolanaWithRetry((connection) =>
-          connection.simulateTransaction(signedTx, {
-            commitment: 'confirmed',
-            replaceRecentBlockhash: true,
-          })
-        )
-
-        if (simulationResult.value.err) {
-          throw new TransactionError(
-            LiFiErrorCode.TransactionSimulationFailed,
-            'Transaction simulation failed'
-          )
-        }
-
-        const confirmedTx = await sendAndConfirmTransaction(signedTx)
-
-        if (!confirmedTx.signatureResult) {
-          throw new TransactionError(
-            LiFiErrorCode.TransactionExpired,
-            'Transaction has expired: The block height has exceeded the maximum allowed limit.'
-          )
-        }
-
-        if (confirmedTx.signatureResult.err) {
-          const reason =
-            typeof confirmedTx.signatureResult.err === 'object'
-              ? JSON.stringify(confirmedTx.signatureResult.err)
-              : confirmedTx.signatureResult.err
-          throw new TransactionError(
-            LiFiErrorCode.TransactionFailed,
-            `Transaction failed: ${reason}`
-          )
-        }
-
-        // Transaction has been confirmed and we can update the process
-        process = this.statusManager.updateProcess(
-          step,
-          process.type,
-          'PENDING',
-          {
-            txHash: confirmedTx.txSignature,
-            txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${confirmedTx.txSignature}`,
-          }
-        )
-
-        if (isBridgeExecution) {
-          process = this.statusManager.updateProcess(step, process.type, 'DONE')
-        }
-      } catch (e: any) {
-        const error = await parseSolanaErrors(e, step, process)
-        process = this.statusManager.updateProcess(
-          step,
-          process.type,
-          'FAILED',
-          {
-            error: {
-              message: error.cause.message,
-              code: error.code,
-            },
-          }
-        )
-        this.statusManager.updateExecution(step, 'FAILED')
-        throw error
-      }
-    }
-
-    await waitForDestinationChainTransaction(
-      step,
-      process,
-      fromChain,
-      toChain,
-      this.statusManager
-    )
-
-    // DONE
-    return step
-  }
-}

package/src/core/Solana/connection.ts

@@ -1,51 +0,0 @@
-import { ChainId } from '@lifi/types'
-import { Connection } from '@solana/web3.js'
-import { getRpcUrls } from '../rpc.js'
-
-const connections = new Map<string, Connection>()
-
-/**
- * Initializes the Solana connections if they haven't been initialized yet.
- * @returns - Promise that resolves when connections are initialized.
- */
-const ensureConnections = async (): Promise<void> => {
-  const rpcUrls = await getRpcUrls(ChainId.SOL)
-  for (const rpcUrl of rpcUrls) {
-    if (!connections.get(rpcUrl)) {
-      const connection = new Connection(rpcUrl)
-      connections.set(rpcUrl, connection)
-    }
-  }
-}
-
-/**
- * Wrapper around getting the connection (RPC provider) for Solana
- * @returns - Solana RPC connections
- */
-export const getSolanaConnections = async (): Promise<Connection[]> => {
-  await ensureConnections()
-  return Array.from(connections.values())
-}
-
-/**
- * Calls a function on the Connection instances with retry logic.
- * @param fn - The function to call, which receives a Connection instance.
- * @returns - The result of the function call.
- */
-export async function callSolanaWithRetry<R>(
-  fn: (connection: Connection) => Promise<R>
-): Promise<R> {
-  // Ensure connections are initialized
-  await ensureConnections()
-  let lastError: any = null
-  for (const connection of connections.values()) {
-    try {
-      const result = await fn(connection)
-      return result
-    } catch (error) {
-      lastError = error
-    }
-  }
-  // Throw the last encountered error
-  throw lastError
-}

package/src/core/Solana/getSNSAddress.ts

@@ -1,32 +0,0 @@
-import { isSVMAddress } from './isSVMAddress.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 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 (!isSVMAddress(data.result)) {
-      return
-    }
-
-    return data.result
-  } catch (_) {
-    // ignore
-    return
-  }
-}

package/src/core/Solana/getSolanaBalance.ts

@@ -1,114 +0,0 @@
-import type { ChainId, Token, TokenAmount } from '@lifi/types'
-import { PublicKey } from '@solana/web3.js'
-import { SolSystemProgram } from '../../constants.js'
-import { withDedupe } from '../../utils/withDedupe.js'
-import { callSolanaWithRetry } from './connection.js'
-import { Token2022ProgramId, TokenProgramId } from './types.js'
-
-export const getSolanaBalance = async (
-  walletAddress: string,
-  tokens: Token[]
-): Promise<TokenAmount[]> => {
-  if (tokens.length === 0) {
-    return []
-  }
-  const { chainId } = tokens[0]
-  for (const token of tokens) {
-    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 accountPublicKey = new PublicKey(walletAddress)
-  const tokenProgramIdPublicKey = new PublicKey(TokenProgramId)
-  const token2022ProgramIdPublicKey = new PublicKey(Token2022ProgramId)
-  const [slot, balance, tokenAccountsByOwner, token2022AccountsByOwner] =
-    await Promise.allSettled([
-      withDedupe(
-        () =>
-          callSolanaWithRetry((connection) => connection.getSlot('confirmed')),
-        { id: `${getSolanaBalanceDefault.name}.getSlot` }
-      ),
-      withDedupe(
-        () =>
-          callSolanaWithRetry((connection) =>
-            connection.getBalance(accountPublicKey, 'confirmed')
-          ),
-        { id: `${getSolanaBalanceDefault.name}.getBalance` }
-      ),
-      withDedupe(
-        () =>
-          callSolanaWithRetry((connection) =>
-            connection.getParsedTokenAccountsByOwner(
-              accountPublicKey,
-              {
-                programId: tokenProgramIdPublicKey,
-              },
-              'confirmed'
-            )
-          ),
-        {
-          id: `${getSolanaBalanceDefault.name}.getParsedTokenAccountsByOwner.${TokenProgramId}`,
-        }
-      ),
-      withDedupe(
-        () =>
-          callSolanaWithRetry((connection) =>
-            connection.getParsedTokenAccountsByOwner(
-              accountPublicKey,
-              {
-                programId: token2022ProgramIdPublicKey,
-              },
-              'confirmed'
-            )
-          ),
-        {
-          id: `${getSolanaBalanceDefault.name}.getParsedTokenAccountsByOwner.${Token2022ProgramId}`,
-        }
-      ),
-    ])
-  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
-      : []),
-    ...(token2022AccountsByOwner.status === 'fulfilled'
-      ? token2022AccountsByOwner.value.value
-      : []),
-  ].reduce(
-    (tokenAmounts: Record<string, bigint>, value: any) => {
-      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[SolSystemProgram] = 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/isSVMAddress.ts

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

package/src/core/Solana/parseSolanaErrors.ts

@@ -1,50 +0,0 @@
-import type { LiFiStep } from '@lifi/types'
-import { BaseError } from '../../errors/baseError.js'
-import { ErrorMessage, LiFiErrorCode } from '../../errors/constants.js'
-import { TransactionError, UnknownError } from '../../errors/errors.js'
-import { SDKError } from '../../errors/SDKError.js'
-import type { Process } from '../types.js'
-
-export const parseSolanaErrors = async (
-  e: Error,
-  step?: LiFiStep,
-  process?: Process
-): Promise<SDKError> => {
-  if (e instanceof SDKError) {
-    e.step = e.step ?? step
-    e.process = e.process ?? process
-    return e
-  }
-
-  const baseError = handleSpecificErrors(e)
-
-  return new SDKError(baseError, step, process)
-}
-
-const handleSpecificErrors = (e: any) => {
-  if (e.name === 'WalletSignTransactionError') {
-    return new TransactionError(LiFiErrorCode.SignatureRejected, e.message, e)
-  }
-
-  if (e.name === 'SendTransactionError') {
-    return new TransactionError(LiFiErrorCode.TransactionFailed, e.message, e)
-  }
-
-  if (e.name === 'TransactionExpiredBlockheightExceededError') {
-    return new TransactionError(LiFiErrorCode.TransactionExpired, e.message, e)
-  }
-
-  if (e.message?.includes('simulate')) {
-    return new TransactionError(
-      LiFiErrorCode.TransactionSimulationFailed,
-      e.message,
-      e
-    )
-  }
-
-  if (e instanceof BaseError) {
-    return e
-  }
-
-  return new UnknownError(e.message || ErrorMessage.UnknownError, e)
-}

package/src/core/Solana/resolveSolanaAddress.ts

@@ -1,7 +0,0 @@
-import { getSNSAddress } from './getSNSAddress.js'
-
-export async function resolveSolanaAddress(
-  name: string
-): Promise<string | undefined> {
-  return await getSNSAddress(name)
-}