@argonprotocol/bitcoin 1.3.0

package/lib/index.d.ts

@@ -0,0 +1,52 @@
+import { BIP32Interface } from 'bip32';
+import { networks, Psbt, Transaction } from 'bitcoinjs-lib';
+import { IBitcoinLock, ArgonPrimitivesBitcoinBitcoinNetwork, IReleaseRequest } from '@argonprotocol/mainchain';
+
+declare class CosignScript {
+    readonly lock: IBitcoinLock;
+    private readonly network;
+    constructor(lock: IBitcoinLock, network: networks.Network | ArgonPrimitivesBitcoinBitcoinNetwork);
+    getFundingPsbt(): Psbt;
+    calculateFee(feeRatePerSatVb: bigint, toScriptPubkey: string): bigint;
+    calculateScriptPubkey(): string;
+    getCosignPsbt(args: {
+        utxoRef: {
+            txid: string;
+            vout: number;
+        };
+        releaseRequest: IReleaseRequest;
+    }): Psbt;
+    psbtFromHex(psbtHex: string): Psbt;
+    /**
+     * Cosigns the PSBT with the vault xpub.
+     * @param psbt - The PSBT to cosign.
+     * @param lock - The Bitcoin lock containing the vault information.
+     * @param vaultXpriv - The vault's extended private key of which the xpub was used to create the vault.
+     */
+    vaultCosignPsbt(psbt: Psbt, lock: IBitcoinLock, vaultXpriv: BIP32Interface): Psbt;
+    /**
+     * Cosigns the transaction.
+     */
+    cosignAndGenerateTx(args: {
+        releaseRequest: IReleaseRequest;
+        vaultCosignature: Uint8Array;
+        utxoRef: {
+            txid: string;
+            vout: number;
+        };
+        ownerXpriv: BIP32Interface;
+        ownerXprivChildHdPath?: string;
+        addTx?: string;
+    }): Transaction;
+    static getBitcoinJsNetwork(network: ArgonPrimitivesBitcoinBitcoinNetwork): networks.Network;
+}
+
+declare function getChildXpriv(bip39Seed: Buffer, hdPath: string, network?: networks.Network): BIP32Interface;
+declare function getBip39Seed(mnemonic: string, passphrase?: string): Buffer;
+declare function getXpubFromXpriv(xpriv: BIP32Interface): string;
+declare function getCompressedPubkey(pubkey: string | Buffer): Buffer;
+declare function stripLeadingHexPrefix(hex: string): string;
+declare function addressBytesHex(addressString: string, network: networks.Network): string;
+declare function keyToBuffer(key: string | Buffer): Buffer;
+
+export { CosignScript, addressBytesHex, getBip39Seed, getChildXpriv, getCompressedPubkey, getXpubFromXpriv, keyToBuffer, stripLeadingHexPrefix };

package/lib/index.js

@@ -0,0 +1,455 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ts/CosignScript.ts
+import { networks as networks2, payments, Psbt, Transaction } from "bitcoinjs-lib";
+
+// 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-7MW5MTH2.wasm";
+
+// ts/wasm/bitcoin_bindings_bg.js
+var wasm;
+function __wbg_set_wasm(val) {
+  wasm = val;
+}
+var lTextDecoder = typeof TextDecoder === "undefined" ? (0, module.require)("util").TextDecoder : TextDecoder;
+var cachedTextDecoder = new lTextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+var cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+var WASM_VECTOR_LEN = 0;
+var lTextEncoder = typeof TextEncoder === "undefined" ? (0, module.require)("util").TextEncoder : TextEncoder;
+var cachedTextEncoder = new lTextEncoder("utf-8");
+var encodeString = typeof cachedTextEncoder.encodeInto === "function" ? function(arg, view) {
+  return cachedTextEncoder.encodeInto(arg, view);
+} : function(arg, view) {
+  const buf = cachedTextEncoder.encode(arg);
+  view.set(buf);
+  return {
+    read: arg.length,
+    written: buf.length
+  };
+};
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === void 0) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr2;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8ArrayMemory0();
+  let offset = 0;
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 127) break;
+    mem[ptr + offset] = code;
+  }
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
+    }
+    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+    const ret = encodeString(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN = offset;
+  return ptr;
+}
+function takeFromExternrefTable0(idx) {
+  const value = wasm.__wbindgen_export_3.get(idx);
+  wasm.__externref_table_dealloc(idx);
+  return value;
+}
+function createCosignPubkey(vault_pubkey_hex, vault_claim_pubkey_hex, owner_pubkey_hex, vault_claim_height, open_claim_height, created_at_height, bitcoin_network) {
+  let deferred5_0;
+  let deferred5_1;
+  try {
+    const ptr0 = passStringToWasm0(vault_pubkey_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(vault_claim_pubkey_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(owner_pubkey_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.createCosignPubkey(ptr0, len0, ptr1, len1, ptr2, len2, vault_claim_height, open_claim_height, created_at_height, bitcoin_network);
+    var ptr4 = ret[0];
+    var len4 = ret[1];
+    if (ret[3]) {
+      ptr4 = 0;
+      len4 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred5_0 = ptr4;
+    deferred5_1 = len4;
+    return getStringFromWasm0(ptr4, len4);
+  } finally {
+    wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+  }
+}
+function calculateFee(vault_pubkey_hex, vault_claim_pubkey_hex, owner_pubkey_hex, vault_claim_height, open_claim_height, created_at_height, bitcoin_network, fee_rate_sats_per_vb, to_script_pubkey) {
+  const ptr0 = passStringToWasm0(vault_pubkey_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passStringToWasm0(vault_claim_pubkey_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ptr2 = passStringToWasm0(owner_pubkey_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len2 = WASM_VECTOR_LEN;
+  const ptr3 = passStringToWasm0(to_script_pubkey, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len3 = WASM_VECTOR_LEN;
+  const ret = wasm.calculateFee(ptr0, len0, ptr1, len1, ptr2, len2, vault_claim_height, open_claim_height, created_at_height, bitcoin_network, fee_rate_sats_per_vb, ptr3, len3);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return BigInt.asUintN(64, ret[0]);
+}
+function signPsbtDerived(psbt_hex, xpriv_b58, xpriv_hd_path, finalize) {
+  let deferred5_0;
+  let deferred5_1;
+  try {
+    const ptr0 = passStringToWasm0(psbt_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(xpriv_b58, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(xpriv_hd_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.signPsbtDerived(ptr0, len0, ptr1, len1, ptr2, len2, finalize);
+    var ptr4 = ret[0];
+    var len4 = ret[1];
+    if (ret[3]) {
+      ptr4 = 0;
+      len4 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred5_0 = ptr4;
+    deferred5_1 = len4;
+    return getStringFromWasm0(ptr4, len4);
+  } finally {
+    wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+  }
+}
+function signPsbt(psbt_hex, bitcoin_network, private_key_hex, finalize) {
+  let deferred4_0;
+  let deferred4_1;
+  try {
+    const ptr0 = passStringToWasm0(psbt_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(private_key_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.signPsbt(ptr0, len0, bitcoin_network, ptr1, len1, finalize);
+    var ptr3 = ret[0];
+    var len3 = ret[1];
+    if (ret[3]) {
+      ptr3 = 0;
+      len3 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred4_0 = ptr3;
+    deferred4_1 = len3;
+    return getStringFromWasm0(ptr3, len3);
+  } finally {
+    wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+  }
+}
+function getCosignPsbt(txid, vout, satoshis, vault_pubkey_hex, vault_claim_pubkey_hex, owner_pubkey_hex, vault_claim_height, open_claim_height, created_at_height, bitcoin_network, to_script_pubkey_hex, bitcoin_network_fee) {
+  let deferred7_0;
+  let deferred7_1;
+  try {
+    const ptr0 = passStringToWasm0(txid, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(vault_pubkey_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(vault_claim_pubkey_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ptr3 = passStringToWasm0(owner_pubkey_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len3 = WASM_VECTOR_LEN;
+    const ptr4 = passStringToWasm0(to_script_pubkey_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len4 = WASM_VECTOR_LEN;
+    const ret = wasm.getCosignPsbt(ptr0, len0, vout, satoshis, ptr1, len1, ptr2, len2, ptr3, len3, vault_claim_height, open_claim_height, created_at_height, bitcoin_network, ptr4, len4, bitcoin_network_fee);
+    var ptr6 = ret[0];
+    var len6 = ret[1];
+    if (ret[3]) {
+      ptr6 = 0;
+      len6 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred7_0 = ptr6;
+    deferred7_1 = len6;
+    return getStringFromWasm0(ptr6, len6);
+  } finally {
+    wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
+  }
+}
+var BitcoinNetwork = Object.freeze({
+  /**
+   * Mainnet Bitcoin.
+   */
+  Bitcoin: 0,
+  "0": "Bitcoin",
+  /**
+   * Bitcoin's testnet network.
+   */
+  Testnet: 1,
+  "1": "Testnet",
+  /**
+   * Bitcoin's signet network
+   */
+  Signet: 2,
+  "2": "Signet",
+  /**
+   * Bitcoin's regtest network.
+   */
+  Regtest: 3,
+  "3": "Regtest"
+});
+
+// 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 getChildXpriv(bip39Seed, hdPath, network) {
+  const root = BIP32Factory(ecc).fromSeed(bip39Seed, network);
+  return root.derivePath(hdPath);
+}
+function getBip39Seed(mnemonic, passphrase) {
+  return bip39.mnemonicToSeedSync(mnemonic, passphrase);
+}
+function getXpubFromXpriv(xpriv) {
+  return xpriv.neutered().toBase58();
+}
+function getCompressedPubkey(pubkey) {
+  const pubkeyBuffer = keyToBuffer(pubkey);
+  if (ecc.isPointCompressed(pubkeyBuffer)) {
+    return pubkeyBuffer;
+  }
+  return Buffer.from(ecc.pointCompress(pubkeyBuffer, true));
+}
+function stripLeadingHexPrefix(hex) {
+  if (hex.startsWith("0x")) {
+    return hex.slice(2);
+  }
+  return hex;
+}
+function addressBytesHex(addressString, network) {
+  if (addressString.startsWith("0x")) {
+    return addressString;
+  }
+  console.log("Converting address to bytes:", addressString, network);
+  if (/^[0-9a-fA-F]+$/.test(addressString) && !addressString.startsWith("bc")) {
+    return `0x${addressString}`;
+  }
+  const scriptbuf = address.toOutputScript(addressString, network);
+  return `0x${scriptbuf.toString("hex")}`;
+}
+function keyToBuffer(key) {
+  if (typeof key === "string") {
+    key = stripLeadingHexPrefix(key);
+    return Buffer.from(key, "hex");
+  }
+  return Buffer.from(key);
+}
+
+// ts/CosignScript.ts
+var CosignScript = class _CosignScript {
+  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
+      );
+    }
+  }
+  network;
+  getFundingPsbt() {
+    const { lock, network } = this;
+    return new Psbt({ network }).addOutput({
+      script: keyToBuffer(lock.p2wshScriptHashHex),
+      value: Number(lock.satoshis)
+    });
+  }
+  calculateFee(feeRatePerSatVb, toScriptPubkey) {
+    toScriptPubkey = addressBytesHex(toScriptPubkey, this.network);
+    const { lock, network } = this;
+    return calculateFee(
+      lock.vaultPubkey,
+      lock.vaultClaimPubkey,
+      lock.ownerPubkey,
+      BigInt(lock.vaultClaimHeight),
+      BigInt(lock.openClaimHeight),
+      BigInt(lock.createdAtHeight),
+      toBitcoinNetwork(network),
+      feeRatePerSatVb,
+      toScriptPubkey
+    );
+  }
+  calculateScriptPubkey() {
+    const { lock, network } = this;
+    return createCosignPubkey(
+      lock.vaultPubkey,
+      lock.vaultClaimPubkey,
+      lock.ownerPubkey,
+      BigInt(lock.vaultClaimHeight),
+      BigInt(lock.openClaimHeight),
+      BigInt(lock.createdAtHeight),
+      toBitcoinNetwork(network)
+    );
+  }
+  getCosignPsbt(args) {
+    const { lock, network } = this;
+    const { releaseRequest, utxoRef } = args;
+    releaseRequest.toScriptPubkey = addressBytesHex(releaseRequest.toScriptPubkey, network);
+    const psbtStr = getCosignPsbt(
+      utxoRef.txid,
+      utxoRef.vout,
+      lock.satoshis,
+      lock.vaultPubkey,
+      lock.vaultClaimPubkey,
+      lock.ownerPubkey,
+      BigInt(lock.vaultClaimHeight),
+      BigInt(lock.openClaimHeight),
+      BigInt(lock.createdAtHeight),
+      toBitcoinNetwork(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) {
+      throw new Error("PSBT has no inputs");
+    }
+    if (psbt.data.outputs.length === 0) {
+      throw new Error("PSBT has no outputs");
+    }
+    return psbt;
+  }
+  /**
+   * Cosigns the PSBT with the vault xpub.
+   * @param psbt - The PSBT to cosign.
+   * @param lock - The Bitcoin lock containing the vault information.
+   * @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)) {
+      throw new Error(
+        `Vault xpub fingerprint ${parentFingerprint.toString("hex")} does not match the vault xpriv fingerprint ${vaultXpriv.fingerprint.toString("hex")}`
+      );
+    }
+    const childPath = `${lock.vaultXpubSources.cosignHdIndex}`;
+    const pubkey = vaultXpriv.derivePath(childPath).publicKey;
+    const vaultPubkey = keyToBuffer(lock.vaultPubkey);
+    if (!vaultPubkey.equals(pubkey)) {
+      throw new Error(
+        `Vault pubkey ${vaultPubkey.toString("hex")} does not match the derived pubkey ${pubkey.toString("hex")} using path ${childPath}`
+      );
+    }
+    const signedPsbt = signPsbtDerived(psbt.toHex(), vaultXpriv.toBase58(), childPath, false);
+    psbt = this.psbtFromHex(signedPsbt);
+    return psbt;
+  }
+  /**
+   * Cosigns the transaction.
+   */
+  cosignAndGenerateTx(args) {
+    const { lock } = this;
+    const psbt = this.getCosignPsbt(args);
+    const { addTx, vaultCosignature, ownerXpriv, ownerXprivChildHdPath } = args;
+    psbt.updateInput(0, {
+      partialSig: [
+        {
+          pubkey: keyToBuffer(lock.vaultPubkey),
+          signature: Buffer.from(vaultCosignature)
+        }
+      ]
+    });
+    const derivePubkey = ownerXpriv.publicKey;
+    const ownerPubkey = keyToBuffer(lock.ownerPubkey);
+    if (!ownerPubkey.equals(derivePubkey)) {
+      throw new Error(
+        `Owner pubkey ${ownerPubkey.toString("hex")} does not match the derived pubkey ${derivePubkey.toString("hex")}`
+      );
+    }
+    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 scripts = [
+          payments.p2wpkh({ pubkey: ownerPubkey }).output,
+          payments.p2sh({ redeem: payments.p2wpkh({ pubkey: ownerPubkey }) }).output,
+          payments.p2pkh({ pubkey: ownerPubkey }).output
+        ];
+        if (scripts.some((x) => x && output.script.equals(x))) {
+          psbt.addInput({
+            hash: tx.getId(),
+            index: i,
+            witnessUtxo: {
+              script: output.script,
+              value: output.value
+            }
+          });
+        }
+      }
+    }
+    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);
+  }
+};
+function toBitcoinNetwork(network) {
+  if (network === networks2.bitcoin) {
+    return BitcoinNetwork.Bitcoin;
+  } else if (network === networks2.testnet) {
+    return BitcoinNetwork.Testnet;
+  } else if (network === networks2.regtest) {
+    return BitcoinNetwork.Regtest;
+  }
+  throw new Error("Unsupported network: " + network);
+}
+export {
+  CosignScript,
+  addressBytesHex,
+  getBip39Seed,
+  getChildXpriv,
+  getCompressedPubkey,
+  getXpubFromXpriv,
+  keyToBuffer,
+  stripLeadingHexPrefix
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@argonprotocol/bitcoin",
+  "version": "1.3.0",
+  "description": "A client for interop with bitcoin in nodejs.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/argonprotocol/mainchain.git"
+  },
+  "author": "Argon Foundation",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/argonprotocol/mainchain/issues"
+  },
+  "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",
+    "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"
+  },
+  "files": [
+    "lib/"
+  ],
+  "type": "module",
+  "bin": "./lib/cli.js",
+  "module": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "dependencies": {
+    "@argonprotocol/mainchain": "1.3.0",
+    "bignumber.js": "^9.1.2",
+    "bip32": "^4.0.0",
+    "bip39": "^3.1.0",
+    "bitcoinjs-lib": "^6.1.7",
+    "tiny-secp256k1": "^2.2.3"
+  },
+  "devDependencies": {
+    "@argonprotocol/testing": "1.3.0",
+    "tsup": "^8.4.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.8.3",
+    "vite-plugin-wasm": "^3.4.1",
+    "vitest": "^3.1.1",
+    "wasm-pack": "^0.13.1"
+  },
+  "packageManager": "yarn@4.1.0"
+}