@teleportdao/bitcoin 1.6.0 → 1.7.0

package/src/bitcoin-interface.ts

@@ -3,130 +3,77 @@ import { runWithRetries } from "./utils/tools"
 import {
   parseRawTransaction,
   calculateMerkleProof,
-  parseBlockHeader,
   extractTransactionsAndBlockInfoFromRawBlock,
 } from "./bitcoin-utils"
-import { checkAndParseProtocolRequest } from "./helper/teleport-request-helper"
-import { getBurnTransactionInfo } from "./helper/burn-request-helper"
 import { BitcoinInterfaceUtils } from "./bitcoin-interface-utils"
-import type { BitcoinConnectionInfo } from "./transaction-builder/bitcoin-transaction-builder"
+import type { BitcoinConnectionInfo } from "./type"
 import type { SignerInfo } from "./transaction-builder/transaction-builder"
 
 export class BitcoinInterface extends BitcoinInterfaceUtils {
-  rpcProvider?: bitcoinProvider.RPC
-  apiProviderName!: string
-  minTeleporterFeeAmount: number
-  provider: any
+  rpcProvider?: bitcoinProvider.BitcoinRPC
+  utxoProvider: bitcoinProvider.Types.UtxoProvider
+  apiProvider: bitcoinProvider.MempoolSpace
 
-  apiProvider!:
-    | bitcoinProvider.ApiProviders.BlockStream
-    | bitcoinProvider.ApiProviders.NowNodes
-    | bitcoinProvider.ApiProviders.MempoolSpace
-
-  constructor(
-    connectionInfo: BitcoinConnectionInfo,
-    networkName: string,
-    config = { minTeleporterFeeAmount: 0 },
-  ) {
+  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)
-    } else if (
-      connectionInfo.api.provider !== "BlockStream" &&
-      connectionInfo.api.provider !== "MempoolSpace"
-    ) {
-      throw new Error(
-        "if rpc is disabled, we just support BlockStream Or MempoolSpace as api provider",
-      )
     }
-
-    if (connectionInfo.api.enabled) {
-      this.apiProviderName = connectionInfo.api.provider
-      this.apiProvider = bitcoinProvider.getApiProvider(connectionInfo.api as any, networkName)!
-    }
-
-    this.minTeleporterFeeAmount = config.minTeleporterFeeAmount
-    this.provider = this.rpcProvider || this.apiProvider
+    this.utxoProvider = bitcoinProvider.getUtxoProvider(connectionInfo.api as any, networkName)!
   }
 
-  static checkAndParseProtocolRequest(
-    vouts: any[],
-    address: string,
-    config?: {
-      minTeleporterFeeAmount: number
-    },
-  ) {
-    return checkAndParseProtocolRequest(vouts, address, config)
-  }
-
-  static getBurnTransactionInfo(address: string, vin: any[], vouts: any[]) {
-    return getBurnTransactionInfo(address, vin, vouts)
+  async getFeeRate(speed?: "normal" | "slow" | "fast") {
+    return new bitcoinProvider.MempoolSpace(this.testnet).getRecommendedFeeRate(speed)
   }
 
-  // rpc + api
-
-  // general
   async getLatestBlockNumber(): Promise<number> {
-    let latestHeight = await this.provider.getLatestBlockNumber()
+    let latestHeight = await (this.rpcProvider || this.apiProvider)!.getLatestBlockNumber()
     return latestHeight
   }
 
   async getBlockHash(blockNumber: number): Promise<string> {
-    let headerHash = await runWithRetries(() => this.provider.getBlockHash(blockNumber))
+    let headerHash = await runWithRetries(() =>
+      (this.rpcProvider || this.apiProvider)!.getBlockHash(blockNumber),
+    )
     return headerHash
   }
 
   async getBlockHeaderHex(blockNumber: number): Promise<string> {
-    let headerHex = await runWithRetries(() => this.provider.getBlockHeaderHex(blockNumber))
+    let headerHex = await runWithRetries(() =>
+      (this.rpcProvider || this.apiProvider)!.getBlockHeaderHex(blockNumber),
+    )
     return headerHex
   }
 
-  async getTransaction(txId: string): Promise<bitcoinProvider.Types.ConfirmedTransaction> {
-    return this.provider.getTransaction(txId)
+  async getTransaction(txId: string) {
+    return (this.rpcProvider || this.apiProvider)!.getTransaction(txId)
   }
 
-  // speed : low normal fast
-  async getFeeRate(speed?: "normal" | "slow" | "fast") {
-    return new bitcoinProvider.ApiProviders.MempoolSpace(this.testnet).getRecommendedFeeRate(speed)
+  async getRawTransaction(txId: string) {
+    return (this.rpcProvider || this.apiProvider)!.getRawTransaction(txId)
   }
 
-  // ----------- specific
-
-  // relayer
-  async getHexBlockHeaders(startBlockNumber: number, endBlockNumber: number) {
-    const blockHeaders = []
-    let difficulty = null
-    let hexBlockHeaders = ""
-
-    let fromBlockNumber = startBlockNumber
-    for (let blockNumber = startBlockNumber; blockNumber <= endBlockNumber; blockNumber += 1) {
-      let blockHeader = await this.getBlockHeaderHex(blockNumber)
-      console.log("block", blockNumber)
-      let parsedBlockHeader = parseBlockHeader(blockHeader)
-      if (difficulty && parsedBlockHeader.difficulty !== difficulty) {
-        blockHeaders.push({
-          hexBlockHeaders,
-          fromBlockNumber,
-          toBlockNumber: blockNumber - 1,
-          difficulty,
-        })
-        hexBlockHeaders = blockHeader
-        fromBlockNumber = blockNumber
-      } else {
-        hexBlockHeaders += blockHeader
-      }
-      difficulty = parsedBlockHeader.difficulty
-    }
-    if (hexBlockHeaders) {
-      blockHeaders.push({
-        hexBlockHeaders,
-        fromBlockNumber,
-        toBlockNumber: endBlockNumber,
-        difficulty,
-      })
+  async getMerkleProof(
+    txId: string,
+    blockHash: string,
+  ): Promise<{
+    intermediateNodes: string
+    transactionIndex: number
+  }> {
+    if (!this.rpcProvider) {
+      return this.apiProvider.getMerkleProof(txId)
     }
-
-    return blockHeaders
+    let txIds = await runWithRetries(() => this.rpcProvider!.getBlockTransactionIds(blockHash), {
+      maxTries: 10,
+      retrySleep: 2000,
+    })
+    let proof = calculateMerkleProof(txIds, txId)
+    return proof
   }
 
   async getRequestProof(transaction: {
@@ -139,54 +86,47 @@ export class BitcoinInterface extends BitcoinInterfaceUtils {
       transactionIndex: number
     }
   }) {
-    let transactionHex =
-      transaction.hex || (await this.provider.getRawTransaction(transaction.txId))
+    let transactionHex = transaction.hex || (await this.getRawTransaction(transaction.txId))
 
-    let txInfo:
-      | {
-          txId: any
-          version: any
-          locktime: any
-          blockNumber: any
-          blockHash: any
-          vout: any
-          vin: any
-        }
-      | undefined
+    let blockHash = transaction.blockHash
+    let blockNumber = transaction.blockNumber
     if (!(transaction.blockHash && transaction.blockNumber)) {
-      txInfo = await this.provider.getTransaction(transaction.txId)
+      let txInfo = await this.getTransaction(transaction.txId)
+      blockHash = txInfo.blockHash
+      blockNumber = txInfo.blockNumber
     }
-    let blockHash: string = transaction.blockHash || txInfo?.blockHash
-    let blockNumber: number = transaction.blockNumber || txInfo?.blockNumber
     let parsedTx = parseRawTransaction(transactionHex)
     let merkleProof =
-      transaction.merkleProof || (await this.getMerkleProof(transaction.txId, blockHash))
+      transaction.merkleProof || (await this.getMerkleProof(transaction.txId, blockHash!))
 
     return {
       parsedTx,
       merkleProof,
-      blockNumber,
-      blockHash,
+      blockNumber: blockNumber!,
+      blockHash: blockHash!,
     }
   }
 
-  async getMerkleProof(txId: string, blockHash: string) {
-    if (!this.rpcProvider) {
-      throw new Error("RPC provider not set")
+  async getUtxo(address: string) {
+    if (!this.apiProvider) {
+      throw new Error("api provider not set")
     }
-    let txIds = await runWithRetries(() => this.rpcProvider!.getBlockTransactionIds(blockHash), {
-      maxTries: 10,
-      retrySleep: 2000,
-    })
-    // let a = await this.provider.getMerkleProof(txId)
-    let proof = calculateMerkleProof(txIds, txId)
-    // console.log(a.intermediateNodes === proof.intermediateNodes)
-    return proof
+    return this.apiProvider.getUtxos(address)
   }
 
-  // ------------------ utxo providers --------------------------------
+  async getExtendedUtxo(signerInfo: SignerInfo) {
+    if (!this.apiProvider) {
+      throw new Error("api provider not set")
+    }
+    let utxos = await this.apiProvider.getUtxos(signerInfo.address)
+    return utxos.map((tx: any) => ({
+      hash: tx.txId,
+      value: tx.value,
+      index: tx.index,
+      signerInfo,
+    }))
+  }
 
-  // teleporter + locker
   async getAddressesUtxo(allAddresses: string[]) {
     if (!this.apiProvider) {
       throw new Error("api provider not set")
@@ -203,7 +143,7 @@ export class BitcoinInterface extends BitcoinInterfaceUtils {
     for (let addresses of chunkOfAddresses) {
       const allPromises = []
       for (let address of addresses) {
-        let promise = await this.apiProvider.getUtxos(address)
+        let promise = await this.getUtxo(address)
         allPromises.push(promise)
       }
       let result = await Promise.all(allPromises)
@@ -215,41 +155,30 @@ export class BitcoinInterface extends BitcoinInterfaceUtils {
     return results.flat(1)
   }
 
-  async getAddressesExtendedUtxo(allAddressesInfo: SignerInfo[]) {
+  async getAddressesExtendedUtxo(signerInfos: SignerInfo[]) {
     if (!this.apiProvider) {
-      throw new Error("this function need an api provider")
+      throw new Error("api provider not set")
     }
-    const chunkOfAddressesInfo = []
+    const chunkOfAddresses = []
     const chunkLength = 20
-    for (let i = 0; i < allAddressesInfo.length; i += chunkLength) {
-      const tmp = allAddressesInfo.slice(i, i + chunkLength)
-      chunkOfAddressesInfo.push(tmp)
+    for (let i = 0; i < signerInfos.length; i += chunkLength) {
+      const tmp = signerInfos.slice(i, i + chunkLength)
+      chunkOfAddresses.push(tmp)
     }
 
     let results = []
 
-    for (let addressesInfo of chunkOfAddressesInfo) {
+    for (let addresses of chunkOfAddresses) {
       const allPromises = []
-      for (let info of addressesInfo) {
-        let promise = this.apiProvider.getUtxos(info.address)
+      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
-          .map((utxos, i) =>
-            utxos.map((tx: any) => ({
-              hash: tx.txId,
-              value: tx.value,
-              index: tx.index,
-              signerInfo: addressesInfo[i],
-            })),
-          )
-          .flat(1),
-      )
+      results.push(result.flat(1))
     }
     return results.flat(1)
   }
@@ -258,13 +187,20 @@ export class BitcoinInterface extends BitcoinInterfaceUtils {
     if (!this.apiProvider) {
       throw new Error("this function need an api provider")
     }
-    let utxos = (await this.apiProvider.getUtxos(address)) ?? []
-    return utxos.reduce((a: any, tx: any) => a + Number(tx.value), 0)
+    return this.apiProvider.getBalance(address)
   }
 
-  // ------------------ utxo provider + rpc or blockstream----------------
-  // teleporter
-  async getBlockTransactions(addresses: string[], blockNumber: number, inputTxIds = []) {
+  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")
     }
@@ -275,177 +211,37 @@ export class BitcoinInterface extends BitcoinInterfaceUtils {
         retrySleep: 2000,
       },
     )
-    let { withdrawTxs, depositTxs } = extractTransactionsAndBlockInfoFromRawBlock(
+    return extractTransactionsAndBlockInfoFromRawBlock(
       rawBlockHex,
       blockNumber,
       addresses,
       inputTxIds,
       this.network,
     )
-    return depositTxs.concat(withdrawTxs)
   }
 
-  // teleporter
+  // from start+1 to end
   async getMultipleBlocksTransactions(
     addresses: string[],
     startBlockNumber: number,
     endBlockNumber: number,
-    inputTxIds = [],
+    inputTxIds: {
+      txId: string
+      index: number
+      address: string
+      script?: string | undefined
+      value?: number | undefined
+    }[] = [],
   ) {
-    if (endBlockNumber - startBlockNumber > 20) {
-      throw new Error("cant get more than 20 block per function call")
-    }
     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)
-      // await sleep(200)
+      blockTxs.push(response.withdrawTxs, response.depositTxs)
     }
     blockTxs = await Promise.all(blockTxs)
     return blockTxs.flat(1)
   }
-
-  // teleporter
-  async getTransactionHistory(
-    addresses: string[],
-    startBlockNumber: number,
-    endBlockNumber?: number,
-  ) {
-    if (this.rpcProvider) {
-      let endBlock = endBlockNumber || (await this.getLatestBlockNumber())
-      let startBlock = Math.max(+startBlockNumber, +endBlock - 20)
-      return this.getMultipleBlocksTransactions(addresses, startBlock, endBlock)
-    }
-    if (this.apiProviderName !== "BlockStream" && this.apiProviderName !== "MempoolSpace") {
-      throw new Error("not support this api provider")
-    }
-    let txs = await (this.apiProvider as any).getTransactionHistoryForMultipleAddresses(
-      addresses,
-      startBlockNumber,
-    )
-    return txs.flat(1)
-  }
-
-  // ------------------just blockstream----------------------
-  async getMempoolTransactionHistory(addresses: string[]) {
-    if (this.apiProviderName !== "BlockStream" && this.apiProviderName !== "MempoolSpace") {
-      throw new Error("not support this api provider")
-    }
-    let txs = await (this.apiProvider as any).getMempoolTransactionHistoryForMultipleAddresses(
-      addresses,
-    )
-    return txs.flat(1)
-  }
-
-  async getTeleporterRequests(
-    addresses: string[],
-    startblockNumber: number,
-    endBlockNumber: number,
-    mempool = false,
-  ) {
-    // transaction in StartBlock is not returned --> (startblockNumber,endBlockNumber]
-    let transactions = mempool
-      ? await this.getMempoolTransactionHistory(addresses)
-      : await this.getTransactionHistory(addresses, startblockNumber, endBlockNumber)
-
-    let requests = []
-    let invalidRequests = []
-
-    for (let inputTx of transactions) {
-      let { transaction, request, lockerAddress, lockerLockingScript } =
-        await this.getTeleportRequestByTx(inputTx, inputTx.address)
-      if (request.status) {
-        requests.push({ transaction, request, lockerAddress, lockerLockingScript })
-      } else if (request.code !== "NO_OP_RETURN") {
-        invalidRequests.push({ transaction, request, lockerAddress, lockerLockingScript })
-      }
-    }
-    return { requests, invalidRequests }
-  }
-
-  async getTeleportRequestByTx(
-    inputTransaction: {
-      txId: any
-      version?: any
-      locktime?: any
-      blockNumber?: any
-      blockHash?: any
-      vout?: any
-      vin?: any
-      addressScript?: any
-    },
-    lockerAddress: string,
-  ) {
-    let transaction = inputTransaction
-    if (!transaction.txId) throw new Error("txId not exist")
-    if (!transaction?.vout) {
-      transaction = await this.getTransaction(transaction.txId)
-    }
-    let vout = transaction.vout
-    let request = checkAndParseProtocolRequest(vout, lockerAddress, {
-      minTeleporterFeeAmount: this.minTeleporterFeeAmount,
-    })
-    let lockerLockingScript: string =
-      transaction.addressScript ||
-      this.convertAddressToScript(lockerAddress).script!.toString("hex")
-
-    return {
-      transaction,
-      request,
-      lockerAddress,
-      lockerLockingScript,
-    }
-  }
-
-  async getLockersBurnTransactions(
-    addresses: string[],
-    startBlockNumber: number,
-    endBlockNumber: number,
-    mempool = false,
-  ) {
-    let transactions = mempool
-      ? await this.getMempoolTransactionHistory(addresses)
-      : await this.getTransactionHistory(addresses, startBlockNumber, endBlockNumber)
-
-    let validTxs = []
-    for (let transaction of transactions) {
-      let address = transaction.address
-      // check if its a transaction to spend btc
-      let txBurnInfo = await this.getTransactionBurnInfoByTx(transaction, address)
-      if (txBurnInfo) {
-        const { burnInfo, lockerAddress, lockerLockingScript } = txBurnInfo
-        validTxs.push({
-          transaction,
-          burnInfo,
-          lockerAddress,
-          lockerLockingScript,
-        })
-      }
-    }
-    return validTxs
-  }
-
-  async getTransactionBurnInfoByTx(
-    transaction: {
-      txId: any
-      vout?: any
-      vin?: any
-      addressScript?: any
-    },
-    lockerAddress: string,
-  ) {
-    if (!transaction.txId) throw new Error("txId not exist")
-    let vin = transaction.vin || (await this.getTransaction(transaction.txId)).vin
-    let burnInfo = getBurnTransactionInfo(lockerAddress, vin, transaction.vout)
-    if (!burnInfo) return null
-    let lockerLockingScript: string =
-      transaction.addressScript ||
-      this.convertAddressToScript(lockerAddress).script!.toString("hex")
-    return {
-      burnInfo,
-      lockerAddress,
-      lockerLockingScript,
-    }
-  }
 }
+
+export default BitcoinInterface

package/src/bitcoin-utils.ts

@@ -5,6 +5,7 @@ import BIP32Factory from "bip32"
 import * as ecc from "@bitcoinerlab/secp256k1"
 import * as bitcoin from "bitcoinjs-lib"
 import * as bitcoinEcPair from "bitcoinjs-ecpair"
+import { Transaction } from "./type"
 
 const bip32 = BIP32Factory(ecc)
 const ECPair = bitcoinEcPair.ECPair
@@ -206,7 +207,7 @@ export function convertBitcoinScriptToAddress(script: Buffer, network = bitcoin.
   try {
     return bitcoin.address.fromOutputScript(script, network)
   } catch (error) {
-    return null
+    return undefined
   }
 }
 
@@ -250,7 +251,7 @@ export function extractTransactionsAndBlockInfoFromRawBlock(
   inputTxIds: {
     txId: string
     index: number
-    address?: string
+    address: string
     script?: string
     value?: number
   }[] = [],
@@ -274,32 +275,6 @@ export function extractTransactionsAndBlockInfoFromRawBlock(
 
   let blockTxIds = block.transactions!.map((tx) => tx.getId())
 
-  type Transaction = {
-    txId: string
-    version: number
-    locktime: number
-    blockNumber: number
-    blockHash: string
-    merkleProof: {
-      intermediateNodes: string
-      transactionIndex: number
-    }
-    vout: {
-      address: string | null
-      script: string
-      value: number
-    }[]
-    vin: {
-      txId: string
-      index: number
-      address?: string | null
-      script?: string | null
-      value?: number | null
-    }[]
-    address: string
-    addressScript: string
-  }
-
   let withdrawTxs: Transaction[] = []
   let depositTxs: Transaction[] = []
   block.transactions?.forEach((tx) => {
@@ -333,9 +308,9 @@ export function extractTransactionsAndBlockInfoFromRawBlock(
           return {
             txId: Buffer.from(vi.hash).reverse().toString("hex"),
             index: vi.index,
-            address: viInput?.address || null,
-            script: viInput?.script || null,
-            value: viInput?.value || null,
+            address: viInput?.address,
+            script: viInput?.script,
+            value: viInput?.value,
           }
         }),
         address: inputTxAddress,
@@ -359,7 +334,6 @@ export function extractTransactionsAndBlockInfoFromRawBlock(
     })
 
     if (isDeposit && addressIndex >= 0) {
-      // todo we can optimize this calculation (in following function, merkle tree calculate each times but we can do this once for block)
       let txMerkleProof = calculateMerkleProof(blockTxIds, txId, merkleRoot)
       depositTxs.push({
         txId: tx.getId(),