@argonprotocol/bitcoin 1.3.2 → 1.3.3

package/lib/index.js

@@ -5,17 +5,22 @@ var __export = (target, all) => {
 };
 
 // ts/index.ts
-import { Transaction as Transaction2, Psbt as Psbt2, networks as networks3, Network, address as address2 } from "bitcoinjs-lib";
+import { Transaction as Transaction2, Address as Address2, p2wsh as p2wsh2, p2wpkh as p2wpkh2, p2sh as p2sh2, p2pk, p2pkh as p2pkh2 } from "@scure/btc-signer";
 
 // ts/CosignScript.ts
-import { networks as networks2, payments, Psbt, Transaction } from "bitcoinjs-lib";
+import { p2pkh, p2sh, p2wpkh, p2wsh, Transaction } from "@scure/btc-signer";
+import {
+  hexToU8a as hexToU8a2,
+  u8aEq,
+  u8aToHex as u8aToHex2
+} from "@argonprotocol/mainchain";
 
 // ts/wasm/bitcoin_bindings_bg.wasm
 var bitcoin_bindings_bg_exports = {};
 __export(bitcoin_bindings_bg_exports, {
   default: () => bitcoin_bindings_bg_default
 });
-var bitcoin_bindings_bg_default = "./bitcoin_bindings_bg-NTNPUTAE.wasm";
+var bitcoin_bindings_bg_default = "./bitcoin_bindings_bg-WMK2AQRE.wasm";
 
 // ts/wasm/bitcoin_bindings_bg.js
 var wasm;
@@ -226,77 +231,108 @@ var BitcoinNetwork = Object.freeze({
 
 // ts/wasm/bitcoin_bindings.js
 __wbg_set_wasm(bitcoin_bindings_bg_exports);
-(void 0)();
 
 // ts/KeysHelper.ts
-import { address } from "bitcoinjs-lib";
-import BIP32Factory from "bip32";
-import * as ecc from "tiny-secp256k1";
-import * as bip39 from "bip39";
-function getBip32Factory() {
-  return BIP32Factory(ecc);
+import { Address, NETWORK, OutScript, TEST_NETWORK } from "@scure/btc-signer";
+import { bech32 } from "@scure/base";
+import { HDKey } from "@scure/bip32";
+import { hexToU8a, u8aToHex } from "@argonprotocol/mainchain";
+import * as secp256k1 from "@noble/secp256k1";
+function getBip32Version(network) {
+  if (!network) {
+    return void 0;
+  }
+  if (network === BitcoinNetwork.Testnet || network === BitcoinNetwork.Signet) {
+    return {
+      private: 70615956,
+      // tprv
+      public: 70617039
+      // tpub
+    };
+  }
+  if (network === BitcoinNetwork.Regtest) {
+    return {
+      private: 70615956,
+      // rprv
+      public: 70617039
+      // rpub
+    };
+  }
+  return void 0;
 }
 function getChildXpriv(bip39Seed, hdPath, network) {
-  const root = BIP32Factory(ecc).fromSeed(bip39Seed, network);
-  return root.derivePath(hdPath);
-}
-function getBip39Seed(mnemonic, passphrase) {
-  return bip39.mnemonicToSeedSync(mnemonic, passphrase);
+  const root = HDKey.fromMasterSeed(bip39Seed, getBip32Version(network));
+  return root.derive(hdPath);
 }
 function getXpubFromXpriv(xpriv) {
-  return xpriv.neutered().toBase58();
+  return xpriv.publicExtendedKey;
 }
 function getCompressedPubkey(pubkey) {
-  const pubkeyBuffer = keyToBuffer(pubkey);
-  if (ecc.isPointCompressed(pubkeyBuffer)) {
-    return pubkeyBuffer;
+  const pubkeyUint8Array = keyToU8a(pubkey);
+  if (pubkeyUint8Array.length === 33) {
+    return pubkeyUint8Array;
   }
-  return Buffer.from(ecc.pointCompress(pubkeyBuffer, true));
+  const point = secp256k1.Point.fromHex(pubkeyUint8Array);
+  return point.toRawBytes(true);
 }
-function stripLeadingHexPrefix(hex) {
-  if (hex.startsWith("0x")) {
-    return hex.slice(2);
+function getBech32Prefix(network) {
+  return getScureNetwork(network).bech32;
+}
+function p2wshScriptHexToAddress(scriptPubKeyHex, network) {
+  const script = hexToU8a(scriptPubKeyHex);
+  if (Buffer.byteLength(script) !== 34 || script[0] !== 0 || script[1] !== 32) {
+    throw new Error("Invalid P2WSH scriptPubKey");
   }
-  return hex;
+  const witnessProgram = script.slice(2);
+  const version = 0;
+  const prefix = getBech32Prefix(network);
+  return bech32.encode(prefix, [version, ...bech32.toWords(witnessProgram)]);
 }
-function addressBytesHex(addressString, network) {
-  if (addressString.startsWith("0x")) {
-    return addressString;
+function addressBytesHex(address, network) {
+  if (address.startsWith("0x")) {
+    return address;
   }
-  console.log("Converting address to bytes:", addressString, network);
-  if (/^[0-9a-fA-F]+$/.test(addressString) && !addressString.startsWith("bc")) {
-    return `0x${addressString}`;
+  const bech32Prefix = getBech32Prefix(network);
+  if (/^[0-9a-fA-F]+$/.test(address) && !address.startsWith("bc") && !address.startsWith(bech32Prefix)) {
+    return `0x${address}`;
   }
-  const scriptbuf = address.toOutputScript(addressString, network);
-  return `0x${scriptbuf.toString("hex")}`;
+  const btcNetwork = getScureNetwork(network);
+  const decoded = Address(btcNetwork).decode(address);
+  const out = OutScript.encode(decoded);
+  return u8aToHex(out);
+}
+function keyToU8a(pubkey) {
+  return typeof pubkey === "string" ? hexToU8a(pubkey) : pubkey;
 }
-function keyToBuffer(key) {
-  if (typeof key === "string") {
-    key = stripLeadingHexPrefix(key);
-    return Buffer.from(key, "hex");
+function getScureNetwork(network) {
+  if (network === BitcoinNetwork.Bitcoin) {
+    return NETWORK;
+  } else if (network === BitcoinNetwork.Testnet || network === BitcoinNetwork.Signet) {
+    return TEST_NETWORK;
+  } else {
+    return {
+      bech32: "bcrt",
+      pubKeyHash: 111,
+      scriptHash: 196,
+      wif: 239
+    };
   }
-  return Buffer.from(key);
 }
 
 // ts/CosignScript.ts
-var CosignScript = class _CosignScript {
+var CosignScript = class {
   constructor(lock, network) {
     this.lock = lock;
-    if (network === networks2.bitcoin || network === networks2.testnet || network === networks2.regtest) {
-      this.network = network;
-    } else {
-      this.network = _CosignScript.getBitcoinJsNetwork(
-        network
-      );
-    }
+    this.network = network;
   }
-  network;
   getFundingPsbt() {
     const { lock, network } = this;
-    return new Psbt({ network }).addOutput({
-      script: keyToBuffer(lock.p2wshScriptHashHex),
-      value: Number(lock.satoshis)
+    const tx = new Transaction();
+    tx.addOutput({
+      script: keyToU8a(lock.p2wshScriptHashHex),
+      amount: lock.satoshis
     });
+    return tx.toPSBT(0);
   }
   calculateFee(feeRatePerSatVb, toScriptPubkey) {
     toScriptPubkey = addressBytesHex(toScriptPubkey, this.network);
@@ -308,7 +344,7 @@ var CosignScript = class _CosignScript {
       BigInt(lock.vaultClaimHeight),
       BigInt(lock.openClaimHeight),
       BigInt(lock.createdAtHeight),
-      toBitcoinNetwork(network),
+      network,
       feeRatePerSatVb,
       toScriptPubkey
     );
@@ -322,7 +358,7 @@ var CosignScript = class _CosignScript {
       BigInt(lock.vaultClaimHeight),
       BigInt(lock.openClaimHeight),
       BigInt(lock.createdAtHeight),
-      toBitcoinNetwork(network)
+      network
     );
   }
   getCosignPsbt(args) {
@@ -339,21 +375,22 @@ var CosignScript = class _CosignScript {
       BigInt(lock.vaultClaimHeight),
       BigInt(lock.openClaimHeight),
       BigInt(lock.createdAtHeight),
-      toBitcoinNetwork(network),
+      network,
       releaseRequest.toScriptPubkey,
       releaseRequest.bitcoinNetworkFee
     );
     return this.psbtFromHex(psbtStr);
   }
   psbtFromHex(psbtHex) {
-    const psbt = Psbt.fromHex(psbtHex.replace(/^0x(.+)/, "$1"), { network: this.network });
-    if (psbt.data.inputs.length === 0) {
+    const psbtBytes = hexToU8a2(psbtHex);
+    const tx = Transaction.fromPSBT(psbtBytes);
+    if (tx.inputsLength === 0) {
       throw new Error("PSBT has no inputs");
     }
-    if (psbt.data.outputs.length === 0) {
+    if (tx.outputsLength === 0) {
       throw new Error("PSBT has no outputs");
     }
-    return psbt;
+    return tx;
   }
   /**
    * Cosigns the PSBT with the vault xpub.
@@ -362,21 +399,33 @@ var CosignScript = class _CosignScript {
    * @param vaultXpriv - The vault's extended private key of which the xpub was used to create the vault.
    */
   vaultCosignPsbt(psbt, lock, vaultXpriv) {
-    const parentFingerprint = Buffer.from(lock.vaultXpubSources.parentFingerprint);
-    if (!parentFingerprint.equals(vaultXpriv.fingerprint)) {
+    const parentFingerprint = lock.vaultXpubSources.parentFingerprint;
+    const vaultFingerprint = vaultXpriv.identifier?.slice(0, 4);
+    if (!vaultFingerprint) {
+      throw new Error("Could not get vault fingerprint from HDKey");
+    }
+    if (!u8aEq(parentFingerprint, vaultFingerprint)) {
       throw new Error(
-        `Vault xpub fingerprint ${parentFingerprint.toString("hex")} does not match the vault xpriv fingerprint ${vaultXpriv.fingerprint.toString("hex")}`
+        `Vault xpub fingerprint ${u8aToHex2(parentFingerprint)} does not match the vault xpriv fingerprint ${u8aToHex2(vaultFingerprint)}`
       );
     }
     const childPath = `${lock.vaultXpubSources.cosignHdIndex}`;
-    const pubkey = vaultXpriv.derivePath(childPath).publicKey;
-    const vaultPubkey = keyToBuffer(lock.vaultPubkey);
-    if (!vaultPubkey.equals(pubkey)) {
+    const pubkey = vaultXpriv.deriveChild(lock.vaultXpubSources.cosignHdIndex).publicKey;
+    if (!pubkey) {
+      throw new Error(`Failed to derive public key for path ${childPath}`);
+    }
+    const vaultPubkey = keyToU8a(lock.vaultPubkey);
+    if (!u8aEq(vaultPubkey, pubkey)) {
       throw new Error(
-        `Vault pubkey ${vaultPubkey.toString("hex")} does not match the derived pubkey ${pubkey.toString("hex")} using path ${childPath}`
+        `Vault pubkey ${u8aToHex2(vaultPubkey)} does not match the derived pubkey ${u8aToHex2(pubkey)} using path ${childPath}`
       );
     }
-    const signedPsbt = signPsbtDerived(psbt.toHex(), vaultXpriv.toBase58(), childPath, false);
+    const signedPsbt = signPsbtDerived(
+      u8aToHex2(psbt.toPSBT()),
+      vaultXpriv.privateExtendedKey,
+      childPath,
+      false
+    );
     psbt = this.psbtFromHex(signedPsbt);
     return psbt;
   }
@@ -388,84 +437,80 @@ var CosignScript = class _CosignScript {
     const psbt = this.getCosignPsbt(args);
     const { addTx, vaultCosignature, ownerXpriv, ownerXprivChildHdPath } = args;
     psbt.updateInput(0, {
-      partialSig: [
-        {
-          pubkey: keyToBuffer(lock.vaultPubkey),
-          signature: Buffer.from(vaultCosignature)
-        }
-      ]
+      partialSig: [[keyToU8a(lock.vaultPubkey), vaultCosignature]]
     });
     const derivePubkey = ownerXpriv.publicKey;
-    const ownerPubkey = keyToBuffer(lock.ownerPubkey);
-    if (!ownerPubkey.equals(derivePubkey)) {
+    if (!derivePubkey) {
+      throw new Error("Failed to derive owner public key");
+    }
+    const ownerPubkey = keyToU8a(lock.ownerPubkey);
+    if (!u8aEq(ownerPubkey, derivePubkey)) {
       throw new Error(
-        `Owner pubkey ${ownerPubkey.toString("hex")} does not match the derived pubkey ${derivePubkey.toString("hex")}`
+        `Owner pubkey ${u8aToHex2(ownerPubkey)} does not match the derived pubkey ${u8aToHex2(derivePubkey)}`
       );
     }
     if (addTx) {
-      const tx = Transaction.fromHex(addTx.replace(/^0x(.+)/, "$1"));
-      for (let i = 0; i < tx.outs.length; i++) {
-        const output = tx.outs[i];
+      const addTxBytes = hexToU8a2(addTx);
+      const tx = Transaction.fromPSBT(addTxBytes);
+      for (let i = 0; i < tx.outputsLength; i++) {
+        const output = tx.getOutput(i);
+        const network = getScureNetwork(this.network);
         const scripts = [
-          payments.p2wpkh({ pubkey: ownerPubkey }).output,
-          payments.p2sh({ redeem: payments.p2wpkh({ pubkey: ownerPubkey }) }).output,
-          payments.p2pkh({ pubkey: ownerPubkey }).output
+          p2wpkh(ownerPubkey, network).script,
+          p2wsh(p2wpkh(ownerPubkey, network), network).script,
+          p2sh(p2pkh(ownerPubkey, network), network).script,
+          p2pkh(ownerPubkey, network).script
         ];
-        if (scripts.some((x) => x && output.script.equals(x))) {
+        if (scripts.some((x) => x && output.script && u8aEq(output.script, x))) {
           psbt.addInput({
-            hash: tx.getId(),
+            txid: tx.id,
             index: i,
             witnessUtxo: {
               script: output.script,
-              value: output.value
+              amount: output.amount
             }
           });
         }
       }
     }
-    const signedPsbt = ownerXprivChildHdPath ? signPsbtDerived(psbt.toHex(), ownerXpriv.toBase58(), ownerXprivChildHdPath, true) : signPsbt(
-      psbt.toHex(),
-      toBitcoinNetwork(this.network),
-      ownerXpriv.privateKey.toString("hex"),
-      true
-    );
-    const finalPsbt = this.psbtFromHex(signedPsbt);
-    return finalPsbt.extractTransaction();
-  }
-  static getBitcoinJsNetwork(network) {
-    if (network.isBitcoin) return networks2.bitcoin;
-    if (network.isTestnet || network.isSignet) return networks2.testnet;
-    if (network.isRegtest) return networks2.regtest;
-    throw new Error("Unsupported network: " + network);
+    const psbtBytes = u8aToHex2(psbt.toPSBT());
+    const signedPsbt = ownerXprivChildHdPath ? signPsbtDerived(psbtBytes, ownerXpriv.privateExtendedKey, ownerXprivChildHdPath, true) : signPsbt(psbtBytes, this.network, u8aToHex2(ownerXpriv.privateKey, void 0, false), true);
+    return this.psbtFromHex(signedPsbt);
   }
 };
-function toBitcoinNetwork(network) {
-  if (network === networks2.bitcoin) {
+function getBitcoinNetworkFromApi(network) {
+  if (network.isBitcoin) {
     return BitcoinNetwork.Bitcoin;
-  } else if (network === networks2.testnet) {
+  } else if (network.isTestnet) {
     return BitcoinNetwork.Testnet;
-  } else if (network === networks2.regtest) {
+  } else if (network.isRegtest) {
     return BitcoinNetwork.Regtest;
   }
   throw new Error("Unsupported network: " + network);
 }
 
 // ts/index.ts
-import * as bip392 from "bip39";
+import * as bip39 from "@scure/bip39";
 export {
+  Address2 as Address,
+  BitcoinNetwork,
   CosignScript,
-  Network,
-  Psbt2 as Psbt,
+  HDKey,
   Transaction2 as Transaction,
-  address2 as address,
   addressBytesHex,
-  bip392 as bip39,
-  getBip32Factory,
-  getBip39Seed,
+  bip39,
+  getBech32Prefix,
+  getBip32Version,
+  getBitcoinNetworkFromApi,
   getChildXpriv,
   getCompressedPubkey,
+  getScureNetwork,
   getXpubFromXpriv,
-  keyToBuffer,
-  networks3 as networks,
-  stripLeadingHexPrefix
+  keyToU8a,
+  p2pk,
+  p2pkh2 as p2pkh,
+  p2sh2 as p2sh,
+  p2wpkh2 as p2wpkh,
+  p2wsh2 as p2wsh,
+  p2wshScriptHexToAddress
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@argonprotocol/bitcoin",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "description": "A client for interop with bitcoin in nodejs.",
   "repository": {
     "type": "git",
@@ -13,7 +13,7 @@
   },
   "homepage": "https://github.com/argonprotocol/mainchain#readme",
   "scripts": {
-    "wasm-pack": "wasm-pack build --target bundler --release --out-dir ts/wasm --out-name bitcoin_bindings --no-pack --no-opt",
+    "wasm-pack": "wasm-pack build --target bundler --release --out-dir ts/wasm --out-name bitcoin_bindings --no-pack --no-opt && node clean-wasm.js",
     "prebuild": "yarn workspace @argonprotocol/mainchain run build",
     "build": "yarn wasm-pack && yarn tsc",
     "pretsc": "yarn workspace @argonprotocol/mainchain run tsc",
@@ -23,22 +23,33 @@
     "tsup": "yarn tsc"
   },
   "files": [
-    "lib/"
+    "lib/",
+    "browser/"
   ],
   "type": "module",
-  "bin": "./lib/cli.js",
   "module": "./lib/index.js",
   "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js",
+      "browser": {
+        "types": "./browser/index.d.ts",
+        "default": "./browser/index.js"
+      }
+    }
+  },
   "dependencies": {
-    "@argonprotocol/mainchain": "1.3.2",
-    "bignumber.js": "^9.1.2",
-    "bip32": "^4.0.0",
-    "bip39": "^3.1.0",
-    "bitcoinjs-lib": "^6.1.7",
-    "tiny-secp256k1": "^2.2.3"
+    "@argonprotocol/mainchain": "1.3.3",
+    "@noble/secp256k1": "^2.3.0",
+    "@scure/bip32": "^1.7.0",
+    "@scure/bip39": "^1.6.0",
+    "@scure/btc-signer": "^1.8.1",
+    "bignumber.js": "^9.1.2"
   },
   "devDependencies": {
-    "@argonprotocol/testing": "1.3.2",
+    "@argonprotocol/testing": "1.3.3",
+    "@types/node": "22.16.3",
     "tsup": "^8.4.0",
     "tsx": "^4.19.2",
     "typescript": "^5.8.3",