@teleportdao/bitcoin 1.4.4 → 1.4.7

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

@@ -1,18 +1,52 @@
-const bip39 = require("bip39")
-const bip32 = require("bip32")
+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 bitcoin from "bitcoinjs-lib"
+
+// bitcoin.initEccLib(ecc)
+// const bip32 = BIP32Factory(ecc)
+const ECPair = bitcoin.ECPair
+
 let varUnit = require("varuint-bitcoin")
 const fastRoot = require("merkle-lib/fastRoot")
 const merkle = require("merkle-lib")
 const merkleProof = require("merkle-lib/proof")
-const bitcoin = require("bitcoinjs-lib")
-const networks = require("./utils/networks")
 
-function generateMnemonic() {
+// const bip32Prefix = {
+//   xprv: "0x0488ade4", // Mainnet - P2PKH or P2SH  - m/44'/0'
+//   yprv: "0x049d7878", // Mainnet - P2WPKH in P2SH - m/49'/0'
+//   zprv: "0x04b2430c", // Mainnet - P2WPKH 	     - m/84'/0'
+//   Yprv: "0x0295b005", // Mainnet - Multi-signature P2WSH in P2SH
+//   Zprv: "0x02aa7a99", // Mainnet - Multi-signature P2WSH
+//   tprv: "0x04358394", // Testnet - P2PKH or P2SH  - m/44'/1'
+//   uprv: "0x044a4e28", // Testnet - P2WPKH in P2SH - m/49'/1'
+//   vprv: "0x045f18bc", // Testnet - P2WPKH         - m/84'/1'
+//   Uprv: "0x024285b5", // Testnet - Multi-signature P2WSH in P2SH
+//   Vprv: "0x02575048", // Testnet - Multi-signature P2WSH
+
+//   xpub: "0x0488b21e", // Mainnet - P2PKH or P2SH  - m/44'/0'
+//   ypub: "0x049d7cb2", // Mainnet - P2WPKH in P2SH - m/49'/0'
+//   zpub: "0x04b24746", // Mainnet - P2WPKH 	     - m/84'/0'
+//   Ypub: "0x0295b43f", // Mainnet - Multi-signature P2WSH in P2SH
+//   Zpub: "0x02aa7ed3", // Mainnet - Multi-signature P2WSH
+//   tpub: "0x043587cf", // Testnet - P2PKH or P2SH  - m/44'/1'
+//   upub: "0x044a5262", // Testnet - P2WPKH in P2SH - m/49'/1'
+//   vpub: "0x045f1cf6", // Testnet - P2WPKH         - m/84'/1'
+//   Upub: "0x024289ef", // Testnet - Multi-signature P2WSH in P2SH
+//   Vpub: "0x02575483", // Testnet - Multi-signature P2WSH
+// }
+export { networks }
+
+export function generateMnemonic() {
   const mnemonic = bip39.generateMnemonic(256)
   return mnemonic
 }
 
-function parseRawTransaction(rawTransaction) {
+export function parseRawTransaction(rawTransaction: string) {
   const size = {
     version: 4,
     flag: 2,
@@ -68,147 +102,12 @@ function parseRawTransaction(rawTransaction) {
   return { version, flag, vin, vout, witness, locktime }
 }
 
-function reverseBytes(hexInput) {
+export function reverseBytes(hexInput: string) {
   return Buffer.from(hexInput, "hex").reverse().toString("hex")
 }
 
-function getAddressType(address, network = bitcoin.networks.bitcoin) {
-  if (address.startsWith(`${network.bech32}1p`)) {
-    // todo : check length - it could be p2wsh
-    return "p2tr"
-  }
-  if (address.startsWith(network.bech32)) {
-    // todo : check length - it could be p2wsh
-    return "p2wpkh"
-  }
-  let base58Data = bitcoin.address.fromBase58Check(address)
-  if (base58Data.version === Number(network.scriptHash)) {
-    return "p2sh"
-  }
-  if (base58Data.version === Number(network.pubKeyHash)) {
-    return "p2pkh"
-  }
-
-  throw new Error("invalid address")
-}
-
-function createAddressObjectByHash({ addressType, hash }, network = bitcoin.networks.bitcoin) {
-  let addressObject
-  switch (addressType) {
-    case "p2pkh":
-      addressObject = bitcoin.payments.p2pkh({
-        hash,
-        network,
-      })
-      break
-    case "p2wpkh":
-      addressObject = bitcoin.payments.p2wpkh({
-        hash,
-        network,
-      })
-      break
-    case "p2sh":
-      addressObject = bitcoin.payments.p2sh({
-        hash,
-        network,
-      })
-      break
-    default:
-      throw new Error("address type is incorrect")
-  }
-  return addressObject
-}
-
-function createAddressObjectByScript({ addressType, script }, network = bitcoin.networks.bitcoin) {
-  let addressObject
-  switch (addressType) {
-    case "p2pkh":
-      addressObject = bitcoin.payments.p2pkh({
-        output: script,
-        network,
-      })
-      break
-    case "p2wpkh":
-      addressObject = bitcoin.payments.p2wpkh({
-        output: script,
-        network,
-      })
-      break
-    case "p2sh":
-      addressObject = bitcoin.payments.p2sh({
-        output: script,
-        network,
-      })
-      break
-    default:
-      throw new Error("address type is incorrect")
-  }
-  return addressObject
-}
-
-function createAddressObjectByPublicKey(
-  { addressType, publicKey },
-  network = bitcoin.networks.bitcoin,
-) {
-  let addressObject
-
-  switch (addressType) {
-    case "p2pkh":
-      addressObject = bitcoin.payments.p2pkh({
-        pubkey: publicKey,
-        network,
-      })
-      break
-    case "p2wpkh":
-      addressObject = bitcoin.payments.p2wpkh({
-        pubkey: publicKey,
-        network,
-      })
-      break
-    case "p2sh-p2wpkh":
-      addressObject = bitcoin.payments.p2sh({
-        redeem: bitcoin.payments.p2wpkh({
-          pubkey: publicKey,
-          network,
-        }),
-      })
-      break
-    default:
-      throw new Error("address type is incorrect")
-  }
-  return addressObject
-}
-
-function createAddressObjectByAddress(address, network = bitcoin.networks.bitcoin) {
-  let addressType = getAddressType(address, network)
-  let addressObject
-  switch (addressType) {
-    case "p2pkh":
-      addressObject = bitcoin.payments.p2pkh({
-        address,
-        network,
-      })
-      break
-    case "p2wpkh":
-      addressObject = bitcoin.payments.p2wpkh({
-        address,
-        network,
-      })
-      break
-    case "p2sh":
-      addressObject = bitcoin.payments.p2sh({
-        address,
-        network,
-      })
-      break
-    default:
-      throw new Error("address type is incorrect")
-  }
-  return { addressObject, addressType }
-}
-
-function getPublicKeyHexByXpubAndIndex(
-  xpub,
+export function getPublicKeyHexByXpubAndIndex(
+  xpub: string,
   index = 0,
   isChange = false,
   network = networks.bitcoin,
@@ -220,22 +119,32 @@ function getPublicKeyHexByXpubAndIndex(
     .publicKey.toString("hex")
 }
 
-function getPubKeyFromPrivateKeyWIF(privateKeyWIF, network = bitcoin.networks.bitcoin) {
+export function getPubKeyFromPrivateKeyWIF(
+  privateKeyWIF: string,
+  network = bitcoin.networks.bitcoin,
+) {
   let key = bitcoin.ECPair.fromWIF(privateKeyWIF, network)
   return key.publicKey
 }
 
-function getPubKeyFromPrivateKeyHex(privateKeyHex, network = bitcoin.networks.bitcoin) {
-  let key = bitcoin.ECPair.fromPrivateKey(Buffer.from(privateKeyHex, "hex"), network)
+export function getPubKeyFromPrivateKeyHex(
+  privateKeyHex: string,
+  network = bitcoin.networks.bitcoin,
+) {
+  let key = bitcoin.ECPair.fromPrivateKey(Buffer.from(privateKeyHex, "hex"), { network })
   return key.publicKey
 }
 
-function getPrivateKeyHexFromWIF(privateKeyWIF, network = bitcoin.networks.bitcoin) {
+export function getPrivateKeyHexFromWIF(privateKeyWIF: string, network = bitcoin.networks.bitcoin) {
   let key = bitcoin.ECPair.fromWIF(privateKeyWIF, network)
-  return key.privateKey.toString("hex")
+  return key.privateKey!.toString("hex")
 }
 
-function calculateMerkleProof(blockTransactions, txId, blockMerkleRoot = undefined) {
+export function calculateMerkleProof(
+  blockTransactions: string[],
+  txId: string,
+  blockMerkleRoot?: string,
+) {
   let transactionIndex = blockTransactions.findIndex((tx) => tx === txId)
   if (transactionIndex < 0) throw new Error("txId is not in this tree")
   let data = blockTransactions.map((a) => Buffer.from(a, "hex").reverse())
@@ -244,17 +153,17 @@ function calculateMerkleProof(blockTransactions, txId, blockMerkleRoot = undefin
     blockMerkleRoot &&
     blockMerkleRoot !== fastRoot(data, bitcoin.crypto.hash256).toString("hex")
   ) {
-    throw new Error("calculated anf block merkleRoot not matched")
+    throw new Error("calculated merkleRoot and block merkleRoot not matched")
   }
 
   let tree = merkle(data, bitcoin.crypto.hash256)
   let proof = merkleProof(tree, data[transactionIndex])
 
   let intermediateNodesArray = proof
-    .map((_id) => _id && _id.toString("hex"))
-    .filter((_id) => _id != null)
-  let intermediateNodes = intermediateNodesArray.reduce(
-    (a, value, index) =>
+    .map((_id?: Buffer) => _id && _id.toString("hex"))
+    .filter((_id?: Buffer) => _id != null)
+  let intermediateNodes: string = intermediateNodesArray.reduce(
+    (a: string, value: string, index: number) =>
       index !== transactionIndex % 2 && index < intermediateNodesArray.length - 1 ? a + value : a,
     "0x",
   )
@@ -264,8 +173,10 @@ function calculateMerkleProof(blockTransactions, txId, blockMerkleRoot = undefin
   }
 }
 
-function parseBlockHeader(headerHex) {
-  const size = {
+export function parseBlockHeader(headerHex: string) {
+  const size: {
+    [key: string]: number
+  } = {
     version: 4,
     previousBlockHash: 32,
     merkleRoot: 32,
@@ -274,32 +185,45 @@ function parseBlockHeader(headerHex) {
     nonce: 4,
   }
   let offset = 0
-  let result = {}
+  let result: {
+    [key: string]: string
+  } = {}
   for (let key in size) {
     result[key] = headerHex.slice(offset, offset + size[key] * 2)
     offset += size[key] * 2
   }
-  return result
+  return result as {
+    version: string
+    previousBlockHash: string
+    merkleRoot: string
+    timestamp: string
+    difficulty: string
+    nonce: string
+  }
 }
 
-function convertBitcoinScriptToAddress(script, network = bitcoin.networks.bitcoin) {
+export function convertBitcoinScriptToAddress(script: Buffer, network = bitcoin.networks.bitcoin) {
   try {
-    return bitcoin.address?.fromOutputScript(script, network)
+    return bitcoin.address.fromOutputScript(script, network)
   } catch (error) {
     return null
   }
 }
 
-function parseRawBlock(rawBlockHex, blockNumber = undefined, network = bitcoin.networks.network) {
+export function parseRawBlock(
+  rawBlockHex: string,
+  blockNumber?: number,
+  network = bitcoin.networks.bitcoin,
+) {
   let block = bitcoin.Block.fromBuffer(Buffer.from(rawBlockHex, "hex"))
   let blockHash = block.getHash().toString("hex")
-  let merkleRoot = block.merkleRoot.toString("hex")
-  let prvBlockHash = block.prevHash.toString("hex")
+  let merkleRoot = block.merkleRoot!.toString("hex")
+  let prvBlockHash = block.prevHash!.toString("hex")
   return {
     blockNumber,
     merkleRoot,
     prvBlockHash,
-    transactions: block.transactions.map((tx) => ({
+    transactions: block.transactions?.map((tx) => ({
       txId: tx.getId(),
       version: tx.version,
       locktime: tx.locktime,
@@ -319,23 +243,23 @@ function parseRawBlock(rawBlockHex, blockNumber = undefined, network = bitcoin.n
   }
 }
 
-function extractTransactionsAndBlockInfoFromRawBlock(
-  rawBlockHex,
-  blockNumber,
-  addresses = [],
-  /**
-   * inputTxIds = {
-   * txId : string
-   * index: number
-   * }[]
-   */
-  inputTxIds = [],
+export function extractTransactionsAndBlockInfoFromRawBlock(
+  rawBlockHex: string,
+  blockNumber: number,
+  addresses: string[] = [],
+  inputTxIds: {
+    txId: string
+    index: number
+    address?: string
+    script?: string
+    value?: number
+  }[] = [],
   network = bitcoin.networks.bitcoin,
 ) {
   let block = bitcoin.Block.fromBuffer(Buffer.from(rawBlockHex, "hex"))
   let blockHash = block.getHash().reverse().toString("hex")
-  let merkleRoot = block.merkleRoot.toString("hex")
-  let prvBlockHash = block.prevHash.toString("hex")
+  let merkleRoot = block.merkleRoot!.toString("hex")
+  let prvBlockHash = block.prevHash!.toString("hex")
 
   let blockInfo = {
     blockNumber,
@@ -345,17 +269,43 @@ function extractTransactionsAndBlockInfoFromRawBlock(
   }
 
   let addressScript = addresses.map((address) =>
-    createAddressObjectByAddress(address, network).addressObject.output.toString("hex"),
+    createAddressObjectByAddress(address, network).addressObject.output!.toString("hex"),
   )
 
-  let blockTxIds = block.transactions.map((tx) => tx.getId())
+  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 = []
-  let depositTxs = []
-  block.transactions.forEach((tx) => {
+  let withdrawTxs: Transaction[] = []
+  let depositTxs: Transaction[] = []
+  block.transactions?.forEach((tx) => {
     let txId = tx.getId()
 
-    let inputTxAddress
+    let inputTxAddress: string | undefined
     let isWithdraw = tx.ins.find((vi) => {
       let viTxId = Buffer.from(vi.hash).reverse().toString("hex")
       let viInput = inputTxIds.find((vin) => vin.txId === viTxId && vin.index === vi.index)
@@ -383,20 +333,20 @@ 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 || null,
+            script: viInput?.script || null,
+            value: viInput?.value || null,
           }
         }),
         address: inputTxAddress,
         addressScript: createAddressObjectByAddress(
           inputTxAddress,
           network,
-        ).addressObject.output.toString("hex"),
+        ).addressObject.output!.toString("hex"),
       })
     }
 
-    let addressIndex
+    let addressIndex: number = -1
     let isDeposit = tx.outs.find((blockTxVo) => {
       let sIndex = addressScript.findIndex(
         (addScript) => addScript === blockTxVo.script.toString("hex"),
@@ -439,7 +389,7 @@ function extractTransactionsAndBlockInfoFromRawBlock(
   }
 }
 
-function validateAddress(address, network = bitcoin.networks.bitcoin) {
+export function validateAddress(address: string, network = bitcoin.networks.bitcoin) {
   try {
     let isValid = false
     let isAddressSegwit = address.startsWith(network.bech32)
@@ -458,30 +408,201 @@ function validateAddress(address, network = bitcoin.networks.bitcoin) {
   }
 }
 
-module.exports = {
-  parseRawTransaction,
-  calculateMerkleProof,
-  createAddressObjectByHash,
-  createAddressObjectByPublicKey,
-  createAddressObjectByAddress,
-  createAddressObjectByScript,
-
-  // ------------------------
-  getAddressType,
-  getPubKeyFromPrivateKeyWIF,
-  getPubKeyFromPrivateKeyHex,
-  getPublicKeyHexByXpubAndIndex,
-  getPrivateKeyHexFromWIF,
-  reverseBytes,
-
-  parseBlockHeader,
-  generateMnemonic,
-
-  // ---------------------------
-  parseRawBlock,
-  extractTransactionsAndBlockInfoFromRawBlock,
-  // -----------------------------
-  validateAddress,
-
-  networks,
+function toXOnlyPublicKey(pubKey: Buffer) {
+  return pubKey.length === 32 ? pubKey : pubKey.slice(1, 33)
+}
+
+export function getAddressType(address: string, network = bitcoin.networks.bitcoin) {
+  if (address.startsWith(`${network.bech32}1p`)) {
+    // todo : check length - it could be p2wsh
+    return "p2tr"
+  }
+  if (address.startsWith(network.bech32)) {
+    // todo : check length - it could be p2wsh
+    return "p2wpkh"
+  }
+  let base58Data = bitcoin.address.fromBase58Check(address)
+  if (base58Data.version === Number(network.scriptHash)) {
+    return "p2sh"
+  }
+  if (base58Data.version === Number(network.pubKeyHash)) {
+    return "p2pkh"
+  }
+
+  throw new Error("invalid address")
+}
+
+export function createAddressObjectByScript(
+  { addressType, script }: { addressType: string; script: Buffer },
+  network: bitcoin.Network = bitcoin.networks.bitcoin,
+) {
+  let addressObject
+  switch (addressType) {
+    case "p2pkh":
+      addressObject = bitcoin.payments.p2pkh({
+        output: script,
+        network,
+      })
+      break
+    case "p2wpkh":
+      addressObject = bitcoin.payments.p2wpkh({
+        output: script,
+        network,
+      })
+      break
+    case "p2sh":
+      addressObject = bitcoin.payments.p2sh({
+        output: script,
+        network,
+      })
+      break
+    case "p2wsh":
+      addressObject = bitcoin.payments.p2wsh({
+        output: script,
+        network,
+      })
+      break
+    // case "p2tr":
+    //   addressObject = bitcoin.payments.p2tr({
+    //     output: script,
+    //     network,
+    //   })
+    //   break
+    default:
+      throw new Error("address type is incorrect")
+  }
+  return addressObject
+}
+
+export function createAddressObjectByHash(
+  { addressType, hash }: { addressType: string; hash: Buffer },
+  network: bitcoin.Network = bitcoin.networks.bitcoin,
+) {
+  let addressObject
+  switch (addressType) {
+    case "p2pkh":
+      addressObject = bitcoin.payments.p2pkh({
+        hash,
+        network,
+      })
+      break
+    case "p2wpkh":
+      addressObject = bitcoin.payments.p2wpkh({
+        hash,
+        network,
+      })
+      break
+    case "p2sh":
+      addressObject = bitcoin.payments.p2sh({
+        hash,
+        network,
+      })
+      break
+    case "p2wsh":
+      addressObject = bitcoin.payments.p2wsh({
+        hash,
+        network,
+      })
+      break
+    // case "p2tr":
+    //   // here hash is the public key of tweaked private key
+    //   addressObject = bitcoin.payments.p2tr({
+    //     pubkey: hash,
+    //     network,
+    //   })
+    // break
+    default:
+      throw new Error("address type is incorrect")
+  }
+  return addressObject
+}
+
+export function createAddressObjectByPublicKey(
+  { addressType, publicKey }: { addressType: string; publicKey: Buffer },
+  network: bitcoin.Network = bitcoin.networks.bitcoin,
+): bitcoin.payments.Payment {
+  let addressObject
+  switch (addressType) {
+    case "p2pkh":
+      addressObject = bitcoin.payments.p2pkh({
+        pubkey: publicKey,
+        network,
+      })
+      break
+    case "p2wpkh":
+      addressObject = bitcoin.payments.p2wpkh({
+        pubkey: publicKey,
+        network,
+      })
+      break
+    case "p2sh-p2wpkh":
+      addressObject = bitcoin.payments.p2sh({
+        redeem: bitcoin.payments.p2wpkh({
+          pubkey: publicKey,
+          network,
+        }),
+      })
+      break
+    case "p2tr":
+    // // 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")
+  }
+  return addressObject
+}
+
+export function createAddressObjectByAddress(address: string, network = bitcoin.networks.bitcoin) {
+  let addressType = getAddressType(address, network)
+  let addressObject
+  switch (addressType) {
+    case "p2pkh":
+      addressObject = bitcoin.payments.p2pkh({
+        address,
+        network,
+      })
+      break
+    case "p2wpkh":
+      addressObject = bitcoin.payments.p2wpkh({
+        address,
+        network,
+      })
+      break
+    case "p2sh":
+      addressObject = bitcoin.payments.p2sh({
+        address,
+        network,
+      })
+      break
+    // case "p2tr":
+    //   addressObject = bitcoin.payments.p2tr({
+    //     address,
+    //     network,
+    //   })
+    //   break
+    default:
+      throw new Error("address type is incorrect")
+  }
+  return { addressObject, addressType }
+}
+
+export function publicKeyConvertor(publicKeyHex: string, compressed = true) {
+  let pubkey = ECPair.fromPublicKey(Buffer.from(publicKeyHex, "hex"), {
+    compressed,
+  })
+  return pubkey.publicKey.toString("hex")
+}
+
+export const addressTypeHelper: {
+  addressTypesNumber: {
+    [key: string]: number
+  }
+  addressTypes: string[]
+} = {
+  addressTypesNumber: { p2pk: 0, p2pkh: 1, p2sh: 2, p2wpkh: 3, p2wsh: 4, p2tr: 5 },
+  addressTypes: ["p2pk", "p2pkh", "p2sh", "p2wpkh", "p2wsh", "p2tr"],
 }

package/src/index.ts

@@ -1,8 +1,5 @@
-// eslint-disable-next-line global-require
-import { default as TeleportDaoPayment } from "./teleport-dao-payments"
-import bitcoinUtils from "./bitcoin-utils"
-import BitcoinInterface from "./bitcoin-interface"
-import BitcoinInterfaceUtils from "./bitcoin-interface-utils"
-import { BitcoinBase } from "./bitcoin-base"
-
-export { TeleportDaoPayment, BitcoinInterface, BitcoinInterfaceUtils, bitcoinUtils, BitcoinBase }
+export * as bitcoinUtils from "./bitcoin-utils"
+export * from "./teleport-dao-payments"
+export * from "./bitcoin-interface"
+export * from "./bitcoin-interface-utils"
+export * from "./bitcoin-base"