@teleportdao/bitcoin 1.9.0 → 2.0.2

package/src/bitcoin-interface-wallet.ts

@@ -0,0 +1,114 @@
+import { bitcoin as bitcoinProvider } from "@teleportdao/providers"
+import { BitcoinInterfaceUtils } from "./bitcoin-interface-utils"
+import type { BitcoinWalletInterfaceConnectionInfo } from "./type"
+import type { SignerInfo } from "./transaction-builder/transaction-builder"
+
+export class BitcoinInterfaceWallet extends BitcoinInterfaceUtils {
+  utxoProvider: bitcoinProvider.Types.UtxoProvider
+  apiProvider: bitcoinProvider.MempoolSpace
+
+  constructor(networkName: string, connectionInfo?: BitcoinWalletInterfaceConnectionInfo) {
+    super(networkName)
+    if (connectionInfo?.api?.provider === "BlockStream") {
+      this.apiProvider = new bitcoinProvider.BlockStream(this.testnet)
+    } else {
+      this.apiProvider = new bitcoinProvider.MempoolSpace(this.testnet)
+    }
+
+    this.utxoProvider = connectionInfo?.utxo
+      ? bitcoinProvider.getUtxoProvider(connectionInfo.utxo, networkName)!
+      : this.apiProvider
+  }
+
+  async getFeeRate(speed?: "normal" | "slow" | "fast") {
+    return new bitcoinProvider.MempoolSpace(this.testnet).getRecommendedFeeRate(speed)
+  }
+
+  async getUtxo(address: string) {
+    if (!this.utxoProvider) {
+      throw new Error("utxo provider not set")
+    }
+    return this.utxoProvider.getUtxos(address)
+  }
+
+  async getRawTransaction(txId: string) {
+    if (this.utxoProvider.getRawTransaction) {
+      return this.utxoProvider.getRawTransaction(txId)
+    }
+    return this.apiProvider.getRawTransaction(txId)
+  }
+
+  async sendRawTransaction(txHex: string) {
+    if (this.utxoProvider.sendRawTransaction) {
+      return this.utxoProvider.sendRawTransaction(txHex)
+    }
+    return this.apiProvider.sendRawTransaction(txHex)
+  }
+
+  async getExtendedUtxo(signerInfo: SignerInfo) {
+    let utxos = await this.getUtxo(signerInfo.address)
+    return utxos.map((tx) => ({
+      hash: tx.txId,
+      value: tx.value,
+      index: tx.index,
+      signerInfo,
+    }))
+  }
+
+  async getAddressesUtxo(allAddresses: string[]) {
+    const chunkOfAddresses = []
+    const chunkLength = 20
+    for (let i = 0; i < allAddresses.length; i += chunkLength) {
+      const tmp = allAddresses.slice(i, i + chunkLength)
+      chunkOfAddresses.push(tmp)
+    }
+
+    let results = []
+
+    for (let addresses of chunkOfAddresses) {
+      const allPromises = []
+      for (let address of addresses) {
+        let promise = await this.getUtxo(address)
+        allPromises.push(promise)
+      }
+      let result = await Promise.all(allPromises)
+      if (result.flat(1).length === 0) {
+        break
+      }
+      results.push(result.flat(1))
+    }
+    return results.flat(1)
+  }
+
+  async getAddressesExtendedUtxo(signerInfos: SignerInfo[]) {
+    const chunkOfAddresses = []
+    const chunkLength = 20
+    for (let i = 0; i < signerInfos.length; i += chunkLength) {
+      const tmp = signerInfos.slice(i, i + chunkLength)
+      chunkOfAddresses.push(tmp)
+    }
+
+    let results = []
+
+    for (let addresses of chunkOfAddresses) {
+      const allPromises = []
+      for (let signerInfo of addresses) {
+        let promise = await this.getExtendedUtxo(signerInfo)
+        allPromises.push(promise)
+      }
+      let result = await Promise.all(allPromises)
+      if (result.flat(1).length === 0) {
+        break
+      }
+      results.push(result.flat(1))
+    }
+    return results.flat(1)
+  }
+
+  async getBalance(address: string) {
+    let utxos = await this.utxoProvider.getUtxos(address)
+    return utxos.reduce((a, tx) => a + Number(tx.value), 0)
+  }
+}
+
+export default BitcoinInterfaceWallet

package/src/bitcoin-interface.ts

@@ -1,239 +1,156 @@
-import { bitcoin as bitcoinProvider } from "@teleportdao/providers"
-import { runWithRetries } from "./utils/tools"
-import {
-  parseRawTransaction,
-  calculateMerkleProof,
-  extractTransactionsAndBlockInfoFromRawBlock,
-} from "./bitcoin-utils"
-import { BitcoinInterfaceUtils } from "./bitcoin-interface-utils"
-import type { BitcoinConnectionInfo } from "./type"
-import type { SignerInfo } from "./transaction-builder/transaction-builder"
-
-export class BitcoinInterface extends BitcoinInterfaceUtils {
-  rpcProvider?: bitcoinProvider.BitcoinRPC
-  utxoProvider: bitcoinProvider.Types.UtxoProvider
-  apiProvider: bitcoinProvider.MempoolSpace
-
-  constructor(connectionInfo: BitcoinConnectionInfo, networkName: string) {
-    super(networkName)
-    if (connectionInfo.api.provider === "BlockStream") {
-      this.apiProvider = new bitcoinProvider.BlockStream(this.testnet)
-    } else {
-      this.apiProvider = new bitcoinProvider.MempoolSpace(this.testnet)
-    }
-    if (connectionInfo.rpc?.enabled) {
-      this.rpcProvider = bitcoinProvider.getRpcProvider(connectionInfo.rpc)
-    }
-    //
-    const utxoProvider = connectionInfo.utxo || connectionInfo.api
-    this.utxoProvider = bitcoinProvider.getUtxoProvider(utxoProvider, networkName)!
-  }
-
-  async getFeeRate(speed?: "normal" | "slow" | "fast") {
-    return new bitcoinProvider.MempoolSpace(this.testnet).getRecommendedFeeRate(speed)
-  }
-
-  async getLatestBlockNumber(): Promise<number> {
-    let latestHeight = await (this.rpcProvider || this.apiProvider)!.getLatestBlockNumber()
-    return latestHeight
-  }
-
-  async getBlockHash(blockNumber: number): Promise<string> {
-    let headerHash = await runWithRetries(() =>
-      (this.rpcProvider || this.apiProvider)!.getBlockHash(blockNumber),
-    )
-    return headerHash
-  }
-
-  async getBlockHeaderHex(blockNumber: number): Promise<string> {
-    let headerHex = await runWithRetries(() =>
-      (this.rpcProvider || this.apiProvider)!.getBlockHeaderHex(blockNumber),
-    )
-    return headerHex
-  }
-
-  async getTransaction(txId: string) {
-    return (this.rpcProvider || this.apiProvider)!.getTransaction(txId)
-  }
-
-  async getRawTransaction(txId: string) {
-    return (this.rpcProvider || this.apiProvider)!.getRawTransaction(txId)
-  }
-
-  async getMerkleProof(
-    txId: string,
-    blockHash: string,
-  ): Promise<{
-    intermediateNodes: string
-    transactionIndex: number
-  }> {
-    if (!this.rpcProvider) {
-      return this.apiProvider.getMerkleProof(txId)
-    }
-    let txIds = await runWithRetries(() => this.rpcProvider!.getBlockTransactionIds(blockHash), {
-      maxTries: 10,
-      retrySleep: 2000,
-    })
-    let proof = calculateMerkleProof(txIds, txId)
-    return proof
-  }
-
-  async getRequestProof(transaction: {
-    txId: string
-    hex?: string
-    blockHash?: string
-    blockNumber?: number
-    merkleProof?: {
-      intermediateNodes: string
-      transactionIndex: number
-    }
-  }) {
-    let transactionHex = transaction.hex || (await this.getRawTransaction(transaction.txId))
-
-    let blockHash = transaction.blockHash
-    let blockNumber = transaction.blockNumber
-    if (!(transaction.blockHash && transaction.blockNumber)) {
-      let txInfo = await this.getTransaction(transaction.txId)
-      blockHash = txInfo.blockHash
-      blockNumber = txInfo.blockNumber
-    }
-    let parsedTx = parseRawTransaction(transactionHex)
-    let merkleProof =
-      transaction.merkleProof || (await this.getMerkleProof(transaction.txId, blockHash!))
-
-    return {
-      parsedTx,
-      merkleProof,
-      blockNumber: blockNumber!,
-      blockHash: blockHash!,
-    }
-  }
-
-  async getUtxo(address: string) {
-    if (!this.utxoProvider) {
-      throw new Error("utxo provider not set")
-    }
-    return this.utxoProvider.getUtxos(address)
-  }
-
-  async getExtendedUtxo(signerInfo: SignerInfo) {
-    let utxos = await this.getUtxo(signerInfo.address)
-    return utxos.map((tx) => ({
-      hash: tx.txId,
-      value: tx.value,
-      index: tx.index,
-      signerInfo,
-    }))
-  }
-
-  async getAddressesUtxo(allAddresses: string[]) {
-    const chunkOfAddresses = []
-    const chunkLength = 20
-    for (let i = 0; i < allAddresses.length; i += chunkLength) {
-      const tmp = allAddresses.slice(i, i + chunkLength)
-      chunkOfAddresses.push(tmp)
-    }
-
-    let results = []
-
-    for (let addresses of chunkOfAddresses) {
-      const allPromises = []
-      for (let address of addresses) {
-        let promise = await this.getUtxo(address)
-        allPromises.push(promise)
-      }
-      let result = await Promise.all(allPromises)
-      if (result.flat(1).length === 0) {
-        break
-      }
-      results.push(result.flat(1))
-    }
-    return results.flat(1)
-  }
-
-  async getAddressesExtendedUtxo(signerInfos: SignerInfo[]) {
-    const chunkOfAddresses = []
-    const chunkLength = 20
-    for (let i = 0; i < signerInfos.length; i += chunkLength) {
-      const tmp = signerInfos.slice(i, i + chunkLength)
-      chunkOfAddresses.push(tmp)
-    }
-
-    let results = []
-
-    for (let addresses of chunkOfAddresses) {
-      const allPromises = []
-      for (let signerInfo of addresses) {
-        let promise = await this.getExtendedUtxo(signerInfo)
-        allPromises.push(promise)
-      }
-      let result = await Promise.all(allPromises)
-      if (result.flat(1).length === 0) {
-        break
-      }
-      results.push(result.flat(1))
-    }
-    return results.flat(1)
-  }
-
-  async getBalance(address: string) {
-    let utxos = await this.utxoProvider.getUtxos(address)
-    return utxos.reduce((a, tx) => a + Number(tx.value), 0)
-  }
-
-  // rpc
-  async getBlockTransactions(
-    addresses: string[],
-    blockNumber: number,
-    inputTxIds: {
-      txId: string
-      index: number
-      address: string
-      script?: string | undefined
-      value?: number | undefined
-    }[] = [],
-  ) {
-    if (!this.rpcProvider) {
-      throw new Error("RPC provider not set")
-    }
-    let rawBlockHex = await runWithRetries(
-      () => this.rpcProvider!.getBlockByBlockNumber(blockNumber, 0),
-      {
-        maxTries: 10,
-        retrySleep: 2000,
-      },
-    )
-    return extractTransactionsAndBlockInfoFromRawBlock(
-      rawBlockHex,
-      blockNumber,
-      addresses,
-      inputTxIds,
-      this.network,
-    )
-  }
-
-  // from start+1 to end
-  async getMultipleBlocksTransactions(
-    addresses: string[],
-    startBlockNumber: number,
-    endBlockNumber: number,
-    inputTxIds: {
-      txId: string
-      index: number
-      address: string
-      script?: string | undefined
-      value?: number | undefined
-    }[] = [],
-  ) {
-    let blockTxs = []
-    for (let blockNumber = +startBlockNumber + 1; blockNumber <= endBlockNumber; blockNumber += 1) {
-      console.log(blockNumber)
-      const response = await this.getBlockTransactions(addresses, blockNumber, inputTxIds)
-      blockTxs.push(response.withdrawTxs, response.depositTxs)
-    }
-    blockTxs = await Promise.all(blockTxs)
-    return blockTxs.flat(1)
-  }
-}
-
-export default BitcoinInterface
+import { bitcoin as bitcoinProvider } from "@teleportdao/providers"
+import { runWithRetries } from "./utils/tools"
+import {
+  parseRawTransaction,
+  calculateMerkleProof,
+  extractTransactionsAndBlockInfoFromRawBlock,
+} from "./bitcoin-utils"
+import BitcoinInterfaceWallet from "./bitcoin-interface-wallet"
+import type { BitcoinInterfaceConnectionInfo } from "./type"
+
+export class BitcoinInterface extends BitcoinInterfaceWallet {
+  rpcProvider?: bitcoinProvider.BitcoinRPC
+
+  constructor(networkName: string, connectionInfo?: BitcoinInterfaceConnectionInfo) {
+    super(networkName, connectionInfo)
+    if (connectionInfo?.rpc) {
+      this.rpcProvider = bitcoinProvider.getRpcProvider(connectionInfo.rpc)
+    }
+  }
+
+  async getLatestBlockNumber(): Promise<number> {
+    let latestHeight = await (this.rpcProvider || this.apiProvider).getLatestBlockNumber()
+    return latestHeight
+  }
+
+  async getBlockHash(blockNumber: number): Promise<string> {
+    let headerHash = await runWithRetries(() =>
+      (this.rpcProvider || this.apiProvider).getBlockHash(blockNumber),
+    )
+    return headerHash
+  }
+
+  async getBlockHeaderHex(blockNumber: number): Promise<string> {
+    let headerHex = await runWithRetries(() =>
+      (this.rpcProvider || this.apiProvider).getBlockHeaderHex(blockNumber),
+    )
+    return headerHex
+  }
+
+  async getTransaction(txId: string) {
+    return (this.rpcProvider || this.apiProvider).getTransaction(txId)
+  }
+
+  async getRawTransaction(txId: string) {
+    return (this.rpcProvider || this.apiProvider).getRawTransaction(txId)
+  }
+
+  async sendRawTransaction(txId: string) {
+    return (this.rpcProvider || this.apiProvider).sendRawTransaction(txId)
+  }
+
+  async getMerkleProof(
+    txId: string,
+    blockHash: string,
+  ): Promise<{
+    intermediateNodes: string
+    transactionIndex: number
+  }> {
+    if (!this.rpcProvider) {
+      return this.apiProvider.getMerkleProof(txId)
+    }
+    let txIds = await runWithRetries(() => this.rpcProvider!.getBlockTransactionIds(blockHash), {
+      maxTries: 10,
+      retrySleep: 2000,
+    })
+    let proof = calculateMerkleProof(txIds, txId)
+    return proof
+  }
+
+  async getRequestProof(transaction: {
+    txId: string
+    hex?: string
+    blockHash?: string
+    blockNumber?: number
+    merkleProof?: {
+      intermediateNodes: string
+      transactionIndex: number
+    }
+  }) {
+    let transactionHex = transaction.hex || (await this.getRawTransaction(transaction.txId))
+
+    let blockHash = transaction.blockHash
+    let blockNumber = transaction.blockNumber
+    if (!(transaction.blockHash && transaction.blockNumber)) {
+      let txInfo = await this.getTransaction(transaction.txId)
+      blockHash = txInfo.blockHash
+      blockNumber = txInfo.blockNumber
+    }
+    let parsedTx = parseRawTransaction(transactionHex)
+    let merkleProof =
+      transaction.merkleProof || (await this.getMerkleProof(transaction.txId, blockHash!))
+
+    return {
+      parsedTx,
+      merkleProof,
+      blockNumber: blockNumber!,
+      blockHash: blockHash!,
+    }
+  }
+
+  // rpc
+  async getBlockTransactions(
+    addresses: string[],
+    blockNumber: number,
+    inputTxIds: {
+      txId: string
+      index: number
+      address: string
+      script?: string | undefined
+      value?: number | undefined
+    }[] = [],
+  ) {
+    if (!this.rpcProvider) {
+      throw new Error("RPC provider not set")
+    }
+    let rawBlockHex = await runWithRetries(
+      () => this.rpcProvider!.getBlockByBlockNumber(blockNumber, 0),
+      {
+        maxTries: 10,
+        retrySleep: 2000,
+      },
+    )
+    return extractTransactionsAndBlockInfoFromRawBlock(
+      rawBlockHex,
+      blockNumber,
+      addresses,
+      inputTxIds,
+      this.network,
+    )
+  }
+
+  // from start+1 to end
+  async getMultipleBlocksTransactions(
+    addresses: string[],
+    startBlockNumber: number,
+    endBlockNumber: number,
+    inputTxIds: {
+      txId: string
+      index: number
+      address: string
+      script?: string | undefined
+      value?: number | undefined
+    }[] = [],
+  ) {
+    let blockTxs = []
+    for (let blockNumber = +startBlockNumber + 1; blockNumber <= endBlockNumber; blockNumber += 1) {
+      console.log(blockNumber)
+      const response = await this.getBlockTransactions(addresses, blockNumber, inputTxIds)
+      blockTxs.push(response.withdrawTxs, response.depositTxs)
+    }
+    blockTxs = await Promise.all(blockTxs)
+    return blockTxs.flat(1)
+  }
+}
+
+export default BitcoinInterface