@teleportdao/bitcoin 1.4.7 → 1.4.9

package/src/sign/sign-transaction.ts

@@ -1,16 +1,44 @@
-import { Psbt, crypto, Network, ECPair } from "bitcoinjs-lib"
-// import ECPairFactory from "ecpair"
-// import * as ecc from "tiny-secp256k1"
-import { ExtendedUnsignedTransaction } from "../transaction-builder/transaction-builder"
-// import * as bitcoin from "bitcoinjs-lib"
+import { Psbt, crypto, Network } from "bitcoinjs-lib"
+// import BIP32Factory from "bip32"
+import ecc from "@bitcoinerlab/secp256k1"
+import * as bitcoinEcPair from "bitcoinjs-ecpair"
+const ECPair = bitcoinEcPair.ECPair
 
-// bitcoin.initEccLib(ecc)
-// // const bip32 = BIP32Factory(ecc)
-// const ECPair = ECPairFactory(ecc)
+function tapTweakHash(pubKey: Buffer, h?: Buffer) {
+  return crypto.taggedHash("TapTweak", Buffer.concat(h ? [pubKey, h] : [pubKey]))
+}
+
+function tweakSigner(
+  privateKey: Buffer,
+  opts = {} as {
+    [key: string]: Buffer
+  },
+  network: Network,
+) {
+  let newPrv = privateKey
+  let keyPair = ECPair.fromPrivateKey(privateKey, {
+    network: network,
+    compressed: true,
+  })
+
+  if (!keyPair.privateKey) throw new Error("private key not exist")
+
+  if (keyPair.publicKey.toString("hex").startsWith("03")) {
+    newPrv = ecc.privateNegate(keyPair.privateKey) as Buffer
+  }
+
+  const tweakedPrivateKey = ecc.privateAdd(
+    newPrv,
+    tapTweakHash(Buffer.from(keyPair.publicKey.toString("hex").slice(2), "hex"), opts?.tweakHash),
+  )
+  if (!tweakedPrivateKey) {
+    throw new Error("Invalid tweaked private key!")
+  }
 
-// function tapTweakHash(pubKey: Buffer, h?: Buffer) {
-//   return crypto.taggedHash('TapTweak', Buffer.concat(h ? [pubKey, h] : [pubKey]))
-// }
+  return ECPair.fromPrivateKey(Buffer.from(tweakedPrivateKey), {
+    network: network,
+  })
+}
 
 class BitcoinLikeSignTransaction {
   network: Network
@@ -18,38 +46,6 @@ class BitcoinLikeSignTransaction {
     this.network = network
   }
 
-  // tweakSigner(
-  //   privateKey: Buffer,
-  //   opts = {} as {
-  //     [key: string]: Buffer
-  //   },
-  // ) {
-  //   let newPrv = privateKey
-  //   let keyPair = ECPair.fromPrivateKey(privateKey, {
-  //     network: this.network,
-  //     compressed: true,
-  //   })
-
-  //   if (!keyPair.privateKey) throw new Error("private key not exist")
-
-  //   if (keyPair.publicKey.toString("hex").startsWith("03")) {
-  //     newPrv = ecc.privateNegate(keyPair.privateKey) as Buffer
-  //   }
-
-  //   const tweakedPrivateKey = ecc.privateAdd(
-  //     newPrv,
-  //     tapTweakHash(Buffer.from(keyPair.publicKey.toString("hex").slice(2), "hex"), opts?.tweakHash),
-  //   )
-  //   if (!tweakedPrivateKey) {
-  //     throw new Error("Invalid tweaked private key!")
-  //   }
-
-  //   return ECPair.fromPrivateKey(Buffer.from(tweakedPrivateKey), {
-  //     network: this.network,
-  //   })
-  // }
-
-  // todo : change to psbt
   async signPsbt(
     unsignedPsbt: {
       unsignedTransaction: string
@@ -68,7 +64,13 @@ class BitcoinLikeSignTransaction {
     let numberOfInputs = psbt.inputCount
 
     for (let i = 0; i < numberOfInputs; i += 1) {
-      await psbt.signInputAsync(i, keyPair)
+      let type = psbt.getInputType(i)
+      if (type === "nonstandard") {
+        let a = tweakSigner(privateKey, undefined, this.network)
+        await psbt.signInputAsync(i, a)
+      } else {
+        await psbt.signInputAsync(i, keyPair)
+      }
     }
 
     // psbt.signAllInputs(keyPair)
@@ -82,13 +84,12 @@ class BitcoinLikeSignTransaction {
     )
     const psbt =
       finals.length === 1 ? finals[0] : new Psbt({ network: this.network }).combine(...finals)
+
     psbt.finalizeAllInputs()
 
-    // psbt.finalizeAllInputs()
-    // const tx = psbt.extractTransaction()
-    // const rawTx = tx.toBuffer()
-    // const hex = rawTx.toString("hex")
     let finalizeTx = psbt.extractTransaction()
+    // const rawTx = finalizeTx.toBuffer()
+    // const hex = rawTx.toString("hex")
     return finalizeTx.toHex()
   }
 }

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

@@ -19,7 +19,7 @@ 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,
+    "p2sh-p2wpkh": TX_INPUT_BASE + TX_INPUT_P2SH_P2PKH,
   },
   baseTxBytes: TX_EMPTY_SIZE,
   bytePerOutput: TX_OUTPUT_BASE + TX_OUTPUT_P2PKH,
@@ -230,29 +230,47 @@ class BaseBitcoinLikeTransaction {
     if (!inputs || !outputs) {
       throw new Error("not enough balance")
     }
+    // console.log(inputs, outputs, feeRate)
+    const inputsSizes = inputs.map(
+      (i) =>
+        componentBytes.bytePerInput[
+          i.signerInfo.addressType as keyof typeof componentBytes.bytePerInput
+        ],
+    )
+    const outputSizes = outputs.length * componentBytes.bytePerOutput
+
+    // console.log(inputsSizes, outputSizes)
+
+    const txSize =
+      componentBytes.baseTxBytes +
+      inputsSizes.reduce((a, c) => a + c, 0) +
+      outputSizes +
+      componentBytes.bytePerOutput
+
+    const txFee = txSize * feeRate
+    let diff = fee - txFee
+    // console.log({ txSize, txFee, diff, fee })
+
     let changeIndex = outputs.findIndex((x) => !x?.address && !x.script && (x.value || 0) > 0)
     let change: ChangeTarget | undefined
-    if (changeIndex >= 0) {
+    if (changeIndex >= 0 || diff > 600) {
+      if (changeIndex >= 0) {
+        diff = diff + componentBytes.bytePerOutput * feeRate
+      }
+
+      if (diff < 0) {
+        diff = 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,
-        }
+      change = {
+        address: changeObject.address,
+        value: changeIndex >= 0 ? outputs[changeIndex].value + diff : diff,
+      }
+      fee = fee - diff
+      if (changeIndex >= 0) {
+        outputs.splice(changeIndex, 1)
       }
-      outputs.splice(changeIndex, 1)
     }
 
     return {