@teleportdao/bitcoin 2.2.4 → 2.3.0-alpha.0

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

@@ -2,7 +2,11 @@
 /* eslint-disable no-underscore-dangle */
 import * as bitcoin from "bitcoinjs-lib"
 
-import { createAddressObjectByPublicKey, getAddressType } from "../bitcoin-utils"
+import {
+  createAddressObjectByPublicKey,
+  getAddressType,
+  createMultisigAddressObjectByPublicKeys,
+} from "../bitcoin-utils"
 
 const coinselect = require("coinselect")
 const coinselectSplit = require("coinselect/split")
@@ -22,24 +26,30 @@ const coinselectAccumulative = require("coinselect/accumulative")
 //     p2wpkh: 35, // 31
 //     p2sh: 35, // 32
 //     p2tr: 45, // 43
+//     p2tr: 45, // 43
 //     default: 35,
 //   },
 //
 // }
+
+const SINGLESIG_TYPES = ["p2pkh", "p2wpkh", "p2sh-p2wpkh", "p2tr"]
+const MULTISIG_TYPES = ["p2sh", "p2wsh", "p2sh-p2wsh"]
+
 export const componentBytes = {
   bytePerInput: {
-    p2pkh: 148,
-    p2wpkh: 68, // 68
-    "p2sh-p2wpkh": 91,
-    p2tr: 58, // actual 58
+    p2pkh: 152, // 149
+    p2wpkh: 72, // 68
+    "p2sh-p2wpkh": 96, // 91
+    p2tr: 62, //  58
     default: 100,
   },
   baseTxBytes: 10 + 5, // +5 extra bytes to be sure
   bytePerOutput: {
-    p2pkh: 34, // 34
-    p2wpkh: 31, // 31
-    p2sh: 32, // 32
-    p2tr: 43, // 43
+    p2pkh: 34, // 33
+    p2wpkh: 31, // 30
+    p2sh: 32, // 31
+    p2tr: 43, // 42
+    p2wsh: 44, // 43
     default: 35,
     max: 45,
   },
@@ -50,6 +60,76 @@ export const componentBytes = {
   },
 }
 
+// P2SH | 46 + 74n + 34m
+// P2SH-P2WSH | (306 + 76n + 34m) / 4
+// P2WSH | (166 + 76n + 34m) / 4
+
+export function getInputSize(
+  addressType: string,
+  details?: {
+    // op return or other script
+    script?: string
+    // n of m multisig
+    n?: number
+    m?: number
+  },
+) {
+  let { m = 3 } = details || {}
+  const n = details?.n || m || 2
+  if (addressType === "p2sh") {
+    return 46 + 74 * n + 34 * m
+  }
+  if (addressType === "p2sh-p2wsh") {
+    return +((306 + 76 * n + 34 * m) / 4).toFixed()
+  }
+  if (addressType === "p2wsh") {
+    return +((166 + 76 * n + 34 * m) / 4).toFixed()
+  }
+
+  return (
+    componentBytes.bytePerInput[addressType as keyof typeof componentBytes.bytePerInput] ||
+    componentBytes.bytePerInput.default
+  )
+}
+
+export function getOutputSize(
+  output: {
+    addressType?: string
+    address?: string
+    script?: Buffer
+  },
+  // use network to decode address
+  network: bitcoin.Network = bitcoin.networks.bitcoin,
+) {
+  if (output.addressType) {
+    return (
+      componentBytes.bytePerOutput[
+        output.addressType as keyof typeof componentBytes.bytePerOutput
+      ] || componentBytes.bytePerOutput.default
+    )
+  }
+  if (output.address) {
+    let addressType = "max"
+    try {
+      addressType = getAddressType(output.address, network)
+    } catch {
+      addressType = "max"
+    }
+    return (
+      componentBytes.bytePerOutput[addressType as keyof typeof componentBytes.bytePerOutput] ||
+      componentBytes.bytePerOutput.max
+    )
+  }
+
+  if (output.script) {
+    if (output.script.byteLength < 255) {
+      return output.script.byteLength + componentBytes.scriptExtraBytes.lessThan255
+    }
+    return output.script.byteLength + componentBytes.scriptExtraBytes.moreThan255
+  }
+  throw new Error("invalid output")
+}
+
 export const DUST = 1000
 
 export type Utxo = {
@@ -57,14 +137,21 @@ export type Utxo = {
   value: number
   index: number
 }
+
 export type SignerInfo = {
   address: string
   publicKey: string
   addressType: string
+
+  //
+  publicKeys?: string[]
+  numberOfSigners?: number
+
   derivationPath?: string
   masterFingerprint?: string
   includeHex?: boolean
 }
+
 export type ExtendedUtxo = {
   signerInfo: SignerInfo
   hash: string
@@ -102,6 +189,7 @@ export type BitcoinJSInputInfo = ExtendedUtxo & {
     value: number
   }
   redeemScript?: Buffer
+  witnessScript?: Buffer
   tapInternalKey?: Buffer
 }
 
@@ -135,6 +223,8 @@ function coinSelectInOrder(
 }
 
 export abstract class BaseTransactionBuilder {
+  MULTISIG_TYPES = MULTISIG_TYPES
+
   testnet: boolean
   network: bitcoin.Network
   maximumNumberOfOutputsInTransaction: number
@@ -161,11 +251,25 @@ export abstract class BaseTransactionBuilder {
     this.dustLimit = dustLimit || 1 * 2 * componentBytes.bytePerInput.p2pkh
   }
 
+  isMultiSig(addressType: string) {
+    return this.MULTISIG_TYPES.includes(addressType)
+  }
+
   // eslint-disable-next-line no-unused-vars, class-methods-use-this
   abstract _getTransactionHex(transactionId: string): Promise<string>
 
   // eslint-disable-next-line no-unused-vars, class-methods-use-this
-  createAddressObject(input: { addressType: string; publicKey: Buffer }) {
+  createAddressObject(input: {
+    addressType: string
+    publicKey: Buffer
+    publicKeys?: Buffer[]
+    numberOfSigners?: number
+  }) {
+    if (this.MULTISIG_TYPES.includes(input.addressType))
+      return createMultisigAddressObjectByPublicKeys(input.addressType, {
+        publicKeys: input.publicKeys!,
+        numberOfSigners: input.numberOfSigners,
+      })
     return createAddressObjectByPublicKey(input, this.network)
   }
 
@@ -192,7 +296,12 @@ export abstract class BaseTransactionBuilder {
   }
 
   calculateTxSize(
-    inputTypes: string[],
+    inputTypes: {
+      addressType: string
+      n?: number
+      m?: number
+      script?: string
+    }[],
     outputs: {
       script?: Buffer
       address?: string
@@ -200,33 +309,19 @@ export abstract class BaseTransactionBuilder {
     }[],
     changeAddressType = "default",
   ) {
-    const inputsSizes = inputTypes.map(
-      (addressType) =>
-        componentBytes.bytePerInput[addressType as keyof typeof componentBytes.bytePerInput],
+    const inputsSizes = inputTypes.map(({ addressType, n, m }) =>
+      getInputSize(addressType, { n, m }),
     )
     const outputSizes = outputs.map((outP: any) => {
-      if (outP.address) {
-        let addressType = "default"
-        try {
-          addressType = getAddressType(outP.address, this.network)
-        } catch {
-          addressType = "default"
-        }
-        return componentBytes.bytePerOutput[
-          addressType as keyof typeof componentBytes.bytePerOutput
-        ]
-      }
-
-      if (outP.script) {
-        if (outP.script.byteLength < 255) {
-          return outP.script.byteLength + componentBytes.scriptExtraBytes.lessThan255
-        }
-        return outP.script.byteLength + componentBytes.scriptExtraBytes.moreThan255
+      if (!outP.address && !outP.script) {
+        return getOutputSize(
+          {
+            addressType: changeAddressType,
+          },
+          this.network,
+        )
       }
-
-      return componentBytes.bytePerOutput[
-        changeAddressType as keyof typeof componentBytes.bytePerOutput
-      ]
+      return getOutputSize(outP, this.network)
     })
 
     const txSize: number =
@@ -260,9 +355,10 @@ export abstract class BaseTransactionBuilder {
       (u) =>
         u.value >
         +feeRate *
-          componentBytes.bytePerInput[
-            u.signerInfo.addressType as keyof typeof componentBytes.bytePerInput
-          ],
+          getInputSize(u.signerInfo.addressType, {
+            m: u.signerInfo.publicKeys?.length,
+            n: u.signerInfo.numberOfSigners,
+          }),
     )
     let selectResponse
     switch (selectType) {
@@ -316,13 +412,17 @@ export abstract class BaseTransactionBuilder {
       changeAddressType = "default"
     }
 
-    const txSize =
-      this.calculateTxSize(
-        inputs.map((i) => i.signerInfo.addressType),
-        outputs,
-        changeAddressType,
-      ) + componentBytes.bytePerOutput.default
+    const txSize = this.calculateTxSize(
+      inputs.map((i) => ({
+        addressType: i.signerInfo.addressType,
+        m: i.signerInfo.publicKeys?.length,
+        n: i.signerInfo.numberOfSigners,
+      })),
+      outputs,
+      changeAddressType,
+    )
 
+    let extraChangeFee = Math.round(componentBytes.bytePerOutput.default * feeRate)
     let txFee = Math.round(txSize * feeRate)
     if (Math.round(feeRate) === 1) {
       txFee = Math.round(txFee + txFee * 0.1)
@@ -330,7 +430,8 @@ export abstract class BaseTransactionBuilder {
     if (
       inputs.reduce((a, b) => a + b.value, 0) -
         outputs.filter((o) => o.address || o.script).reduce((a, b) => a + b.value, 0) -
-        txFee <
+        txFee -
+        extraChangeFee <
       0
     ) {
       let spendableBalance = inputs.reduce((a, b) => a + b.value, 0)
@@ -346,35 +447,58 @@ export abstract class BaseTransactionBuilder {
         )}`,
       )
     }
+
     let diff = fee - txFee
     let changeIndex = outputs.findIndex((x) => !x?.address && !x.script && (x.value || 0) > 0)
     let change: ChangeTarget | undefined
-    if (changeIndex >= 0 || diff > DUST) {
-      if (changeIndex >= 0) {
-        diff = diff + componentBytes.bytePerOutput.default * Math.round(feeRate)
-      }
-
-      if (diff < 0) {
-        diff = 0
-      }
 
+    if (diff > 0) {
       if (selectType === "full") {
         outputs[0].value = outputs[0].value + diff
         fee = fee - diff
-      } else {
+      } else if (changeIndex >= 0) {
         if (!changeObject) throw new Error("change not exist")
         change = {
           address: changeObject.address,
-          value: changeIndex >= 0 ? outputs[changeIndex].value + diff : diff,
+          value: outputs[changeIndex].value + diff,
         }
         fee = fee - diff
+      } else if (diff - extraChangeFee > DUST) {
+        if (!changeObject) throw new Error("change not exist")
+        change = {
+          address: changeObject.address,
+          value: diff - extraChangeFee,
+        }
+        fee = fee - diff + extraChangeFee
       }
+    } else if (-1 * diff > 0) {
+      const positiveDiff = -1 * diff
 
-      if (changeIndex >= 0) {
-        outputs.splice(changeIndex, 1)
+      // if we don't have change we should consider extra ChangeFee
+      let currentChangeValue = changeIndex > 0 ? outputs[changeIndex].value : -1 * extraChangeFee
+      if (currentChangeValue - positiveDiff < -1 * DUST) {
+        throw new Error(`not enough balance.`) // it should no happen
+      }
+
+      if (changeIndex > 0) {
+        if (!changeObject) throw new Error("change not exist")
+        change =
+          outputs[changeIndex].value - positiveDiff > DUST
+            ? {
+                address: changeObject.address,
+                value: outputs[changeIndex].value - positiveDiff,
+              }
+            : undefined
+        fee = fee + positiveDiff
       }
     }
 
+    if (changeIndex >= 0) {
+      outputs.splice(changeIndex, 1)
+    }
+
+    console.log(fee, outputs, change)
+
     return {
       inputs,
       fee,
@@ -433,11 +557,21 @@ export abstract class BaseTransactionBuilder {
     })[] = baseInputs
     const transactionHex: { [key: string]: string } = {}
     for (let i in inputs) {
-      let { address, publicKey, derivationPath, masterFingerprint, addressType } =
-        inputs[i].signerInfo
+      let {
+        address,
+        publicKey,
+        derivationPath,
+        masterFingerprint,
+        addressType,
+        publicKeys,
+        numberOfSigners,
+      } = inputs[i].signerInfo
       // todo : support without publicKey
+
       let addressObject = this.createAddressObject({
         publicKey: Buffer.from(publicKey, "hex"),
+        publicKeys: publicKeys?.map((p) => Buffer.from(p, "hex")),
+        numberOfSigners,
         addressType,
       })
       if (derivationPath && masterFingerprint && addressObject.pubkey) {
@@ -475,7 +609,8 @@ export abstract class BaseTransactionBuilder {
           script: addressObject.output,
           value: inputs[i].value,
         }
-        if (!addressObject?.redeem?.output) throw new Error("invalid signer info for p2sh address")
+        if (!addressObject?.redeem?.output)
+          throw new Error("invalid signer info for p2sh-p2wpkh address")
         inputs[i].redeemScript = addressObject.redeem.output
 
         if (inputs[i].signerInfo.includeHex) {
@@ -493,6 +628,51 @@ export abstract class BaseTransactionBuilder {
         if (!addressObject.pubkey) throw new Error("invalid signer info for p2tr address (pubkey)")
         inputs[i].tapInternalKey = addressObject.internalPubkey
 
+        if (inputs[i].signerInfo.includeHex) {
+          const txHex =
+            transactionHex[inputs[i].hash] || (await this._getTransactionHex(inputs[i].hash))
+          transactionHex[inputs[i].hash] = txHex
+          inputs[i].nonWitnessUtxo = Buffer.from(txHex, "hex")
+        }
+      }
+      // multisig
+      else if (addressType === "p2sh") {
+        const txHex =
+          transactionHex[inputs[i].hash] || (await this._getTransactionHex(inputs[i].hash))
+        transactionHex[inputs[i].hash] = txHex
+        inputs[i].nonWitnessUtxo = Buffer.from(txHex, "hex")
+
+        if (!addressObject.output) throw new Error("invalid signer info")
+        if (!addressObject?.redeem?.output) throw new Error("invalid signer info for p2sh address")
+        inputs[i].redeemScript = addressObject.redeem.output
+      } else if (addressType === "p2wsh") {
+        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 p2wsh address")
+        inputs[i].witnessScript = addressObject.redeem?.output
+
+        if (inputs[i].signerInfo.includeHex) {
+          const txHex =
+            transactionHex[inputs[i].hash] || (await this._getTransactionHex(inputs[i].hash))
+          transactionHex[inputs[i].hash] = txHex
+          inputs[i].nonWitnessUtxo = Buffer.from(txHex, "hex")
+        }
+      } else if (addressType === "p2sh-p2wsh") {
+        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 (!addressObject?.redeem?.redeem?.output)
+          throw new Error("invalid signer info for p2sh-p2wsh address")
+        inputs[i].witnessScript = addressObject.redeem.redeem.output
+
         if (inputs[i].signerInfo.includeHex) {
           const txHex =
             transactionHex[inputs[i].hash] || (await this._getTransactionHex(inputs[i].hash))
@@ -525,70 +705,29 @@ export abstract class BaseTransactionBuilder {
     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,
-            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,
-            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,
-            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,
-            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")
+      const i = {
+        hash: input.hash,
+        index: +input.index,
+        witnessUtxo: input.witnessUtxo,
+        nonWitnessUtxo: input.nonWitnessUtxo,
+        redeemScript: input.redeemScript,
+        sequence,
+        bip32Derivation: input.bip32Derivation,
+        // multisig
+        witnessScript: input.witnessScript,
+        // taproot
+        tapInternalKey: input.tapInternalKey,
       }
+
+      if (!i.bip32Derivation) delete i.bip32Derivation
+      if (!i.nonWitnessUtxo) delete i.nonWitnessUtxo
+      if (!i.witnessUtxo) delete i.witnessUtxo
+      if (!i.redeemScript) delete i.redeemScript
+      if (!i.witnessScript) delete i.witnessScript
+      if (!i.tapInternalKey) delete i.tapInternalKey
+
+      newPsbt.addInput(i)
+      // console.log(i)
     }
 
     // add outputs
@@ -613,7 +752,7 @@ export abstract class BaseTransactionBuilder {
 
     const unsignedPsbtBaseText = newPsbt.toBase64()
 
-    const safeAddressTypeForPossibleTxId = ["p2wpkh", "p2tr"]
+    const safeAddressTypeForPossibleTxId = ["p2wpkh", "p2tr", "p2wsh"]
     const isPossibleTxId = inputs.reduce(
       (a, b) => a && safeAddressTypeForPossibleTxId.includes(b.signerInfo.addressType),
       true,
@@ -681,6 +820,7 @@ export abstract class BaseTransactionBuilder {
     let psbt = bitcoin.Psbt.fromBase64(unsignedPsbt, {
       network: this.network,
     })
+
     return (psbt as any).__CACHE.__TX.getId()
   }
 }