@argonprotocol/bitcoin 1.3.2 → 1.3.4

package/lib/index.js

@@ -5,17 +5,41 @@ 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
+// wasm-module:/home/runner/work/mainchain/mainchain/bitcoin/nodejs/ts/wasm/bitcoin_bindings_bg.wasm
 var bitcoin_bindings_bg_exports = {};
 __export(bitcoin_bindings_bg_exports, {
-  default: () => bitcoin_bindings_bg_default
+  __externref_table_dealloc: () => __externref_table_dealloc,
+  __wbindgen_export_3: () => __wbindgen_export_3,
+  __wbindgen_free: () => __wbindgen_free,
+  __wbindgen_malloc: () => __wbindgen_malloc,
+  __wbindgen_realloc: () => __wbindgen_realloc,
+  __wbindgen_start: () => __wbindgen_start,
+  calculateFee: () => calculateFee2,
+  createCosignPubkey: () => createCosignPubkey2,
+  getCosignPsbt: () => getCosignPsbt2,
+  instance: () => instance,
+  memory: () => memory,
+  module: () => module2,
+  rustsecp256k1_v0_10_0_context_create: () => rustsecp256k1_v0_10_0_context_create,
+  rustsecp256k1_v0_10_0_context_destroy: () => rustsecp256k1_v0_10_0_context_destroy,
+  rustsecp256k1_v0_10_0_default_error_callback_fn: () => rustsecp256k1_v0_10_0_default_error_callback_fn,
+  rustsecp256k1_v0_10_0_default_illegal_callback_fn: () => rustsecp256k1_v0_10_0_default_illegal_callback_fn,
+  signPsbt: () => signPsbt2,
+  signPsbtDerived: () => signPsbtDerived2
 });
-var bitcoin_bindings_bg_default = "./bitcoin_bindings_bg-NTNPUTAE.wasm";
+
+// wasm-deferred:/home/runner/work/mainchain/mainchain/bitcoin/nodejs/ts/wasm/bitcoin_bindings_bg.wasm
+var bitcoin_bindings_bg_default = "./bitcoin_bindings_bg-67GA3ENS.wasm";
 
 // ts/wasm/bitcoin_bindings_bg.js
 var wasm;
@@ -79,6 +103,13 @@ function passStringToWasm0(arg, malloc, realloc) {
   WASM_VECTOR_LEN = offset;
   return ptr;
 }
+var cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+  if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
+    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+  }
+  return cachedDataViewMemory0;
+}
 function takeFromExternrefTable0(idx) {
   const value = wasm.__wbindgen_export_3.get(idx);
   wasm.__externref_table_dealloc(idx);
@@ -223,80 +254,206 @@ var BitcoinNetwork = Object.freeze({
   Regtest: 3,
   "3": "Regtest"
 });
+function __wbg_error_7534b8e9a36f1ab4(arg0, arg1) {
+  let deferred0_0;
+  let deferred0_1;
+  try {
+    deferred0_0 = arg0;
+    deferred0_1 = arg1;
+    console.error(getStringFromWasm0(arg0, arg1));
+  } finally {
+    wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+  }
+}
+function __wbg_new_8a6f238a6ece86ea() {
+  const ret = new Error();
+  return ret;
+}
+function __wbg_stack_0ed75d68575b0f3c(arg0, arg1) {
+  const ret = arg1.stack;
+  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len1 = WASM_VECTOR_LEN;
+  getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+  getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+}
+function __wbindgen_init_externref_table() {
+  const table = wasm.__wbindgen_export_3;
+  const offset = table.grow(4);
+  table.set(0, void 0);
+  table.set(offset + 0, void 0);
+  table.set(offset + 1, null);
+  table.set(offset + 2, true);
+  table.set(offset + 3, false);
+  ;
+}
+function __wbindgen_string_new(arg0, arg1) {
+  const ret = getStringFromWasm0(arg0, arg1);
+  return ret;
+}
+function __wbindgen_throw(arg0, arg1) {
+  throw new Error(getStringFromWasm0(arg0, arg1));
+}
+
+// wasm-module:/home/runner/work/mainchain/mainchain/bitcoin/nodejs/ts/wasm/bitcoin_bindings_bg.wasm
+var imports = {
+  ["./bitcoin_bindings_bg.js"]: {
+    __wbindgen_string_new,
+    __wbg_new_8a6f238a6ece86ea,
+    __wbg_stack_0ed75d68575b0f3c,
+    __wbg_error_7534b8e9a36f1ab4,
+    __wbindgen_throw,
+    __wbindgen_init_externref_table
+  }
+};
+async function loadWasm(module3, imports2) {
+  if (typeof module3 === "string") {
+    if (module3.startsWith("./")) {
+      module3 = new URL(module3, import.meta.url).href;
+    }
+    if (module3.startsWith("file://")) {
+      const fs = await import("fs");
+      module3 = await fs.promises.readFile(new URL(module3));
+    } else {
+      const moduleRequest = await fetch(module3);
+      if (typeof WebAssembly.instantiateStreaming === "function") {
+        try {
+          return await WebAssembly.instantiateStreaming(moduleRequest, imports2);
+        } catch (e) {
+          if (moduleRequest.headers.get("Content-Type") != "application/wasm") {
+            console.warn(e);
+          } else {
+            throw e;
+          }
+        }
+      }
+      module3 = await moduleRequest.arrayBuffer();
+    }
+  }
+  return await WebAssembly.instantiate(module3, imports2);
+}
+var { instance, module: module2 } = await loadWasm(bitcoin_bindings_bg_default, imports);
+var memory = instance.exports.memory;
+var createCosignPubkey2 = instance.exports.createCosignPubkey;
+var calculateFee2 = instance.exports.calculateFee;
+var signPsbtDerived2 = instance.exports.signPsbtDerived;
+var signPsbt2 = instance.exports.signPsbt;
+var getCosignPsbt2 = instance.exports.getCosignPsbt;
+var rustsecp256k1_v0_10_0_context_create = instance.exports.rustsecp256k1_v0_10_0_context_create;
+var rustsecp256k1_v0_10_0_context_destroy = instance.exports.rustsecp256k1_v0_10_0_context_destroy;
+var rustsecp256k1_v0_10_0_default_illegal_callback_fn = instance.exports.rustsecp256k1_v0_10_0_default_illegal_callback_fn;
+var rustsecp256k1_v0_10_0_default_error_callback_fn = instance.exports.rustsecp256k1_v0_10_0_default_error_callback_fn;
+var __wbindgen_free = instance.exports.__wbindgen_free;
+var __wbindgen_malloc = instance.exports.__wbindgen_malloc;
+var __wbindgen_realloc = instance.exports.__wbindgen_realloc;
+var __wbindgen_export_3 = instance.exports.__wbindgen_export_3;
+var __externref_table_dealloc = instance.exports.__externref_table_dealloc;
+var __wbindgen_start = instance.exports.__wbindgen_start;
 
 // ts/wasm/bitcoin_bindings.js
 __wbg_set_wasm(bitcoin_bindings_bg_exports);
-(void 0)();
+__wbindgen_start();
 
 // 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 getBech32Prefix(network) {
+  return getScureNetwork(network).bech32;
 }
-function stripLeadingHexPrefix(hex) {
-  if (hex.startsWith("0x")) {
-    return hex.slice(2);
+function p2wshScriptHexToAddress(scriptPubKeyHex, network) {
+  const script = hexToU8a(scriptPubKeyHex);
+  if (script.byteLength !== 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 keyToBuffer(key) {
-  if (typeof key === "string") {
-    key = stripLeadingHexPrefix(key);
-    return Buffer.from(key, "hex");
+function keyToU8a(pubkey) {
+  return typeof pubkey === "string" ? hexToU8a(pubkey) : pubkey;
+}
+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 +465,7 @@ var CosignScript = class _CosignScript {
       BigInt(lock.vaultClaimHeight),
       BigInt(lock.openClaimHeight),
       BigInt(lock.createdAtHeight),
-      toBitcoinNetwork(network),
+      network,
       feeRatePerSatVb,
       toScriptPubkey
     );
@@ -322,7 +479,7 @@ var CosignScript = class _CosignScript {
       BigInt(lock.vaultClaimHeight),
       BigInt(lock.openClaimHeight),
       BigInt(lock.createdAtHeight),
-      toBitcoinNetwork(network)
+      network
     );
   }
   getCosignPsbt(args) {
@@ -339,21 +496,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 +520,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 +558,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)) {
+    const derivePubkey = ownerXprivChildHdPath ? ownerXpriv.derive(ownerXprivChildHdPath).publicKey : ownerXpriv.publicKey;
+    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.4",
   "description": "A client for interop with bitcoin in nodejs.",
   "repository": {
     "type": "git",
@@ -13,32 +13,54 @@
   },
   "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",
     "prebuild": "yarn workspace @argonprotocol/mainchain run build",
     "build": "yarn wasm-pack && yarn tsc",
     "pretsc": "yarn workspace @argonprotocol/mainchain run tsc",
     "tsc": "yarn pretsc && tsup",
     "test": "yarn build && vitest --run --typecheck --disableConsoleIntercept",
     "test:ci": "yarn tsc && vitest --run --disableConsoleIntercept",
-    "tsup": "yarn tsc"
+    "tsup": "yarn tsc",
+    "watch": "yarn pretsc && tsup --watch"
   },
   "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"
+      }
+    },
+    "./browser": {
+      "types": "./browser/index.d.ts",
+      "default": "./browser/index.js"
+    }
+  },
+  "sideEffects": [
+    "./ts/wasm/bitcoin_bindings.js",
+    "./lib/index.js",
+    "./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.4",
+    "@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.4",
+    "@types/node": "22.16.3",
+    "esbuild-plugin-wasm": "^1.1.0",
     "tsup": "^8.4.0",
     "tsx": "^4.19.2",
     "typescript": "^5.8.3",