@lifi/sdk 3.0.0-alpha.9 → 3.0.0-beta.0

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/KeypairWalletAdapter.ts

@@ -0,0 +1,100 @@
+import { ed25519 } from '@noble/curves/ed25519'
+import type {
+  SignerWalletAdapter,
+  WalletName,
+} from '@solana/wallet-adapter-base'
+import {
+  BaseSignerWalletAdapter,
+  WalletConfigError,
+  WalletNotConnectedError,
+  WalletReadyState,
+  isVersionedTransaction,
+} from '@solana/wallet-adapter-base'
+import type {
+  Transaction,
+  TransactionVersion,
+  VersionedTransaction,
+} from '@solana/web3.js'
+import { Keypair } from '@solana/web3.js'
+import { decode } 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(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(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

@@ -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,331 @@
+import type { ExtendedTransactionInfo, FullStatusData } from '@lifi/types'
+import { type SignerWalletAdapter } from '@solana/wallet-adapter-base'
+import {
+  VersionedTransaction,
+  type SendOptions,
+  type SignatureResult,
+} from '@solana/web3.js'
+import { config } from '../../config.js'
+import { getStepTransaction } from '../../services/api.js'
+import { base64ToUint8Array } from '../../utils/base64ToUint8Array.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: SignerWalletAdapter
+}
+
+const TX_RETRY_INTERVAL = 500
+// https://solana.com/docs/advanced/confirmation
+const TIMEOUT_PERIOD = 60_000
+
+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'
+
+    // STEP 2: Get transaction
+    let process = this.statusManager.findOrCreateProcess(
+      step,
+      currentProcessType
+    )
+
+    if (process.status !== 'DONE') {
+      try {
+        const connection = await getSolanaConnection()
+
+        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(
+          base64ToUint8Array(transactionRequest.data)
+        )
+
+        const blockhashResult = await connection.getLatestBlockhashAndContext({
+          commitment: 'confirmed',
+        })
+
+        // Update transaction recent blockhash with the latest blockhash
+        versionedTransaction.message.recentBlockhash =
+          blockhashResult.value.blockhash
+
+        this.checkWalletAdapter(step)
+
+        const signedTx =
+          await this.walletAdapter.signTransaction(versionedTransaction)
+
+        process = this.statusManager.updateProcess(
+          step,
+          process.type,
+          'PENDING'
+        )
+
+        const rawTransactionOptions: SendOptions = {
+          // Skipping preflight i.e. tx simulation by RPC as we simulated the tx above
+          skipPreflight: true,
+          // Setting max retries to 0 as we are handling retries manually
+          // Set this manually so that the default is skipped
+          maxRetries: 0,
+          // https://solana.com/docs/advanced/confirmation#use-an-appropriate-preflight-commitment-level
+          preflightCommitment: 'confirmed',
+          // minContextSlot: blockhashResult.context.slot,
+        }
+
+        const txSignature = await connection.sendRawTransaction(
+          signedTx.serialize(),
+          rawTransactionOptions
+        )
+
+        // In the following section, we wait and constantly check for the transaction to be confirmed
+        // and resend the transaction if it is not confirmed within a certain time interval
+        // thus handling tx retries on the client side rather than relying on the RPC
+        const confirmTransactionPromise = connection
+          .confirmTransaction(
+            {
+              signature: txSignature,
+              blockhash: blockhashResult.value.blockhash,
+              lastValidBlockHeight: blockhashResult.value.lastValidBlockHeight,
+            },
+            'confirmed'
+          )
+          .then((result) => result.value)
+
+        let confirmedTx: SignatureResult | null = null
+        const startTime = Date.now()
+
+        while (!confirmedTx && Date.now() - startTime <= TIMEOUT_PERIOD) {
+          confirmedTx = await Promise.race([
+            confirmTransactionPromise,
+            new Promise<null>((resolve) =>
+              setTimeout(() => {
+                resolve(null)
+              }, TX_RETRY_INTERVAL)
+            ),
+          ])
+          if (confirmedTx) {
+            break
+          }
+
+          await connection.sendRawTransaction(
+            signedTx.serialize(),
+            rawTransactionOptions
+          )
+        }
+
+        if (confirmedTx?.err) {
+          throw new TransactionError(
+            LiFiErrorCode.TransactionFailed,
+            `Transaction failed: ${confirmedTx?.err}`
+          )
+        }
+
+        if (!confirmedTx) {
+          throw new TransactionError(
+            LiFiErrorCode.TransactionFailed,
+            'Failed to land the transaction'
+          )
+        }
+
+        // Transaction has been confirmed and we can update the process
+        process = this.statusManager.updateProcess(
+          step,
+          process.type,
+          'PENDING',
+          {
+            txHash: txSignature,
+            txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${txSignature}`,
+          }
+        )
+
+        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
+    if (isBridgeExecution) {
+      process = this.statusManager.findOrCreateProcess(
+        step,
+        'RECEIVING_CHAIN',
+        'PENDING'
+      )
+    }
+    let statusResponse: FullStatusData
+    try {
+      if (!process.txHash) {
+        throw new Error('Transaction hash is undefined.')
+      }
+      statusResponse = (await waitForReceivingTransaction(
+        process.txHash,
+        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,17 @@
+import { ChainType } from '@lifi/types'
+import type { SignerWalletAdapter } from '@solana/wallet-adapter-base'
+import { type SDKProvider } 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 const TokenProgramAddress = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'