@teleportdao/bitcoin 1.4.3 → 1.4.6

package/src/transaction-builder/transaction-builder-common.js

@@ -1,236 +0,0 @@
-/* eslint-disable no-underscore-dangle */
-
-const bitcoin = require("bitcoinjs-lib")
-const coinselect = require("coinselect")
-const coinselectSplit = require("coinselect/split")
-const coinselectAccumulative = require("coinselect/accumulative")
-
-const { createAddressObjectByPublicKey } = require("../bitcoin-utils")
-
-const TX_EMPTY_SIZE = 4 + 1 + 1 + 4
-const TX_INPUT_BASE = 32 + 4 + 1 + 4
-const TX_INPUT_P2PKH = 107
-const TX_INPUT_P2SH_P2PKH = 50
-const TX_INPUT_P2WPKH = 47
-const TX_OUTPUT_BASE = 8 + 1
-const TX_OUTPUT_P2PKH = 25
-
-const componentBytes = {
-  bytePerInput: {
-    p2pkh: TX_INPUT_BASE + TX_INPUT_P2PKH,
-    p2wpkh: TX_INPUT_BASE + TX_INPUT_P2WPKH,
-    p2shp2wpkh: TX_INPUT_BASE + TX_INPUT_P2SH_P2PKH,
-  },
-  baseTxBytes: TX_EMPTY_SIZE,
-  bytePerOutput: TX_OUTPUT_BASE + TX_OUTPUT_P2PKH,
-}
-
-class BaseBitcoinLikeTransaction {
-  // abstract
-  constructor({
-    network,
-    testnet,
-    feeMin = 0,
-    dustLimit,
-    maximumNumberOfOutputsInTransaction = 50,
-  }) {
-    this.testnet = testnet
-    this.network = network
-    this.maximumNumberOfOutputsInTransaction = maximumNumberOfOutputsInTransaction
-    this.feeMin = feeMin
-    this.dustLimit = dustLimit || 1 * 2 * componentBytes.bytePerInput.p2pkh
-  }
-
-  // eslint-disable-next-line no-unused-vars, class-methods-use-this
-  async _getUtxo(userAddress) {
-    // The child has implemented this method.
-    throw new Error("Do not call abstract method directly")
-    // return utxo
-  }
-
-  // eslint-disable-next-line no-unused-vars, class-methods-use-this
-  async _getTransactionHex(transactionId) {
-    // The child has implemented this method.
-    throw new Error("Do not call abstract method directly")
-    // return utxo
-  }
-
-  // eslint-disable-next-line no-unused-vars, class-methods-use-this
-  async convertBaseInputsToInputs(baseInputs) {
-    // The child has implemented this method.
-    throw new Error("Do not call abstract method directly")
-    // return utxo
-  }
-
-  // eslint-disable-next-line no-unused-vars, class-methods-use-this
-  async createUnsignedTransaction(baseInputs) {
-    // The child has implemented this method.
-    throw new Error("Do not call abstract method directly")
-    // return utxo
-  }
-
-  // eslint-disable-next-line no-unused-vars, class-methods-use-this
-  createAddressObject({ addressType, publicKey }) {
-    return createAddressObjectByPublicKey({ addressType, publicKey }, this.network)
-  }
-
-  validateAddress(address) {
-    try {
-      let isValid = false
-      let network = this.network
-      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
-    }
-  }
-
-  static helperHandleInputsAndOutputs({
-    targets,
-    extendedUtxo,
-    feeRate,
-    changeAddress,
-    selectType = "normal", // "accumulative" | "normal" | "full"
-  }) {
-    let selectResponse
-    switch (selectType) {
-      case "normal":
-        selectResponse = coinselect(extendedUtxo, targets, Math.round(feeRate))
-
-        break
-      case "accumulative":
-        selectResponse = coinselectAccumulative(extendedUtxo, targets, Math.round(feeRate))
-        break
-      case "full":
-        selectResponse = coinselectSplit(
-          extendedUtxo,
-          [{ address: targets[0].address }],
-          Math.round(feeRate),
-        )
-        break
-
-      default:
-        break
-    }
-    let { inputs, outputs, fee } = selectResponse
-
-    if (!inputs || !outputs) {
-      throw new Error("not enough balance")
-    }
-    let changeIndex = outputs.findIndex((x) => !x.address && !x.script && x.value > 0)
-    let change
-    if (changeIndex >= 0) {
-      change = {
-        address: changeAddress,
-        value: outputs[changeIndex].value,
-      }
-      outputs.splice(changeIndex, 1)
-    }
-
-    return {
-      inputs,
-      fee,
-      outputs,
-      change,
-    }
-  }
-
-  async getExtendedUtxo(signerInfo) {
-    let utxo = await this._getUtxo(signerInfo.address)
-    const extendedUtxo = utxo.map((input) => ({
-      ...input,
-      signerInfo,
-    }))
-    if (!extendedUtxo || extendedUtxo.length === 0) {
-      throw new Error("no utxo found")
-    }
-    return extendedUtxo
-  }
-
-  /**
-   *
-   * @param {*} param0
-   * @returns
-   */
-  async convertUtxoToInput({ extendedUtxo, targets, changeAddress, feeRate, selectType }) {
-    let {
-      inputs: filteredInputs,
-      outputs,
-      change,
-      fee,
-    } = BaseBitcoinLikeTransaction.helperHandleInputsAndOutputs({
-      targets,
-      extendedUtxo,
-      feeRate,
-      changeAddress,
-      selectType,
-    })
-
-    let inputs = await this.convertBaseInputsToInputs(filteredInputs)
-
-    return {
-      inputs,
-      outputs,
-      change,
-      fee,
-      feeRate,
-    }
-  }
-
-  /**
-   *
-   * @param {*} param0
-   * @returns
-   */
-  async processUnsignedTransaction({
-    extendedUtxo,
-    targets = [],
-    changeAddress = undefined,
-    fullAmount = false,
-    feeRate,
-    selfTransaction = false,
-    selectType = "normal",
-  }) {
-    if (!selfTransaction && targets.length === 0) throw new Error("no target")
-
-    const { inputs, outputs, change, fee } = await this.convertUtxoToInput({
-      extendedUtxo,
-      targets,
-      changeAddress,
-      feeRate,
-      selectType: fullAmount ? "full" : selectType,
-    })
-    let unsignedTransaction = await this.createUnsignedTransaction({
-      inputs,
-      outputs,
-      change,
-      fee,
-      feeRate,
-    })
-
-    return unsignedTransaction
-  }
-
-  getOpReturnTarget(dataHex) {
-    if (!dataHex.length > 0) throw new Error("invalid data in hex")
-    const embed = bitcoin.payments.embed({
-      data: [Buffer.from(dataHex, "hex")],
-      network: this.network,
-    })
-    return {
-      script: embed.output,
-      value: 0,
-    }
-  }
-}
-
-module.exports = BaseBitcoinLikeTransaction

package/src/transaction-builder/transaction-builder.js

@@ -1,159 +0,0 @@
-const bitcoin = require("bitcoinjs-lib")
-const BaseBitcoinLikeTransactionBuilderCommon = require("./transaction-builder-common")
-
-class BaseBitcoinLikeTransaction extends BaseBitcoinLikeTransactionBuilderCommon {
-  async convertBaseInputsToInputs(baseInputs = []) {
-    let inputs = baseInputs
-    let transactionId = null
-    let transactionHex = null
-    for (let i in inputs) {
-      let { address, publicKey, derivationPath, masterFingerprint, addressType } =
-        inputs[i].signerInfo
-      let addressObject = this.createAddressObject({
-        address,
-        publicKey: publicKey ? Buffer.from(publicKey, "hex") : null,
-        addressType,
-      })
-      if (derivationPath && masterFingerprint && publicKey && true) {
-        inputs[i].bip32Derivation = [
-          {
-            path: derivationPath,
-            pubkey: addressObject.pubkey,
-            masterFingerprint: Buffer.from(masterFingerprint, "hex"),
-          },
-        ]
-      }
-      if (addressType === "p2pkh") {
-        // add p2pkh data
-        if (transactionId === inputs[i].hash) {
-          inputs[i].nonWitnessUtxo = Buffer.from(transactionHex, "hex")
-        } else {
-          transactionHex = await this._getTransactionHex(inputs[i].hash)
-          inputs[i].nonWitnessUtxo = Buffer.from(transactionHex, "hex")
-          transactionId = inputs[i].hash
-        }
-      } else if (addressType === "p2wpkh") {
-        // add p2wpkh data
-        inputs[i].witnessUtxo = {
-          script: addressObject.output,
-          value: inputs[i].value,
-        }
-      } else if (addressType === "p2sh-p2wpkh") {
-        // add p2sh-p2wpkh data
-        inputs[i].witnessUtxo = {
-          script: addressObject.output,
-          value: inputs[i].value,
-        }
-        inputs[i].redeemScript = addressObject.redeem.output
-      }
-    }
-
-    return inputs
-  }
-
-  /**
-   *
-   * @param {*} param0
-   * @returns
-   */
-  createUnsignedTransaction({
-    inputs,
-    outputs,
-    change,
-    fee, // not used  in this section - just returned
-    feeRate,
-  }) {
-    const { network } = this
-    const newPsbt = new bitcoin.Psbt({ network })
-    newPsbt.setMaximumFeeRate = feeRate + feeRate / 100
-    // add input
-    for (const input of inputs) {
-      let { addressType } = input.signerInfo
-      switch (addressType) {
-        case "p2pkh": {
-          let i = {
-            hash: input.hash,
-            index: Number(input.index),
-            nonWitnessUtxo: input.nonWitnessUtxo,
-            sequence: 0xffffffff - 1,
-          }
-          if (input.bip32Derivation) i.bip32Derivation = input.bip32Derivation
-          newPsbt.addInput(i)
-          break
-        }
-        case "p2wpkh": {
-          let i = {
-            hash: input.hash,
-            index: Number(input.index),
-            witnessUtxo: input.witnessUtxo,
-            sequence: 0xffffffff - 1,
-          }
-          if (input.bip32Derivation) i.bip32Derivation = input.bip32Derivation
-          newPsbt.addInput(i)
-          break
-        }
-        case "p2sh-p2wpkh": {
-          let i = {
-            hash: input.hash,
-            index: Number(input.index),
-            witnessUtxo: input.witnessUtxo,
-            redeemScript: input.redeemScript,
-            sequence: 0xffffffff - 1,
-          }
-          if (input.bip32Derivation) i.bip32Derivation = input.bip32Derivation
-          newPsbt.addInput(i)
-          break
-        }
-        default:
-          throw new Error("address type is incorrect")
-      }
-    }
-
-    // add outputs
-    for (const target of outputs) {
-      newPsbt.addOutput(target)
-    }
-
-    // add changeAddress
-    if (change && Object.keys(change).length !== 0) {
-      newPsbt.addOutput({
-        address: change.address,
-        value: Number(change.value),
-      })
-    }
-
-    // check created outputs with targets
-    for (let i in outputs) {
-      if (newPsbt.txOutputs[i].address !== outputs[i].address) {
-        throw new Error("error address")
-      }
-      if (newPsbt.txOutputs[i].value !== outputs[i].value) {
-        throw new Error("error value")
-      }
-    }
-    if (change && Object.keys(change).length !== 0) {
-      if (newPsbt.txOutputs[outputs.length].address !== change.address) {
-        throw new Error("error change address")
-      }
-      if (newPsbt.txOutputs[outputs.length].value !== change.value) {
-        throw new Error("error change value")
-      }
-    }
-
-    const unsignedPsbtBaseText = newPsbt.toBase64()
-    return {
-      unsignedTransaction: unsignedPsbtBaseText,
-      outputs,
-      inputs: inputs.map((tx) => ({
-        hash: tx.hash,
-        value: Number(tx.value),
-        index: tx.index,
-        signerInfo: tx.signerInfo,
-      })),
-      fee,
-      change,
-    }
-  }
-}
-
-module.exports = BaseBitcoinLikeTransaction