Class BlockchainClient

constructor

• new BlockchainClient(
      __namedParameters: BlockchainClientParams,
  ): BlockchainClient

  Parameters

  • __namedParameters: BlockchainClientParams

  Returns BlockchainClient

ReadonlybitcoindParams

Optional Readonlynetwork

Optional Readonlyprovider

Readonlytype

broadcastTransaction

• broadcastTransaction(rawTx: string): Promise<any>

  Parameters

  • rawTx: string

  Returns Promise<any>

fetchAddressUtxos

• fetchAddressUtxos(address: string): Promise<any>

  Parameters

  • address: string

  Returns Promise<any>

formatUtxo

• formatUtxo(utxo: UTXO): Promise<any>

  Parameters

  • utxo: UTXO

  Returns Promise<any>

getAddressStatus

• getAddressStatus(address: string): Promise<any>

  Parameters

  • address: string

  Returns Promise<any>

getAddressTransactionHistory

• getAddressTransactionHistory(
      address: string | string[],
      count?: number,
      skip?: number,
  ): Promise<TransactionDetails[]>

  Retrieves transaction history for one or more addresses (public clients only)

  This method is designed for public blockchain explorers (Mempool/Blockstream) that maintain address indexes, allowing efficient address-specific queries.

  Why this method is PUBLIC CLIENT ONLY:

  • Public APIs maintain address indexes for efficient lookups
  • Bitcoin Core doesn't support address-specific queries (see getWalletTransactionHistory)
  • Allows querying multiple addresses with Promise.all for efficiency

  For PRIVATE clients: Use getWalletTransactionHistory() which returns all wallet transactions

  Parameters

  • address: string | string[]

    Single address or array of addresses to query
  • count: number = 10

    Number of transactions to return per address (1-100)
  • skip: number = 0

    Number of transactions to skip for pagination

  Returns Promise<TransactionDetails[]>

  Combined array of transactions sorted by time (newest first)

  Throws

  Error if called on private client

  Example

  // Single address
  const txs = await client.getAddressTransactionHistory("bc1q...");
  
  // Multiple addresses
  const txs = await client.getAddressTransactionHistory(["bc1q...", "bc1p..."]);
  Copy

  See

  getWalletTransactionHistory - For private clients

getAddressTransactions

• getAddressTransactions(address: string): Promise<Transaction[]>

  Parameters

  • address: string

  Returns Promise<Transaction[]>

getAddressUtxos

• getAddressUtxos(address: string): Promise<any>

  Parameters

  • address: string

  Returns Promise<any>

getBlockFeeRatePercentileHistory

• getBlockFeeRatePercentileHistory(): Promise<FeeRatePercentile[]>

  Returns Promise<FeeRatePercentile[]>

getFeeEstimate

• getFeeEstimate(blocks?: number): Promise<any>

  Parameters

  • blocks: number = 3

  Returns Promise<any>

getFeesForPendingTransaction

• getFeesForPendingTransaction(txid: string): Promise<null | string>

  Retrieves the fee information for a pending (incoming) transaction .

  Standard methods like getTransaction do not provide fee details for transactions where the user is the recipient. However, this information is required for fee bumping strategies like CPFP (Child Pays For Parent).

  This method :

  • For private nodes: Uses getmempoolentry to fetch fee data from the node's mempool
  • For public APIs: Uses mempool.space transaction endpoint to get fee information
  • Returns null if the transaction is not pending (not in mempool)

  Parameters

  • txid: string

    Transaction ID to get fees

  Returns Promise<null | string>

  Tx fees in satoshis, or null if transaction is not pending

  See

  • https://developer.bitcoin.org/reference/rpc/getmempoolentry.html?highlight=getmempoolentry
  • https://mempool.space/docs/api/rest#get-transaction

getTransaction

• getTransaction(txid: string, forceRawTx?: boolean): Promise<TransactionDetails>

  Parameters

  • txid: string
  • forceRawTx: boolean = false

  Returns Promise<TransactionDetails>

getTransactionHex

• getTransactionHex(txid: string): Promise<any>

  Parameters

  • txid: string

  Returns Promise<any>

getWalletInfo

• getWalletInfo(): Promise<RPCResponse<unknown>>

  Returns Promise<RPCResponse<unknown>>

getWalletTransaction

• getWalletTransaction(txid: string): Promise<TransactionDetails>

  Gets detailed information about a wallet transaction including fee information

  This method is specifically for transactions that are tracked by the wallet, and provides fee information that isn't available in the general getTransaction method. This is especially useful for private nodes where fee information is critical for UI display.

  Parameters

  • txid: string

    Transaction ID to retrieve

  Returns Promise<TransactionDetails>

  Normalized transaction details with fee information

  See

  https://developer.bitcoin.org/reference/rpc/gettransaction.html

getWalletTransactionHistory

• getWalletTransactionHistory(
      count?: number,
      skip?: number,
      includeWatchOnly?: boolean,
  ): Promise<WalletTransactionDetails[]>

  Retrieves transaction history for a Bitcoin Core wallet (private client only)

  This method returns only "send" (spent) transactions from the wallet. This design decision was made after extensive discussion about Bitcoin Core's limitations:

  1. Bitcoin Core doesn't maintain an address index for performance/privacy reasons
  2. The listtransactions RPC returns ALL wallet transactions with no address filtering
  3. Filtering by address after fetching would be O(n*m) complexity for multiple addresses

  Why this method is PRIVATE CLIENT ONLY:

  • Public APIs (Mempool/Blockstream) support direct address querying
  • Bitcoin Core requires different approach due to lack of address indexing
  • This inconsistency is intentional to optimize for each client type's capabilities

  Why only "send" transactions:

  • Unspent "receive" transactions are already available via fetchAddressUtxos()
  • Avoids duplication of data that's accessible through UTXO methods
  • Focuses on spent transactions which are needed for transaction history
  • Coordinator can combine this with UTXO data for complete history

  For PUBLIC clients: Use getAddressTransactionHistory() which supports address filtering

  Parameters

  • count: number = 100

    Number of transactions to return (1-1000)
  • skip: number = 0

    Number of transactions to skip for pagination
  • includeWatchOnly: boolean = true

    Include watch-only addresses in results

  Returns Promise<WalletTransactionDetails[]>

  Array of spent transactions from the wallet

  Throws

  Error if called on public client or if wallet name is missing

  Example

  // For private client - get last 100 spent transactions
  const spentTxs = await client.getWalletTransactionHistory(100);
  
  // For public client - use getAddressTransactionHistory instead
  const addressTxs = await client.getAddressTransactionHistory(address);
  Copy

  See

  • getAddressTransactionHistory - For public clients
  • fetchAddressUtxos - For unspent transactions

importDescriptors

• importDescriptors(
      __namedParameters: { change: string; receive: string; rescan: boolean },
  ): Promise<object>

  Parameters

  • __namedParameters: { change: string; receive: string; rescan: boolean }

  Returns Promise<object>