@arkade-os/sdk 0.5.0-rc.9 → 0.5.1

package/dist/{chunk-VTXMC4N7.cjs → chunk-XLHUGP3G.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,191 +29,13 @@ function _interopNamespace(e) {
 }
 
 var bip68__namespace = /*#__PURE__*/_interopNamespace(bip68);
+var P__namespace = /*#__PURE__*/_interopNamespace(P);
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-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;
-}
 var getNetwork = (network) => {
   const found = networks[network];
   if (!found) throw new Error(`Unsupported network: ${network}`);
@@ -243,6 +66,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}$/;
@@ -349,6 +173,26 @@ 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}`);
+}
+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 = btcSigner.ScriptNum(void 0, true);
 function decodeTapscript(script) {
   const types = [
@@ -596,6 +440,16 @@ exports.CSVMultisigTapscript = void 0;
   }
   CSVMultisigTapscript2.isScriptValid = isScriptValid;
 })(exports.CSVMultisigTapscript || (exports.CSVMultisigTapscript = {}));
+function isConditionScriptValid(script) {
+  const asm = btcSigner.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;
+}
 exports.ConditionCSVMultisigTapscript = void 0;
 ((ConditionCSVMultisigTapscript2) => {
   function encode2(params) {
@@ -620,7 +474,7 @@ exports.ConditionCSVMultisigTapscript = void 0;
       throw isValid;
     }
     const asm = btcSigner.Script.decode(script);
-    let verifyIndex = getVerifyIndex(asm);
+    const verifyIndex = asm.lastIndexOf("VERIFY");
     if (verifyIndex === -1) {
       throw Error("Invalid script: missing VERIFY operation");
     }
@@ -655,26 +509,8 @@ exports.ConditionCSVMultisigTapscript = void 0;
     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 = btcSigner.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;
 })(exports.ConditionCSVMultisigTapscript || (exports.ConditionCSVMultisigTapscript = {}));
@@ -702,7 +538,7 @@ exports.ConditionMultisigTapscript = void 0;
       throw isValid;
     }
     const asm = btcSigner.Script.decode(script);
-    let verifyIndex = getVerifyIndex(asm);
+    const verifyIndex = asm.lastIndexOf("VERIFY");
     if (verifyIndex === -1) {
       throw Error("Invalid script: missing VERIFY operation");
     }
@@ -737,26 +573,8 @@ exports.ConditionMultisigTapscript = void 0;
     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 = btcSigner.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;
 })(exports.ConditionMultisigTapscript || (exports.ConditionMultisigTapscript = {}));
@@ -881,7 +699,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);
 }
@@ -901,7 +737,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");
     }
@@ -916,15 +752,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.
@@ -1007,21 +874,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: payment_js.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 = exports.CSVMultisigTapscript.decode(script).params;
+      sequence = timelockToSequence(params.timelock);
+    } catch {
+      const params = exports.CLTVMultisigTapscript.decode(script).params;
+      sequence = Number(params.absoluteTimelock);
+    }
+  } catch {
+  }
+  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}.`);
+    }
+  }
+}
+
+// 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 */]
+    },
+    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)
+  ],
+  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 {
-    const scriptWithLeafVersion = tapLeafScript[1];
-    const script = scriptWithLeafVersion.subarray(0, scriptWithLeafVersion.length - 1);
-    try {
-      const params = exports.CSVMultisigTapscript.decode(script).params;
-      sequence = timelockToSequence(params.timelock);
-    } catch {
-      const params = exports.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
@@ -1049,11 +1218,15 @@ function resolveEventSource(override) {
 }
 
 // package.json
-var version = "0.5.0-rc.9";
+var version = "0.5.1";
 
 // 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;
@@ -1102,27 +1275,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 };
 }
 
@@ -1146,15 +1304,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);
@@ -1230,8 +1386,8 @@ exports.Intent = void 0;
     }
     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);
   }
@@ -1286,7 +1442,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");
@@ -1296,7 +1451,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");
@@ -1305,7 +1459,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);
@@ -1333,8 +1486,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: {
@@ -1368,14 +1522,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) {
@@ -1425,6 +1572,7 @@ function eventSourceIterator(eventSource) {
     cleanedUp = true;
     eventSource.removeEventListener("message", messageHandler);
     eventSource.removeEventListener("error", errorHandler);
+    eventSource.removeEventListener("failure", failureHandler);
   };
   const close = () => {
     if (closed) return;
@@ -1451,10 +1599,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;
@@ -1464,8 +1610,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) {
@@ -1503,6 +1652,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";
 }
@@ -1512,7 +1675,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();
@@ -1545,6 +1708,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;
@@ -1750,6 +1916,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(
@@ -1815,20 +1995,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,
@@ -1838,129 +2012,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: exports.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: exports.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`;
@@ -2083,22 +2215,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: exports.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;
   }
@@ -2364,11 +2490,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) {
@@ -2378,11 +2509,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;
 }
@@ -2405,7 +2543,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;
 }
@@ -2416,15 +2554,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 {
@@ -2439,6 +2581,7 @@ function isVirtualCoin(input) {
   return typeof input === "object" && input !== null && typeof input.script === "string";
 }
 
+exports.ARKADE_VERSION_HEADERS = ARKADE_VERSION_HEADERS;
 exports.ArkAddress = ArkAddress;
 exports.ArkError = ArkError;
 exports.ArkErrorName = ArkErrorName;
@@ -2447,6 +2590,7 @@ exports.ArkPsbtFieldKeyType = ArkPsbtFieldKeyType;
 exports.BITCOIN_EMULATOR_PUBKEY = BITCOIN_EMULATOR_PUBKEY;
 exports.ConditionWitness = ConditionWitness;
 exports.CosignerPublicKey = CosignerPublicKey;
+exports.DEFAULT_ARKADE_EMULATOR_URL = DEFAULT_ARKADE_EMULATOR_URL;
 exports.DEFAULT_ARKADE_SERVER_URL = DEFAULT_ARKADE_SERVER_URL;
 exports.DEFAULT_NETWORK = DEFAULT_NETWORK;
 exports.DEFAULT_NETWORK_NAME = DEFAULT_NETWORK_NAME;
@@ -2475,6 +2619,8 @@ exports.VtxoTreeExpiry = VtxoTreeExpiry;
 exports.__export = __export;
 exports.assembleBtcdTaprootTree = assembleBtcdTaprootTree;
 exports.assertAllowedSighashTypes = assertAllowedSighashTypes;
+exports.assertNonNegativeMs = assertNonNegativeMs;
+exports.assertTimerMs = assertTimerMs;
 exports.baseFetch = baseFetch;
 exports.buildVersion = buildVersion;
 exports.canRecoverOnchain = canRecoverOnchain;
@@ -2486,7 +2632,6 @@ exports.craftToSpendTx = craftToSpendTx;
 exports.decodeTapscript = decodeTapscript;
 exports.defaultEmulatorPubkey = defaultEmulatorPubkey;
 exports.eventSourceIterator = eventSourceIterator;
-exports.fetch = fetch;
 exports.fetchVtxoCreatedAtByTxid = fetchVtxoCreatedAtByTxid;
 exports.formatSighash = formatSighash;
 exports.getAllNormalizedVtxos = getAllNormalizedVtxos;
@@ -2495,7 +2640,6 @@ exports.getConfiguredEventSource = getConfiguredEventSource;
 exports.getNetwork = getNetwork;
 exports.getNormalizedVtxos = getNormalizedVtxos;
 exports.getSequence = getSequence;
-exports.hasTerminalSpend = hasTerminalSpend;
 exports.isArkError = isArkError;
 exports.isEventSourceError = isEventSourceError;
 exports.isEventSourceUnavailableError = isEventSourceUnavailableError;
@@ -2503,21 +2647,26 @@ exports.isFetchTimeoutError = isFetchTimeoutError;
 exports.isPastExpiry = isPastExpiry;
 exports.isRetryableProviderError = isRetryableProviderError;
 exports.isVirtualCoin = isVirtualCoin;
+exports.isVtxoSpent = isVtxoSpent;
 exports.maybeArkError = maybeArkError;
 exports.networkFromArkadeInfo = networkFromArkadeInfo;
 exports.networks = networks;
 exports.normalizeVtxo = normalizeVtxo;
 exports.rateGate = rateGate;
+exports.requiresForfeit = requiresForfeit;
 exports.resolveEmulatorPubkey = resolveEmulatorPubkey;
 exports.resolveEventSource = resolveEventSource;
 exports.resolveTimeHeight = resolveTimeHeight;
 exports.scriptFromTapLeafScript = scriptFromTapLeafScript;
 exports.sdkVersion = sdkVersion;
+exports.sequenceToCanonicalTimelock = sequenceToCanonicalTimelock;
 exports.sequenceToTimelock = sequenceToTimelock;
 exports.setArkPsbtField = setArkPsbtField;
+exports.streamFailureError = streamFailureError;
 exports.throwIfHttpUnavailable = throwIfHttpUnavailable;
 exports.timelockToSequence = timelockToSequence;
+exports.toBIP371TapTree = toBIP371TapTree;
 exports.toOffchainInputFeeParams = toOffchainInputFeeParams;
 exports.toProviderUnavailable = toProviderUnavailable;
-//# sourceMappingURL=chunk-VTXMC4N7.cjs.map
-//# sourceMappingURL=chunk-VTXMC4N7.cjs.map
+//# sourceMappingURL=chunk-XLHUGP3G.cjs.map
+//# sourceMappingURL=chunk-XLHUGP3G.cjs.map