@teleportdao/bitcoin 1.4.3 → 1.4.6

package/src/{bitcoin-interface.js → bitcoin-interface.ts}

@@ -1,350 +1,420 @@
-const { getRpcProvider, getApiProvider } = require("@teleportdao/providers").bitcoin
-const { runWithRetries, sleep } = require("./utils/tools")
-const {
-  parseRawTransaction,
-  calculateMerkleProof,
-  parseBlockHeader,
-  extractTransactionsAndBlockInfoFromRawBlock,
-} = require("./bitcoin-utils")
-const { checkAndParseProtocolRequest } = require("./helper/teleport-request-helper")
-const { getBurnTransactionInfo } = require("./helper/burn-request-helper")
-const BitcoinInterfaceUtils = require("./bitcoin-interface-utils")
-
-class BitcoinInterface extends BitcoinInterfaceUtils {
-  constructor(connectionInfo, networkName, config = { minTeleporterFeeAmount: 0 }) {
-    super(networkName)
-    if (connectionInfo.rpc?.enabled) {
-      this.rpcProvider = getRpcProvider(connectionInfo.rpc)
-    } else if (connectionInfo.api.provider !== "BlockStream") {
-      throw new Error("if rpc is disabled, we just support BlockStream as api provider")
-    }
-
-    if (connectionInfo.api.enabled) {
-      this.apiProviderName = connectionInfo.api.provider
-      this.apiProvider = getApiProvider(connectionInfo.api, networkName)
-    }
-
-    this.minTeleporterFeeAmount = config.minTeleporterFeeAmount
-    this.provider = this.rpcProvider || this.apiProvider
-  }
-
-  // rpc + api
-
-  // general
-  async getLatestBlockNumber() {
-    let latestHeight = await this.provider.getLatestBlockNumber()
-    return latestHeight
-  }
-
-  async getBlockHash(blockNumber) {
-    let headerHash = await runWithRetries(() => this.provider.getBlockHash(blockNumber))
-    return headerHash
-  }
-
-  async getBlockHeaderHex(blockNumber) {
-    let headerHex = await runWithRetries(() => this.provider.getBlockHeaderHex(blockNumber))
-    return headerHex
-  }
-
-  async getTransaction(txId) {
-    return this.provider.getTransaction(txId)
-  }
-
-  // speed : low normal fast
-  async getFeeRate(speed = "normal") {
-    if (!(speed === "normal" || speed === "slow" || speed === "fast")) {
-      throw new Error("incorrect speed")
-    }
-    let fee = await this.provider.getFeeRate(speed)
-    return +fee
-  }
-
-  // ----------- specific
-
-  // relayer
-  async getHexBlockHeaders(startBlockNumber, endBlockNumber) {
-    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,
-      })
-    }
-
-    return blockHeaders
-  }
-
-  async getRequestProof(transaction) {
-    let transactionHex =
-      transaction.hex || (await this.provider.getRawTransaction(transaction.txId))
-
-    let txInfo
-    if (!(transaction.blockHash && transaction.blockNumber)) {
-      txInfo = await this.provider.getTransaction(transaction.txId)
-    }
-    let blockHash = transaction.blockHash || txInfo.blockHash
-    let blockNumber = transaction.blockNumber || txInfo.blockNumber
-    let parsedTx = parseRawTransaction(transactionHex)
-    let merkleProof =
-      transaction.merkleProof || (await this.getMerkleProof(transaction.txId, blockHash))
-
-    return {
-      parsedTx,
-      merkleProof,
-      blockNumber,
-      blockHash,
-    }
-  }
-
-  async getMerkleProof(txId, blockHash) {
-    let txIds = await this.provider.getBlockTransactionIds(blockHash)
-    // let a = await this.provider.getMerkleProof(txId)
-    let proof = calculateMerkleProof(txIds, txId)
-    // console.log(a.intermediateNodes === proof.intermediateNodes)
-    return proof
-  }
-
-  // ------------------ utxo providers --------------------------------
-
-  // teleporter + locker
-  async getAddressesUtxo(allAddresses) {
-    if (!this.apiProvider) {
-      throw new Error("this function need an api provider")
-    }
-    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.apiProvider.getUtxos(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(allAddressesInfo) {
-    if (!this.apiProvider) {
-      throw new Error("this function need an api provider")
-    }
-    const chunkOfAddressesInfo = []
-    const chunkLength = 20
-    for (let i = 0; i < allAddressesInfo.length; i += chunkLength) {
-      const tmp = allAddressesInfo.slice(i, i + chunkLength)
-      chunkOfAddressesInfo.push(tmp)
-    }
-
-    let results = []
-
-    for (let addressesInfo of chunkOfAddressesInfo) {
-      const allPromises = []
-      for (let info of addressesInfo) {
-        let promise = this.apiProvider.getUtxos(info.address)
-        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) => ({
-              hash: tx.txId,
-              value: tx.value,
-              index: tx.index,
-              ...addressesInfo[i],
-              signerInfo: addressesInfo[i],
-            })),
-          )
-          .flat(1),
-      )
-    }
-    return results.flat(1)
-  }
-
-  async getBalance(address) {
-    if (!this.apiProvider) {
-      throw new Error("this function need an api provider")
-    }
-    let utxos = (await this.apiProvider.getUtxos(address)) ?? []
-    return utxos.reduce((a, tx) => a + Number(tx.value), 0)
-  }
-
-  // ------------------ utxo provider + rpc or blockstream----------------
-  // teleporter
-  async getBlockTransactions(addresses, blockNumber, inputTxIds = []) {
-    let rawBlockHex = await this.rpcProvider.getBlockByBlockNumber(blockNumber, 0)
-    let { withdrawTxs, depositTxs } = extractTransactionsAndBlockInfoFromRawBlock(
-      rawBlockHex,
-      blockNumber,
-      addresses,
-      inputTxIds,
-      this.network,
-    )
-    return depositTxs.concat(withdrawTxs)
-  }
-
-  // teleporter
-  async getMultipleBlocksTransactions(
-    addresses,
-    startBlockNumber,
-    endBlockNumber,
-    inputTxIds = [],
-  ) {
-    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) {
-      const response = this.getBlockTransactions(addresses, blockNumber, inputTxIds)
-      blockTxs.push(response)
-      await sleep(200)
-    }
-    blockTxs = await Promise.all(blockTxs)
-    return blockTxs.flat(1)
-  }
-
-  // teleporter
-  async getTransactionHistory(addresses, startBlockNumber, endBlockNumber) {
-    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") {
-      throw new Error("just support BlockStream as api provider for this function")
-    }
-    let txs = await this.apiProvider.getTransactionHistoryForMultipleAddresses(
-      addresses,
-      startBlockNumber,
-    )
-    return txs.flat(1)
-  }
-
-  // ------------------just blockstream----------------------
-  async getMempoolTransactionHistory(addresses) {
-    if (this.apiProviderName !== "BlockStream") {
-      throw new Error("teleporter just support BlockStream as api provider")
-    }
-    let txs = await this.apiProvider.getMempoolTransactionHistoryForMultipleAddresses(addresses)
-    return txs.flat(1)
-  }
-
-  async getTeleporterRequests(addresses, startblockNumber, endBlockNumber, 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, lockerAddress) {
-    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 =
-      transaction.addressScript || this.convertAddressToScript(lockerAddress).script.toString("hex")
-
-    return {
-      transaction,
-      request,
-      lockerAddress,
-      lockerLockingScript,
-    }
-  }
-
-  async getLockersBurnTransactions(addresses, startBlockNumber, endBlockNumber, 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, lockerAddress) {
-    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 =
-      transaction.addressScript || this.convertAddressToScript(lockerAddress).script.toString("hex")
-    return {
-      burnInfo,
-      lockerAddress,
-      lockerLockingScript,
-    }
-  }
-}
-
-module.exports = BitcoinInterface
+import { bitcoin as bitcoinProvider } from "@teleportdao/providers"
+import { runWithRetries, sleep } 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 { SignerInfo } from "./transaction-builder/transaction-builder"
+
+export class BitcoinInterface extends BitcoinInterfaceUtils {
+  rpcProvider?: bitcoinProvider.RPC
+  apiProviderName!: string
+  // todo : add provider type
+  minTeleporterFeeAmount: number
+  provider: bitcoinProvider.ApiProviders.BlockStream | bitcoinProvider.RPC
+  apiProvider!: bitcoinProvider.ApiProviders.BlockStream
+  constructor(
+    connectionInfo: BitcoinConnectionInfo,
+    networkName: string,
+    config = { minTeleporterFeeAmount: 0 },
+  ) {
+    super(networkName)
+    if (connectionInfo.rpc?.enabled) {
+      this.rpcProvider = bitcoinProvider.getRpcProvider(connectionInfo.rpc)
+    } else if (connectionInfo.api.provider !== "BlockStream") {
+      throw new Error("if rpc is disabled, we just support BlockStream 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
+  }
+
+  // rpc + api
+
+  // general
+  async getLatestBlockNumber() {
+    let latestHeight = await this.provider.getLatestBlockNumber()
+    return latestHeight
+  }
+
+  async getBlockHash(blockNumber: number) {
+    let headerHash = await runWithRetries(() => this.provider.getBlockHash(blockNumber))
+    return headerHash
+  }
+
+  async getBlockHeaderHex(blockNumber: number) {
+    let headerHex = await runWithRetries(() => this.provider.getBlockHeaderHex(blockNumber))
+    return headerHex
+  }
+
+  async getTransaction(txId: string) {
+    return this.provider.getTransaction(txId)
+  }
+
+  // speed : low normal fast
+  async getFeeRate(speed: "normal" | "slow" | "fast" = "normal") {
+    if (!(speed === "normal" || speed === "slow" || speed === "fast")) {
+      throw new Error("incorrect speed")
+    }
+    let fee = await this.provider.getFeeRate(speed)
+    return +fee
+  }
+
+  // ----------- 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,
+      })
+    }
+
+    return blockHeaders
+  }
+
+  async getRequestProof(transaction: {
+    txId: string
+    hex?: string
+    blockHash?: string
+    blockNumber?: number
+    merkleProof?: {
+      intermediateNodes: string
+      transactionIndex: number
+    }
+  }) {
+    let transactionHex =
+      transaction.hex || (await this.provider.getRawTransaction(transaction.txId))
+
+    let txInfo:
+      | {
+          txId: any
+          version: any
+          locktime: any
+          blockNumber: any
+          blockHash: any
+          vout: any
+          vin: any
+        }
+      | undefined
+    if (!(transaction.blockHash && transaction.blockNumber)) {
+      txInfo = await this.provider.getTransaction(transaction.txId)
+    }
+    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))
+
+    return {
+      parsedTx,
+      merkleProof,
+      blockNumber,
+      blockHash,
+    }
+  }
+
+  async getMerkleProof(txId: string, blockHash: string) {
+    if (!this.rpcProvider) {
+      throw new Error("RPC provider not set")
+    }
+    let txIds = await this.rpcProvider.getBlockTransactionIds(blockHash)
+    // let a = await this.provider.getMerkleProof(txId)
+    let proof = calculateMerkleProof(txIds, txId)
+    // console.log(a.intermediateNodes === proof.intermediateNodes)
+    return proof
+  }
+
+  // ------------------ utxo providers --------------------------------
+
+  // teleporter + locker
+  async getAddressesUtxo(allAddresses: string[]) {
+    if (!this.apiProvider) {
+      throw new Error("api provider not set")
+    }
+    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.apiProvider.getUtxos(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(allAddressesInfo: SignerInfo[]) {
+    if (!this.apiProvider) {
+      throw new Error("this function need an api provider")
+    }
+    const chunkOfAddressesInfo = []
+    const chunkLength = 20
+    for (let i = 0; i < allAddressesInfo.length; i += chunkLength) {
+      const tmp = allAddressesInfo.slice(i, i + chunkLength)
+      chunkOfAddressesInfo.push(tmp)
+    }
+
+    let results = []
+
+    for (let addressesInfo of chunkOfAddressesInfo) {
+      const allPromises = []
+      for (let info of addressesInfo) {
+        let promise = this.apiProvider.getUtxos(info.address)
+        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) => ({
+              hash: tx.txId,
+              value: tx.value,
+              index: tx.index,
+              signerInfo: addressesInfo[i],
+            })),
+          )
+          .flat(1),
+      )
+    }
+    return results.flat(1)
+  }
+
+  async getBalance(address: string) {
+    if (!this.apiProvider) {
+      throw new Error("this function need an api provider")
+    }
+    let utxos = (await this.apiProvider.getUtxos(address)) ?? []
+    return utxos.reduce((a, tx) => a + Number(tx.value), 0)
+  }
+
+  // ------------------ utxo provider + rpc or blockstream----------------
+  // teleporter
+  async getBlockTransactions(addresses: string[], blockNumber: number, inputTxIds = []) {
+    if (!this.rpcProvider) {
+      throw new Error("RPC provider not set")
+    }
+    let rawBlockHex = await this.rpcProvider.getBlockByBlockNumber(blockNumber, 0)
+    let { withdrawTxs, depositTxs } = extractTransactionsAndBlockInfoFromRawBlock(
+      rawBlockHex,
+      blockNumber,
+      addresses,
+      inputTxIds,
+      this.network,
+    )
+    return depositTxs.concat(withdrawTxs)
+  }
+
+  // teleporter
+  async getMultipleBlocksTransactions(
+    addresses: string[],
+    startBlockNumber: number,
+    endBlockNumber: number,
+    inputTxIds = [],
+  ) {
+    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) {
+      const response = this.getBlockTransactions(addresses, blockNumber, inputTxIds)
+      blockTxs.push(response)
+      await sleep(200)
+    }
+    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") {
+      throw new Error("just support BlockStream as api provider for this function")
+    }
+    let txs = await this.apiProvider.getTransactionHistoryForMultipleAddresses(
+      addresses,
+      startBlockNumber,
+    )
+    return txs.flat(1)
+  }
+
+  // ------------------just blockstream----------------------
+  async getMempoolTransactionHistory(addresses: string[]) {
+    if (this.apiProviderName !== "BlockStream") {
+      throw new Error("teleporter just support BlockStream as api provider")
+    }
+    let txs = await this.apiProvider.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,
+    }
+  }
+}