@arkade-os/sdk 0.5.0-rc.8 → 0.5.0

package/dist/{chunk-MTYQXZ2T.js → chunk-ZOEB53NQ.js}

@@ -1,9 +1,10 @@
-import { ScriptNum, OP, p2tr_ms, Script, SigHash, p2tr, TAPROOT_UNSPENDABLE_KEY, Address, RawWitness, Transaction as Transaction$1 } from '@scure/btc-signer';
-import * as bip68 from 'bip68';
-import { TEST_NETWORK, NETWORK } from '@scure/btc-signer/utils.js';
+import { TEST_NETWORK, NETWORK, concatBytes } from '@scure/btc-signer/utils.js';
 import { hex, bech32m } from '@scure/base';
-import { Script as Script$1 } from '@scure/btc-signer/script.js';
+import { VarBytes, Script as Script$1 } from '@scure/btc-signer/script.js';
+import * as bip68 from 'bip68';
+import { ScriptNum, OP, p2tr_ms, Script, SigHash, p2tr, taprootNumsKey, Address, RawWitness, Transaction as Transaction$1, RawTx } from '@scure/btc-signer';
 import { TAP_LEAF_VERSION } from '@scure/btc-signer/payment.js';
+import * as P from 'micro-packed';
 import { PSBTOutput } from '@scure/btc-signer/psbt.js';
 import { schnorr } from '@noble/curves/secp256k1.js';
 
@@ -12,185 +13,6 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var Transaction = class extends Transaction$1 {
-  static ARK_TX_OPTS = {
-    allowUnknown: true,
-    allowUnknownOutputs: true,
-    allowUnknownInputs: true
-  };
-  constructor(opts) {
-    super(withArkOpts(opts));
-  }
-  static fromPSBT(psbt_, opts) {
-    return Transaction$1.fromPSBT(psbt_, withArkOpts(opts));
-  }
-  static fromRaw(raw, opts) {
-    return Transaction$1.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 = [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.encode(
-    timelock.type === "blocks" ? { blocks: Number(timelock.value) } : { seconds: Number(timelock.value) }
-  );
-}
-function sequenceToTimelock(sequence) {
-  const decoded = bip68.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 */]
-    },
-    RawWitness.encode(value)
-  ],
-  decode: (value) => nullIfCatch(() => {
-    if (!checkKeyMatch(value[0], "condition" /* ConditionWitness */)) return null;
-    return 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 */]
-    },
-    ScriptNum(6, true).encode(value.value === 0n ? 0n : value.value)
-  ],
-  decode: (unknown) => nullIfCatch(() => {
-    if (!checkKeyMatch(unknown[0], "expiry" /* VtxoTreeExpiry */)) return null;
-    const v = 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;
-}
 var getNetwork = (network) => {
   const found = networks[network];
   if (!found) throw new Error(`Unsupported network: ${network}`);
@@ -221,6 +43,7 @@ function withArkPrefix(network, prefix, name) {
   };
 }
 var DEFAULT_ARKADE_SERVER_URL = "https://arkade.computer";
+var DEFAULT_ARKADE_EMULATOR_URL = "https://emulator.arkade.computer";
 var DEFAULT_NETWORK = networks.bitcoin;
 var DEFAULT_NETWORK_NAME = "bitcoin";
 var COMPRESSED_PUBKEY = /^0[23][0-9a-f]{64}$/;
@@ -327,6 +150,26 @@ var ArkAddress = class _ArkAddress {
     return Script$1.encode(["RETURN", this.vtxoTaprootKey]);
   }
 };
+function timelockToSequence(timelock) {
+  return bip68.encode(
+    timelock.type === "blocks" ? { blocks: Number(timelock.value) } : { seconds: Number(timelock.value) }
+  );
+}
+function sequenceToTimelock(sequence) {
+  const decoded = bip68.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}`);
+}
+function sequenceToCanonicalTimelock(sequence) {
+  if (sequence < 0n || sequence >= 0x80000000n) return void 0;
+  const timelock = sequenceToTimelock(Number(sequence));
+  return BigInt(timelockToSequence(timelock)) === sequence ? timelock : void 0;
+}
 var MinimalScriptNum = ScriptNum(void 0, true);
 function decodeTapscript(script) {
   const types = [
@@ -574,6 +417,16 @@ var CSVMultisigTapscript;
   }
   CSVMultisigTapscript2.isScriptValid = isScriptValid;
 })(CSVMultisigTapscript || (CSVMultisigTapscript = {}));
+function isConditionScriptValid(script) {
+  const asm = Script.decode(script);
+  if (asm.length < 1) {
+    return new Error(`Invalid script: too short (expected at least 1)`);
+  }
+  if (asm.lastIndexOf("VERIFY") === -1) {
+    return new Error("Invalid script: missing VERIFY operation");
+  }
+  return true;
+}
 var ConditionCSVMultisigTapscript;
 ((ConditionCSVMultisigTapscript2) => {
   function encode2(params) {
@@ -598,7 +451,7 @@ var ConditionCSVMultisigTapscript;
       throw isValid;
     }
     const asm = Script.decode(script);
-    let verifyIndex = getVerifyIndex(asm);
+    const verifyIndex = asm.lastIndexOf("VERIFY");
     if (verifyIndex === -1) {
       throw Error("Invalid script: missing VERIFY operation");
     }
@@ -633,26 +486,8 @@ var ConditionCSVMultisigTapscript;
     return tapscript.type === "condition-csv-multisig" /* ConditionCSVMultisig */;
   }
   ConditionCSVMultisigTapscript2.is = is;
-  function getVerifyIndex(asm) {
-    let verifyIndex = -1;
-    for (let i = asm.length - 1; i >= 0; i--) {
-      if (asm[i] === "VERIFY") {
-        verifyIndex = i;
-        return verifyIndex;
-      }
-    }
-    return verifyIndex;
-  }
   function isScriptValid(script) {
-    const asm = Script.decode(script);
-    if (asm.length < 1) {
-      return new Error(`Invalid script: too short (expected at least 1)`);
-    }
-    let verifyIndex = getVerifyIndex(asm);
-    if (verifyIndex === -1) {
-      return new Error("Invalid script: missing VERIFY operation");
-    }
-    return true;
+    return isConditionScriptValid(script);
   }
   ConditionCSVMultisigTapscript2.isScriptValid = isScriptValid;
 })(ConditionCSVMultisigTapscript || (ConditionCSVMultisigTapscript = {}));
@@ -680,7 +515,7 @@ var ConditionMultisigTapscript;
       throw isValid;
     }
     const asm = Script.decode(script);
-    let verifyIndex = getVerifyIndex(asm);
+    const verifyIndex = asm.lastIndexOf("VERIFY");
     if (verifyIndex === -1) {
       throw Error("Invalid script: missing VERIFY operation");
     }
@@ -715,26 +550,8 @@ var ConditionMultisigTapscript;
     return tapscript.type === "condition-multisig" /* ConditionMultisig */;
   }
   ConditionMultisigTapscript2.is = is;
-  function getVerifyIndex(asm) {
-    let verifyIndex = -1;
-    for (let i = asm.length - 1; i >= 0; i--) {
-      if (asm[i] === "VERIFY") {
-        verifyIndex = i;
-        return verifyIndex;
-      }
-    }
-    return verifyIndex;
-  }
   function isScriptValid(script) {
-    const asm = Script.decode(script);
-    if (asm.length < 1) {
-      return new Error(`Invalid script: too short (expected at least 1)`);
-    }
-    let verifyIndex = getVerifyIndex(asm);
-    if (verifyIndex === -1) {
-      return new Error("Invalid script: missing VERIFY operation");
-    }
-    return true;
+    return isConditionScriptValid(script);
   }
   ConditionMultisigTapscript2.isScriptValid = isScriptValid;
 })(ConditionMultisigTapscript || (ConditionMultisigTapscript = {}));
@@ -859,7 +676,25 @@ function assembleBtcdTaprootTree(scripts) {
   }
   return branches[0];
 }
-var TapTreeCoder = 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.array(
+  null,
+  P.struct({ depth: P.U8, version: P.U8, script: VarBytes })
+);
 function scriptFromTapLeafScript(leaf) {
   return leaf[1].subarray(0, leaf[1].length - 1);
 }
@@ -879,7 +714,7 @@ var VtxoScript = class _VtxoScript {
   constructor(scripts) {
     this.scripts = scripts;
     const tapTree = assembleBtcdTaprootTree(scripts);
-    const payment = p2tr(TAPROOT_UNSPENDABLE_KEY, tapTree, void 0, true);
+    const payment = p2tr(taprootNumsKey(), tapTree, void 0, true);
     if (!payment.tapLeafScript || payment.tapLeafScript.length !== scripts.length) {
       throw new Error("invalid scripts");
     }
@@ -894,15 +729,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 !== 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.
@@ -985,21 +851,323 @@ var VtxoScript = class _VtxoScript {
     return paths;
   }
 };
-function getSequence(tapLeafScript) {
-  let sequence = void 0;
+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: TAP_LEAF_VERSION,
+    script: scriptFromTapLeafScript(leaf)
+  }));
+}
+function getSequence(tapLeafScript) {
+  let sequence = void 0;
+  try {
+    const scriptWithLeafVersion = tapLeafScript[1];
+    const script = scriptWithLeafVersion.subarray(0, scriptWithLeafVersion.length - 1);
+    try {
+      const params = CSVMultisigTapscript.decode(script).params;
+      sequence = timelockToSequence(params.timelock);
+    } catch {
+      const params = CLTVMultisigTapscript.decode(script).params;
+      sequence = Number(params.absoluteTimelock);
+    }
+  } catch {
+  }
+  return sequence;
+}
+var Transaction = class extends Transaction$1 {
+  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 Transaction$1.fromPSBT(psbt_, withArkOpts(opts));
+    } catch (err) {
+      const repaired = repairLegacyOutputTapTrees(psbt_);
+      if (!repaired) throw err;
+      return Transaction$1.fromPSBT(repaired, withArkOpts(opts));
+    }
+  }
+  static fromRaw(raw, opts) {
+    return Transaction$1.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 {
+    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 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 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 = [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}.`);
+    }
+  }
+}
+
+// src/utils/time.ts
+function assertNonNegativeMs(name, ms) {
+  if (ms !== void 0 && (!Number.isSafeInteger(ms) || ms < 0)) {
+    throw new Error(`${name} must be a non-negative safe integer`);
+  }
+}
+var MAX_TIMER_MS = 2 ** 31 - 1;
+function assertTimerMs(name, ms) {
+  assertNonNegativeMs(name, ms);
+  if (ms !== void 0 && ms > MAX_TIMER_MS) {
+    throw new Error(`${name} must not exceed ${MAX_TIMER_MS} milliseconds`);
+  }
+}
+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 ?? [];
+  return unknown.map((u) => coder.decode(u)).filter((v) => v !== null);
+}
+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 */]
+    },
+    RawWitness.encode(value)
+  ],
+  decode: (value) => nullIfCatch(() => {
+    if (!checkKeyMatch(value[0], "condition" /* ConditionWitness */)) return null;
+    return 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 */]
+    },
+    ScriptNum(6, true).encode(value.value)
+  ],
+  decode: (unknown) => nullIfCatch(() => {
+    if (!checkKeyMatch(unknown[0], "expiry" /* VtxoTreeExpiry */)) return null;
+    const v = 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 {
-    const scriptWithLeafVersion = tapLeafScript[1];
-    const script = scriptWithLeafVersion.subarray(0, scriptWithLeafVersion.length - 1);
-    try {
-      const params = CSVMultisigTapscript.decode(script).params;
-      sequence = timelockToSequence(params.timelock);
-    } catch {
-      const params = CLTVMultisigTapscript.decode(script).params;
-      sequence = Number(params.absoluteTimelock);
-    }
+    return fn();
   } catch {
+    return null;
   }
-  return sequence;
+};
+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
@@ -1027,11 +1195,15 @@ function resolveEventSource(override) {
 }
 
 // package.json
-var version = "0.5.0-rc.8";
+var version = "0.5.0";
 
 // src/utils/fetch.ts
 var buildVersion = "0.9.9";
 var sdkVersion = `ts-sdk/${version}`;
+var ARKADE_VERSION_HEADERS = {
+  "X-Build-Version": buildVersion,
+  "X-SDK-VERSION": sdkVersion
+};
 var FetchError = class extends Error {
   /** The request URL that failed, when derivable from the `fetch` input. */
   url;
@@ -1080,27 +1252,12 @@ function baseFetch(input, init) {
 }
 function fetch(input, init) {
   const headers = new Headers(init?.headers);
-  headers.set("X-Build-Version", buildVersion);
-  headers.set("X-SDK-VERSION", sdkVersion);
+  for (const [name, value] of Object.entries(ARKADE_VERSION_HEADERS)) headers.set(name, value);
   return baseFetch(input, { ...init, headers });
 }
 function describeRequest(input, init) {
-  let url;
-  if (typeof input === "string") {
-    url = input;
-  } else if (input instanceof URL) {
-    url = input.href;
-  } else {
-    url = input.url;
-  }
-  let method;
-  if (init?.method !== void 0) {
-    method = init.method;
-  } else if (input instanceof Request) {
-    method = input.method;
-  } else {
-    method = "GET";
-  }
+  const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+  const method = init?.method !== void 0 ? init.method : input instanceof Request ? input.method : "GET";
   return { url, method };
 }
 
@@ -1124,15 +1281,13 @@ var ArkErrorName = {
   INVALID_TX_FILTER: "INVALID_TX_FILTER",
   TX_FILTERS_LIMIT_EXCEEDED: "TX_FILTERS_LIMIT_EXCEEDED",
   /**
-   * A CLTV closure was spent before its absolute locktime matured. Raised only by
-   * `submitTx` (never `finalizeTx`), with metadata
-   * `{ locktime, current_locktime, type: "height" | "time" }`.
-   *
-   * Self-healing, so defer and retry rather than fail: the server matures a
-   * seconds-locktime against the **chain tip block's timestamp**, not its wall clock,
-   * so a spend attempted promptly at maturity is rejected until a later block lands.
+   * A CLTV closure was spent before its absolute locktime matured. `submitTx` only, with
+   * metadata `{ locktime, current_locktime, type: "height" | "time" }`. Self-healing, so defer
+   * and retry: the server matures a seconds-locktime against the **chain tip block's
+   * timestamp**, not wall clock, so a prompt spend is rejected until a later block lands.
    */
-  FORFEIT_CLOSURE_LOCKED: "FORFEIT_CLOSURE_LOCKED"
+  FORFEIT_CLOSURE_LOCKED: "FORFEIT_CLOSURE_LOCKED",
+  INVALID_INTENT_PROOF: "INVALID_INTENT_PROOF"
 };
 function isArkError(error, name) {
   return error instanceof ArkError && (name === void 0 || error.name === name);
@@ -1208,8 +1363,8 @@ var Intent;
     }
     if (ins.length == 0) throw new Error("intent proof requires at least one input");
     const inputs = ins.map(prepareCoinAsIntentProofInput);
-    if (!validateInputs(inputs)) ;
-    if (!validateOutputs(outputs)) ;
+    validateInputs(inputs);
+    validateOutputs(outputs);
     const toSpend = craftToSpendTx(message, inputs[0].witnessUtxo.script);
     return craftToSignTx(toSpend, inputs, outputs, message);
   }
@@ -1264,7 +1419,6 @@ var OP_RETURN_EMPTY_PKSCRIPT = new Uint8Array([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");
@@ -1274,7 +1428,6 @@ function validateInput(input) {
 }
 function validateInputs(inputs) {
   inputs.forEach(validateInput);
-  return true;
 }
 function validateOutput(output) {
   if (output.amount === void 0) throw new Error("intent proof output requires amount");
@@ -1283,7 +1436,6 @@ function validateOutput(output) {
 }
 function validateOutputs(outputs) {
   outputs.forEach(validateOutput);
-  return true;
 }
 function craftToSpendTx(message, pkScript, tag = TAG_INTENT_PROOF) {
   const messageHash = hashMessage(message, tag);
@@ -1311,8 +1463,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: {
@@ -1346,14 +1499,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) {
@@ -1403,6 +1549,7 @@ function eventSourceIterator(eventSource) {
     cleanedUp = true;
     eventSource.removeEventListener("message", messageHandler);
     eventSource.removeEventListener("error", errorHandler);
+    eventSource.removeEventListener("failure", failureHandler);
   };
   const close = () => {
     if (closed) return;
@@ -1429,10 +1576,8 @@ function eventSourceIterator(eventSource) {
       messageQueue.push(event);
     }
   };
-  const errorHandler = () => {
+  const rejectWith = (error) => {
     if (closed) return;
-    const error = new Error("EventSource error");
-    error.name = "EventSourceError";
     if (errorResolve) {
       const reject = errorResolve;
       messageResolve = null;
@@ -1442,8 +1587,11 @@ function eventSourceIterator(eventSource) {
       errorQueue.push(error);
     }
   };
+  const errorHandler = () => rejectWith(eventSourceError("EventSource error"));
+  const failureHandler = (event) => rejectWith(streamFailureError(event.data));
   eventSource.addEventListener("message", messageHandler);
   eventSource.addEventListener("error", errorHandler);
+  eventSource.addEventListener("failure", failureHandler);
   const gen = (async function* () {
     try {
       while (!closed) {
@@ -1481,6 +1629,20 @@ function eventSourceIterator(eventSource) {
   };
   return managed;
 }
+function eventSourceError(message) {
+  const error = new Error(message);
+  error.name = "EventSourceError";
+  return error;
+}
+function streamFailureError(data) {
+  let message = String(data);
+  try {
+    const parsed = typeof data === "string" ? JSON.parse(data) : data;
+    if (typeof parsed?.message === "string") message = parsed.message;
+  } catch {
+  }
+  return eventSourceError(`EventSource failure: ${message}`);
+}
 function isEventSourceError(error) {
   return error instanceof Error && error.name === "EventSourceError";
 }
@@ -1490,7 +1652,7 @@ var DEFAULT_MAX_CONCURRENT = 6;
 var DEFAULT_COOLDOWN_MS = 5e3;
 var MAX_COOLDOWN_MS = 6e4;
 var DEFAULT_JITTER_MS = 500;
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, Math.min(ms, MAX_TIMER_MS)));
 function parseRetryAfterMs(header) {
   if (header === null || header === void 0) return void 0;
   const trimmed = header.trim();
@@ -1523,6 +1685,9 @@ var OriginRateGate = class {
   maxCooldownMs;
   jitterMs;
   constructor(options) {
+    assertNonNegativeMs("defaultCooldownMs", options?.defaultCooldownMs);
+    assertNonNegativeMs("maxCooldownMs", options?.maxCooldownMs);
+    assertNonNegativeMs("jitterMs", options?.jitterMs);
     this.maxConcurrent = options?.maxConcurrent ?? DEFAULT_MAX_CONCURRENT;
     this.defaultCooldownMs = options?.defaultCooldownMs ?? DEFAULT_COOLDOWN_MS;
     this.maxCooldownMs = options?.maxCooldownMs ?? MAX_COOLDOWN_MS;
@@ -1728,6 +1893,20 @@ var RestArkProvider = class {
       "Arkade server reported a configuration digest mismatch; server info was refreshed. Rebuild and retry the request under the new server info."
     );
   }
+  async postJson(url, body, failureMessage) {
+    const response = await this.authedFetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      handleError(errorText, failureMessage(errorText, response));
+    }
+    return response;
+  }
   async getInfo() {
     const url = `${this.serverUrl}/v1/info`;
     const response = await rateGate.runHttp(
@@ -1793,20 +1972,14 @@ var RestArkProvider = class {
   }
   async submitTx(signedArkTx, checkpointTxs) {
     const url = `${this.serverUrl}/v1/tx/submit`;
-    const response = await this.authedFetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
+    const response = await this.postJson(
+      url,
+      {
         signedArkTx,
         checkpointTxs
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      handleError(errorText, `Failed to submit virtual transaction: ${errorText}`);
-    }
+      },
+      (errorText) => `Failed to submit virtual transaction: ${errorText}`
+    );
     const data = await response.json();
     return {
       arkTxid: data.arkTxid,
@@ -1816,129 +1989,87 @@ var RestArkProvider = class {
   }
   async finalizeTx(arkTxid, finalCheckpointTxs) {
     const url = `${this.serverUrl}/v1/tx/finalize`;
-    const response = await this.authedFetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
+    await this.postJson(
+      url,
+      {
         arkTxid,
         finalCheckpointTxs
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      handleError(errorText, `Failed to finalize offchain transaction: ${errorText}`);
-    }
+      },
+      (errorText) => `Failed to finalize offchain transaction: ${errorText}`
+    );
   }
   async registerIntent(intent) {
     const url = `${this.serverUrl}/v1/batch/registerIntent`;
-    const response = await this.authedFetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
+    const response = await this.postJson(
+      url,
+      {
         intent: {
           proof: intent.proof,
           message: Intent.encodeMessage(intent.message)
         }
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      handleError(errorText, `Failed to register intent: ${errorText}`);
-    }
+      },
+      (errorText) => `Failed to register intent: ${errorText}`
+    );
     const data = await response.json();
     return data.intentId;
   }
   async deleteIntent(intent) {
     const url = `${this.serverUrl}/v1/batch/deleteIntent`;
-    const response = await this.authedFetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
+    await this.postJson(
+      url,
+      {
         intent: {
           proof: intent.proof,
           message: Intent.encodeMessage(intent.message)
         }
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      handleError(errorText, `Failed to delete intent: ${errorText}`);
-    }
+      },
+      (errorText) => `Failed to delete intent: ${errorText}`
+    );
   }
   async confirmRegistration(intentId) {
     const url = `${this.serverUrl}/v1/batch/ack`;
-    const response = await this.authedFetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
+    await this.postJson(
+      url,
+      {
         intentId
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      handleError(errorText, `Failed to confirm registration: ${errorText}`);
-    }
+      },
+      (errorText) => `Failed to confirm registration: ${errorText}`
+    );
   }
   async submitTreeNonces(batchId, pubkey, nonces) {
     const url = `${this.serverUrl}/v1/batch/tree/submitNonces`;
-    const response = await this.authedFetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
+    await this.postJson(
+      url,
+      {
         batchId,
         pubkey,
         treeNonces: encodeMusig2Nonces(nonces)
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      handleError(errorText, `Failed to submit tree nonces: ${errorText}`);
-    }
+      },
+      (errorText) => `Failed to submit tree nonces: ${errorText}`
+    );
   }
   async submitTreeSignatures(batchId, pubkey, signatures) {
     const url = `${this.serverUrl}/v1/batch/tree/submitSignatures`;
-    const response = await this.authedFetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
+    await this.postJson(
+      url,
+      {
         batchId,
         pubkey,
         treeSignatures: encodeMusig2Signatures(signatures)
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      handleError(errorText, `Failed to submit tree signatures: ${errorText}`);
-    }
+      },
+      (errorText) => `Failed to submit tree signatures: ${errorText}`
+    );
   }
   async submitSignedForfeitTxs(signedForfeitTxs, signedCommitmentTx) {
     const url = `${this.serverUrl}/v1/batch/submitForfeitTxs`;
-    const response = await this.authedFetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
+    await this.postJson(
+      url,
+      {
         signedForfeitTxs,
         signedCommitmentTx
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      handleError(errorText, `Failed to submit forfeit transactions: ${response.statusText}`);
-    }
+      },
+      (_, res) => `Failed to submit forfeit transactions: ${res.statusText}`
+    );
   }
   getEventStream(signal, topics) {
     const url = `${this.serverUrl}/v1/batch/events`;
@@ -2061,22 +2192,16 @@ var RestArkProvider = class {
   }
   async getPendingTxs(intent) {
     const url = `${this.serverUrl}/v1/tx/pending`;
-    const response = await this.authedFetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
+    const response = await this.postJson(
+      url,
+      {
         intent: {
           proof: intent.proof,
           message: Intent.encodeMessage(intent.message)
         }
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      handleError(errorText, `Failed to get pending transactions: ${errorText}`);
-    }
+      },
+      (errorText) => `Failed to get pending transactions: ${errorText}`
+    );
     const data = await response.json();
     return data.pendingTxs;
   }
@@ -2342,11 +2467,16 @@ async function getNormalizedVtxos(provider, opts) {
   const { vtxos, page } = await provider.getVtxos(opts);
   return { vtxos: vtxos.map(normalizeVtxo), page };
 }
+var SCRIPT_CHUNK_CONCURRENCY = 4;
 async function getAllNormalizedVtxos(provider, scripts, opts = {}) {
   const { pageSize = DEFAULT_PAGE_SIZE, ...filters } = opts;
   const all = [];
+  const chunks = [];
   for (let i = 0; i < scripts.length; i += SCRIPT_QUERY_CHUNK_SIZE) {
-    const chunk = scripts.slice(i, i + SCRIPT_QUERY_CHUNK_SIZE);
+    chunks.push(scripts.slice(i, i + SCRIPT_QUERY_CHUNK_SIZE));
+  }
+  const fetchChunk = async (chunk) => {
+    const result = [];
     let pageIndex = 0;
     let hasMore = true;
     while (hasMore) {
@@ -2356,11 +2486,18 @@ async function getAllNormalizedVtxos(provider, scripts, opts = {}) {
         pageIndex,
         pageSize
       });
-      all.push(...vtxos);
+      result.push(...vtxos);
       hasMore = page ? vtxos.length === pageSize : false;
       pageIndex++;
       if (hasMore) await new Promise((r) => setTimeout(r, 500));
     }
+    return result;
+  };
+  for (let i = 0; i < chunks.length; i += SCRIPT_CHUNK_CONCURRENCY) {
+    const batch = await Promise.all(
+      chunks.slice(i, i + SCRIPT_CHUNK_CONCURRENCY).map(fetchChunk)
+    );
+    for (const result of batch) all.push(...result);
   }
   return all;
 }
@@ -2383,7 +2520,7 @@ async function fetchVtxoCreatedAtByTxid(provider, txids) {
   }
   return createdAt;
 }
-function hasTerminalSpend(vtxo) {
+function isVtxoSpent(vtxo) {
   const n = normalizeVtxo(vtxo);
   return !!n.isSpent || !!n.spentBy || !!n.settledBy;
 }
@@ -2394,15 +2531,19 @@ function isPastExpiry(vtxo, now) {
 }
 function canSpendOffchain(vtxo, now) {
   const n = normalizeVtxo(vtxo);
-  return !hasTerminalSpend(n) && !n.isUnrolled && !(n.isSwept || isPastExpiry(n, now));
+  return !isVtxoSpent(n) && !n.isUnrolled && !(n.isSwept || isPastExpiry(n, now));
 }
 function canRecoverOnchain(vtxo, now) {
   const n = normalizeVtxo(vtxo);
-  return !hasTerminalSpend(n) && !n.isUnrolled && (n.isSwept || isPastExpiry(n, now));
+  return !isVtxoSpent(n) && !n.isUnrolled && (n.isSwept || isPastExpiry(n, now));
 }
 function canSweepOnchain(vtxo) {
   const n = normalizeVtxo(vtxo);
-  return !hasTerminalSpend(n) && !!n.isUnrolled;
+  return !isVtxoSpent(n) && !!n.isUnrolled;
+}
+function requiresForfeit(vtxo) {
+  const n = normalizeVtxo(vtxo);
+  return !n.isSwept && !n.isUnrolled;
 }
 function toOffchainInputFeeParams(vtxo) {
   return {
@@ -2417,6 +2558,6 @@ function isVirtualCoin(input) {
   return typeof input === "object" && input !== null && typeof input.script === "string";
 }
 
-export { ArkAddress, ArkError, ArkErrorName, ArkPsbtFieldKey, ArkPsbtFieldKeyType, BITCOIN_EMULATOR_PUBKEY, CLTVMultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, ConditionWitness, CosignerPublicKey, DEFAULT_ARKADE_SERVER_URL, DEFAULT_NETWORK, DEFAULT_NETWORK_NAME, DEFAULT_PAGE_SIZE, DigestMismatchError, EXPIRY_MIN_PLAUSIBLE_MS, EventSourceUnavailableError, FetchError, INFO_FETCH_TIMEOUT_MS, Intent, MUTINYNET_EMULATOR_PUBKEY, MultisigTapscript, OP_RETURN_EMPTY_PKSCRIPT, PrevArkTxField, PrevoutTxField, ProviderUnavailableError, READ_TIMEOUT_MS, REGTEST_EMULATOR_PUBKEY, RestArkProvider, SCRIPT_QUERY_CHUNK_SIZE, ServerResponseMismatchError, SettlementEventType, TapTreeCoder, Transaction, VtxoScript, VtxoTaprootTree, VtxoTreeExpiry, __export, assembleBtcdTaprootTree, assertAllowedSighashTypes, baseFetch, buildVersion, canRecoverOnchain, canSpendOffchain, canSweepOnchain, configureEventSource, convertVtxo, craftToSpendTx, decodeTapscript, defaultEmulatorPubkey, eventSourceIterator, fetch, fetchVtxoCreatedAtByTxid, formatSighash, getAllNormalizedVtxos, getArkPsbtFields, getConfiguredEventSource, getNetwork, getNormalizedVtxos, getSequence, hasTerminalSpend, isArkError, isEventSourceError, isEventSourceUnavailableError, isFetchTimeoutError, isPastExpiry, isRetryableProviderError, isVirtualCoin, maybeArkError, networkFromArkadeInfo, networks, normalizeVtxo, rateGate, resolveEmulatorPubkey, resolveEventSource, resolveTimeHeight, scriptFromTapLeafScript, sdkVersion, sequenceToTimelock, setArkPsbtField, throwIfHttpUnavailable, timelockToSequence, toOffchainInputFeeParams, toProviderUnavailable };
-//# sourceMappingURL=chunk-MTYQXZ2T.js.map
-//# sourceMappingURL=chunk-MTYQXZ2T.js.map
+export { ARKADE_VERSION_HEADERS, ArkAddress, ArkError, ArkErrorName, ArkPsbtFieldKey, ArkPsbtFieldKeyType, BITCOIN_EMULATOR_PUBKEY, CLTVMultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, ConditionWitness, CosignerPublicKey, DEFAULT_ARKADE_EMULATOR_URL, DEFAULT_ARKADE_SERVER_URL, DEFAULT_NETWORK, DEFAULT_NETWORK_NAME, DEFAULT_PAGE_SIZE, DigestMismatchError, EXPIRY_MIN_PLAUSIBLE_MS, EventSourceUnavailableError, FetchError, INFO_FETCH_TIMEOUT_MS, Intent, MUTINYNET_EMULATOR_PUBKEY, MultisigTapscript, OP_RETURN_EMPTY_PKSCRIPT, PrevArkTxField, PrevoutTxField, ProviderUnavailableError, READ_TIMEOUT_MS, REGTEST_EMULATOR_PUBKEY, RestArkProvider, SCRIPT_QUERY_CHUNK_SIZE, ServerResponseMismatchError, SettlementEventType, TapTreeCoder, Transaction, VtxoScript, VtxoTaprootTree, VtxoTreeExpiry, __export, assembleBtcdTaprootTree, assertAllowedSighashTypes, assertNonNegativeMs, assertTimerMs, baseFetch, buildVersion, canRecoverOnchain, canSpendOffchain, canSweepOnchain, configureEventSource, convertVtxo, craftToSpendTx, decodeTapscript, defaultEmulatorPubkey, eventSourceIterator, fetchVtxoCreatedAtByTxid, formatSighash, getAllNormalizedVtxos, getArkPsbtFields, getConfiguredEventSource, getNetwork, getNormalizedVtxos, getSequence, isArkError, isEventSourceError, isEventSourceUnavailableError, isFetchTimeoutError, isPastExpiry, isRetryableProviderError, isVirtualCoin, isVtxoSpent, maybeArkError, networkFromArkadeInfo, networks, normalizeVtxo, rateGate, requiresForfeit, resolveEmulatorPubkey, resolveEventSource, resolveTimeHeight, scriptFromTapLeafScript, sdkVersion, sequenceToCanonicalTimelock, sequenceToTimelock, setArkPsbtField, streamFailureError, throwIfHttpUnavailable, timelockToSequence, toBIP371TapTree, toOffchainInputFeeParams, toProviderUnavailable };
+//# sourceMappingURL=chunk-ZOEB53NQ.js.map
+//# sourceMappingURL=chunk-ZOEB53NQ.js.map