@lifi/sdk 3.3.0-beta.2 → 3.3.0-beta.4

package/src/core/UTXO/utxo-stack/actions/waitForTransaction.ts

@@ -1,387 +0,0 @@
-import { Transaction, address } from 'bitcoinjs-lib'
-import {
-  type Chain,
-  type Client,
-  TransactionNotFoundError,
-  TransactionReceiptNotFoundError,
-  type Transport,
-  WaitForTransactionReceiptTimeoutError,
-  stringify,
-  withRetry,
-} from 'viem'
-import { getAction } from 'viem/utils'
-import type { UTXOTransaction } from '../types/transaction.js'
-import { observe } from '../utils/observe.js'
-import { getBlock } from './getBlock.js'
-import { getBlockStats } from './getBlockStats.js'
-import { getUTXOTransaction } from './getUTXOTransaction.js'
-import { watchBlockNumber } from './watchBlockNumber.js'
-
-export type ReplacementReason = 'cancelled' | 'replaced' | 'repriced'
-export type ReplacementReturnType = {
-  reason: ReplacementReason
-  replacedTransaction: Transaction
-  transaction: UTXOTransaction
-}
-
-export type WaitForTransactionReceiptReturnType = UTXOTransaction
-
-export type WithRetryParameters = {
-  // The delay (in ms) between retries.
-  delay?:
-    | ((config: { count: number; error: Error }) => number)
-    | number
-    | undefined
-  // The max number of times to retry.
-  retryCount?: number | undefined
-}
-
-export type WaitForTransactionReceiptParameters = {
-  /** The Id of the transaction. */
-  txId: string
-  /** The hex string of the raw transaction. */
-  txHex: string
-  /** The sender address of the transaction. */
-  senderAddress?: string
-  /**
-   * The number of confirmations (blocks that have passed) to wait before resolving.
-   * @default 1
-   */
-  confirmations?: number | undefined
-  /** Optional callback to emit if the transaction has been replaced. */
-  onReplaced?: ((response: ReplacementReturnType) => void) | undefined
-  /**
-   * Polling frequency (in ms). Defaults to the client's pollingInterval config.
-   * @default client.pollingInterval
-   */
-  pollingInterval?: number | undefined
-  /**
-   * Number of times to retry if the transaction or block is not found.
-   * @default 6 (exponential backoff)
-   */
-  retryCount?: number
-  /**
-   * Time to wait (in ms) between retries.
-   */
-  retryDelay?: ((config: { count: number; error: Error }) => number) | number
-  /** Optional timeout (in milliseconds) to wait before stopping polling. */
-  timeout?: number | undefined
-}
-
-/**
- * Waits for the transaction to be included on a block (one confirmation), and then returns the transaction.
- * - JSON-RPC Methods:
- * - Polls getrawtransaction on each block until it has been processed.
- * - If a transaction has been replaced:
- * - Calls getblock and extracts the transactions
- * - Checks if one of the transactions is a replacement
- * - If so, calls getrawtransaction.
- *
- * The `waitForTransaction` action additionally supports replacement detection (e.g. RBF - transactions replaced-by-fee ).
- *
- * Transactions can be replaced when a user modifies their transaction in their wallet (to speed up or cancel).
- * https://bitcoinops.org/en/topics/replace-by-fee/
- *
- * There are 3 types of Transaction Replacement reasons:
- *
- * - `repriced`: The fee has been modified (e.g. same outputs, different amounts)
- * - `cancelled`: The Transaction has been cancelled (e.g. output is sender address)
- * - `replaced`: The Transaction has been replaced (e.g. different outputs)
- * @param client - Client to use
- * @param parameters - {@link WaitForTransactionReceiptParameters}
- * @returns The UTXO transaction. {@link WaitForTransactionReceiptReturnType}
- */
-export async function waitForTransaction<chain extends Chain | undefined>(
-  client: Client<Transport, chain>,
-  {
-    confirmations = 1,
-    txId,
-    txHex,
-    senderAddress,
-    onReplaced,
-    pollingInterval = client.pollingInterval,
-    retryCount = 10,
-    retryDelay = 3_000,
-    timeout,
-  }: WaitForTransactionReceiptParameters
-): Promise<WaitForTransactionReceiptReturnType> {
-  const observerId = stringify(['waitForTransaction', client.uid, txId])
-
-  let count = 0
-  let transaction: UTXOTransaction | undefined
-  let replacedTransaction: Transaction | undefined
-  let retrying = false
-
-  return new Promise((resolve, reject) => {
-    if (timeout) {
-      setTimeout(
-        () =>
-          reject(
-            new WaitForTransactionReceiptTimeoutError({ hash: txId as never })
-          ),
-        timeout
-      )
-    }
-
-    const _unobserve = observe(
-      observerId,
-      { onReplaced, resolve, reject },
-      (emit) => {
-        const _unwatch = getAction(
-          client,
-          watchBlockNumber,
-          'watchBlockNumber'
-        )({
-          emitMissed: true,
-          emitOnBegin: true,
-          pollingInterval,
-          async onBlockNumber(blockNumber_) {
-            const done = (fn: () => void) => {
-              _unwatch()
-              fn()
-              _unobserve()
-            }
-
-            let blockNumber = blockNumber_
-
-            if (retrying) {
-              return
-            }
-            if (count > retryCount) {
-              done(() =>
-                emit.reject(
-                  new WaitForTransactionReceiptTimeoutError({
-                    hash: txId as never,
-                  })
-                )
-              )
-            }
-
-            try {
-              // If we already have a valid receipt, let's check if we have enough
-              // confirmations. If we do, then we can resolve.
-              if (transaction?.blockhash) {
-                const blockStats = await getAction(
-                  client,
-                  getBlockStats,
-                  'getBlockStats'
-                )({
-                  blockHash: transaction.blockhash,
-                  stats: ['height'],
-                })
-                if (
-                  confirmations > 1 &&
-                  (!blockStats.height ||
-                    blockNumber - blockStats.height + 1 < confirmations)
-                ) {
-                  return
-                }
-                done(() => emit.resolve(transaction!))
-                return
-              }
-
-              // Get the transaction to check if it's been replaced.
-              // We need to retry as some RPC Providers may be slow to sync
-              // up mined transactions.
-              retrying = true
-              transaction = await withRetry(
-                () =>
-                  getAction(
-                    client,
-                    getUTXOTransaction,
-                    'getUTXOTransaction'
-                    // If transaction exists it might be the replaced one with different txId
-                  )({ txId: transaction?.txid || txId }),
-                {
-                  delay: retryDelay,
-                  retryCount,
-                }
-              )
-              if (transaction.blockhash) {
-                const blockStats = await getAction(
-                  client,
-                  getBlockStats,
-                  'getBlockStats'
-                )({
-                  blockHash: transaction.blockhash,
-                  stats: ['height'],
-                })
-                if (blockStats.height) {
-                  blockNumber = blockStats.height
-                }
-              }
-              retrying = false
-
-              // Check if transaction has been processed.
-              if (!transaction?.confirmations) {
-                throw new TransactionReceiptNotFoundError({
-                  hash: txId as never,
-                })
-              }
-
-              // Check if we have enough confirmations. If not, continue polling.
-              if (transaction.confirmations < confirmations) {
-                return
-              }
-
-              done(() => emit.resolve(transaction!))
-            } catch (err) {
-              // If the receipt is not found, the transaction will be pending.
-              // We need to check if it has potentially been replaced.
-              if (
-                err instanceof TransactionNotFoundError ||
-                err instanceof TransactionReceiptNotFoundError
-              ) {
-                try {
-                  replacedTransaction = Transaction.fromHex(
-                    transaction?.hex || txHex
-                  )
-
-                  // Let's retrieve the transactions from the current block.
-                  // We need to retry as some RPC Providers may be slow to sync
-                  // up mined blocks.
-                  retrying = true
-                  const block = await withRetry(
-                    () =>
-                      getAction(
-                        client,
-                        getBlock,
-                        'getBlock'
-                      )({
-                        blockNumber,
-                      }),
-                    {
-                      delay: retryDelay,
-                      retryCount,
-                      // shouldRetry: ({ error }) =>
-                      //   error instanceof BlockNotFoundError,
-                    }
-                  )
-                  retrying = false
-
-                  // Create a set of input identifiers for mempool transaction
-                  const replacedTransactionInputs = new Set<string>()
-
-                  for (const input of replacedTransaction.ins) {
-                    const txid = Array.from(input.hash)
-                      .reverse()
-                      .map((byte) => `00${byte.toString(16)}`.slice(-2))
-                      .join('')
-                    const vout = input.index
-                    const inputId = `${txid}:${vout}`
-                    replacedTransactionInputs.add(inputId)
-                  }
-
-                  let replacementTransaction: Transaction | undefined
-
-                  for (const tx of block.transactions!) {
-                    if (tx.isCoinbase()) {
-                      continue
-                    }
-
-                    // Check if any input of this transaction matches an input of mempool transaction
-                    for (const input of tx.ins) {
-                      const txid = Array.from(input.hash)
-                        .reverse()
-                        .map((byte) => `00${byte.toString(16)}`.slice(-2))
-                        .join('')
-                      const vout = input.index
-                      const inputId = `${txid}:${vout}`
-                      if (replacedTransactionInputs.has(inputId)) {
-                        replacementTransaction = tx
-                        break
-                      }
-                    }
-                    if (replacementTransaction) {
-                      break
-                    }
-                  }
-
-                  // If we couldn't find a replacement transaction, continue polling.
-                  if (!replacementTransaction) {
-                    return
-                  }
-
-                  // If we found a replacement transaction, return it's receipt.
-                  transaction = await getAction(
-                    client,
-                    getUTXOTransaction,
-                    'getUTXOTransaction'
-                  )({
-                    txId: replacementTransaction.getId(),
-                  })
-
-                  // Check if we have enough confirmations. If not, continue polling.
-                  if (
-                    transaction.confirmations &&
-                    transaction.confirmations < confirmations
-                  ) {
-                    return
-                  }
-
-                  let reason: ReplacementReason = 'replaced'
-
-                  // Function to get output addresses
-                  function getOutputAddresses(tx: Transaction): string[] {
-                    const addresses: string[] = []
-                    for (const output of tx.outs) {
-                      try {
-                        const outputAddress = address.fromOutputScript(
-                          output.script
-                        )
-                        addresses.push(outputAddress)
-                      } catch (_e) {
-                        // Handle non-standard scripts (e.g., OP_RETURN)
-                      }
-                    }
-                    return addresses
-                  }
-
-                  // Get the recipient addresses from the original transaction
-                  const originalOutputAddresses =
-                    getOutputAddresses(replacedTransaction)
-
-                  // Get the recipient addresses from the replacement transaction
-                  const replacementOutputAddresses = getOutputAddresses(
-                    replacementTransaction
-                  )
-
-                  if (
-                    originalOutputAddresses.length ===
-                      replacementOutputAddresses.length &&
-                    originalOutputAddresses.every((address) =>
-                      replacementOutputAddresses.includes(address)
-                    )
-                  ) {
-                    reason = 'repriced'
-                  } else if (
-                    senderAddress &&
-                    replacementOutputAddresses.length === 1 &&
-                    replacementOutputAddresses.includes(senderAddress)
-                  ) {
-                    reason = 'cancelled'
-                  }
-
-                  done(() => {
-                    emit.onReplaced?.({
-                      reason,
-                      replacedTransaction: replacedTransaction!,
-                      transaction: transaction!,
-                    })
-                    emit.resolve(transaction!)
-                  })
-                } catch (err_) {
-                  done(() => emit.reject(err_))
-                }
-              } else {
-                done(() => emit.reject(err))
-              }
-            } finally {
-              count++
-            }
-          },
-        })
-      }
-    )
-  })
-}

package/src/core/UTXO/utxo-stack/actions/watchBlockNumber.ts

@@ -1,105 +0,0 @@
-import { type Chain, type Client, type Transport, stringify } from 'viem'
-import { getAction } from 'viem/utils'
-import { observe } from '../utils/observe.js'
-import { poll } from '../utils/poll.js'
-import { type GetBlockCountReturnType, getBlockCount } from './getBlockCount.js'
-
-export type OnBlockNumberParameter = GetBlockCountReturnType
-export type OnBlockNumberFn = (
-  blockNumber: OnBlockNumberParameter,
-  prevBlockNumber: OnBlockNumberParameter | undefined
-) => Promise<void>
-
-export type WatchBlockNumberParameters = {
-  /** The callback to call when a new block number is received. */
-  onBlockNumber: OnBlockNumberFn
-  /** The callback to call when an error occurred when trying to get for a new block. */
-  onError?: ((error: Error) => void) | undefined
-} & {
-  /** Whether or not to emit the missed block numbers to the callback. */
-  emitMissed?: boolean | undefined
-  /** Whether or not to emit the latest block number to the callback when the subscription opens. */
-  emitOnBegin?: boolean | undefined
-  /** Polling frequency (in ms). Defaults to Client's pollingInterval config. */
-  pollingInterval?: number | undefined
-}
-
-export type WatchBlockNumberReturnType = () => void
-
-/**
- * Watches and returns incoming block numbers.
- * @param client - Client to use
- * @param parameters - {@link WatchBlockNumberParameters}
- * @returns A function that can be invoked to stop watching for new block numbers. {@link WatchBlockNumberReturnType}
- */
-export function watchBlockNumber<
-  chain extends Chain | undefined,
-  transport extends Transport,
->(
-  client: Client<transport, chain>,
-  {
-    emitOnBegin = false,
-    emitMissed = false,
-    onBlockNumber,
-    onError,
-    pollingInterval = client.pollingInterval,
-  }: WatchBlockNumberParameters
-): WatchBlockNumberReturnType {
-  let prevBlockNumber: GetBlockCountReturnType | undefined
-
-  const observerId = stringify([
-    'watchBlockNumber',
-    client.uid,
-    emitOnBegin,
-    emitMissed,
-    pollingInterval,
-  ])
-
-  // TODO (edge cases):
-  // 1) Stop iterating block numbers if we are happy with the result of one onBlockNumber execution but there is more in the queue.
-  // 2) If we missed some time - user closed the page and came back when the block is already mined.
-  // In this case we probably want to save the block when we send the transaction and track the currently checked blocks until we find the relevant one.
-  return observe(observerId, { onBlockNumber, onError }, (emit) =>
-    poll(
-      async () => {
-        try {
-          const blockNumber = await getAction(
-            client,
-            getBlockCount,
-            'getBlockCount'
-          )({ cacheTime: 0 })
-
-          if (prevBlockNumber) {
-            // If the current block number is the same as the previous,
-            // we can skip.
-            if (blockNumber === prevBlockNumber) {
-              return
-            }
-
-            // If we have missed out on some previous blocks, and the
-            // `emitMissed` flag is truthy, let's emit those blocks.
-            if (blockNumber - prevBlockNumber > 1 && emitMissed) {
-              for (let i = prevBlockNumber + 1; i < blockNumber; i++) {
-                await emit.onBlockNumber(i, prevBlockNumber)
-                prevBlockNumber = i
-              }
-            }
-          }
-
-          // If the next block number is greater than the previous,
-          // it is not in the past, and we can emit the new block number.
-          if (!prevBlockNumber || blockNumber > prevBlockNumber) {
-            await emit.onBlockNumber(blockNumber, prevBlockNumber)
-            prevBlockNumber = blockNumber
-          }
-        } catch (err) {
-          emit.onError?.(err as Error)
-        }
-      },
-      {
-        emitOnBegin,
-        interval: pollingInterval,
-      }
-    )
-  )
-}

package/src/core/UTXO/utxo-stack/clients/types.ts

@@ -1,48 +0,0 @@
-import type { EIP1193RequestFn } from 'viem'
-
-export type UTXOWalletSchema = readonly [
-  {
-    Method: 'signPsbt'
-    Parameters: SignPsbtParameters
-    ReturnType: SignPsbtReturnType
-  },
-]
-
-export type SignPsbtParameters = {
-  /** The PSBT encoded as a hexadecimal string */
-  psbt: string
-  /**
-   * Array of objects specifying details about the inputs to be signed
-   */
-  inputsToSign: {
-    /**
-     * The SigHash type to use for signing (e.g., SIGHASH_ALL).
-     * If not specified, a default value is used.
-     */
-    sigHash?: number
-    /** The Bitcoin address associated with the input that will be signed */
-    address: string
-    /** An array of indexes in the PSBT corresponding to the inputs that need to be signed */
-    signingIndexes: number[]
-  }[]
-  /**
-   * Whether to finalize the PSBT after signing.
-   * If `true`, the PSBT will be completed and ready for broadcasting.
-   * If `false` or omitted, the PSBT remains partially signed.
-   * Some wallets does not support it.
-   */
-  finalize?: boolean
-}
-
-export type SignPsbtReturnType = string
-
-export type UTXOWalletProvider = {
-  request: EIP1193RequestFn<UTXOWalletSchema>
-}
-
-export type BtcAccount = {
-  address: string
-  addressType: 'p2tr' | 'p2wpkh' | 'p2wsh' | 'p2sh' | 'p2pkh'
-  publicKey: string
-  purpose: 'payment' | 'ordinals'
-}

package/src/core/UTXO/utxo-stack/decorators/UTXOAPIActions.ts

@@ -1,20 +0,0 @@
-import type { Account, Chain, Client, Transport } from 'viem'
-import {
-  type GetBalanceParameters,
-  type GetBalanceReturnType,
-  getBalance,
-} from '../actions/getBalance.js'
-
-export type UTXOAPIActions = {
-  getBalance: (args: GetBalanceParameters) => Promise<GetBalanceReturnType>
-}
-
-export function UTXOAPIActions<
-  transport extends Transport = Transport,
-  chain extends Chain | undefined = Chain | undefined,
-  account extends Account | undefined = Account | undefined,
->(client: Client<transport, chain, account>): UTXOAPIActions {
-  return {
-    getBalance: (args) => getBalance(client, args),
-  }
-}

package/src/core/UTXO/utxo-stack/decorators/UTXOActions.ts

@@ -1,37 +0,0 @@
-import type { Account, Chain, Client, Transport } from 'viem'
-import {
-  type GetBlockCountReturnType,
-  getBlockCount,
-} from '../actions/getBlockCount.js'
-import {
-  type GetUTXOTransactionParameters,
-  type GetUTXOTransactionReturnType,
-  getUTXOTransaction,
-} from '../actions/getUTXOTransaction.js'
-import {
-  type SendUTXOTransactionParameters,
-  type SendUTXOTransactionReturnType,
-  sendUTXOTransaction,
-} from '../actions/sendUTXOTransaction.js'
-
-export type UTXOActions = {
-  getBlockCount: () => Promise<GetBlockCountReturnType>
-  sendUTXOTransaction: (
-    args: SendUTXOTransactionParameters
-  ) => Promise<SendUTXOTransactionReturnType>
-  getUTXOTransaction: (
-    args: GetUTXOTransactionParameters
-  ) => Promise<GetUTXOTransactionReturnType>
-}
-
-export function UTXOActions<
-  transport extends Transport = Transport,
-  chain extends Chain | undefined = Chain | undefined,
-  account extends Account | undefined = Account | undefined,
->(client: Client<transport, chain, account>): UTXOActions {
-  return {
-    getBlockCount: () => getBlockCount(client),
-    sendUTXOTransaction: (args) => sendUTXOTransaction(client, args),
-    getUTXOTransaction: (args) => getUTXOTransaction(client, args),
-  }
-}

package/src/core/UTXO/utxo-stack/transports/utxo/ankr.ts

@@ -1,30 +0,0 @@
-import type { RpcMethods } from './types.js'
-
-type AnkrBalanceResponse = {
-  address: string
-  balance: string
-  totalReceived: string
-  totalSent: string
-  unconfirmedBalance: string
-  unconfirmedTxs: number
-  txs: number
-  error: string
-}
-
-export const ankrMethods: RpcMethods = {
-  getBalance: async (client, baseUrl, { address }) => {
-    const apiUrl = `${baseUrl}/address/${address}?details=basic`
-    const response = (await client.request({
-      url: apiUrl,
-      fetchOptions: { method: 'GET' },
-    })) as unknown as AnkrBalanceResponse
-    if (response.error) {
-      return {
-        error: { code: -1, message: response.error },
-      }
-    }
-    return {
-      result: BigInt(response.balance),
-    }
-  },
-}

package/src/core/UTXO/utxo-stack/transports/utxo/blockchair.ts

@@ -1,27 +0,0 @@
-import type { RpcMethods } from './types.js'
-
-type BlockchairBalanceResponse = {
-  data: Record<string, any>
-  context: { code: number; error: string }
-}
-
-export const blockchairMethods: RpcMethods = {
-  getBalance: async (client, baseUrl, { address }) => {
-    const apiUrl = `${baseUrl}/addresses/balances/?addresses=${address}`
-    const response = (await client.request({
-      url: apiUrl,
-      fetchOptions: { method: 'GET' },
-    })) as unknown as BlockchairBalanceResponse
-    if (response.context?.code !== 200) {
-      return {
-        error: {
-          code: response.context?.code,
-          message: response.context?.error,
-        },
-      }
-    }
-    return {
-      result: BigInt(response.data[address]),
-    }
-  },
-}

package/src/core/UTXO/utxo-stack/transports/utxo/blockcypher.ts

@@ -1,32 +0,0 @@
-import type { RpcMethods } from './types.js'
-
-type BlockcypherBalanceResponse = {
-  address: string
-  total_received: number
-  total_sent: number
-  balance: number
-  unconfirmed_balance: number
-  final_balance: number
-  n_tx: number
-  unconfirmed_n_tx: number
-  final_n_tx: number
-  error?: string
-}
-
-export const blockcypherMethods: RpcMethods = {
-  getBalance: async (client, baseUrl, { address }) => {
-    const apiUrl = `${baseUrl}/addrs/${address}`
-    const response = (await client.request({
-      url: apiUrl,
-      fetchOptions: { method: 'GET' },
-    })) as unknown as BlockcypherBalanceResponse
-    if (response.error) {
-      return {
-        error: { code: -1, message: response.error },
-      }
-    }
-    return {
-      result: BigInt(response.balance),
-    }
-  },
-}