@argonprotocol/bitcoin 1.3.2 → 1.3.3

package/browser/index.js

@@ -0,0 +1,746 @@
+import { Address, OutScript, NETWORK, TEST_NETWORK, Transaction, p2wpkh, p2wsh, p2sh, p2pkh } from '@scure/btc-signer';
+export { Address, Transaction, p2pk, p2pkh, p2sh, p2wpkh, p2wsh } from '@scure/btc-signer';
+import { hexToU8a, u8aToHex, u8aEq } from '@argonprotocol/mainchain';
+import { HDKey } from '@scure/bip32';
+export { HDKey } from '@scure/bip32';
+import * as secp256k1 from '@noble/secp256k1';
+import * as bip39 from '@scure/bip39';
+export { bip39 };
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// 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-WMK2AQRE.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);
+
+// node_modules/@scure/base/lib/esm/index.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function isArrayOf(isString, arr) {
+  if (!Array.isArray(arr))
+    return false;
+  if (arr.length === 0)
+    return true;
+  if (isString) {
+    return arr.every((item) => typeof item === "string");
+  } else {
+    return arr.every((item) => Number.isSafeInteger(item));
+  }
+}
+function afn(input) {
+  if (typeof input !== "function")
+    throw new Error("function expected");
+  return true;
+}
+function astr(label, input) {
+  if (typeof input !== "string")
+    throw new Error(`${label}: string expected`);
+  return true;
+}
+function anumber(n) {
+  if (!Number.isSafeInteger(n))
+    throw new Error(`invalid integer: ${n}`);
+}
+function aArr(input) {
+  if (!Array.isArray(input))
+    throw new Error("array expected");
+}
+function astrArr(label, input) {
+  if (!isArrayOf(true, input))
+    throw new Error(`${label}: array of strings expected`);
+}
+function anumArr(label, input) {
+  if (!isArrayOf(false, input))
+    throw new Error(`${label}: array of numbers expected`);
+}
+// @__NO_SIDE_EFFECTS__
+function chain(...args) {
+  const id = (a) => a;
+  const wrap = (a, b) => (c) => a(b(c));
+  const encode = args.map((x) => x.encode).reduceRight(wrap, id);
+  const decode = args.map((x) => x.decode).reduce(wrap, id);
+  return { encode, decode };
+}
+// @__NO_SIDE_EFFECTS__
+function alphabet(letters) {
+  const lettersA = letters.split("") ;
+  const len = lettersA.length;
+  astrArr("alphabet", lettersA);
+  const indexes = new Map(lettersA.map((l, i) => [l, i]));
+  return {
+    encode: (digits) => {
+      aArr(digits);
+      return digits.map((i) => {
+        if (!Number.isSafeInteger(i) || i < 0 || i >= len)
+          throw new Error(`alphabet.encode: digit index outside alphabet "${i}". Allowed: ${letters}`);
+        return lettersA[i];
+      });
+    },
+    decode: (input) => {
+      aArr(input);
+      return input.map((letter) => {
+        astr("alphabet.decode", letter);
+        const i = indexes.get(letter);
+        if (i === void 0)
+          throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
+        return i;
+      });
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function join(separator = "") {
+  astr("join", separator);
+  return {
+    encode: (from) => {
+      astrArr("join.decode", from);
+      return from.join(separator);
+    },
+    decode: (to) => {
+      astr("join.decode", to);
+      return to.split(separator);
+    }
+  };
+}
+var gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
+var radix2carry = /* @__NO_SIDE_EFFECTS__ */ (from, to) => from + (to - gcd(from, to));
+var powers = /* @__PURE__ */ (() => {
+  let res = [];
+  for (let i = 0; i < 40; i++)
+    res.push(2 ** i);
+  return res;
+})();
+function convertRadix2(data, from, to, padding) {
+  aArr(data);
+  if (from <= 0 || from > 32)
+    throw new Error(`convertRadix2: wrong from=${from}`);
+  if (to <= 0 || to > 32)
+    throw new Error(`convertRadix2: wrong to=${to}`);
+  if (/* @__PURE__ */ radix2carry(from, to) > 32) {
+    throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${/* @__PURE__ */ radix2carry(from, to)}`);
+  }
+  let carry = 0;
+  let pos = 0;
+  const max = powers[from];
+  const mask = powers[to] - 1;
+  const res = [];
+  for (const n of data) {
+    anumber(n);
+    if (n >= max)
+      throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
+    carry = carry << from | n;
+    if (pos + from > 32)
+      throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
+    pos += from;
+    for (; pos >= to; pos -= to)
+      res.push((carry >> pos - to & mask) >>> 0);
+    const pow = powers[pos];
+    if (pow === void 0)
+      throw new Error("invalid carry");
+    carry &= pow - 1;
+  }
+  carry = carry << to - pos & mask;
+  if (!padding && pos >= from)
+    throw new Error("Excess padding");
+  if (!padding && carry > 0)
+    throw new Error(`Non-zero padding: ${carry}`);
+  if (padding && pos > 0)
+    res.push(carry >>> 0);
+  return res;
+}
+// @__NO_SIDE_EFFECTS__
+function radix2(bits, revPadding = false) {
+  anumber(bits);
+  if (/* @__PURE__ */ radix2carry(8, bits) > 32 || /* @__PURE__ */ radix2carry(bits, 8) > 32)
+    throw new Error("radix2: carry overflow");
+  return {
+    encode: (bytes) => {
+      if (!isBytes(bytes))
+        throw new Error("radix2.encode input should be Uint8Array");
+      return convertRadix2(Array.from(bytes), 8, bits, !revPadding);
+    },
+    decode: (digits) => {
+      anumArr("radix2.decode", digits);
+      return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
+    }
+  };
+}
+function unsafeWrapper(fn) {
+  afn(fn);
+  return function(...args) {
+    try {
+      return fn.apply(null, args);
+    } catch (e) {
+    }
+  };
+}
+var BECH_ALPHABET = /* @__PURE__ */ chain(/* @__PURE__ */ alphabet("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), /* @__PURE__ */ join(""));
+var POLYMOD_GENERATORS = [996825010, 642813549, 513874426, 1027748829, 705979059];
+function bech32Polymod(pre) {
+  const b = pre >> 25;
+  let chk = (pre & 33554431) << 5;
+  for (let i = 0; i < POLYMOD_GENERATORS.length; i++) {
+    if ((b >> i & 1) === 1)
+      chk ^= POLYMOD_GENERATORS[i];
+  }
+  return chk;
+}
+function bechChecksum(prefix, words, encodingConst = 1) {
+  const len = prefix.length;
+  let chk = 1;
+  for (let i = 0; i < len; i++) {
+    const c = prefix.charCodeAt(i);
+    if (c < 33 || c > 126)
+      throw new Error(`Invalid prefix (${prefix})`);
+    chk = bech32Polymod(chk) ^ c >> 5;
+  }
+  chk = bech32Polymod(chk);
+  for (let i = 0; i < len; i++)
+    chk = bech32Polymod(chk) ^ prefix.charCodeAt(i) & 31;
+  for (let v of words)
+    chk = bech32Polymod(chk) ^ v;
+  for (let i = 0; i < 6; i++)
+    chk = bech32Polymod(chk);
+  chk ^= encodingConst;
+  return BECH_ALPHABET.encode(convertRadix2([chk % powers[30]], 30, 5, false));
+}
+// @__NO_SIDE_EFFECTS__
+function genBech32(encoding) {
+  const ENCODING_CONST = 1 ;
+  const _words = /* @__PURE__ */ radix2(5);
+  const fromWords = _words.decode;
+  const toWords = _words.encode;
+  const fromWordsUnsafe = unsafeWrapper(fromWords);
+  function encode(prefix, words, limit = 90) {
+    astr("bech32.encode prefix", prefix);
+    if (isBytes(words))
+      words = Array.from(words);
+    anumArr("bech32.encode", words);
+    const plen = prefix.length;
+    if (plen === 0)
+      throw new TypeError(`Invalid prefix length ${plen}`);
+    const actualLength = plen + 7 + words.length;
+    if (limit !== false && actualLength > limit)
+      throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`);
+    const lowered = prefix.toLowerCase();
+    const sum = bechChecksum(lowered, words, ENCODING_CONST);
+    return `${lowered}1${BECH_ALPHABET.encode(words)}${sum}`;
+  }
+  function decode(str, limit = 90) {
+    astr("bech32.decode input", str);
+    const slen = str.length;
+    if (slen < 8 || limit !== false && slen > limit)
+      throw new TypeError(`invalid string length: ${slen} (${str}). Expected (8..${limit})`);
+    const lowered = str.toLowerCase();
+    if (str !== lowered && str !== str.toUpperCase())
+      throw new Error(`String must be lowercase or uppercase`);
+    const sepIndex = lowered.lastIndexOf("1");
+    if (sepIndex === 0 || sepIndex === -1)
+      throw new Error(`Letter "1" must be present between prefix and data only`);
+    const prefix = lowered.slice(0, sepIndex);
+    const data = lowered.slice(sepIndex + 1);
+    if (data.length < 6)
+      throw new Error("Data must be at least 6 characters long");
+    const words = BECH_ALPHABET.decode(data).slice(0, -6);
+    const sum = bechChecksum(prefix, words, ENCODING_CONST);
+    if (!data.endsWith(sum))
+      throw new Error(`Invalid checksum in ${str}: expected "${sum}"`);
+    return { prefix, words };
+  }
+  const decodeUnsafe = unsafeWrapper(decode);
+  function decodeToBytes(str) {
+    const { prefix, words } = decode(str, false);
+    return { prefix, words, bytes: fromWords(words) };
+  }
+  function encodeFromBytes(prefix, bytes) {
+    return encode(prefix, toWords(bytes));
+  }
+  return {
+    encode,
+    decode,
+    encodeFromBytes,
+    decodeToBytes,
+    decodeUnsafe,
+    fromWords,
+    fromWordsUnsafe,
+    toWords
+  };
+}
+var bech32 = /* @__PURE__ */ genBech32();
+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 = HDKey.fromMasterSeed(bip39Seed, getBip32Version(network));
+  return root.derive(hdPath);
+}
+function getXpubFromXpriv(xpriv) {
+  return xpriv.publicExtendedKey;
+}
+function getCompressedPubkey(pubkey) {
+  const pubkeyUint8Array = keyToU8a(pubkey);
+  if (pubkeyUint8Array.length === 33) {
+    return pubkeyUint8Array;
+  }
+  const point = secp256k1.Point.fromHex(pubkeyUint8Array);
+  return point.toRawBytes(true);
+}
+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");
+  }
+  const witnessProgram = script.slice(2);
+  const version = 0;
+  const prefix = getBech32Prefix(network);
+  return bech32.encode(prefix, [version, ...bech32.toWords(witnessProgram)]);
+}
+function addressBytesHex(address, network) {
+  if (address.startsWith("0x")) {
+    return address;
+  }
+  const bech32Prefix = getBech32Prefix(network);
+  if (/^[0-9a-fA-F]+$/.test(address) && !address.startsWith("bc") && !address.startsWith(bech32Prefix)) {
+    return `0x${address}`;
+  }
+  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 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
+    };
+  }
+}
+
+// ts/CosignScript.ts
+var CosignScript = class {
+  constructor(lock, network) {
+    this.lock = lock;
+    this.network = network;
+  }
+  getFundingPsbt() {
+    const { lock, network } = this;
+    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);
+    const { lock, network } = this;
+    return calculateFee(
+      lock.vaultPubkey,
+      lock.vaultClaimPubkey,
+      lock.ownerPubkey,
+      BigInt(lock.vaultClaimHeight),
+      BigInt(lock.openClaimHeight),
+      BigInt(lock.createdAtHeight),
+      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),
+      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),
+      network,
+      releaseRequest.toScriptPubkey,
+      releaseRequest.bitcoinNetworkFee
+    );
+    return this.psbtFromHex(psbtStr);
+  }
+  psbtFromHex(psbtHex) {
+    const psbtBytes = hexToU8a(psbtHex);
+    const tx = Transaction.fromPSBT(psbtBytes);
+    if (tx.inputsLength === 0) {
+      throw new Error("PSBT has no inputs");
+    }
+    if (tx.outputsLength === 0) {
+      throw new Error("PSBT has no outputs");
+    }
+    return tx;
+  }
+  /**
+   * 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 = 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 ${u8aToHex(parentFingerprint)} does not match the vault xpriv fingerprint ${u8aToHex(vaultFingerprint)}`
+      );
+    }
+    const childPath = `${lock.vaultXpubSources.cosignHdIndex}`;
+    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 ${u8aToHex(vaultPubkey)} does not match the derived pubkey ${u8aToHex(pubkey)} using path ${childPath}`
+      );
+    }
+    const signedPsbt = signPsbtDerived(
+      u8aToHex(psbt.toPSBT()),
+      vaultXpriv.privateExtendedKey,
+      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: [[keyToU8a(lock.vaultPubkey), vaultCosignature]]
+    });
+    const derivePubkey = 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 ${u8aToHex(ownerPubkey)} does not match the derived pubkey ${u8aToHex(derivePubkey)}`
+      );
+    }
+    if (addTx) {
+      const addTxBytes = hexToU8a(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 = [
+          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 && u8aEq(output.script, x))) {
+          psbt.addInput({
+            txid: tx.id,
+            index: i,
+            witnessUtxo: {
+              script: output.script,
+              amount: output.amount
+            }
+          });
+        }
+      }
+    }
+    const psbtBytes = u8aToHex(psbt.toPSBT());
+    const signedPsbt = ownerXprivChildHdPath ? signPsbtDerived(psbtBytes, ownerXpriv.privateExtendedKey, ownerXprivChildHdPath, true) : signPsbt(psbtBytes, this.network, u8aToHex(ownerXpriv.privateKey, void 0, false), true);
+    return this.psbtFromHex(signedPsbt);
+  }
+};
+function getBitcoinNetworkFromApi(network) {
+  if (network.isBitcoin) {
+    return BitcoinNetwork.Bitcoin;
+  } else if (network.isTestnet) {
+    return BitcoinNetwork.Testnet;
+  } else if (network.isRegtest) {
+    return BitcoinNetwork.Regtest;
+  }
+  throw new Error("Unsupported network: " + network);
+}
+/*! Bundled license information:
+
+@scure/base/lib/esm/index.js:
+  (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
+
+export { BitcoinNetwork, CosignScript, addressBytesHex, getBech32Prefix, getBip32Version, getBitcoinNetworkFromApi, getChildXpriv, getCompressedPubkey, getScureNetwork, getXpubFromXpriv, keyToU8a, p2wshScriptHexToAddress };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map