@teleportdao/bitcoin 1.0.0

package/src/bitcoin-utils.js

@@ -0,0 +1,443 @@
+const bip39 = require("bip39")
+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) {
+  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) {
+  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) {
+  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) {
+  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) {
+  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 }
+}
+
+// not used
+
+async function deriveAddressFromPubKey(pubKey, network) {
+  let { address } = this.bitcoinJS.payments.p2pkh({
+    network,
+    pubkey: Buffer.from(pubKey, "hex"),
+  })
+  return address
+}
+
+async function deriveAddressFromBufferPubKey(pubKey, network) {
+  let { address } = this.bitcoinJS.payments.p2pkh({ network, pubkey: pubKey })
+  return address
+}
+
+async function getPubKeyFromPrivateKey(privateKey, network) {
+  let key = bitcoin.ECPair.fromWIF(privateKey, network)
+  return key.publicKey
+}
+
+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) {
+  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) => ({
+        address: convertBitcoinScriptToAddress(vo.script, network),
+        script: vo.script.toString("hex"),
+        value: vo.value,
+      })),
+      vin: tx.ins.map((vi) => ({
+        txId: vi.hash.reverse().toString("hex"),
+        index: vi.index,
+        // // todo optional get from utxo
+        // address: null,
+        // script: null,
+        // value: null,
+      })),
+    })),
+  }
+}
+
+function extractTransactionsAndBlockInfoFromRawBlock(
+  rawBlockHex,
+  blockNumber,
+  addresses = [],
+  inputs = [],
+  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 transactionAddressIndex
+
+    // todo : withdraw txs not working (we cant use utxo here)
+    let txVinInput = inputs.find((vin) => vin.txId === txId)
+    if (txVinInput) {
+      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 viInput = inputs.find((vin) => vin.txId === txId)
+          return {
+            txId: vi.hash.reverse().toString("hex"),
+            index: vi.index,
+            address: viInput.address || null,
+            script: viInput.script || null,
+            value: viInput.value || null,
+          }
+        }),
+        address: txVinInput.address,
+        addressScript: createAddressObjectByAddress(
+          txVinInput.address,
+          network,
+        ).addressObject.output.toString("hex"),
+      })
+    } else if (
+      tx.outs.findIndex((blockTxVo) => {
+        let sIndex = addressScript.findIndex(
+          (addScript) => addScript === blockTxVo.script.toString("hex"),
+        )
+        if (sIndex >= 0) {
+          transactionAddressIndex = sIndex
+          return true
+        }
+        return false
+      }) >= 0
+    ) {
+      // todo we can optimize this calculation (in following function, merkle tree calculate each times but we can do this once for this 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: vi.hash.reverse().toString("hex"),
+          index: vi.index,
+          // // todo optional get from utxo
+          // address: null,
+          // script: null,
+          // value: null,
+        })),
+        addressScript: addressScript[transactionAddressIndex],
+        address: addresses[transactionAddressIndex],
+      })
+    }
+  })
+  return {
+    blockInfo,
+    withdrawTxs,
+    depositTxs,
+  }
+}
+
+module.exports = {
+  parseRawTransaction,
+  calculateMerkleProof,
+  createAddressObjectByHash,
+  createAddressObjectByPublicKey,
+  createAddressObjectByAddress,
+  createAddressObjectByScript,
+
+  // ------------------------
+  getAddressType,
+  deriveAddressFromPubKey,
+  deriveAddressFromBufferPubKey,
+  getPubKeyFromPrivateKey,
+  reverseBytes,
+
+  parseBlockHeader,
+  generateMnemonic,
+
+  // ---------------------------
+  parseRawBlock,
+  extractTransactionsAndBlockInfoFromRawBlock,
+
+  // -----------------------------
+  networks,
+}

package/src/helper/burn-request-helper.js

@@ -0,0 +1,27 @@
+function getBurnTransactionInfo(address, vin = [], vouts = []) {
+  let lockerVinIndex = vin.findIndex((vi) => vi.address === address)
+  if (lockerVinIndex >= 0) {
+    let lockerVin = vin[lockerVinIndex]
+    lockerVin.vinIndex = lockerVinIndex
+    let totalInputValue = vin.reduce((acc, current) => +acc + +current.value, 0)
+    let receivers = []
+    let changes = []
+    for (let i in vouts) {
+      let vout = {
+        ...vouts[i],
+        index: i,
+      }
+      if (vout.address === address) {
+        changes.push(vout)
+      } else {
+        receivers.push(vout)
+      }
+    }
+    return { receivers, changes, totalInputValue, lockerVin }
+  }
+  return null
+}
+
+module.exports = {
+  getBurnTransactionInfo,
+}

package/src/helper/teleport-request-helper.js

@@ -0,0 +1,162 @@
+const { requestTypes: teleportRequestsType } = require("@teleportdao/configs").teleswap
+
+function parseTeleportAndExchangeRequest(data) {
+  let parsedData = {}
+  parsedData.requestType = "transfer"
+
+  let offset = 0
+  parsedData.chainId = Number(`0x${data.slice(offset, (offset += 2))}`) // 1 bytes
+  parsedData.appId = Number(`0x${data.slice(offset, (offset += 4))}`) // 2 bytes
+  parsedData.recipientAddress = `0x${data.slice(offset, (offset += 40))}` // 20 bytes
+  parsedData.percentageFee = Number(`0x${data.slice(offset, (offset += 4))}`) / 100 // 2 bytes
+  parsedData.speed = data.slice(offset, (offset += 2)) === "01" // 1 byte
+  if (data.length === offset) {
+    return {
+      status: true,
+      data: parsedData,
+    }
+  }
+
+  parsedData.requestType = "exchange"
+  parsedData.exchangeTokenAddress = `0x${data.slice(offset, (offset += 40))}` // 20 bytes
+  parsedData.outputAmount = Number(`0x${data.slice(offset, (offset += 56))}`) // 28 bytes
+  parsedData.deadline = Number(`0x${data.slice(offset, (offset += 8))}`) // 4 bytes
+  parsedData.isFixedToken = data.slice(offset, (offset += 2)) === "01" // 1 byte
+  if (data.length === offset) {
+    return {
+      status: true,
+      data: parsedData,
+    }
+  }
+
+  return {
+    status: false,
+    message: `invalid OP_RETURN data for requestType: 'transfer or exchange'. invalid data length : ${data.length} - valid length : ${offset}`,
+    code: "INVALID_OP_RETURN",
+  }
+}
+
+function parseLendAndBorrowRequest(data) {
+  let parsedData = {}
+  parsedData.requestType = "lend"
+
+  let offset = 0
+  parsedData.chainId = Number(`0x${data.slice(offset, (offset += 2))}`) // 1 bytes
+  parsedData.appId = Number(`0x${data.slice(offset, (offset += 4))}`) // 2 bytes
+  parsedData.recipientAddress = `0x${data.slice(offset, (offset += 40))}` // 20 bytes
+  parsedData.percentageFee = Number(`0x${data.slice(offset, (offset += 4))}`) / 100 // 2 bytes
+  parsedData.mode = Number(`0x${data.slice(offset, (offset += 2))}`) // 1 byte
+  if (data.length === offset) {
+    return {
+      status: true,
+      data: parsedData,
+    }
+  }
+  parsedData.requestType = "borrow"
+  parsedData.tokenAddress = `0x${data.slice(offset, (offset += 40))}` // 20 bytes
+  parsedData.borrowAmount = Number(`0x${data.slice(offset, (offset += 56))}`) // 28 bytes
+  if (data.length === offset) {
+    return {
+      status: true,
+      data: parsedData,
+    }
+  }
+  return {
+    status: false,
+    message: `invalid OP_RETURN data for requestType: 'lend or borrow'. invalid data length : ${data.length} - valid length : ${offset}`,
+    code: "INVALID_OP_RETURN",
+  }
+}
+
+function parseRawRequest(opReturnData) {
+  let data = opReturnData.slice(2, 4) === "4c" ? opReturnData.slice(6) : opReturnData.slice(4)
+
+  // eslint-disable-next-line no-unused-vars
+  let _chainId = Number(`0x${data.slice(0, 2)}`) // 1 bytes
+  let appIdHex = data.slice(2, 6) // 2 bytes
+  if (!appIdHex) {
+    return {
+      status: false,
+      message: `invalid OP_RETURN data : ${data}`,
+      code: "INVALID_APP_ID",
+    }
+  }
+
+  let appId = Number(`0x${appIdHex}`) // 2 bytes
+
+  //   get type base on appId
+  let requestType = teleportRequestsType.find(
+    (rs) => appId >= rs.appIdRange[0] && appId <= rs.appIdRange[1],
+  )?.type
+
+  switch (requestType) {
+    case "teleport":
+    case "exchange":
+      return parseTeleportAndExchangeRequest(data)
+    case "lend":
+      return parseLendAndBorrowRequest(data)
+    default:
+      return {
+        status: false,
+        message: `invalid appId : ${appId}`,
+        code: "INVALID_OP_RETURN",
+      }
+  }
+}
+
+function validateRequestAndValue(data, value, { minTeleporterFeeAmount = 0 }) {
+  if (!data) {
+    return {
+      status: false,
+      message: "no data to validate. it should not happen",
+      code: "NOT_ACCEPTED_BY_TELEPORTER",
+    }
+  }
+
+  if (+data.percentageFee > 100) {
+    return {
+      status: false,
+      message: `percentageFee greater than 100 is invalid. percentageFee: ${data.percentageFee}`,
+      code: "INVALID_FEE",
+    }
+  }
+
+  if ((data.percentageFee / 100) * +value <= minTeleporterFeeAmount) {
+    return {
+      status: false,
+      message: `fee amount is less than or equal minimum teleporter fee amount.percentageFee: ${
+        data.percentageFee
+      } - value: ${value} - feeAmount  ${((data.percentageFee / 100) * +value).toFixed(
+        8,
+      )} - minimumFee: ${minTeleporterFeeAmount}`,
+      code: "NOT_ACCEPTED_BY_TELEPORTER",
+    }
+  }
+
+  return {
+    status: true,
+    data,
+    value,
+  }
+}
+
+function checkAndParseProtocolRequest(vouts, address, config = { minTeleporterFeeAmount: 0 }) {
+  let opReturnData = vouts.find((vout_) => vout_.script.startsWith("6a"))?.script || null
+  if (opReturnData) {
+    let value = vouts.find((vout_) => vout_.address === address)?.value || 0
+    let dataResponse = parseRawRequest(opReturnData)
+    if (dataResponse.status) {
+      return validateRequestAndValue(dataResponse.data, value, config)
+    }
+    return dataResponse
+  }
+  return {
+    status: false,
+    message: "transaction outputs should contain OP_RETURN",
+    code: "NO_OP_RETURN",
+  }
+}
+
+module.exports = {
+  checkAndParseProtocolRequest,
+}

package/src/index.js

@@ -0,0 +1,15 @@
+// eslint-disable-next-line global-require
+global.Buffer = global.Buffer || require("buffer").Buffer
+const TeleportDaoPayment = require("./teleport-dao-payments")
+const bitcoinUtils = require("./bitcoin-utils")
+const BitcoinInterface = require("./bitcoin-interface")
+const BitcoinInterfaceUtils = require("./bitcoin-interface-utils")
+const BitcoinBase = require("./bitcoin-base")
+
+module.exports = {
+  TeleportDaoPayment,
+  BitcoinInterface,
+  BitcoinInterfaceUtils,
+  bitcoinUtils,
+  BitcoinBase,
+}

package/src/sign/sign-transaction.js

@@ -0,0 +1,36 @@
+const bitcoin = require("bitcoinjs-lib")
+
+class BitcoinLikeSignTransaction {
+  constructor(network) {
+    this.network = network
+  }
+
+  async signPsbt(extendedUnsignedTransaction, privateKey) {
+    const { network } = this
+    const keyPair = bitcoin.ECPair.fromPrivateKey(privateKey, {
+      network,
+      compressed: true,
+    })
+    const psbt = bitcoin.Psbt.fromBase64(extendedUnsignedTransaction.unsignedTransaction, {
+      network,
+    })
+    psbt.signAllInputs(keyPair)
+
+    const partialSigendPsbt = psbt.toBase64()
+    return partialSigendPsbt
+  }
+
+  finalizePsbts(psbtsBase64 = []) {
+    const finals = psbtsBase64.map((psbtBase64) =>
+      bitcoin.Psbt.fromBase64(psbtBase64, { network: this.network }),
+    )
+    const psbt =
+      finals.length === 1
+        ? finals[0]
+        : new bitcoin.Psbt({ network: this.network }).combine(...finals)
+    psbt.finalizeAllInputs()
+    return psbt.extractTransaction().toHex()
+  }
+}
+
+module.exports = BitcoinLikeSignTransaction