@lifi/sdk 3.13.5 → 4.0.0-alpha.1

package/src/core/Solana/sendAndConfirmTransaction.ts

@@ -1,132 +0,0 @@
-import type {
-  SendOptions,
-  SignatureResult,
-  VersionedTransaction,
-} from '@solana/web3.js'
-import bs58 from 'bs58'
-import { sleep } from '../../utils/sleep.js'
-import { getSolanaConnections } from './connection.js'
-
-type ConfirmedTransactionResult = {
-  signatureResult: SignatureResult | null
-  txSignature: string
-}
-
-/**
- * Sends a Solana transaction to multiple RPC endpoints and returns the confirmation
- * as soon as any of them confirm the transaction.
- * @param signedTx - The signed transaction to send.
- * @returns - The confirmation result of the transaction.
- */
-export async function sendAndConfirmTransaction(
-  signedTx: VersionedTransaction
-): Promise<ConfirmedTransactionResult> {
-  const connections = await getSolanaConnections()
-
-  const signedTxSerialized = signedTx.serialize()
-  // Create transaction hash (signature)
-  const txSignature = bs58.encode(signedTx.signatures[0])
-
-  if (!txSignature) {
-    throw new Error('Transaction signature is missing.')
-  }
-
-  const rawTransactionOptions: SendOptions = {
-    // We can skip preflight check after the first transaction has been sent
-    // https://solana.com/docs/advanced/retry#the-cost-of-skipping-preflight
-    skipPreflight: true,
-    // Setting max retries to 0 as we are handling retries manually
-    maxRetries: 0,
-    // https://solana.com/docs/advanced/confirmation#use-an-appropriate-preflight-commitment-level
-    preflightCommitment: 'confirmed',
-  }
-
-  const abortController = new AbortController()
-
-  const confirmPromises = connections.map(async (connection) => {
-    try {
-      // Send initial transaction for this connection
-      try {
-        await connection.sendRawTransaction(
-          signedTxSerialized,
-          rawTransactionOptions
-        )
-      } catch (_) {
-        // Continue with confirmation even if initial send fails
-      }
-
-      const [blockhashResult, initialBlockHeight] = await Promise.all([
-        connection.getLatestBlockhash('confirmed'),
-        connection.getBlockHeight('confirmed'),
-      ])
-      let currentBlockHeight = initialBlockHeight
-      let signatureResult: SignatureResult | null = null
-
-      const pollingPromise = (async () => {
-        while (
-          currentBlockHeight < blockhashResult.lastValidBlockHeight &&
-          !abortController.signal.aborted
-        ) {
-          const statusResponse = await connection.getSignatureStatuses([
-            txSignature,
-          ])
-
-          const status = statusResponse.value[0]
-          if (
-            status &&
-            (status.confirmationStatus === 'confirmed' ||
-              status.confirmationStatus === 'finalized')
-          ) {
-            signatureResult = status
-            // Immediately abort all other connections when we find a result
-            abortController.abort()
-            return status
-          }
-
-          await sleep(400)
-        }
-        return null
-      })()
-
-      const sendingPromise = (async (): Promise<SignatureResult | null> => {
-        while (
-          currentBlockHeight < blockhashResult.lastValidBlockHeight &&
-          !abortController.signal.aborted &&
-          !signatureResult
-        ) {
-          try {
-            await connection.sendRawTransaction(
-              signedTxSerialized,
-              rawTransactionOptions
-            )
-          } catch (_) {
-            // Continue trying even if individual sends fail
-          }
-
-          await sleep(1000)
-          if (!abortController.signal.aborted) {
-            currentBlockHeight = await connection.getBlockHeight('confirmed')
-          }
-        }
-        return null
-      })()
-
-      // Wait for polling to find the result
-      const result = await Promise.race([pollingPromise, sendingPromise])
-      return result
-    } catch (error) {
-      if (abortController.signal.aborted) {
-        return null // Don't treat abortion as an error
-      }
-      throw error
-    }
-  })
-
-  const signatureResult = await Promise.any(confirmPromises).catch(() => null)
-
-  if (!abortController.signal.aborted) {
-    abortController.abort()
-  }
-
-  return { signatureResult, txSignature }
-}

package/src/core/Solana/types.ts

@@ -1,22 +0,0 @@
-import { ChainType } from '@lifi/types'
-import type { SignerWalletAdapter } from '@solana/wallet-adapter-base'
-import type { SDKProvider, StepExecutorOptions } from '../types.js'
-
-export interface SolanaProviderOptions {
-  getWalletAdapter?: () => Promise<SignerWalletAdapter>
-}
-
-export interface SolanaProvider extends SDKProvider {
-  setOptions(options: SolanaProviderOptions): void
-}
-
-export function isSolana(provider: SDKProvider): provider is SolanaProvider {
-  return provider.type === ChainType.SVM
-}
-
-export interface SolanaStepExecutorOptions extends StepExecutorOptions {
-  walletAdapter: SignerWalletAdapter
-}
-
-export const TokenProgramId = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'
-export const Token2022ProgramId = 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb'

package/src/core/Sui/Sui.ts

@@ -1,41 +0,0 @@
-import { ChainType } from '@lifi/types'
-import { isValidSuiAddress } from '@mysten/sui/utils'
-import type { StepExecutorOptions } from '../types.js'
-import { getSuiBalance } from './getSuiBalance.js'
-import { resolveSuiAddress } from './resolveSuiAddress.js'
-import { SuiStepExecutor } from './SuiStepExecutor.js'
-import type { SuiProvider, SuiProviderOptions } from './types.js'
-
-export function Sui(options?: SuiProviderOptions): SuiProvider {
-  const _options: SuiProviderOptions = options ?? {}
-  return {
-    get type() {
-      return ChainType.MVM
-    },
-    isAddress: isValidSuiAddress,
-    resolveAddress: resolveSuiAddress,
-    getBalance: getSuiBalance,
-    async getStepExecutor(
-      options: StepExecutorOptions
-    ): Promise<SuiStepExecutor> {
-      if (!_options.getWallet) {
-        throw new Error('getWallet is not provided.')
-      }
-
-      const wallet = await _options.getWallet()
-
-      const executor = new SuiStepExecutor({
-        wallet,
-        routeId: options.routeId,
-        executionOptions: {
-          ...options.executionOptions,
-        },
-      })
-
-      return executor
-    },
-    setOptions(options: SuiProviderOptions) {
-      Object.assign(_options, options)
-    },
-  }
-}

package/src/core/Sui/SuiStepExecutor.ts

@@ -1,204 +0,0 @@
-import {
-  signAndExecuteTransaction,
-  type WalletWithRequiredFeatures,
-} from '@mysten/wallet-standard'
-import { config } from '../../config.js'
-import { LiFiErrorCode } from '../../errors/constants.js'
-import { TransactionError } from '../../errors/errors.js'
-import { getStepTransaction } from '../../services/api.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 { parseSuiErrors } from './parseSuiErrors.js'
-import { callSuiWithRetry } from './suiClient.js'
-import type { SuiStepExecutorOptions } from './types.js'
-
-export class SuiStepExecutor extends BaseStepExecutor {
-  private wallet: WalletWithRequiredFeatures
-
-  constructor(options: SuiStepExecutorOptions) {
-    super(options)
-    this.wallet = options.wallet
-  }
-
-  checkWallet = (step: LiFiStepExtended) => {
-    // Prevent execution of the quote by wallet different from the one which requested the quote
-    if (
-      !this.wallet.accounts?.some?.(
-        (account) => account.address === 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(step.action.fromAddress!, 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,
-          }
-        }
-
-        const transactionRequestData = transactionRequest.data
-
-        if (!transactionRequestData) {
-          throw new TransactionError(
-            LiFiErrorCode.TransactionUnprepared,
-            'Unable to prepare transaction.'
-          )
-        }
-
-        this.checkWallet(step)
-
-        // We give users 2 minutes to sign the transaction
-        const signedTx = await signAndExecuteTransaction(this.wallet, {
-          account: this.wallet.accounts.find(
-            (account) => account.address === step.action.fromAddress
-          )!,
-          chain: 'sui:mainnet',
-          transaction: {
-            toJSON: async () => transactionRequestData,
-          },
-        })
-
-        process = this.statusManager.updateProcess(
-          step,
-          process.type,
-          'PENDING'
-        )
-
-        const result = await callSuiWithRetry((client) =>
-          client.waitForTransaction({
-            digest: signedTx.digest,
-            options: {
-              showEffects: true,
-            },
-          })
-        )
-
-        if (result.effects?.status.status !== 'success') {
-          throw new TransactionError(
-            LiFiErrorCode.TransactionFailed,
-            `Transaction failed: ${result.effects?.status.error}`
-          )
-        }
-
-        // Transaction has been confirmed and we can update the process
-        process = this.statusManager.updateProcess(
-          step,
-          process.type,
-          'PENDING',
-          {
-            txHash: result.digest,
-            txLink: `${fromChain.metamask.blockExplorerUrls[0]}txblock/${result.digest}`,
-          }
-        )
-
-        if (isBridgeExecution) {
-          process = this.statusManager.updateProcess(step, process.type, 'DONE')
-        }
-      } catch (e: any) {
-        const error = await parseSuiErrors(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
-    )
-
-    return step
-  }
-}

package/src/core/Sui/getSuiBalance.ts

@@ -1,86 +0,0 @@
-import type { Token, TokenAmount } from '@lifi/types'
-import { withDedupe } from '../../utils/withDedupe.js'
-import { callSuiWithRetry } from './suiClient.js'
-import { SuiTokenLongAddress, SuiTokenShortAddress } from './types.js'
-
-export async function getSuiBalance(
-  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 getSuiBalanceDefault(chainId, tokens, walletAddress)
-}
-
-const getSuiBalanceDefault = async (
-  _chainId: number,
-  tokens: Token[],
-  walletAddress: string
-): Promise<TokenAmount[]> => {
-  const [coins, checkpoint] = await Promise.allSettled([
-    withDedupe(
-      () =>
-        callSuiWithRetry((client) =>
-          client.getAllBalances({
-            owner: walletAddress,
-          })
-        ),
-      { id: `${getSuiBalanceDefault.name}.getAllBalances` }
-    ),
-    withDedupe(
-      () =>
-        callSuiWithRetry((client) =>
-          client.getLatestCheckpointSequenceNumber()
-        ),
-      { id: `${getSuiBalanceDefault.name}.getLatestCheckpointSequenceNumber` }
-    ),
-  ])
-
-  const coinsResult = coins.status === 'fulfilled' ? coins.value : []
-  const blockNumber =
-    checkpoint.status === 'fulfilled' ? BigInt(checkpoint.value) : 0n
-
-  const walletTokenAmounts = coinsResult.reduce(
-    (tokenAmounts, coin) => {
-      const amount = BigInt(coin.totalBalance)
-      if (amount > 0n) {
-        tokenAmounts[coin.coinType] = amount
-      }
-      return tokenAmounts
-    },
-    {} as Record<string, bigint>
-  )
-
-  const suiTokenBalance = coinsResult.find(
-    (coin) => coin.coinType === SuiTokenShortAddress
-  )
-  if (suiTokenBalance?.totalBalance) {
-    walletTokenAmounts[SuiTokenLongAddress] = BigInt(
-      suiTokenBalance.totalBalance
-    )
-  }
-
-  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/Sui/getSuiNSAddress.ts

@@ -1,40 +0,0 @@
-import { SuiClient } from '@mysten/sui/client'
-
-const SNS_REGISTRY_ID =
-  '0x6e0ddefc0ad3ed64f53f5f91b7023077b2f7c131d7e6d5e0d1a0e4e6f1a2c3b4'
-
-export async function getSuiNSAddress(
-  name: string,
-  rpcUrl?: string
-): Promise<string | undefined> {
-  const client = new SuiClient({
-    url: rpcUrl || 'https://fullnode.mainnet.sui.io:443',
-  })
-
-  try {
-    const result = await client.getObject({
-      id: SNS_REGISTRY_ID,
-      options: {
-        showContent: true,
-      },
-    })
-
-    if (!result.data?.content) {
-      return
-    }
-
-    const registry = result.data.content as any
-    const nameRecord = registry.fields.records.find(
-      (record: any) => record.fields.name === name
-    )
-
-    if (!nameRecord) {
-      return
-    }
-
-    return nameRecord.fields.address
-  } catch (error) {
-    console.error('Error resolving SuiNS address:', error)
-    return
-  }
-}

package/src/core/Sui/parseSuiErrors.ts

@@ -1,55 +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 parseSuiErrors = 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) => {
-  const isRejection =
-    typeof e === 'string'
-      ? e.toLowerCase().includes('reject')
-      : e.message?.toLowerCase().includes('reject')
-
-  if (isRejection) {
-    return new TransactionError(LiFiErrorCode.SignatureRejected, e.message, e)
-  }
-
-  if (
-    e.message?.toLowerCase().includes('transaction') &&
-    (e.message?.toLowerCase().includes('failed') ||
-      e.message?.toLowerCase().includes('error'))
-  ) {
-    return new TransactionError(LiFiErrorCode.TransactionFailed, e.message, e)
-  }
-
-  if (e.message?.includes('simulate') || e.message?.includes('simulation')) {
-    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/Sui/resolveSuiAddress.ts

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

package/src/core/Sui/suiClient.ts

@@ -1,42 +0,0 @@
-import { ChainId } from '@lifi/types'
-import { SuiClient } from '@mysten/sui/client'
-import { getRpcUrls } from '../rpc.js'
-
-const clients = new Map<string, SuiClient>()
-
-/**
- * Initializes the Sui clients if they haven't been initialized yet.
- * @returns - Promise that resolves when clients are initialized.
- */
-const ensureClients = async (): Promise<void> => {
-  const rpcUrls = await getRpcUrls(ChainId.SUI)
-  for (const rpcUrl of rpcUrls) {
-    if (!clients.get(rpcUrl)) {
-      const client = new SuiClient({ url: rpcUrl })
-      clients.set(rpcUrl, client)
-    }
-  }
-}
-
-/**
- * Calls a function on the SuiClient instances with retry logic.
- * @param fn - The function to call, which receives a SuiClient instance.
- * @returns - The result of the function call.
- */
-export async function callSuiWithRetry<R>(
-  fn: (client: SuiClient) => Promise<R>
-): Promise<R> {
-  // Ensure clients are initialized
-  await ensureClients()
-  let lastError: any = null
-  for (const client of clients.values()) {
-    try {
-      const result = await fn(client)
-      return result
-    } catch (error) {
-      lastError = error
-    }
-  }
-  // Throw the last encountered error
-  throw lastError
-}

package/src/core/Sui/types.ts

@@ -1,23 +0,0 @@
-import { ChainType } from '@lifi/types'
-import type { WalletWithRequiredFeatures } from '@mysten/wallet-standard'
-import type { SDKProvider, StepExecutorOptions } from '../types.js'
-
-export interface SuiProviderOptions {
-  getWallet?: () => Promise<WalletWithRequiredFeatures>
-}
-
-export interface SuiProvider extends SDKProvider {
-  setOptions(options: SuiProviderOptions): void
-}
-
-export function isSui(provider: SDKProvider): provider is SuiProvider {
-  return provider.type === ChainType.MVM
-}
-
-export interface SuiStepExecutorOptions extends StepExecutorOptions {
-  wallet: WalletWithRequiredFeatures
-}
-
-export const SuiTokenShortAddress = '0x2::sui::SUI'
-export const SuiTokenLongAddress =
-  '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI'

package/src/core/UTXO/UTXO.ts

@@ -1,41 +0,0 @@
-import { isUTXOAddress } from '@bigmi/core'
-import { ChainType } from '@lifi/types'
-import type { StepExecutorOptions } from '../types.js'
-import { getUTXOBalance } from './getUTXOBalance.js'
-import { resolveUTXOAddress } from './resolveUTXOAddress.js'
-import type { UTXOProvider, UTXOProviderOptions } from './types.js'
-import { UTXOStepExecutor } from './UTXOStepExecutor.js'
-
-export function UTXO(options?: UTXOProviderOptions): UTXOProvider {
-  const _options: UTXOProviderOptions = options ?? {}
-  return {
-    get type() {
-      return ChainType.UTXO
-    },
-    isAddress: isUTXOAddress,
-    resolveAddress: resolveUTXOAddress,
-    getBalance: getUTXOBalance,
-    async getStepExecutor(
-      options: StepExecutorOptions
-    ): Promise<UTXOStepExecutor> {
-      if (!_options.getWalletClient) {
-        throw new Error('Client is not provided.')
-      }
-
-      const walletClient = await _options.getWalletClient()
-
-      const executor = new UTXOStepExecutor({
-        client: walletClient,
-        routeId: options.routeId,
-        executionOptions: {
-          ...options.executionOptions,
-        },
-      })
-
-      return executor
-    },
-    setOptions(options: UTXOProviderOptions) {
-      Object.assign(_options, options)
-    },
-  }
-}