@teleportdao/bitcoin 1.4.0 → 1.4.4

package/src/transaction-builder/transaction-builder.ts

@@ -0,0 +1,490 @@
+/* eslint-disable no-underscore-dangle */
+import * as bitcoin from "bitcoinjs-lib"
+
+import { createAddressObjectByPublicKey, getAddressType } from "../bitcoin-utils"
+
+const coinselect = require("coinselect")
+const coinselectSplit = require("coinselect/split")
+const coinselectAccumulative = require("coinselect/accumulative")
+
+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,
+}
+
+export type Utxo = {
+  hash: string
+  value: number
+  index: number
+}
+export type SignerInfo = {
+  address: string
+  publicKey: string
+  addressType: string
+  derivationPath?: string
+  masterFingerprint?: string
+}
+export type ExtendedUtxo = {
+  signerInfo: SignerInfo
+  hash: string
+  value: number
+  index: number
+}
+
+export type TargetAddress = {
+  address: string
+  value: number
+}
+
+export type TargetScript = {
+  script: Buffer
+  value: number
+}
+export type Target = TargetAddress | TargetScript
+
+export type BitcoinJSInputInfo = ExtendedUtxo & {
+  bip32Derivation?: {
+    path: string
+    pubkey: Buffer
+    masterFingerprint: Buffer
+  }[]
+  nonWitnessUtxo?: Buffer
+  witnessUtxo?: {
+    script: Buffer
+    value: number
+  }
+  redeemScript?: Buffer
+  tapInternalKey?: Buffer
+}
+
+export type ExtendedUnsignedTransaction = {
+  unsignedTransaction: string
+  outputs: Target[]
+  inputs: {
+    hash: string
+    value: number
+    index: number
+    signerInfo: SignerInfo
+  }[]
+  fee: number
+  change: TargetAddress | undefined
+}
+
+class BaseBitcoinLikeTransaction {
+  testnet: boolean
+  network: bitcoin.Network
+  maximumNumberOfOutputsInTransaction: number
+  feeMin: number
+  dustLimit: number
+  // abstract
+  constructor({
+    network,
+    testnet,
+    feeMin = 0,
+    dustLimit,
+    maximumNumberOfOutputsInTransaction = 50,
+  }: {
+    network: bitcoin.Network
+    testnet: boolean
+    feeMin?: number
+    dustLimit?: number
+    maximumNumberOfOutputsInTransaction?: number
+  }) {
+    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: string): Promise<Utxo[]> {
+    // 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: string): Promise<string> {
+    // 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(input: { addressType: string; publicKey: Buffer }) {
+    return createAddressObjectByPublicKey(input, this.network)
+  }
+
+  // methods
+  validateAddress(address: string) {
+    try {
+      getAddressType(address)
+      return true
+    } catch (error) {
+      return false
+    }
+  }
+
+  getOpReturnTarget(dataHex: string) {
+    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,
+    }
+  }
+
+  async getExtendedUtxo(signerInfo: 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
+  }
+
+  static helperHandleInputsAndOutputs({
+    targets,
+    extendedUtxo,
+    feeRate,
+    changeAddress,
+    selectType = "normal", // "accumulative" | "normal" | "full"
+  }: {
+    extendedUtxo: ExtendedUtxo[]
+    targets: Target[]
+    feeRate: number
+    changeAddress?: string
+    selectType?: "normal" | "accumulative" | "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":
+        if (!(targets[0] as TargetAddress).address) {
+          throw new Error()
+        }
+        selectResponse = coinselectSplit(
+          extendedUtxo,
+          [{ address: (targets[0] as TargetAddress).address }],
+          Math.round(feeRate),
+        )
+        break
+
+      default:
+        break
+    }
+    let {
+      inputs,
+      outputs,
+      fee,
+    }: {
+      inputs?: ExtendedUtxo[]
+      outputs?: {
+        script?: Buffer
+        address?: Buffer
+        value: number
+      }[]
+      fee: number
+    } = selectResponse
+
+    if (!inputs || !outputs) {
+      throw new Error("not enough balance")
+    }
+    let changeIndex = outputs.findIndex((x) => !x?.address && !x.script && (x.value || 0) > 0)
+    let change: Target | undefined
+    if (changeIndex >= 0) {
+      if (!changeAddress) throw new Error("change address not exist")
+      change = {
+        address: changeAddress,
+        value: outputs[changeIndex].value,
+      }
+      outputs.splice(changeIndex, 1)
+    }
+
+    return {
+      inputs,
+      fee,
+      outputs: outputs as Target[],
+      change: change as TargetAddress,
+    }
+  }
+
+  async filterAndConvertTxDataToStandardFormat({
+    extendedUtxo,
+    targets,
+    changeAddress,
+    feeRate,
+    selectType,
+  }: {
+    extendedUtxo: ExtendedUtxo[]
+    targets: Target[]
+    feeRate: number
+    changeAddress?: string
+    selectType?: "normal" | "accumulative" | "full"
+  }) {
+    let {
+      inputs: filteredInputs,
+      outputs,
+      change,
+      fee,
+    } = BaseBitcoinLikeTransaction.helperHandleInputsAndOutputs({
+      targets,
+      extendedUtxo,
+      feeRate,
+      changeAddress,
+      selectType,
+    })
+
+    let inputs = await this.convertExtendedUtxoToInputs(filteredInputs)
+
+    return {
+      inputs,
+      outputs,
+      change,
+      fee,
+      feeRate,
+    }
+  }
+
+  // ?note : we can extend this class and change this method for network other than bitcoin
+  async convertExtendedUtxoToInputs(baseInputs: ExtendedUtxo[] = []) {
+    let inputs: BitcoinJSInputInfo[] = baseInputs
+    let transactionId: string | null = null
+    let transactionHex: string | null = null
+    for (let i in inputs) {
+      let { address, publicKey, derivationPath, masterFingerprint, addressType } =
+        inputs[i].signerInfo
+      // todo : support without publicKey
+      let addressObject = this.createAddressObject({
+        publicKey: Buffer.from(publicKey, "hex"),
+        addressType,
+      })
+      if (derivationPath && masterFingerprint && addressObject.pubkey) {
+        inputs[i].bip32Derivation = [
+          {
+            path: derivationPath,
+            pubkey: addressObject.pubkey,
+            masterFingerprint: Buffer.from(masterFingerprint, "hex"),
+          },
+        ]
+      }
+      if (addressType === "p2pkh") {
+        // add p2pkh data
+        if (transactionHex && transactionId === inputs[i].hash) {
+          inputs[i].nonWitnessUtxo = Buffer.from(transactionHex, "hex")
+        } else {
+          transactionHex = await this._getTransactionHex(inputs[i].hash)
+          transactionId = inputs[i].hash
+          inputs[i].nonWitnessUtxo = Buffer.from(transactionHex, "hex")
+        }
+      } else if (addressType === "p2wpkh") {
+        // add p2wpkh data
+        if (!addressObject.output) throw new Error("invalid signer info")
+        inputs[i].witnessUtxo = {
+          script: addressObject.output,
+          value: inputs[i].value,
+        }
+      } else if (addressType === "p2sh-p2wpkh") {
+        // add p2sh-p2wpkh data
+        if (!addressObject.output) throw new Error("invalid signer info")
+        inputs[i].witnessUtxo = {
+          script: addressObject.output,
+          value: inputs[i].value,
+        }
+        if (!addressObject?.redeem?.output) throw new Error("invalid signer info for p2sh address")
+        inputs[i].redeemScript = addressObject.redeem.output
+      } else if (addressType === "p2tr") {
+        if (!addressObject.output) throw new Error("invalid signer info")
+        inputs[i].witnessUtxo = {
+          script: addressObject.output,
+          value: inputs[i].value,
+        }
+        if (!addressObject.pubkey) throw new Error("invalid signer info for p2tr address (pubkey)")
+        // todo: fix after update to p2tr
+        inputs[i].tapInternalKey = Buffer.from(publicKey, "hex")
+      }
+    }
+
+    return inputs
+  }
+
+  // ?note : we can extend this class and change this method for network other than bitcoin
+  createUnsignedTransaction({
+    inputs,
+    outputs,
+    change,
+    fee, // not used  in this section - just returned
+    feeRate,
+  }: {
+    inputs: BitcoinJSInputInfo[]
+    outputs: Target[]
+    change?: TargetAddress
+    fee: number
+    feeRate: number
+  }) {
+    const { network } = this
+    const newPsbt = new bitcoin.Psbt({ network })
+    newPsbt.setMaximumFeeRate(+(feeRate + feeRate / 100).toFixed())
+    // 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,
+            bip32Derivation: input.bip32Derivation,
+          }
+          if (!i.bip32Derivation) delete i.bip32Derivation
+          newPsbt.addInput(i)
+          break
+        }
+        case "p2wpkh": {
+          let i = {
+            hash: input.hash,
+            index: Number(input.index),
+            witnessUtxo: input.witnessUtxo,
+            sequence: 0xffffffff - 1,
+            bip32Derivation: input.bip32Derivation,
+          }
+          if (!i.bip32Derivation) delete i.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,
+            bip32Derivation: input.bip32Derivation,
+          }
+          if (!i.bip32Derivation) delete i.bip32Derivation
+          newPsbt.addInput(i)
+          break
+        }
+        case "p2tr": {
+          let i = {
+            hash: input.hash,
+            index: Number(input.index),
+            witnessUtxo: input.witnessUtxo,
+            tapInternalKey: input.tapInternalKey,
+            sequence: 0xffffffff - 1,
+            bip32Derivation: input.bip32Derivation,
+          }
+          if (!i.bip32Derivation) delete i.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
+    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((utx) => ({
+        hash: utx.hash,
+        value: Number(utx.value),
+        index: utx.index,
+        signerInfo: utx.signerInfo,
+      })),
+      fee,
+      change,
+    }
+  }
+
+  async processUnsignedTransaction({
+    extendedUtxo,
+    targets = [],
+    changeAddress = undefined,
+    fullAmount = false,
+    feeRate,
+    selfTransaction = false,
+    selectType = "normal",
+  }: {
+    extendedUtxo: ExtendedUtxo[]
+    targets: Target[]
+    feeRate: number
+
+    changeAddress?: string
+    fullAmount?: boolean
+    selfTransaction?: boolean
+    selectType?: "normal" | "accumulative" | "full"
+  }) {
+    if (!selfTransaction && targets.length === 0) throw new Error("no target")
+
+    const { inputs, outputs, change, fee } = await this.filterAndConvertTxDataToStandardFormat({
+      extendedUtxo,
+      targets,
+      changeAddress,
+      feeRate,
+      selectType: fullAmount ? "full" : selectType,
+    })
+    let unsignedTransaction = this.createUnsignedTransaction({
+      inputs,
+      outputs,
+      change,
+      fee,
+      feeRate,
+    })
+
+    return unsignedTransaction
+  }
+}
+
+export default BaseBitcoinLikeTransaction

package/src/index.js

@@ -1,15 +0,0 @@
-// 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

@@ -1,36 +0,0 @@
-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

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

@@ -1,37 +0,0 @@
-const BaseTransactionBuilder = require("./transaction-builder")
-const BitcoinInterface = require("../bitcoin-interface")
-
-class BitcoinTransactionBuilder extends BaseTransactionBuilder {
-  constructor(connectionInfo, networkName, network) {
-    super({
-      network,
-      testnet: networkName?.includes("_testnet"),
-      dustLimit: 1000,
-    })
-    this.btcInterface = new BitcoinInterface(connectionInfo, networkName)
-  }
-
-  async _getUtxo(userAddress) {
-    let utxos = await this.btcInterface.getAddressesUtxo([userAddress])
-    return utxos.map((tx) => ({
-      hash: tx.txId,
-      value: tx.value,
-      index: tx.index,
-    }))
-  }
-
-  async _getFeeRate(speed) {
-    return this.btcInterface.getFeeRate(speed)
-  }
-
-  async _getTransactionHex(transactionId) {
-    return this.btcInterface.provider.getRawTransaction(transactionId)
-  }
-
-  async sendTx(txHex) {
-    let txId = await this.btcInterface.provider.sendRawTransaction(txHex)
-    return txId
-  }
-}
-
-module.exports = BitcoinTransactionBuilder