@teleportdao/bitcoin 1.4.3 → 1.4.6

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

@@ -0,0 +1,61 @@
+import BaseTransactionBuilder from "./transaction-builder"
+import { BitcoinInterface } from "../bitcoin-interface"
+import * as bitcoin from "bitcoinjs-lib"
+
+export type BitcoinConnectionInfo = {
+  rpc?: {
+    enabled?: boolean
+    url: string
+    headers?: {
+      [key: string]: string
+    }
+    auth?: {
+      username: string
+      password: string
+    }
+  }
+  api: {
+    enabled?: boolean
+    token?: string
+    provider: string
+  }
+}
+class BitcoinTransactionBuilder extends BaseTransactionBuilder {
+  btcInterface: BitcoinInterface
+  constructor(
+    connectionInfo: BitcoinConnectionInfo,
+    networkName: string,
+    network = bitcoin.networks.bitcoin,
+  ) {
+    super({
+      network,
+      testnet: networkName?.includes("_testnet"),
+      dustLimit: 1000,
+    })
+    this.btcInterface = new BitcoinInterface(connectionInfo, networkName)
+  }
+
+  async _getUtxo(userAddress: string) {
+    let utxos = await this.btcInterface.getAddressesUtxo([userAddress])
+    return utxos.map((tx) => ({
+      hash: tx.txId as string,
+      value: +tx.value,
+      index: +tx.index,
+    }))
+  }
+
+  async _getFeeRate(speed: "normal" | "slow" | "fast" = "normal") {
+    return this.btcInterface.getFeeRate(speed)
+  }
+
+  async _getTransactionHex(transactionId: string): Promise<string> {
+    return this.btcInterface.provider.getRawTransaction(transactionId)
+  }
+
+  async sendTx(txHex: string): Promise<string> {
+    let txId = await this.btcInterface.provider.sendRawTransaction(txHex)
+    return txId
+  }
+}
+
+export default BitcoinTransactionBuilder

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

@@ -0,0 +1,567 @@
+/* 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
+  includeHex?: boolean
+}
+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 ChangeTarget = TargetAddress & {
+  bip32Derivation?: {
+    path: string
+    pubkey: Buffer
+    masterFingerprint: Buffer
+  }[]
+}
+
+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,
+    changeObject,
+    selectType = "normal", // "accumulative" | "normal" | "full"
+  }: {
+    extendedUtxo: ExtendedUtxo[]
+    targets: Target[]
+    feeRate: number
+    changeObject?: {
+      address: string
+      publicKey?: string
+      addressType?: string
+      derivationPath?: string
+      masterFingerprint?: 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: ChangeTarget | undefined
+    if (changeIndex >= 0) {
+      if (!changeObject) throw new Error("change not exist")
+      if (changeObject.derivationPath && changeObject.masterFingerprint && changeObject.publicKey) {
+        change = {
+          address: changeObject.address,
+          value: outputs[changeIndex].value,
+          bip32Derivation: [
+            {
+              path: changeObject.derivationPath,
+              pubkey: Buffer.from(changeObject.publicKey, "hex"),
+              masterFingerprint: Buffer.from(changeObject.masterFingerprint, "hex"),
+            },
+          ],
+        }
+      } else {
+        change = {
+          address: changeObject.address,
+          value: outputs[changeIndex].value,
+        }
+      }
+      outputs.splice(changeIndex, 1)
+    }
+
+    return {
+      inputs,
+      fee,
+      outputs: outputs as Target[],
+      change,
+    }
+  }
+
+  async filterAndConvertTxDataToStandardFormat({
+    extendedUtxo,
+    targets,
+    changeObject,
+    feeRate,
+    selectType,
+  }: {
+    extendedUtxo: ExtendedUtxo[]
+    targets: Target[]
+    feeRate: number
+    changeObject?: {
+      address: string
+      publicKey?: string
+      addressType?: string
+      derivationPath?: string
+      masterFingerprint?: string
+    }
+    selectType?: "normal" | "accumulative" | "full"
+  }) {
+    let {
+      inputs: filteredInputs,
+      outputs,
+      change,
+      fee,
+    } = BaseBitcoinLikeTransaction.helperHandleInputsAndOutputs({
+      targets,
+      extendedUtxo,
+      feeRate,
+      changeObject,
+      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 & {
+      signerInfo: SignerInfo
+    })[] = 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,
+        }
+
+        if (inputs[i].signerInfo.includeHex) {
+          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 === "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
+
+        if (inputs[i].signerInfo.includeHex) {
+          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 === "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")
+
+        if (inputs[i].signerInfo.includeHex) {
+          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")
+          }
+        }
+      }
+    }
+
+    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?: ChangeTarget
+    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,
+            // we dont need nonWitnessUtxo. bud some application force nonWitnessUtxo
+            nonWitnessUtxo: input.nonWitnessUtxo,
+            sequence: 0xffffffff - 1,
+            bip32Derivation: input.bip32Derivation,
+          }
+          if (!i.bip32Derivation) delete i.bip32Derivation
+          if (!i.nonWitnessUtxo) delete i.nonWitnessUtxo
+          newPsbt.addInput(i)
+          break
+        }
+        case "p2sh-p2wpkh": {
+          let i = {
+            hash: input.hash,
+            index: Number(input.index),
+            witnessUtxo: input.witnessUtxo,
+            // we dont need nonWitnessUtxo. bud some application force nonWitnessUtxo
+            nonWitnessUtxo: input.nonWitnessUtxo,
+            redeemScript: input.redeemScript,
+            sequence: 0xffffffff - 1,
+            bip32Derivation: input.bip32Derivation,
+          }
+          if (!i.bip32Derivation) delete i.bip32Derivation
+          if (!i.nonWitnessUtxo) delete i.nonWitnessUtxo
+          newPsbt.addInput(i)
+          break
+        }
+        case "p2tr": {
+          let i = {
+            hash: input.hash,
+            index: Number(input.index),
+            witnessUtxo: input.witnessUtxo,
+            // we dont need nonWitnessUtxo. bud some application force nonWitnessUtxo
+            nonWitnessUtxo: input.nonWitnessUtxo,
+            tapInternalKey: input.tapInternalKey,
+            sequence: 0xffffffff - 1,
+            bip32Derivation: input.bip32Derivation,
+          }
+          if (!i.bip32Derivation) delete i.bip32Derivation
+          if (!i.nonWitnessUtxo) delete i.nonWitnessUtxo
+          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(change)
+    }
+
+    // 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 | SignerInfo
+    fullAmount?: boolean
+    selfTransaction?: boolean
+    selectType?: "normal" | "accumulative" | "full"
+  }) {
+    if (!selfTransaction && targets.length === 0) throw new Error("no target")
+    let changeObject =
+      typeof changeAddress === "string"
+        ? {
+            address: changeAddress,
+          }
+        : changeAddress
+    const { inputs, outputs, change, fee } = await this.filterAndConvertTxDataToStandardFormat({
+      extendedUtxo,
+      targets,
+      changeObject,
+      feeRate,
+      selectType: fullAmount ? "full" : selectType,
+    })
+    let unsignedTransaction = this.createUnsignedTransaction({
+      inputs,
+      outputs,
+      change,
+      fee,
+      feeRate,
+    })
+
+    return unsignedTransaction
+  }
+}
+
+export default BaseBitcoinLikeTransaction

package/src/utils/{networks.js → networks.ts}

@@ -1,31 +1,33 @@
-const bitcoinLib = require("bitcoinjs-lib")
-
-const networks = {
-  bitcoin: bitcoinLib.networks.bitcoin,
-  bitcoin_testnet: bitcoinLib.networks.testnet,
-
-  litecoin: {
-    messagePrefix: "\x19Litecoin Signed Message:\n",
-    bech32: "ltc",
-    bip32: {
-      public: 0x0488b21e,
-      private: 0x0488ade4,
-    },
-    pubKeyHash: 0x30,
-    scriptHash: 0x32,
-    wif: 0xb0,
-  },
-  litecoin_testnet: {
-    messagePrefix: "\x18Litecoin Signed Message:\n",
-    bech32: "tltc",
-    bip32: {
-      public: 0x043587cf,
-      private: 0x04358394,
-    },
-    pubKeyHash: 0x6f,
-    scriptHash: 0x3a, // old 0xc4 -> 2  deprecated
-    wif: 0xef,
-  },
-}
-
-module.exports = networks
+import * as bitcoinLib from "bitcoinjs-lib"
+
+const networks: {
+  [key: string]: bitcoinLib.Network
+} = {
+  bitcoin: bitcoinLib.networks.bitcoin,
+  bitcoin_testnet: bitcoinLib.networks.testnet,
+
+  litecoin: {
+    messagePrefix: "\x19Litecoin Signed Message:\n",
+    bech32: "ltc",
+    bip32: {
+      public: 0x0488b21e,
+      private: 0x0488ade4,
+    },
+    pubKeyHash: 0x30,
+    scriptHash: 0x32,
+    wif: 0xb0,
+  },
+  litecoin_testnet: {
+    messagePrefix: "\x18Litecoin Signed Message:\n",
+    bech32: "tltc",
+    bip32: {
+      public: 0x043587cf,
+      private: 0x04358394,
+    },
+    pubKeyHash: 0x6f,
+    scriptHash: 0x3a, // old 0xc4 -> 2  deprecated
+    wif: 0xef,
+  },
+}
+
+export default networks