@teleportdao/bitcoin 1.4.3 → 1.4.4

package/src/bitcoin-utils.js

@@ -1,483 +1,487 @@
-const bip39 = require("bip39")
-const bip32 = require("bip32")
-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 mnemonic = bip39.generateMnemonic(256)
-  return mnemonic
-}
-
-function parseRawTransaction(rawTransaction) {
-  const size = {
-    version: 4,
-    flag: 2,
-    tx: 32,
-    index: 4,
-    sequence: 4,
-    amount: 8,
-  }
-
-  let offset = 0
-  let version = rawTransaction.slice(offset, size.version * 2)
-  offset += size.version * 2
-  let flag = rawTransaction.slice(offset, offset + size.flag * 2)
-  offset = flag === "0001" ? offset + size.flag * 2 : offset // * 0x0001 is flag in segwit transactions
-
-  let inputsStartIndex = offset
-
-  let numberOfInputs = varUnit.decode(Buffer.from(rawTransaction.slice(offset), "hex"))
-  let noiSize = varUnit.encodingLength(numberOfInputs)
-  offset += noiSize * 2
-
-  for (let i = 0; i < numberOfInputs; i += 1) {
-    offset += size.tx * 2
-    offset += size.index * 2
-    let sigLength = varUnit.decode(Buffer.from(rawTransaction.slice(offset), "hex"))
-    let sigLengthSize = varUnit.encodingLength(sigLength)
-    offset += sigLengthSize * 2
-    offset += sigLength * 2
-    offset += size.sequence * 2
-  }
-  let inputLastIndex = offset
-  let outputStartIndex = offset
-
-  let numberOfOutputs = varUnit.decode(Buffer.from(rawTransaction.slice(offset), "hex"))
-  let nooSize = varUnit.encodingLength(numberOfOutputs)
-  offset += nooSize * 2
-
-  for (let i = 0; i < numberOfOutputs; i += 1) {
-    offset += size.amount * 2
-    let unlockSigLength = varUnit.decode(Buffer.from(rawTransaction.slice(offset), "hex"))
-    let unlockSigLengthSize = varUnit.encodingLength(unlockSigLength)
-    offset += unlockSigLengthSize * 2
-    offset += unlockSigLength * 2
-  }
-  let outputLastIndex = offset
-
-  version = `0x${version}`
-  flag = `0x${flag}`
-  const vin = `0x${rawTransaction.slice(inputsStartIndex, inputLastIndex)}`
-  const vout = `0x${rawTransaction.slice(outputStartIndex, outputLastIndex)}`
-  let witness = `0x${rawTransaction.slice(outputLastIndex, rawTransaction.length - 8)}`
-  let locktime = `0x${rawTransaction.slice(rawTransaction.length - 8, rawTransaction.length)}`
-  return { version, flag, vin, vout, witness, locktime }
-}
-
-function reverseBytes(hexInput) {
-  return Buffer.from(hexInput, "hex").reverse().toString("hex")
-}
-
-function getAddressType(address, network = bitcoin.networks.bitcoin) {
-  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,
-  index = 0,
-  isChange = false,
-  network = networks.bitcoin,
-) {
-  const node = bip32.fromBase58(xpub, network)
-  return node
-    .derive(isChange ? 1 : 0)
-    .derive(index)
-    .publicKey.toString("hex")
-}
-
-function getPubKeyFromPrivateKeyWIF(privateKeyWIF, 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)
-  return key.publicKey
-}
-
-function getPrivateKeyHexFromWIF(privateKeyWIF, network = bitcoin.networks.bitcoin) {
-  let key = bitcoin.ECPair.fromWIF(privateKeyWIF, network)
-  return key.privateKey.toString("hex")
-}
-
-function calculateMerkleProof(blockTransactions, txId, blockMerkleRoot = undefined) {
-  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())
-
-  if (
-    blockMerkleRoot &&
-    blockMerkleRoot !== fastRoot(data, bitcoin.crypto.hash256).toString("hex")
-  ) {
-    throw new Error("calculated anf 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) =>
-      index !== transactionIndex % 2 && index < intermediateNodesArray.length - 1 ? a + value : a,
-    "0x",
-  )
-  return {
-    intermediateNodes,
-    transactionIndex,
-  }
-}
-
-function parseBlockHeader(headerHex) {
-  const size = {
-    version: 4,
-    previousBlockHash: 32,
-    merkleRoot: 32,
-    timestamp: 4,
-    difficulty: 4,
-    nonce: 4,
-  }
-  let offset = 0
-  let result = {}
-  for (let key in size) {
-    result[key] = headerHex.slice(offset, offset + size[key] * 2)
-    offset += size[key] * 2
-  }
-  return result
-}
-
-function convertBitcoinScriptToAddress(script, network = bitcoin.networks.bitcoin) {
-  try {
-    return bitcoin.address?.fromOutputScript(script, network)
-  } catch (error) {
-    return null
-  }
-}
-
-function parseRawBlock(rawBlockHex, blockNumber = undefined, network = bitcoin.networks.network) {
-  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")
-  return {
-    blockNumber,
-    merkleRoot,
-    prvBlockHash,
-    transactions: block.transactions.map((tx) => ({
-      txId: tx.getId(),
-      version: tx.version,
-      locktime: tx.locktime,
-      blockNumber,
-      blockHash,
-      vout: tx.outs.map((vo, index) => ({
-        address: convertBitcoinScriptToAddress(vo.script, network),
-        script: vo.script.toString("hex"),
-        value: vo.value,
-        index,
-      })),
-      vin: tx.ins.map((vi) => ({
-        txId: Buffer.from(vi.hash).reverse().toString("hex"),
-        index: vi.index,
-      })),
-    })),
-  }
-}
-
-function extractTransactionsAndBlockInfoFromRawBlock(
-  rawBlockHex,
-  blockNumber,
-  addresses = [],
-  /**
-   * inputTxIds = {
-   * txId : string
-   * index: number
-   * }[]
-   */
-  inputTxIds = [],
-  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 blockInfo = {
-    blockNumber,
-    blockHash,
-    merkleRoot,
-    prvBlockHash,
-  }
-
-  let addressScript = addresses.map((address) =>
-    createAddressObjectByAddress(address, network).addressObject.output.toString("hex"),
-  )
-
-  let blockTxIds = block.transactions.map((tx) => tx.getId())
-
-  let withdrawTxs = []
-  let depositTxs = []
-  block.transactions.forEach((tx) => {
-    let txId = tx.getId()
-
-    let inputTxAddress
-    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)
-      inputTxAddress = viInput?.address
-      return !!inputTxAddress
-    })
-    if (isWithdraw && inputTxAddress) {
-      let txMerkleProof = calculateMerkleProof(blockTxIds, txId, merkleRoot)
-
-      withdrawTxs.push({
-        txId: tx.getId(),
-        version: tx.version,
-        locktime: tx.locktime,
-        blockNumber,
-        blockHash,
-        merkleProof: txMerkleProof,
-        vout: tx.outs.map((vo) => ({
-          address: convertBitcoinScriptToAddress(vo.script, network),
-          script: vo.script.toString("hex"),
-          value: vo.value,
-        })),
-        vin: tx.ins.map((vi) => {
-          let viTxId = Buffer.from(vi.hash).reverse().toString("hex")
-          let viInput = inputTxIds.find((vin) => vin.txId === viTxId && vin.index === vi.index)
-          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: inputTxAddress,
-        addressScript: createAddressObjectByAddress(
-          inputTxAddress,
-          network,
-        ).addressObject.output.toString("hex"),
-      })
-    }
-
-    let addressIndex
-    let isDeposit = tx.outs.find((blockTxVo) => {
-      let sIndex = addressScript.findIndex(
-        (addScript) => addScript === blockTxVo.script.toString("hex"),
-      )
-      if (sIndex >= 0) {
-        addressIndex = sIndex
-        return true
-      }
-      return false
-    })
-
-    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(),
-        version: tx.version,
-        locktime: tx.locktime,
-        blockNumber,
-        blockHash,
-        merkleProof: txMerkleProof,
-        vout: tx.outs.map((vo) => ({
-          address: convertBitcoinScriptToAddress(vo.script, network),
-          script: vo.script.toString("hex"),
-          value: vo.value,
-        })),
-        vin: tx.ins.map((vi) => ({
-          txId: Buffer.from(vi.hash).reverse().toString("hex"),
-          index: vi.index,
-        })),
-        addressScript: addressScript[addressIndex],
-        address: addresses[addressIndex],
-      })
-    }
-  })
-  return {
-    blockInfo,
-    withdrawTxs,
-    depositTxs,
-  }
-}
-
-function validateAddress(address, network = bitcoin.networks.bitcoin) {
-  try {
-    let isValid = false
-    let isAddressSegwit = address.startsWith(network.bech32)
-    if (isAddressSegwit) {
-      bitcoin.address.fromBech32(address)
-      isValid = true
-    } else {
-      let base58Data = bitcoin.address.fromBase58Check(address)
-      isValid =
-        base58Data.version === Number(network.scriptHash) ||
-        base58Data.version === Number(network.pubKeyHash)
-    }
-    return isValid
-  } catch (error) {
-    return false
-  }
-}
-
-module.exports = {
-  parseRawTransaction,
-  calculateMerkleProof,
-  createAddressObjectByHash,
-  createAddressObjectByPublicKey,
-  createAddressObjectByAddress,
-  createAddressObjectByScript,
-
-  // ------------------------
-  getAddressType,
-  getPubKeyFromPrivateKeyWIF,
-  getPubKeyFromPrivateKeyHex,
-  getPublicKeyHexByXpubAndIndex,
-  getPrivateKeyHexFromWIF,
-  reverseBytes,
-
-  parseBlockHeader,
-  generateMnemonic,
-
-  // ---------------------------
-  parseRawBlock,
-  extractTransactionsAndBlockInfoFromRawBlock,
-  // -----------------------------
-  validateAddress,
-
-  networks,
-}
+const bip39 = require("bip39")
+const bip32 = require("bip32")
+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 mnemonic = bip39.generateMnemonic(256)
+  return mnemonic
+}
+
+function parseRawTransaction(rawTransaction) {
+  const size = {
+    version: 4,
+    flag: 2,
+    tx: 32,
+    index: 4,
+    sequence: 4,
+    amount: 8,
+  }
+
+  let offset = 0
+  let version = rawTransaction.slice(offset, size.version * 2)
+  offset += size.version * 2
+  let flag = rawTransaction.slice(offset, offset + size.flag * 2)
+  offset = flag === "0001" ? offset + size.flag * 2 : offset // * 0x0001 is flag in segwit transactions
+
+  let inputsStartIndex = offset
+
+  let numberOfInputs = varUnit.decode(Buffer.from(rawTransaction.slice(offset), "hex"))
+  let noiSize = varUnit.encodingLength(numberOfInputs)
+  offset += noiSize * 2
+
+  for (let i = 0; i < numberOfInputs; i += 1) {
+    offset += size.tx * 2
+    offset += size.index * 2
+    let sigLength = varUnit.decode(Buffer.from(rawTransaction.slice(offset), "hex"))
+    let sigLengthSize = varUnit.encodingLength(sigLength)
+    offset += sigLengthSize * 2
+    offset += sigLength * 2
+    offset += size.sequence * 2
+  }
+  let inputLastIndex = offset
+  let outputStartIndex = offset
+
+  let numberOfOutputs = varUnit.decode(Buffer.from(rawTransaction.slice(offset), "hex"))
+  let nooSize = varUnit.encodingLength(numberOfOutputs)
+  offset += nooSize * 2
+
+  for (let i = 0; i < numberOfOutputs; i += 1) {
+    offset += size.amount * 2
+    let unlockSigLength = varUnit.decode(Buffer.from(rawTransaction.slice(offset), "hex"))
+    let unlockSigLengthSize = varUnit.encodingLength(unlockSigLength)
+    offset += unlockSigLengthSize * 2
+    offset += unlockSigLength * 2
+  }
+  let outputLastIndex = offset
+
+  version = `0x${version}`
+  flag = `0x${flag}`
+  const vin = `0x${rawTransaction.slice(inputsStartIndex, inputLastIndex)}`
+  const vout = `0x${rawTransaction.slice(outputStartIndex, outputLastIndex)}`
+  let witness = `0x${rawTransaction.slice(outputLastIndex, rawTransaction.length - 8)}`
+  let locktime = `0x${rawTransaction.slice(rawTransaction.length - 8, rawTransaction.length)}`
+  return { version, flag, vin, vout, witness, locktime }
+}
+
+function reverseBytes(hexInput) {
+  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,
+  index = 0,
+  isChange = false,
+  network = networks.bitcoin,
+) {
+  const node = bip32.fromBase58(xpub, network)
+  return node
+    .derive(isChange ? 1 : 0)
+    .derive(index)
+    .publicKey.toString("hex")
+}
+
+function getPubKeyFromPrivateKeyWIF(privateKeyWIF, 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)
+  return key.publicKey
+}
+
+function getPrivateKeyHexFromWIF(privateKeyWIF, network = bitcoin.networks.bitcoin) {
+  let key = bitcoin.ECPair.fromWIF(privateKeyWIF, network)
+  return key.privateKey.toString("hex")
+}
+
+function calculateMerkleProof(blockTransactions, txId, blockMerkleRoot = undefined) {
+  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())
+
+  if (
+    blockMerkleRoot &&
+    blockMerkleRoot !== fastRoot(data, bitcoin.crypto.hash256).toString("hex")
+  ) {
+    throw new Error("calculated anf 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) =>
+      index !== transactionIndex % 2 && index < intermediateNodesArray.length - 1 ? a + value : a,
+    "0x",
+  )
+  return {
+    intermediateNodes,
+    transactionIndex,
+  }
+}
+
+function parseBlockHeader(headerHex) {
+  const size = {
+    version: 4,
+    previousBlockHash: 32,
+    merkleRoot: 32,
+    timestamp: 4,
+    difficulty: 4,
+    nonce: 4,
+  }
+  let offset = 0
+  let result = {}
+  for (let key in size) {
+    result[key] = headerHex.slice(offset, offset + size[key] * 2)
+    offset += size[key] * 2
+  }
+  return result
+}
+
+function convertBitcoinScriptToAddress(script, network = bitcoin.networks.bitcoin) {
+  try {
+    return bitcoin.address?.fromOutputScript(script, network)
+  } catch (error) {
+    return null
+  }
+}
+
+function parseRawBlock(rawBlockHex, blockNumber = undefined, network = bitcoin.networks.network) {
+  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")
+  return {
+    blockNumber,
+    merkleRoot,
+    prvBlockHash,
+    transactions: block.transactions.map((tx) => ({
+      txId: tx.getId(),
+      version: tx.version,
+      locktime: tx.locktime,
+      blockNumber,
+      blockHash,
+      vout: tx.outs.map((vo, index) => ({
+        address: convertBitcoinScriptToAddress(vo.script, network),
+        script: vo.script.toString("hex"),
+        value: vo.value,
+        index,
+      })),
+      vin: tx.ins.map((vi) => ({
+        txId: Buffer.from(vi.hash).reverse().toString("hex"),
+        index: vi.index,
+      })),
+    })),
+  }
+}
+
+function extractTransactionsAndBlockInfoFromRawBlock(
+  rawBlockHex,
+  blockNumber,
+  addresses = [],
+  /**
+   * inputTxIds = {
+   * txId : string
+   * index: number
+   * }[]
+   */
+  inputTxIds = [],
+  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 blockInfo = {
+    blockNumber,
+    blockHash,
+    merkleRoot,
+    prvBlockHash,
+  }
+
+  let addressScript = addresses.map((address) =>
+    createAddressObjectByAddress(address, network).addressObject.output.toString("hex"),
+  )
+
+  let blockTxIds = block.transactions.map((tx) => tx.getId())
+
+  let withdrawTxs = []
+  let depositTxs = []
+  block.transactions.forEach((tx) => {
+    let txId = tx.getId()
+
+    let inputTxAddress
+    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)
+      inputTxAddress = viInput?.address
+      return !!inputTxAddress
+    })
+    if (isWithdraw && inputTxAddress) {
+      let txMerkleProof = calculateMerkleProof(blockTxIds, txId, merkleRoot)
+
+      withdrawTxs.push({
+        txId: tx.getId(),
+        version: tx.version,
+        locktime: tx.locktime,
+        blockNumber,
+        blockHash,
+        merkleProof: txMerkleProof,
+        vout: tx.outs.map((vo) => ({
+          address: convertBitcoinScriptToAddress(vo.script, network),
+          script: vo.script.toString("hex"),
+          value: vo.value,
+        })),
+        vin: tx.ins.map((vi) => {
+          let viTxId = Buffer.from(vi.hash).reverse().toString("hex")
+          let viInput = inputTxIds.find((vin) => vin.txId === viTxId && vin.index === vi.index)
+          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: inputTxAddress,
+        addressScript: createAddressObjectByAddress(
+          inputTxAddress,
+          network,
+        ).addressObject.output.toString("hex"),
+      })
+    }
+
+    let addressIndex
+    let isDeposit = tx.outs.find((blockTxVo) => {
+      let sIndex = addressScript.findIndex(
+        (addScript) => addScript === blockTxVo.script.toString("hex"),
+      )
+      if (sIndex >= 0) {
+        addressIndex = sIndex
+        return true
+      }
+      return false
+    })
+
+    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(),
+        version: tx.version,
+        locktime: tx.locktime,
+        blockNumber,
+        blockHash,
+        merkleProof: txMerkleProof,
+        vout: tx.outs.map((vo) => ({
+          address: convertBitcoinScriptToAddress(vo.script, network),
+          script: vo.script.toString("hex"),
+          value: vo.value,
+        })),
+        vin: tx.ins.map((vi) => ({
+          txId: Buffer.from(vi.hash).reverse().toString("hex"),
+          index: vi.index,
+        })),
+        addressScript: addressScript[addressIndex],
+        address: addresses[addressIndex],
+      })
+    }
+  })
+  return {
+    blockInfo,
+    withdrawTxs,
+    depositTxs,
+  }
+}
+
+function validateAddress(address, network = bitcoin.networks.bitcoin) {
+  try {
+    let isValid = false
+    let isAddressSegwit = address.startsWith(network.bech32)
+    if (isAddressSegwit) {
+      bitcoin.address.fromBech32(address)
+      isValid = true
+    } else {
+      let base58Data = bitcoin.address.fromBase58Check(address)
+      isValid =
+        base58Data.version === Number(network.scriptHash) ||
+        base58Data.version === Number(network.pubKeyHash)
+    }
+    return isValid
+  } catch (error) {
+    return false
+  }
+}
+
+module.exports = {
+  parseRawTransaction,
+  calculateMerkleProof,
+  createAddressObjectByHash,
+  createAddressObjectByPublicKey,
+  createAddressObjectByAddress,
+  createAddressObjectByScript,
+
+  // ------------------------
+  getAddressType,
+  getPubKeyFromPrivateKeyWIF,
+  getPubKeyFromPrivateKeyHex,
+  getPublicKeyHexByXpubAndIndex,
+  getPrivateKeyHexFromWIF,
+  reverseBytes,
+
+  parseBlockHeader,
+  generateMnemonic,
+
+  // ---------------------------
+  parseRawBlock,
+  extractTransactionsAndBlockInfoFromRawBlock,
+  // -----------------------------
+  validateAddress,
+
+  networks,
+}