@arkade-os/sdk 0.4.78 → 0.4.79

package/dist/{chunk-PWIESIO6.cjs → chunk-DAYCCIRO.cjs}

@@ -1,11 +1,12 @@
 'use strict';
 
-var btcSigner = require('@scure/btc-signer');
-var bip68 = require('bip68');
 var utils_js = require('@scure/btc-signer/utils.js');
 var base = require('@scure/base');
 var script_js = require('@scure/btc-signer/script.js');
+var bip68 = require('bip68');
+var btcSigner = require('@scure/btc-signer');
 var payment_js = require('@scure/btc-signer/payment.js');
+var P = require('micro-packed');
 var psbt_js = require('@scure/btc-signer/psbt.js');
 var secp256k1_js = require('@noble/curves/secp256k1.js');
 
@@ -28,187 +29,9 @@ function _interopNamespace(e) {
 }
 
 var bip68__namespace = /*#__PURE__*/_interopNamespace(bip68);
+var P__namespace = /*#__PURE__*/_interopNamespace(P);
 
-// src/utils/transaction.ts
-var Transaction = class extends btcSigner.Transaction {
-  static ARK_TX_OPTS = {
-    allowUnknown: true,
-    allowUnknownOutputs: true,
-    allowUnknownInputs: true
-  };
-  constructor(opts) {
-    super(withArkOpts(opts));
-  }
-  static fromPSBT(psbt_, opts) {
-    return btcSigner.Transaction.fromPSBT(psbt_, withArkOpts(opts));
-  }
-  static fromRaw(raw, opts) {
-    return btcSigner.Transaction.fromRaw(raw, withArkOpts(opts));
-  }
-};
-function withArkOpts(opts) {
-  return { ...Transaction.ARK_TX_OPTS, ...opts };
-}
-function formatSighash(type) {
-  return `0x${type.toString(16).padStart(2, "0")}`;
-}
-function assertAllowedSighashTypes(tx, allowedSighashTypes = [btcSigner.SigHash.DEFAULT]) {
-  for (let i = 0; i < tx.inputsLength; i++) {
-    const declared = tx.getInput(i).sighashType;
-    if (declared === void 0) continue;
-    if (!allowedSighashTypes.includes(declared)) {
-      throw new Error(`Unallowed sighash type ${formatSighash(declared)} for input ${i}.`);
-    }
-  }
-}
-function timelockToSequence(timelock) {
-  return bip68__namespace.encode(
-    timelock.type === "blocks" ? { blocks: Number(timelock.value) } : { seconds: Number(timelock.value) }
-  );
-}
-function sequenceToTimelock(sequence) {
-  const decoded = bip68__namespace.decode(sequence);
-  if ("blocks" in decoded && decoded.blocks !== void 0) {
-    return { type: "blocks", value: BigInt(decoded.blocks) };
-  }
-  if ("seconds" in decoded && decoded.seconds !== void 0) {
-    return { type: "seconds", value: BigInt(decoded.seconds) };
-  }
-  throw new Error(`Invalid BIP68 sequence: ${sequence}`);
-}
-var ArkPsbtFieldKey = /* @__PURE__ */ ((ArkPsbtFieldKey2) => {
-  ArkPsbtFieldKey2["VtxoTaprootTree"] = "taptree";
-  ArkPsbtFieldKey2["VtxoTreeExpiry"] = "expiry";
-  ArkPsbtFieldKey2["Cosigner"] = "cosigner";
-  ArkPsbtFieldKey2["ConditionWitness"] = "condition";
-  ArkPsbtFieldKey2["PrevArkTx"] = "prevarktx";
-  ArkPsbtFieldKey2["PrevoutTx"] = "prevouttx";
-  return ArkPsbtFieldKey2;
-})(ArkPsbtFieldKey || {});
-var ArkPsbtFieldKeyType = 222;
-function setArkPsbtField(tx, inputIndex, coder, value) {
-  tx.updateInput(inputIndex, {
-    unknown: [...tx.getInput(inputIndex)?.unknown ?? [], coder.encode(value)]
-  });
-}
-function getArkPsbtFields(tx, inputIndex, coder) {
-  const unknown = tx.getInput(inputIndex)?.unknown ?? [];
-  const fields = [];
-  for (const u of unknown) {
-    const v = coder.decode(u);
-    if (v !== null) fields.push(v);
-  }
-  return fields;
-}
-var VtxoTaprootTree = {
-  key: "taptree" /* VtxoTaprootTree */,
-  encode: (value) => [
-    {
-      type: ArkPsbtFieldKeyType,
-      key: encodedPsbtFieldKey["taptree" /* VtxoTaprootTree */]
-    },
-    value
-  ],
-  decode: (value) => nullIfCatch(() => {
-    if (!checkKeyMatch(value[0], "taptree" /* VtxoTaprootTree */)) return null;
-    return value[1];
-  })
-};
-var ConditionWitness = {
-  key: "condition" /* ConditionWitness */,
-  encode: (value) => [
-    {
-      type: ArkPsbtFieldKeyType,
-      key: encodedPsbtFieldKey["condition" /* ConditionWitness */]
-    },
-    btcSigner.RawWitness.encode(value)
-  ],
-  decode: (value) => nullIfCatch(() => {
-    if (!checkKeyMatch(value[0], "condition" /* ConditionWitness */)) return null;
-    return btcSigner.RawWitness.decode(value[1]);
-  })
-};
-var PrevArkTxField = {
-  key: "prevarktx" /* PrevArkTx */,
-  encode: (value) => [
-    {
-      type: ArkPsbtFieldKeyType,
-      key: encodedPsbtFieldKey["prevarktx" /* PrevArkTx */]
-    },
-    value
-  ],
-  decode: (value) => nullIfCatch(() => {
-    if (!checkKeyMatch(value[0], "prevarktx" /* PrevArkTx */)) return null;
-    return value[1];
-  })
-};
-var PrevoutTxField = {
-  key: "prevouttx" /* PrevoutTx */,
-  encode: (value) => [
-    {
-      type: ArkPsbtFieldKeyType,
-      key: encodedPsbtFieldKey["prevouttx" /* PrevoutTx */]
-    },
-    value
-  ],
-  decode: (value) => nullIfCatch(() => {
-    if (!checkKeyMatch(value[0], "prevouttx" /* PrevoutTx */)) return null;
-    return value[1];
-  })
-};
-var CosignerPublicKey = {
-  key: "cosigner" /* Cosigner */,
-  encode: (value) => [
-    {
-      type: ArkPsbtFieldKeyType,
-      key: new Uint8Array([...encodedPsbtFieldKey["cosigner" /* Cosigner */], value.index])
-    },
-    value.key
-  ],
-  decode: (unknown) => nullIfCatch(() => {
-    if (!checkKeyMatch(unknown[0], "cosigner" /* Cosigner */, true)) return null;
-    return {
-      index: unknown[0].key[unknown[0].key.length - 1],
-      key: unknown[1]
-    };
-  })
-};
-var VtxoTreeExpiry = {
-  key: "expiry" /* VtxoTreeExpiry */,
-  encode: (value) => [
-    {
-      type: ArkPsbtFieldKeyType,
-      key: encodedPsbtFieldKey["expiry" /* VtxoTreeExpiry */]
-    },
-    btcSigner.ScriptNum(6, true).encode(value.value === 0n ? 0n : value.value)
-  ],
-  decode: (unknown) => nullIfCatch(() => {
-    if (!checkKeyMatch(unknown[0], "expiry" /* VtxoTreeExpiry */)) return null;
-    const v = btcSigner.ScriptNum(6, true).decode(unknown[1]);
-    if (!v) return null;
-    return sequenceToTimelock(Number(v));
-  })
-};
-var encodedPsbtFieldKey = Object.fromEntries(
-  Object.values(ArkPsbtFieldKey).map((key) => [key, new TextEncoder().encode(key)])
-);
-var nullIfCatch = (fn) => {
-  try {
-    return fn();
-  } catch {
-    return null;
-  }
-};
-function checkKeyMatch(key, arkPsbtFieldKey, prefixOnly = false) {
-  if (key.type !== ArkPsbtFieldKeyType) return false;
-  const expected = encodedPsbtFieldKey[arkPsbtFieldKey];
-  if (key.key.length < expected.length) return false;
-  if (!prefixOnly && key.key.length !== expected.length) return false;
-  for (let i = 0; i < expected.length; i++) {
-    if (key.key[i] !== expected[i]) return false;
-  }
-  return true;
-}
+// src/networks.ts
 var getNetwork = (network) => {
   const found = networks[network];
   if (!found) throw new Error(`Unsupported network: ${network}`);
@@ -344,6 +167,21 @@ var ArkAddress = class _ArkAddress {
     return script_js.Script.encode(["RETURN", this.vtxoTaprootKey]);
   }
 };
+function timelockToSequence(timelock) {
+  return bip68__namespace.encode(
+    timelock.type === "blocks" ? { blocks: Number(timelock.value) } : { seconds: Number(timelock.value) }
+  );
+}
+function sequenceToTimelock(sequence) {
+  const decoded = bip68__namespace.decode(sequence);
+  if ("blocks" in decoded && decoded.blocks !== void 0) {
+    return { type: "blocks", value: BigInt(decoded.blocks) };
+  }
+  if ("seconds" in decoded && decoded.seconds !== void 0) {
+    return { type: "seconds", value: BigInt(decoded.seconds) };
+  }
+  throw new Error(`Invalid BIP68 sequence: ${sequence}`);
+}
 var MinimalScriptNum = btcSigner.ScriptNum(void 0, true);
 function decodeTapscript(script) {
   const types = [
@@ -876,7 +714,25 @@ function assembleBtcdTaprootTree(scripts) {
   }
   return branches[0];
 }
-var TapTreeCoder = psbt_js.PSBTOutput.tapTree[2];
+function btcdLeafLayout(count) {
+  const placeholders = Array.from({ length: count }, () => new Uint8Array());
+  const indexOf = new Map(placeholders.map((script, index) => [script, index]));
+  const layout = [];
+  const walk = (node, depth) => {
+    if (Array.isArray(node)) {
+      walk(node[0], depth + 1);
+      walk(node[1], depth + 1);
+    } else {
+      layout.push({ index: indexOf.get(node.script), depth });
+    }
+  };
+  walk(assembleBtcdTaprootTree(placeholders), 0);
+  return layout;
+}
+var TapTreeCoder = P__namespace.array(
+  null,
+  P__namespace.struct({ depth: P__namespace.U8, version: P__namespace.U8, script: script_js.VarBytes })
+);
 function scriptFromTapLeafScript(leaf) {
   return leaf[1].subarray(0, leaf[1].length - 1);
 }
@@ -896,7 +752,7 @@ var VtxoScript = class _VtxoScript {
   constructor(scripts) {
     this.scripts = scripts;
     const tapTree = assembleBtcdTaprootTree(scripts);
-    const payment = btcSigner.p2tr(btcSigner.TAPROOT_UNSPENDABLE_KEY, tapTree, void 0, true);
+    const payment = btcSigner.p2tr(btcSigner.taprootNumsKey(), tapTree, void 0, true);
     if (!payment.tapLeafScript || payment.tapLeafScript.length !== scripts.length) {
       throw new Error("invalid scripts");
     }
@@ -911,15 +767,46 @@ var VtxoScript = class _VtxoScript {
   /**
    * Decode a virtual output script from an encoded TapTree.
    *
+   * Leaves are normally read in construction order and their depths
+   * ignored: that covers the {@link encode} form (every depth 1) and the
+   * placeholder depths other writers use, such as arkd's. The exception is
+   * the BIP-371 form {@link toBIP371TapTree} writes, whose leaves are in the
+   * tree's DFS order: for some leaf counts (6, 7, 10, ...) that differs from
+   * construction order. A tree whose depths are exactly the shape
+   * `assembleBtcdTaprootTree` builds is that form, so its leaves are mapped
+   * back to construction order first. No construction-order writer produces
+   * that depth sequence when the two orders differ, so this never reorders
+   * a tree that decoded correctly before.
+   *
+   * Every leaf must carry the base tapscript version: the tree is rebuilt
+   * with {@link TAP_LEAF_VERSION} leaves, so any other version would
+   * silently derive a different taproot key.
+   *
    * @param tapTree - Encoded TapTree bytes
    * @returns Decoded virtual output script
    * @throws Error if the TapTree cannot be decoded into a valid script set
+   *         or a leaf carries a version other than {@link TAP_LEAF_VERSION}
    * @see encode
    */
   static decode(tapTree) {
     const leaves = TapTreeCoder.decode(tapTree);
+    const foreign = leaves.find((leaf) => leaf.version !== payment_js.TAP_LEAF_VERSION);
+    if (foreign) {
+      throw new Error(`unsupported tap leaf version 0x${foreign.version.toString(16)}`);
+    }
     const scripts = leaves.map((leaf) => leaf.script);
-    return new _VtxoScript(scripts);
+    if (leaves.every((leaf) => leaf.depth === 1)) {
+      return new _VtxoScript(scripts);
+    }
+    const layout = btcdLeafLayout(leaves.length);
+    if (layout.some((slot, i) => slot.depth !== leaves[i].depth)) {
+      return new _VtxoScript(scripts);
+    }
+    const ordered = new Array(leaves.length);
+    layout.forEach((slot, i) => {
+      ordered[slot.index] = scripts[i];
+    });
+    return new _VtxoScript(ordered);
   }
   /**
    * Encode the virtual output script to a TapTree byte representation.
@@ -1002,6 +889,15 @@ var VtxoScript = class _VtxoScript {
     return paths;
   }
 };
+function toBIP371TapTree(tapTree) {
+  const scripts = TapTreeCoder.decode(tapTree).map((leaf) => leaf.script);
+  const vtxoScript = new VtxoScript(scripts);
+  return vtxoScript.leaves.map((leaf) => ({
+    depth: leaf[0].merklePath.length,
+    version: payment_js.TAP_LEAF_VERSION,
+    script: scriptFromTapLeafScript(leaf)
+  }));
+}
 function getSequence(tapLeafScript) {
   let sequence = void 0;
   try {
@@ -1018,6 +914,290 @@ function getSequence(tapLeafScript) {
   }
   return sequence;
 }
+var Transaction = class extends btcSigner.Transaction {
+  static ARK_TX_OPTS = {
+    unknown: "ignore",
+    allowUnknownOutputs: true,
+    allowUnknownInputs: true
+  };
+  constructor(opts) {
+    super(withArkOpts(opts));
+  }
+  /**
+   * Decode a PSBT. PSBTs carrying a legacy `PSBT_OUT_TAP_TREE` (see
+   * {@link repairLegacyOutputTapTrees}) are repaired and decoded again
+   * instead of being rejected.
+   */
+  static fromPSBT(psbt_, opts) {
+    try {
+      return btcSigner.Transaction.fromPSBT(psbt_, withArkOpts(opts));
+    } catch (err) {
+      const repaired = repairLegacyOutputTapTrees(psbt_);
+      if (!repaired) throw err;
+      return btcSigner.Transaction.fromPSBT(repaired, withArkOpts(opts));
+    }
+  }
+  static fromRaw(raw, opts) {
+    return btcSigner.Transaction.fromRaw(raw, withArkOpts(opts));
+  }
+};
+function withArkOpts(opts) {
+  return { ...Transaction.ARK_TX_OPTS, ...opts };
+}
+var PSBT_MAGIC = new Uint8Array([112, 115, 98, 116, 255]);
+var PSBT_GLOBAL_UNSIGNED_TX = 0;
+var PSBT_GLOBAL_INPUT_COUNT = 4;
+var PSBT_OUT_TAP_TREE = 6;
+function repairLegacyOutputTapTrees(psbt) {
+  let maps;
+  let inputsCount;
+  try {
+    maps = readPsbtMaps(psbt);
+    inputsCount = psbtInputsCount(maps[0]);
+  } catch {
+    return void 0;
+  }
+  let repaired = false;
+  for (const output of maps.slice(1 + inputsCount)) {
+    for (const kv of output) {
+      if (kv.key.length !== 1 || kv.key[0] !== PSBT_OUT_TAP_TREE) continue;
+      const value = legacyTapTreeToBIP371(kv.value);
+      if (!value) continue;
+      kv.value = value;
+      repaired = true;
+    }
+  }
+  return repaired ? writePsbtMaps(maps) : void 0;
+}
+function legacyTapTreeToBIP371(value) {
+  try {
+    psbt_js.PSBTOutput.tapTree[2].decode(value);
+    return void 0;
+  } catch {
+  }
+  let leaves;
+  try {
+    leaves = TapTreeCoder.decode(value);
+  } catch {
+    return void 0;
+  }
+  if (leaves.length === 0 || leaves.some((leaf) => leaf.depth !== 1)) return void 0;
+  try {
+    return TapTreeCoder.encode(toBIP371TapTree(value));
+  } catch {
+    return void 0;
+  }
+}
+function psbtInputsCount(global) {
+  for (const { key, value } of global) {
+    if (key.length !== 1) continue;
+    if (key[0] === PSBT_GLOBAL_UNSIGNED_TX) return btcSigner.RawTx.decode(value).inputs.length;
+    if (key[0] === PSBT_GLOBAL_INPUT_COUNT) return readCompactSize(value, 0)[0];
+  }
+  throw new Error("PSBT: missing input count");
+}
+function readPsbtMaps(psbt) {
+  for (let i = 0; i < PSBT_MAGIC.length; i++) {
+    if (psbt[i] !== PSBT_MAGIC[i]) throw new Error("PSBT: invalid magic");
+  }
+  const maps = [];
+  let pos = PSBT_MAGIC.length;
+  while (pos < psbt.length) {
+    const map = [];
+    for (; ; ) {
+      const [keyLen, afterKeyLen] = readCompactSize(psbt, pos);
+      pos = afterKeyLen;
+      if (keyLen === 0) break;
+      const key = readBytes(psbt, pos, keyLen);
+      pos += keyLen;
+      const [valueLen, afterValueLen] = readCompactSize(psbt, pos);
+      pos = afterValueLen;
+      const value = readBytes(psbt, pos, valueLen);
+      pos += valueLen;
+      map.push({ key, value });
+    }
+    maps.push(map);
+  }
+  if (maps.length === 0) throw new Error("PSBT: missing global map");
+  return maps;
+}
+function writePsbtMaps(maps) {
+  const parts = [PSBT_MAGIC];
+  for (const map of maps) {
+    for (const { key, value } of map) {
+      parts.push(writeCompactSize(key.length), key, writeCompactSize(value.length), value);
+    }
+    parts.push(new Uint8Array([0]));
+  }
+  return utils_js.concatBytes(...parts);
+}
+function readBytes(data, pos, len) {
+  if (pos + len > data.length) throw new Error("PSBT: unexpected end of data");
+  return data.slice(pos, pos + len);
+}
+function readCompactSize(data, pos) {
+  const first = readBytes(data, pos, 1)[0];
+  if (first < 253) return [first, pos + 1];
+  const width = first === 253 ? 2 : first === 254 ? 4 : 8;
+  const bytes = readBytes(data, pos + 1, width);
+  let value = 0;
+  for (let i = width - 1; i >= 0; i--) value = value * 256 + bytes[i];
+  if (!Number.isSafeInteger(value)) throw new Error("PSBT: compact size too large");
+  return [value, pos + 1 + width];
+}
+function writeCompactSize(value) {
+  if (value < 253) return new Uint8Array([value]);
+  const width = value <= 65535 ? 2 : value <= 4294967295 ? 4 : 8;
+  const out = new Uint8Array(1 + width);
+  out[0] = width === 2 ? 253 : width === 4 ? 254 : 255;
+  for (let i = 0, v = value; i < width; i++, v = Math.floor(v / 256)) out[1 + i] = v % 256;
+  return out;
+}
+function formatSighash(type) {
+  return `0x${type.toString(16).padStart(2, "0")}`;
+}
+function assertAllowedSighashTypes(tx, allowedSighashTypes = [btcSigner.SigHash.DEFAULT]) {
+  for (let i = 0; i < tx.inputsLength; i++) {
+    const declared = tx.getInput(i).sighashType;
+    if (declared === void 0) continue;
+    if (!allowedSighashTypes.includes(declared)) {
+      throw new Error(`Unallowed sighash type ${formatSighash(declared)} for input ${i}.`);
+    }
+  }
+}
+var ArkPsbtFieldKey = /* @__PURE__ */ ((ArkPsbtFieldKey2) => {
+  ArkPsbtFieldKey2["VtxoTaprootTree"] = "taptree";
+  ArkPsbtFieldKey2["VtxoTreeExpiry"] = "expiry";
+  ArkPsbtFieldKey2["Cosigner"] = "cosigner";
+  ArkPsbtFieldKey2["ConditionWitness"] = "condition";
+  ArkPsbtFieldKey2["PrevArkTx"] = "prevarktx";
+  ArkPsbtFieldKey2["PrevoutTx"] = "prevouttx";
+  return ArkPsbtFieldKey2;
+})(ArkPsbtFieldKey || {});
+var ArkPsbtFieldKeyType = 222;
+function setArkPsbtField(tx, inputIndex, coder, value) {
+  tx.updateInput(inputIndex, {
+    unknown: [...tx.getInput(inputIndex)?.unknown ?? [], coder.encode(value)]
+  });
+}
+function getArkPsbtFields(tx, inputIndex, coder) {
+  const unknown = tx.getInput(inputIndex)?.unknown ?? [];
+  const fields = [];
+  for (const u of unknown) {
+    const v = coder.decode(u);
+    if (v !== null) fields.push(v);
+  }
+  return fields;
+}
+var VtxoTaprootTree = {
+  key: "taptree" /* VtxoTaprootTree */,
+  encode: (value) => [
+    {
+      type: ArkPsbtFieldKeyType,
+      key: encodedPsbtFieldKey["taptree" /* VtxoTaprootTree */]
+    },
+    value
+  ],
+  decode: (value) => nullIfCatch(() => {
+    if (!checkKeyMatch(value[0], "taptree" /* VtxoTaprootTree */)) return null;
+    return value[1];
+  })
+};
+var ConditionWitness = {
+  key: "condition" /* ConditionWitness */,
+  encode: (value) => [
+    {
+      type: ArkPsbtFieldKeyType,
+      key: encodedPsbtFieldKey["condition" /* ConditionWitness */]
+    },
+    btcSigner.RawWitness.encode(value)
+  ],
+  decode: (value) => nullIfCatch(() => {
+    if (!checkKeyMatch(value[0], "condition" /* ConditionWitness */)) return null;
+    return btcSigner.RawWitness.decode(value[1]);
+  })
+};
+var PrevArkTxField = {
+  key: "prevarktx" /* PrevArkTx */,
+  encode: (value) => [
+    {
+      type: ArkPsbtFieldKeyType,
+      key: encodedPsbtFieldKey["prevarktx" /* PrevArkTx */]
+    },
+    value
+  ],
+  decode: (value) => nullIfCatch(() => {
+    if (!checkKeyMatch(value[0], "prevarktx" /* PrevArkTx */)) return null;
+    return value[1];
+  })
+};
+var PrevoutTxField = {
+  key: "prevouttx" /* PrevoutTx */,
+  encode: (value) => [
+    {
+      type: ArkPsbtFieldKeyType,
+      key: encodedPsbtFieldKey["prevouttx" /* PrevoutTx */]
+    },
+    value
+  ],
+  decode: (value) => nullIfCatch(() => {
+    if (!checkKeyMatch(value[0], "prevouttx" /* PrevoutTx */)) return null;
+    return value[1];
+  })
+};
+var CosignerPublicKey = {
+  key: "cosigner" /* Cosigner */,
+  encode: (value) => [
+    {
+      type: ArkPsbtFieldKeyType,
+      key: new Uint8Array([...encodedPsbtFieldKey["cosigner" /* Cosigner */], value.index])
+    },
+    value.key
+  ],
+  decode: (unknown) => nullIfCatch(() => {
+    if (!checkKeyMatch(unknown[0], "cosigner" /* Cosigner */, true)) return null;
+    return {
+      index: unknown[0].key[unknown[0].key.length - 1],
+      key: unknown[1]
+    };
+  })
+};
+var VtxoTreeExpiry = {
+  key: "expiry" /* VtxoTreeExpiry */,
+  encode: (value) => [
+    {
+      type: ArkPsbtFieldKeyType,
+      key: encodedPsbtFieldKey["expiry" /* VtxoTreeExpiry */]
+    },
+    btcSigner.ScriptNum(6, true).encode(value.value === 0n ? 0n : value.value)
+  ],
+  decode: (unknown) => nullIfCatch(() => {
+    if (!checkKeyMatch(unknown[0], "expiry" /* VtxoTreeExpiry */)) return null;
+    const v = btcSigner.ScriptNum(6, true).decode(unknown[1]);
+    if (!v) return null;
+    return sequenceToTimelock(Number(v));
+  })
+};
+var encodedPsbtFieldKey = Object.fromEntries(
+  Object.values(ArkPsbtFieldKey).map((key) => [key, new TextEncoder().encode(key)])
+);
+var nullIfCatch = (fn) => {
+  try {
+    return fn();
+  } catch {
+    return null;
+  }
+};
+function checkKeyMatch(key, arkPsbtFieldKey, prefixOnly = false) {
+  if (key.type !== ArkPsbtFieldKeyType) return false;
+  const expected = encodedPsbtFieldKey[arkPsbtFieldKey];
+  if (key.key.length < expected.length) return false;
+  if (!prefixOnly && key.key.length !== expected.length) return false;
+  for (let i = 0; i < expected.length; i++) {
+    if (key.key[i] !== expected[i]) return false;
+  }
+  return true;
+}
 
 // src/providers/eventSource.ts
 var GUIDANCE = "Pass one with configureEventSource(url => new EventSource(url)) \u2014 in Node, from the `eventsource` package or by running with --experimental-eventsource. In React Native, use ExpoArkProvider / ExpoIndexerProvider instead.";
@@ -1044,7 +1224,7 @@ function resolveEventSource(override) {
 }
 
 // package.json
-var version = "0.4.78";
+var version = "0.4.79";
 
 // src/utils/fetch.ts
 var buildVersion = "0.9.9";
@@ -1285,7 +1465,6 @@ var OP_RETURN_EMPTY_PKSCRIPT = new Uint8Array([btcSigner.OP.RETURN]);
 var ZERO_32 = new Uint8Array(32).fill(0);
 var MAX_INDEX = 4294967295;
 var TAG_INTENT_PROOF = "ark-intent-proof-message";
-var PSBT_GLOBAL_GENERIC_SIGNED_MESSAGE = 9;
 function validateInput(input) {
   if (input.index === void 0) throw new Error("intent proof input requires index");
   if (input.txid === void 0) throw new Error("intent proof input requires txid");
@@ -1332,8 +1511,9 @@ function craftToSignTx(toSpend, inputs, outputs, message) {
     version: 2,
     lockTime: 0
   });
+  const { unknown: _, ...toSpendInput } = firstInput;
   tx.addInput({
-    ...firstInput,
+    ...toSpendInput,
     txid: toSpend.id,
     index: 0,
     witnessUtxo: {
@@ -1367,14 +1547,7 @@ function craftToSignTx(toSpend, inputs, outputs, message) {
       script: output.script
     });
   }
-  const global = tx.global;
-  global.unknown = [
-    ...global.unknown ?? [],
-    [
-      { type: PSBT_GLOBAL_GENERIC_SIGNED_MESSAGE, key: new Uint8Array() },
-      new TextEncoder().encode(message)
-    ]
-  ];
+  tx.global.genericSignedMessage = new TextEncoder().encode(message);
   return tx;
 }
 function hashMessage(message, tag = TAG_INTENT_PROOF) {
@@ -2572,9 +2745,10 @@ exports.sequenceToTimelock = sequenceToTimelock;
 exports.setArkPsbtField = setArkPsbtField;
 exports.throwIfHttpUnavailable = throwIfHttpUnavailable;
 exports.timelockToSequence = timelockToSequence;
+exports.toBIP371TapTree = toBIP371TapTree;
 exports.toBatchExpiry = toBatchExpiry;
 exports.toOffchainInputFeeParams = toOffchainInputFeeParams;
 exports.toProviderUnavailable = toProviderUnavailable;
 exports.toVirtualStatus = toVirtualStatus;
-//# sourceMappingURL=chunk-PWIESIO6.cjs.map
-//# sourceMappingURL=chunk-PWIESIO6.cjs.map
+//# sourceMappingURL=chunk-DAYCCIRO.cjs.map
+//# sourceMappingURL=chunk-DAYCCIRO.cjs.map