@teleportdao/bitcoin 1.4.4 → 1.4.6

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

@@ -1,27 +1,39 @@
-const { getRpcProvider, getApiProvider } = require("@teleportdao/providers").bitcoin
-const { runWithRetries, sleep } = require("./utils/tools")
-const {
+import { bitcoin as bitcoinProvider } from "@teleportdao/providers"
+import { runWithRetries, sleep } from "./utils/tools"
+import {
   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 }) {
+} 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 = getRpcProvider(connectionInfo.rpc)
+      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 = getApiProvider(connectionInfo.api, networkName)
+      this.apiProvider = bitcoinProvider.getApiProvider(connectionInfo.api as any, networkName)
     }
 
     this.minTeleporterFeeAmount = config.minTeleporterFeeAmount
@@ -36,22 +48,22 @@ class BitcoinInterface extends BitcoinInterfaceUtils {
     return latestHeight
   }
 
-  async getBlockHash(blockNumber) {
+  async getBlockHash(blockNumber: number) {
     let headerHash = await runWithRetries(() => this.provider.getBlockHash(blockNumber))
     return headerHash
   }
 
-  async getBlockHeaderHex(blockNumber) {
+  async getBlockHeaderHex(blockNumber: number) {
     let headerHex = await runWithRetries(() => this.provider.getBlockHeaderHex(blockNumber))
     return headerHex
   }
 
-  async getTransaction(txId) {
+  async getTransaction(txId: string) {
     return this.provider.getTransaction(txId)
   }
 
   // speed : low normal fast
-  async getFeeRate(speed = "normal") {
+  async getFeeRate(speed: "normal" | "slow" | "fast" = "normal") {
     if (!(speed === "normal" || speed === "slow" || speed === "fast")) {
       throw new Error("incorrect speed")
     }
@@ -62,7 +74,7 @@ class BitcoinInterface extends BitcoinInterfaceUtils {
   // ----------- specific
 
   // relayer
-  async getHexBlockHeaders(startBlockNumber, endBlockNumber) {
+  async getHexBlockHeaders(startBlockNumber: number, endBlockNumber: number) {
     const blockHeaders = []
     let difficulty = null
     let hexBlockHeaders = ""
@@ -98,16 +110,35 @@ class BitcoinInterface extends BitcoinInterfaceUtils {
     return blockHeaders
   }
 
-  async getRequestProof(transaction) {
+  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
+    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 = transaction.blockHash || txInfo.blockHash
-    let blockNumber = transaction.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))
@@ -120,8 +151,11 @@ class BitcoinInterface extends BitcoinInterfaceUtils {
     }
   }
 
-  async getMerkleProof(txId, blockHash) {
-    let txIds = await this.provider.getBlockTransactionIds(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)
@@ -131,9 +165,9 @@ class BitcoinInterface extends BitcoinInterfaceUtils {
   // ------------------ utxo providers --------------------------------
 
   // teleporter + locker
-  async getAddressesUtxo(allAddresses) {
+  async getAddressesUtxo(allAddresses: string[]) {
     if (!this.apiProvider) {
-      throw new Error("this function need an api provider")
+      throw new Error("api provider not set")
     }
     const chunkOfAddresses = []
     const chunkLength = 20
@@ -159,7 +193,7 @@ class BitcoinInterface extends BitcoinInterfaceUtils {
     return results.flat(1)
   }
 
-  async getAddressesExtendedUtxo(allAddressesInfo) {
+  async getAddressesExtendedUtxo(allAddressesInfo: SignerInfo[]) {
     if (!this.apiProvider) {
       throw new Error("this function need an api provider")
     }
@@ -189,7 +223,6 @@ class BitcoinInterface extends BitcoinInterfaceUtils {
               hash: tx.txId,
               value: tx.value,
               index: tx.index,
-              ...addressesInfo[i],
               signerInfo: addressesInfo[i],
             })),
           )
@@ -199,7 +232,7 @@ class BitcoinInterface extends BitcoinInterfaceUtils {
     return results.flat(1)
   }
 
-  async getBalance(address) {
+  async getBalance(address: string) {
     if (!this.apiProvider) {
       throw new Error("this function need an api provider")
     }
@@ -209,7 +242,10 @@ class BitcoinInterface extends BitcoinInterfaceUtils {
 
   // ------------------ utxo provider + rpc or blockstream----------------
   // teleporter
-  async getBlockTransactions(addresses, blockNumber, inputTxIds = []) {
+  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,
@@ -223,9 +259,9 @@ class BitcoinInterface extends BitcoinInterfaceUtils {
 
   // teleporter
   async getMultipleBlocksTransactions(
-    addresses,
-    startBlockNumber,
-    endBlockNumber,
+    addresses: string[],
+    startBlockNumber: number,
+    endBlockNumber: number,
     inputTxIds = [],
   ) {
     if (endBlockNumber - startBlockNumber > 20) {
@@ -242,7 +278,11 @@ class BitcoinInterface extends BitcoinInterfaceUtils {
   }
 
   // teleporter
-  async getTransactionHistory(addresses, startBlockNumber, endBlockNumber) {
+  async getTransactionHistory(
+    addresses: string[],
+    startBlockNumber: number,
+    endBlockNumber: number,
+  ) {
     if (this.rpcProvider) {
       let endBlock = endBlockNumber || (await this.getLatestBlockNumber())
       let startBlock = Math.max(+startBlockNumber, +endBlock - 20)
@@ -259,7 +299,7 @@ class BitcoinInterface extends BitcoinInterfaceUtils {
   }
 
   // ------------------just blockstream----------------------
-  async getMempoolTransactionHistory(addresses) {
+  async getMempoolTransactionHistory(addresses: string[]) {
     if (this.apiProviderName !== "BlockStream") {
       throw new Error("teleporter just support BlockStream as api provider")
     }
@@ -267,7 +307,12 @@ class BitcoinInterface extends BitcoinInterfaceUtils {
     return txs.flat(1)
   }
 
-  async getTeleporterRequests(addresses, startblockNumber, endBlockNumber, mempool = false) {
+  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)
@@ -288,18 +333,31 @@ class BitcoinInterface extends BitcoinInterfaceUtils {
     return { requests, invalidRequests }
   }
 
-  async getTeleportRequestByTx(inputTransaction, lockerAddress) {
+  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) {
+    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")
+    let lockerLockingScript: string =
+      transaction.addressScript ||
+      this.convertAddressToScript(lockerAddress).script!.toString("hex")
 
     return {
       transaction,
@@ -309,7 +367,12 @@ class BitcoinInterface extends BitcoinInterfaceUtils {
     }
   }
 
-  async getLockersBurnTransactions(addresses, startBlockNumber, endBlockNumber, mempool = false) {
+  async getLockersBurnTransactions(
+    addresses: string[],
+    startBlockNumber: number,
+    endBlockNumber: number,
+    mempool = false,
+  ) {
     let transactions = mempool
       ? await this.getMempoolTransactionHistory(addresses)
       : await this.getTransactionHistory(addresses, startBlockNumber, endBlockNumber)
@@ -332,13 +395,22 @@ class BitcoinInterface extends BitcoinInterfaceUtils {
     return validTxs
   }
 
-  async getTransactionBurnInfoByTx(transaction, lockerAddress) {
+  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 =
-      transaction.addressScript || this.convertAddressToScript(lockerAddress).script.toString("hex")
+    let lockerLockingScript: string =
+      transaction.addressScript ||
+      this.convertAddressToScript(lockerAddress).script!.toString("hex")
     return {
       burnInfo,
       lockerAddress,
@@ -346,5 +418,3 @@ class BitcoinInterface extends BitcoinInterfaceUtils {
     }
   }
 }
-
-module.exports = BitcoinInterface