@teleportdao/bitcoin 1.4.7 → 1.4.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teleportdao/bitcoin",
-  "version": "1.4.7",
+  "version": "1.4.9",
   "description": "teleswap bitcoin package",
   "main": "dist/index.js",
   "browser": "dist/bundle.js",
@@ -8,30 +8,34 @@
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 2",
     "build:tsc": "tsc",
-    "build:watch": "npx webpack --watch",
+    "build:watch": "npx tsc --watch",
     "build": "npx tsc && npx webpack"
   },
   "author": "",
   "license": "ISC",
   "dependencies": {
+    "@bitcoinerlab/secp256k1": "^1.0.5",
     "@teleportdao/configs": "^1.4.6",
-    "@teleportdao/providers": "^1.4.6",
+    "@teleportdao/providers": "^1.4.9",
     "axios": "^0.27.2",
     "bignumber.js": "^9.1.1",
-    "bip32": "^2.0.6",
-    "bip39": "^3.0.4",
-    "bitcoinjs-lib": "^5.2.0",
-    "buffer": "^6.0.3",
+    "bip32": "^4.0.0",
+    "bip39": "^3.1.0",
+    "bitcoinjs-ecpair": "npm:bitcoinjs-lib@^5.2.0",
+    "bitcoinjs-lib": "^6.1.5",
     "coinselect": "^3.1.13",
-    "ecpair": "^2.1.0",
+    "ecpair": "^2.0.1",
     "merkle-lib": "^2.0.10",
     "merkle-patricia-tree": "^2.3.2",
-    "stream": "^0.0.2",
-    "tiny-secp256k1": "^2.2.1",
+    "npm": "^10.2.3",
+    "uninstall": "^0.0.0",
     "varuint-bitcoin": "^1.1.2"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "a32e568d407d5718e12599fabc55ee0166918f40"
+  "gitHead": "cb98230f4b9dddad7318f3830bc1890e20a3cda4",
+  "devDependencies": {
+    "@babel/preset-react": "^7.23.3"
+  }
 }

package/src/bitcoin-base.ts

@@ -6,13 +6,17 @@ import type { ExtendedUtxo, SignerInfo, Target } from "./transaction-builder/tra
 import BitcoinSign from "./sign/sign-transaction"
 
 import * as bip39 from "bip39"
-import * as bip32 from "bip32"
 import { hdWalletPath } from "@teleportdao/configs"
 import { getPubKeyFromPrivateKeyHex } from "./bitcoin-utils"
 import networks from "./utils/networks"
 import { Network, Payment } from "bitcoinjs-lib"
 import { BitcoinInterface } from "./bitcoin-interface"
 
+import BIP32Factory from "bip32"
+import ecc from "@bitcoinerlab/secp256k1"
+
+const bip32 = BIP32Factory(ecc)
+
 class BitcoinBase {
   network: Network
   hdWalletPath: {
@@ -244,5 +248,4 @@ class BitcoinBase {
     return txId
   }
 }
-
 export { BitcoinBase }

package/src/bitcoin-interface.ts

@@ -11,14 +11,15 @@ 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"
+import ms from "./mempool-space"
 
 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
+  provider: any
+  apiProvider!: bitcoinProvider.ApiProviders.BlockStream | bitcoinProvider.ApiProviders.NowNodes
   constructor(
     connectionInfo: BitcoinConnectionInfo,
     networkName: string,
@@ -33,7 +34,7 @@ export class BitcoinInterface extends BitcoinInterfaceUtils {
 
     if (connectionInfo.api.enabled) {
       this.apiProviderName = connectionInfo.api.provider
-      this.apiProvider = bitcoinProvider.getApiProvider(connectionInfo.api as any, networkName)
+      this.apiProvider = bitcoinProvider.getApiProvider(connectionInfo.api as any, networkName)!
     }
 
     this.minTeleporterFeeAmount = config.minTeleporterFeeAmount
@@ -63,12 +64,8 @@ export class BitcoinInterface extends BitcoinInterfaceUtils {
   }
 
   // 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
+  async getFeeRate(speed?: "normal" | "slow" | "fast") {
+    return new ms(this.testnet).getRecommendedFeeRate(speed)
   }
 
   // ----------- specific
@@ -219,7 +216,7 @@ export class BitcoinInterface extends BitcoinInterfaceUtils {
       results.push(
         result
           .map((utxos, i) =>
-            utxos.map((tx) => ({
+            utxos.map((tx: any) => ({
               hash: tx.txId,
               value: tx.value,
               index: tx.index,
@@ -237,7 +234,7 @@ export class BitcoinInterface extends BitcoinInterfaceUtils {
       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)
+    return utxos.reduce((a: any, tx: any) => a + Number(tx.value), 0)
   }
 
   // ------------------ utxo provider + rpc or blockstream----------------
@@ -269,9 +266,11 @@ export class BitcoinInterface extends BitcoinInterfaceUtils {
     }
     let blockTxs = []
     for (let blockNumber = +startBlockNumber + 1; blockNumber <= endBlockNumber; blockNumber += 1) {
-      const response = this.getBlockTransactions(addresses, blockNumber, inputTxIds)
+      console.log(blockNumber)
+
+      const response = await this.getBlockTransactions(addresses, blockNumber, inputTxIds)
       blockTxs.push(response)
-      await sleep(200)
+      // await sleep(200)
     }
     blockTxs = await Promise.all(blockTxs)
     return blockTxs.flat(1)
@@ -291,7 +290,7 @@ export class BitcoinInterface extends BitcoinInterfaceUtils {
     if (this.apiProviderName !== "BlockStream") {
       throw new Error("just support BlockStream as api provider for this function")
     }
-    let txs = await this.apiProvider.getTransactionHistoryForMultipleAddresses(
+    let txs = await (this.apiProvider as any).getTransactionHistoryForMultipleAddresses(
       addresses,
       startBlockNumber,
     )
@@ -303,7 +302,9 @@ export class BitcoinInterface extends BitcoinInterfaceUtils {
     if (this.apiProviderName !== "BlockStream") {
       throw new Error("teleporter just support BlockStream as api provider")
     }
-    let txs = await this.apiProvider.getMempoolTransactionHistoryForMultipleAddresses(addresses)
+    let txs = await (this.apiProvider as any).getMempoolTransactionHistoryForMultipleAddresses(
+      addresses,
+    )
     return txs.flat(1)
   }
 

package/src/bitcoin-utils.ts

@@ -1,15 +1,13 @@
-import * as bip39 from "bip39"
-import * as bip32 from "bip32"
 import networks from "./utils/networks"
 
-// import BIP32Factory from "bip32"
-// import ECPairFactory from "ecpair"
-// import * as ecc from "tiny-secp256k1"
+import * as bip39 from "bip39"
+import BIP32Factory from "bip32"
+import * as ecc from "@bitcoinerlab/secp256k1"
 import * as bitcoin from "bitcoinjs-lib"
+import * as bitcoinEcPair from "bitcoinjs-ecpair"
 
-// bitcoin.initEccLib(ecc)
-// const bip32 = BIP32Factory(ecc)
-const ECPair = bitcoin.ECPair
+const bip32 = BIP32Factory(ecc)
+const ECPair = bitcoinEcPair.ECPair
 
 let varUnit = require("varuint-bitcoin")
 const fastRoot = require("merkle-lib/fastRoot")
@@ -46,6 +44,44 @@ export function generateMnemonic() {
   return mnemonic
 }
 
+export function reverseBytes(hexInput: string) {
+  return Buffer.from(hexInput, "hex").reverse().toString("hex")
+}
+
+export function getPublicKeyHexByXpubAndIndex(
+  xpub: string,
+  index = 0,
+  isChange = false,
+  network = networks.bitcoin,
+) {
+  const node = bip32.fromBase58(xpub, network)
+  return node
+    .derive(isChange ? 1 : 0)
+    .derive(index)
+    .publicKey.toString("hex")
+}
+
+export function getPubKeyFromPrivateKeyWIF(
+  privateKeyWIF: string,
+  network = bitcoin.networks.bitcoin,
+) {
+  let key = ECPair.fromWIF(privateKeyWIF, network)
+  return key.publicKey
+}
+
+export function getPubKeyFromPrivateKeyHex(
+  privateKeyHex: string,
+  network = bitcoin.networks.bitcoin,
+) {
+  let key = ECPair.fromPrivateKey(Buffer.from(privateKeyHex, "hex"), { network })
+  return key.publicKey
+}
+
+export function getPrivateKeyHexFromWIF(privateKeyWIF: string, network = bitcoin.networks.bitcoin) {
+  let key = ECPair.fromWIF(privateKeyWIF, network)
+  return key.privateKey!.toString("hex")
+}
+
 export function parseRawTransaction(rawTransaction: string) {
   const size = {
     version: 4,
@@ -102,44 +138,6 @@ export function parseRawTransaction(rawTransaction: string) {
   return { version, flag, vin, vout, witness, locktime }
 }
 
-export function reverseBytes(hexInput: string) {
-  return Buffer.from(hexInput, "hex").reverse().toString("hex")
-}
-
-export function getPublicKeyHexByXpubAndIndex(
-  xpub: string,
-  index = 0,
-  isChange = false,
-  network = networks.bitcoin,
-) {
-  const node = bip32.fromBase58(xpub, network)
-  return node
-    .derive(isChange ? 1 : 0)
-    .derive(index)
-    .publicKey.toString("hex")
-}
-
-export function getPubKeyFromPrivateKeyWIF(
-  privateKeyWIF: string,
-  network = bitcoin.networks.bitcoin,
-) {
-  let key = bitcoin.ECPair.fromWIF(privateKeyWIF, network)
-  return key.publicKey
-}
-
-export function getPubKeyFromPrivateKeyHex(
-  privateKeyHex: string,
-  network = bitcoin.networks.bitcoin,
-) {
-  let key = bitcoin.ECPair.fromPrivateKey(Buffer.from(privateKeyHex, "hex"), { network })
-  return key.publicKey
-}
-
-export function getPrivateKeyHexFromWIF(privateKeyWIF: string, network = bitcoin.networks.bitcoin) {
-  let key = bitcoin.ECPair.fromWIF(privateKeyWIF, network)
-  return key.privateKey!.toString("hex")
-}
-
 export function calculateMerkleProof(
   blockTransactions: string[],
   txId: string,
@@ -202,6 +200,7 @@ export function parseBlockHeader(headerHex: string) {
   }
 }
 
+// used in block parser functions ( newt 2 functions )
 export function convertBitcoinScriptToAddress(script: Buffer, network = bitcoin.networks.bitcoin) {
   try {
     return bitcoin.address.fromOutputScript(script, network)
@@ -414,11 +413,11 @@ function toXOnlyPublicKey(pubKey: Buffer) {
 
 export function getAddressType(address: string, network = bitcoin.networks.bitcoin) {
   if (address.startsWith(`${network.bech32}1p`)) {
-    // todo : check length - it could be p2wsh
+    // todo validate p2tr address
     return "p2tr"
   }
   if (address.startsWith(network.bech32)) {
-    // todo : check length - it could be p2wsh
+    bitcoin.address.fromBech32(address)
     return "p2wpkh"
   }
   let base58Data = bitcoin.address.fromBase58Check(address)
@@ -462,12 +461,12 @@ export function createAddressObjectByScript(
         network,
       })
       break
-    // case "p2tr":
-    //   addressObject = bitcoin.payments.p2tr({
-    //     output: script,
-    //     network,
-    //   })
-    //   break
+    case "p2tr":
+      addressObject = bitcoin.payments.p2tr({
+        output: script,
+        network,
+      })
+      break
     default:
       throw new Error("address type is incorrect")
   }
@@ -504,13 +503,13 @@ export function createAddressObjectByHash(
         network,
       })
       break
-    // case "p2tr":
-    //   // here hash is the public key of tweaked private key
-    //   addressObject = bitcoin.payments.p2tr({
-    //     pubkey: hash,
-    //     network,
-    //   })
-    // break
+    case "p2tr":
+      // here hash is the public key of tweaked private key (internal public key)
+      addressObject = bitcoin.payments.p2tr({
+        pubkey: hash,
+        network,
+      })
+      break
     default:
       throw new Error("address type is incorrect")
   }
@@ -544,12 +543,12 @@ export function createAddressObjectByPublicKey(
       })
       break
     case "p2tr":
-    // // this public key is public key of main private key
-    // addressObject = bitcoin.payments.p2tr({
-    //   internalPubkey: toXOnlyPublicKey(publicKey),
-    //   network,
-    // })
-    // break
+      // this public key is public key of main private key
+      addressObject = bitcoin.payments.p2tr({
+        internalPubkey: toXOnlyPublicKey(publicKey),
+        network,
+      })
+      break
     default:
       throw new Error("address type is incorrect")
   }
@@ -578,12 +577,12 @@ export function createAddressObjectByAddress(address: string, network = bitcoin.
         network,
       })
       break
-    // case "p2tr":
-    //   addressObject = bitcoin.payments.p2tr({
-    //     address,
-    //     network,
-    //   })
-    //   break
+    case "p2tr":
+      addressObject = bitcoin.payments.p2tr({
+        address,
+        network,
+      })
+      break
     default:
       throw new Error("address type is incorrect")
   }

package/src/mempool-space.ts

@@ -0,0 +1,255 @@
+import { AxiosInstance } from "axios"
+import { getAxiosInstance } from "./utils/tools"
+
+class BlockStream {
+  api: AxiosInstance
+  constructor(
+    testnet = false,
+    // not used yet
+    _config?: {
+      token?: string
+    },
+  ) {
+    const baseUrl = testnet
+      ? "https://mempool.space/testnet/api/v1"
+      : "https://mempool.space/api/v1"
+    this.api = getAxiosInstance({
+      baseUrl,
+    } as any)
+  }
+
+  async getOutspend(txId: string, index: number) {
+    let response = await this.api.get(`/tx/${txId}/outspend/${index}`)
+    return response.data
+  }
+  async getOutspends(txId: string) {
+    let response = await this.api.get(`/tx/${txId}/outspends`)
+    return response.data
+  }
+
+  async getLatestBlockNumber() {
+    const result = await this.api.get(`/blocks/tip/height`)
+    return result.data
+  }
+
+  async getBlockHash(blockNumber: number) {
+    const result = await this.api.get(`/block-height/${blockNumber}`)
+    return result.data
+  }
+
+  async getBlockHeaderHex(blockNumber: number) {
+    const hash = await this.getBlockHash(blockNumber)
+    const result = await this.api.get(`/block/${hash}/header`)
+    return result.data
+  }
+
+  // --------------
+
+  async getConfirmedTransactions(userAddress: string, lastReceivedTxId = "") {
+    const result = await this.api.get(`/address/${userAddress}/txs/chain/${lastReceivedTxId}`)
+    return result.data
+  }
+
+  async getMempoolTransactions(userAddress: string) {
+    const result = await this.api.get(`/address/${userAddress}/txs/mempool`)
+    return result.data
+  }
+
+  async getTransaction(txId: string) {
+    const result = await this.api.get(`/tx/${txId}`)
+    let tx = result.data
+    return {
+      txId: tx.txid,
+      version: tx.version,
+      locktime: tx.locktime,
+      blockTime: tx.status.block_time,
+      blockNumber: tx.status.block_height || null,
+      blockHash: tx.status.block_hash || null,
+      vout: tx.vout.map((vo: any) => ({
+        address: vo.scriptpubkey_address || null,
+        script: vo.scriptpubkey,
+        value: vo.value,
+      })),
+      vin: tx.vin.map((vi: any) => ({
+        txId: vi.txid,
+        index: vi.vout,
+        address: vi.prevout.scriptpubkey_address || null,
+        script: vi.prevout.scriptpubkey,
+        value: vi.prevout.value,
+      })),
+    }
+  }
+
+  async getRawTransaction(txId: string) {
+    const result = await this.api.get(`/tx/${txId}/hex`)
+    return result.data
+  }
+
+  async getTransactionHistory(userAddress: string, blockNumber = 0, lastSeenTxId = undefined) {
+    let maximumTxsLength = 15
+    // get transactions from lastSeenTxId to the end
+    let fetchTxs = true
+    let allResults = []
+    let lastReceivedTxId = ""
+    while (fetchTxs) {
+      let result = await this.getConfirmedTransactions(userAddress, lastReceivedTxId)
+      let lastSeenTxIdIndex = result.findIndex((tx: any) => tx.txid === lastSeenTxId)
+      result = result.filter((_value: any) => +_value.status.block_height > blockNumber)
+      result =
+        lastSeenTxIdIndex < 0
+          ? result
+          : result.filter((_value: any, index: number) => index < lastSeenTxIdIndex)
+      allResults.push(...result)
+      lastReceivedTxId = result[result.length - 1]?.txid
+      fetchTxs = result.length === maximumTxsLength && lastSeenTxIdIndex < 0 && result.length !== 0
+    }
+
+    return allResults.map((tx) => ({
+      address: userAddress,
+      txId: tx.txid,
+      version: tx.version,
+      locktime: tx.locktime,
+      blockNumber: tx.status.block_height || null,
+      blockHash: tx.status.block_hash || null,
+      blockTime: tx.status.block_time || null,
+      vout: tx.vout.map((vo: any) => ({
+        address: vo.scriptpubkey_address || null,
+        script: vo.scriptpubkey,
+        value: vo.value,
+      })),
+      vin: tx.vin.map((vi: any) => ({
+        txId: vi.txid,
+        index: vi.vout,
+        address: vi.prevout.scriptpubkey_address || null,
+        script: vi.prevout.scriptpubkey,
+        value: vi.prevout.value,
+      })),
+    }))
+  }
+
+  async getMempoolTransactionHistory(userAddress: string) {
+    let result = await this.getMempoolTransactions(userAddress)
+    return result.map((tx: any) => ({
+      address: userAddress,
+      txId: tx.txid,
+      version: tx.version,
+      locktime: tx.locktime,
+      vout: tx.vout.map((vo: any) => ({
+        address: vo.scriptpubkey_address || null,
+        script: vo.scriptpubkey,
+        value: vo.value,
+      })),
+      vin: tx.vin.map((vi: any) => ({
+        txId: vi.txid,
+        index: vi.vout,
+        address: vi.prevout.scriptpubkey_address || null,
+        script: vi.prevout.scriptpubkey,
+        value: vi.prevout.value,
+      })),
+    }))
+  }
+
+  async getMempoolTransactionHistoryForMultipleAddresses(addresses: string[], blockNumber = 0) {
+    const allPromises = []
+    for (let address of addresses) {
+      let promise = await this.getMempoolTransactionHistory(address)
+      allPromises.push(promise)
+    }
+    let result = await Promise.all(allPromises)
+    return result
+  }
+
+  async getTransactionHistoryForMultipleAddresses(userAddresses: string[], blockNumber = 0) {
+    const allPromises = []
+    for (let address of userAddresses) {
+      let promise = await this.getTransactionHistory(address, blockNumber)
+      allPromises.push(promise)
+    }
+    let result = await Promise.all(allPromises)
+    return result
+  }
+
+  async getUtxos(userAddress: string): Promise<
+    {
+      address: string
+      txId: string
+      index: number
+      value: number
+      blockNumber?: number
+    }[]
+  > {
+    const result = await this.api.get(`/address/${userAddress}/utxo`)
+    return result.data.map((tx: any) => ({
+      address: userAddress,
+      txId: tx.txid,
+      index: tx.vout,
+      value: tx.value,
+      blockNumber: tx.status?.block_height || undefined,
+    }))
+  }
+
+  async getBalance(address: string) {
+    let utxos = await this.getUtxos(address)
+    return utxos.reduce((a: any, tx: any) => a + Number(tx.value), 0)
+  }
+
+  async getBlockTransactionIds(blockHash: string) {
+    let result = await this.api.get(`/block/${blockHash}/txids`)
+    return result.data
+  }
+
+  async getFeeRate(speed: "normal" | "slow" | "fast" = "normal") {
+    let result = await this.api.get(`/fee-estimates`)
+    let fees = {
+      slow: +result.data[10],
+      normal: +result.data[6],
+      fast: +result.data[3],
+    }
+    return fees[speed] || fees.normal
+  }
+  async getRecommendedFeeRate(speed: "normal" | "slow" | "fast" = "normal") {
+    let result = await this.api.get(`/fees/recommended`)
+
+    let fees = {
+      slow: +result.data.economyFee,
+      normal: +result.data.halfHourFee,
+      fast: +result.data.fastestFee,
+    }
+    return fees[speed] || fees.normal
+  }
+
+  async sendRawTransaction(rawTransaction: string) {
+    const result = await this.api.post(`/tx`, rawTransaction)
+    return result.data
+  }
+
+  // not used
+
+  async getMerkleProof(txId: string) {
+    let result = (await this.api.get(`/tx/${txId}/merkle-proof`)).data
+    let intermediateNodes = result.merkle.reduce(
+      (a: any, merkle: any) => a + Buffer.from(merkle, "hex").reverse().toString("hex"),
+      "0x",
+    )
+    let transactionIndex = result.pos
+    return {
+      intermediateNodes,
+      transactionIndex,
+    }
+  }
+
+  async getLatestBlock() {
+    const result = await this.api.get(`/blocks`)
+    // 10 newest blocks
+    const blocks = result.data
+    return blocks[0]
+  }
+
+  async getBlock(blockNumber: number) {
+    const blockHash = await this.getBlockHash(blockNumber)
+    const result = await this.api.get(`/block/${blockHash}`)
+    return result.data
+  }
+}
+
+export default BlockStream