@arkade-os/sdk 0.4.53 → 0.4.55

package/dist/chunk-OWCPXRGP.cjs

@@ -0,0 +1,2415 @@
+'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 payment_js = require('@scure/btc-signer/payment.js');
+var psbt_js = require('@scure/btc-signer/psbt.js');
+var secp256k1_js = require('@noble/curves/secp256k1.js');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var bip68__namespace = /*#__PURE__*/_interopNamespace(bip68);
+
+// src/utils/transaction.ts
+var Transaction = class extends btcSigner.Transaction {
+  static ARK_TX_OPTS = {
+    allowUnknown: true,
+    allowUnknownOutputs: true,
+    allowUnknownInputs: true
+  };
+  constructor(opts) {
+    super(withArkOpts(opts));
+  }
+  static fromPSBT(psbt_, opts) {
+    return btcSigner.Transaction.fromPSBT(psbt_, withArkOpts(opts));
+  }
+  static fromRaw(raw, opts) {
+    return btcSigner.Transaction.fromRaw(raw, withArkOpts(opts));
+  }
+};
+function withArkOpts(opts) {
+  return { ...Transaction.ARK_TX_OPTS, ...opts };
+}
+function 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}`);
+  return found;
+};
+var networks = {
+  bitcoin: withArkPrefix(utils_js.NETWORK, "ark"),
+  testnet: withArkPrefix(utils_js.TEST_NETWORK, "tark"),
+  signet: withArkPrefix(utils_js.TEST_NETWORK, "tark"),
+  mutinynet: withArkPrefix(utils_js.TEST_NETWORK, "tark"),
+  regtest: withArkPrefix(
+    {
+      ...utils_js.TEST_NETWORK,
+      bech32: "bcrt",
+      pubKeyHash: 111,
+      scriptHash: 196
+    },
+    "tark"
+  )
+};
+function withArkPrefix(network, prefix) {
+  return {
+    ...network,
+    hrp: prefix
+  };
+}
+var DEFAULT_ARKADE_SERVER_URL = "https://arkade.computer";
+var DEFAULT_NETWORK = networks.bitcoin;
+var DEFAULT_NETWORK_NAME = "bitcoin";
+var ArkAddress = class _ArkAddress {
+  /**
+   * Create an Arkade address from its server public key, Taproot output key, and prefix.
+   *
+   * @param serverPubKey - 32-byte Arkade server public key
+   * @param vtxoTaprootKey - 32-byte Taproot output key (a.k.a. tweaked public key)
+   * @param hrp - Bech32 human-readable prefix
+   * @param version - Address version byte
+   * @defaultValue `version = 0`
+   * @throws Error if either public key is not 32 bytes long
+   */
+  constructor(serverPubKey, vtxoTaprootKey, hrp = DEFAULT_NETWORK.hrp, version2 = 0) {
+    this.serverPubKey = serverPubKey;
+    this.vtxoTaprootKey = vtxoTaprootKey;
+    this.hrp = hrp;
+    this.version = version2;
+    if (serverPubKey.length !== 32) {
+      throw new Error(
+        "Invalid server public key length, expected 32 bytes, got " + serverPubKey.length
+      );
+    }
+    if (vtxoTaprootKey.length !== 32) {
+      throw new Error(
+        "Invalid vtxo taproot public key length, expected 32 bytes, got " + vtxoTaprootKey.length
+      );
+    }
+  }
+  serverPubKey;
+  vtxoTaprootKey;
+  hrp;
+  version;
+  /**
+   * Decode an Arkade address from its bech32m string form.
+   *
+   * @param address - Bech32m-encoded Arkade address
+   * @returns Decoded Arkade address
+   * @throws Error if the address is malformed or has an invalid payload length
+   * @see encode
+   */
+  static decode(address) {
+    const decoded = base.bech32m.decodeUnsafe(address, 1023);
+    if (!decoded) {
+      throw new Error("Invalid address");
+    }
+    const data = new Uint8Array(base.bech32m.fromWords(decoded.words));
+    if (data.length !== 1 + 32 + 32) {
+      throw new Error("Invalid data length, expected 65 bytes, got " + data.length);
+    }
+    const version2 = data[0];
+    const serverPubKey = data.slice(1, 33);
+    const vtxoTaprootPubKey = data.slice(33, 65);
+    return new _ArkAddress(serverPubKey, vtxoTaprootPubKey, decoded.prefix, version2);
+  }
+  /**
+   * Encode the address to its bech32m string form.
+   *
+   * @returns Bech32m-encoded Arkade address
+   * @see decode
+   */
+  encode() {
+    const data = new Uint8Array(1 + 32 + 32);
+    data[0] = this.version;
+    data.set(this.serverPubKey, 1);
+    data.set(this.vtxoTaprootKey, 33);
+    const words = base.bech32m.toWords(data);
+    return base.bech32m.encode(this.hrp, words, 1023);
+  }
+  /** ScriptPubKey used to send non-dust funds to the address. */
+  get pkScript() {
+    return script_js.Script.encode(["OP_1", this.vtxoTaprootKey]);
+  }
+  /** ScriptPubKey used to send sub-dust funds to the address. */
+  get subdustPkScript() {
+    return script_js.Script.encode(["RETURN", this.vtxoTaprootKey]);
+  }
+};
+var MinimalScriptNum = btcSigner.ScriptNum(void 0, true);
+function decodeTapscript(script) {
+  const types = [
+    exports.MultisigTapscript,
+    exports.CSVMultisigTapscript,
+    exports.ConditionCSVMultisigTapscript,
+    exports.ConditionMultisigTapscript,
+    exports.CLTVMultisigTapscript
+  ];
+  for (const type of types) {
+    try {
+      return type.decode(script);
+    } catch (error) {
+      continue;
+    }
+  }
+  throw new Error(`Failed to decode: script ${base.hex.encode(script)} is not a valid tapscript`);
+}
+exports.MultisigTapscript = void 0;
+((MultisigTapscript2) => {
+  ((MultisigType2) => {
+    MultisigType2[MultisigType2["CHECKSIG"] = 0] = "CHECKSIG";
+    MultisigType2[MultisigType2["CHECKSIGADD"] = 1] = "CHECKSIGADD";
+  })(MultisigTapscript2.MultisigType || (MultisigTapscript2.MultisigType = {}));
+  function encode2(params) {
+    if (params.pubkeys.length === 0) {
+      throw new Error("At least 1 pubkey is required");
+    }
+    for (const pubkey of params.pubkeys) {
+      if (pubkey.length !== 32) {
+        throw new Error(`Invalid pubkey length: expected 32, got ${pubkey.length}`);
+      }
+    }
+    if (!params.type) {
+      params.type = 0 /* CHECKSIG */;
+    }
+    if (params.type === 1 /* CHECKSIGADD */) {
+      return {
+        type: "multisig" /* Multisig */,
+        params,
+        script: btcSigner.p2tr_ms(params.pubkeys.length, params.pubkeys).script
+      };
+    }
+    const asm = [];
+    for (let i = 0; i < params.pubkeys.length; i++) {
+      asm.push(params.pubkeys[i]);
+      if (i < params.pubkeys.length - 1) {
+        asm.push("CHECKSIGVERIFY");
+      } else {
+        asm.push("CHECKSIG");
+      }
+    }
+    return {
+      type: "multisig" /* Multisig */,
+      params,
+      script: btcSigner.Script.encode(asm)
+    };
+  }
+  MultisigTapscript2.encode = encode2;
+  function decode2(script) {
+    if (script.length === 0) {
+      throw new Error("Failed to decode: script is empty");
+    }
+    try {
+      return decodeChecksigAdd(script);
+    } catch (error) {
+      try {
+        return decodeChecksig(script);
+      } catch (error2) {
+        throw new Error(
+          `Failed to decode script: ${error2 instanceof Error ? error2.message : String(error2)}`
+        );
+      }
+    }
+  }
+  MultisigTapscript2.decode = decode2;
+  function decodeChecksigAdd(script) {
+    const asm = btcSigner.Script.decode(script);
+    const pubkeys = [];
+    let foundNumEqual = false;
+    for (let i = 0; i < asm.length; i++) {
+      const op = asm[i];
+      if (typeof op !== "string" && typeof op !== "number") {
+        if (op.length !== 32) {
+          throw new Error(`Invalid pubkey length: expected 32, got ${op.length}`);
+        }
+        pubkeys.push(op);
+        if (i + 1 >= asm.length || asm[i + 1] !== "CHECKSIGADD" && asm[i + 1] !== "CHECKSIG") {
+          throw new Error("Expected CHECKSIGADD or CHECKSIG after pubkey");
+        }
+        i++;
+        continue;
+      }
+      if (i === asm.length - 1) {
+        if (op !== "NUMEQUAL") {
+          throw new Error("Expected NUMEQUAL at end of script");
+        }
+        foundNumEqual = true;
+      }
+    }
+    if (!foundNumEqual) {
+      throw new Error("Missing NUMEQUAL operation");
+    }
+    if (pubkeys.length === 0) {
+      throw new Error("Invalid script: must have at least 1 pubkey");
+    }
+    const reconstructed = encode2({
+      pubkeys,
+      type: 1 /* CHECKSIGADD */
+    });
+    if (base.hex.encode(reconstructed.script) !== base.hex.encode(script)) {
+      throw new Error("Invalid script format: script reconstruction mismatch");
+    }
+    return {
+      type: "multisig" /* Multisig */,
+      params: { pubkeys, type: 1 /* CHECKSIGADD */ },
+      script
+    };
+  }
+  function decodeChecksig(script) {
+    const asm = btcSigner.Script.decode(script);
+    const pubkeys = [];
+    for (let i = 0; i < asm.length; i++) {
+      const op = asm[i];
+      if (typeof op !== "string" && typeof op !== "number") {
+        if (op.length !== 32) {
+          throw new Error(`Invalid pubkey length: expected 32, got ${op.length}`);
+        }
+        pubkeys.push(op);
+        if (i + 1 >= asm.length) {
+          throw new Error("Unexpected end of script");
+        }
+        const nextOp = asm[i + 1];
+        if (nextOp !== "CHECKSIGVERIFY" && nextOp !== "CHECKSIG") {
+          throw new Error("Expected CHECKSIGVERIFY or CHECKSIG after pubkey");
+        }
+        if (i === asm.length - 2 && nextOp !== "CHECKSIG") {
+          throw new Error("Last operation must be CHECKSIG");
+        }
+        i++;
+        continue;
+      }
+    }
+    if (pubkeys.length === 0) {
+      throw new Error("Invalid script: must have at least 1 pubkey");
+    }
+    const reconstructed = encode2({ pubkeys, type: 0 /* CHECKSIG */ });
+    if (base.hex.encode(reconstructed.script) !== base.hex.encode(script)) {
+      throw new Error("Invalid script format: script reconstruction mismatch");
+    }
+    return {
+      type: "multisig" /* Multisig */,
+      params: { pubkeys, type: 0 /* CHECKSIG */ },
+      script
+    };
+  }
+  function is(tapscript) {
+    return tapscript.type === "multisig" /* Multisig */;
+  }
+  MultisigTapscript2.is = is;
+})(exports.MultisigTapscript || (exports.MultisigTapscript = {}));
+exports.CSVMultisigTapscript = void 0;
+((CSVMultisigTapscript2) => {
+  function encode2(params) {
+    for (const pubkey of params.pubkeys) {
+      if (pubkey.length !== 32) {
+        throw new Error(`Invalid pubkey length: expected 32, got ${pubkey.length}`);
+      }
+    }
+    const sequence = MinimalScriptNum.encode(BigInt(timelockToSequence(params.timelock)));
+    const asm = [
+      sequence.length === 1 ? sequence[0] : sequence,
+      "CHECKSEQUENCEVERIFY",
+      "DROP"
+    ];
+    const multisigScript = exports.MultisigTapscript.encode(params);
+    const script = new Uint8Array([...btcSigner.Script.encode(asm), ...multisigScript.script]);
+    return {
+      type: "csv-multisig" /* CSVMultisig */,
+      params,
+      script
+    };
+  }
+  CSVMultisigTapscript2.encode = encode2;
+  function decode2(script) {
+    if (script.length === 0) {
+      throw new Error("Failed to decode: script is empty");
+    }
+    const isValid = isScriptValid(script);
+    if (isValid instanceof Error) {
+      throw isValid;
+    }
+    const asm = btcSigner.Script.decode(script);
+    const sequence = asm[0];
+    const multisigScript = new Uint8Array(btcSigner.Script.encode(asm.slice(3)));
+    let multisig;
+    try {
+      multisig = exports.MultisigTapscript.decode(multisigScript);
+    } catch (error) {
+      throw new Error(
+        `Invalid multisig script: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    let sequenceNum;
+    if (typeof sequence === "number") {
+      sequenceNum = sequence;
+    } else {
+      sequenceNum = Number(MinimalScriptNum.decode(sequence));
+    }
+    const timelock = sequenceToTimelock(sequenceNum);
+    const reconstructed = encode2({
+      timelock,
+      ...multisig.params
+    });
+    if (base.hex.encode(reconstructed.script) !== base.hex.encode(script)) {
+      throw new Error("Invalid script format: script reconstruction mismatch");
+    }
+    return {
+      type: "csv-multisig" /* CSVMultisig */,
+      params: {
+        timelock,
+        ...multisig.params
+      },
+      script
+    };
+  }
+  CSVMultisigTapscript2.decode = decode2;
+  function is(tapscript) {
+    return tapscript.type === "csv-multisig" /* CSVMultisig */;
+  }
+  CSVMultisigTapscript2.is = is;
+  function isScriptValid(script) {
+    const asm = btcSigner.Script.decode(script);
+    if (asm.length < 3) {
+      return new Error(`Invalid script: too short (expected at least 3)`);
+    }
+    const sequence = asm[0];
+    if (typeof sequence === "string") {
+      return new Error("Invalid script: expected sequence number");
+    }
+    if (asm[1] !== "CHECKSEQUENCEVERIFY" || asm[2] !== "DROP") {
+      return new Error("Invalid script: expected CHECKSEQUENCEVERIFY DROP");
+    }
+    return true;
+  }
+  CSVMultisigTapscript2.isScriptValid = isScriptValid;
+})(exports.CSVMultisigTapscript || (exports.CSVMultisigTapscript = {}));
+exports.ConditionCSVMultisigTapscript = void 0;
+((ConditionCSVMultisigTapscript2) => {
+  function encode2(params) {
+    const script = new Uint8Array([
+      ...params.conditionScript,
+      ...btcSigner.Script.encode(["VERIFY"]),
+      ...exports.CSVMultisigTapscript.encode(params).script
+    ]);
+    return {
+      type: "condition-csv-multisig" /* ConditionCSVMultisig */,
+      params,
+      script
+    };
+  }
+  ConditionCSVMultisigTapscript2.encode = encode2;
+  function decode2(script) {
+    if (script.length === 0) {
+      throw new Error("Failed to decode: script is empty");
+    }
+    const isValid = isScriptValid(script);
+    if (isValid instanceof Error) {
+      throw isValid;
+    }
+    const asm = btcSigner.Script.decode(script);
+    let verifyIndex = getVerifyIndex(asm);
+    if (verifyIndex === -1) {
+      throw Error("Invalid script: missing VERIFY operation");
+    }
+    const conditionScript = new Uint8Array(btcSigner.Script.encode(asm.slice(0, verifyIndex)));
+    const csvMultisigScript = new Uint8Array(btcSigner.Script.encode(asm.slice(verifyIndex + 1)));
+    let csvMultisig;
+    try {
+      csvMultisig = exports.CSVMultisigTapscript.decode(csvMultisigScript);
+    } catch (error) {
+      throw new Error(
+        `Invalid CSV multisig script: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    const reconstructed = encode2({
+      conditionScript,
+      ...csvMultisig.params
+    });
+    if (base.hex.encode(reconstructed.script) !== base.hex.encode(script)) {
+      throw new Error("Invalid script format: script reconstruction mismatch");
+    }
+    return {
+      type: "condition-csv-multisig" /* ConditionCSVMultisig */,
+      params: {
+        conditionScript,
+        ...csvMultisig.params
+      },
+      script
+    };
+  }
+  ConditionCSVMultisigTapscript2.decode = decode2;
+  function is(tapscript) {
+    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;
+  }
+  ConditionCSVMultisigTapscript2.isScriptValid = isScriptValid;
+})(exports.ConditionCSVMultisigTapscript || (exports.ConditionCSVMultisigTapscript = {}));
+exports.ConditionMultisigTapscript = void 0;
+((ConditionMultisigTapscript2) => {
+  function encode2(params) {
+    const script = new Uint8Array([
+      ...params.conditionScript,
+      ...btcSigner.Script.encode(["VERIFY"]),
+      ...exports.MultisigTapscript.encode(params).script
+    ]);
+    return {
+      type: "condition-multisig" /* ConditionMultisig */,
+      params,
+      script
+    };
+  }
+  ConditionMultisigTapscript2.encode = encode2;
+  function decode2(script) {
+    if (script.length === 0) {
+      throw new Error("Failed to decode: script is empty");
+    }
+    const isValid = isScriptValid(script);
+    if (isValid instanceof Error) {
+      throw isValid;
+    }
+    const asm = btcSigner.Script.decode(script);
+    let verifyIndex = getVerifyIndex(asm);
+    if (verifyIndex === -1) {
+      throw Error("Invalid script: missing VERIFY operation");
+    }
+    const conditionScript = new Uint8Array(btcSigner.Script.encode(asm.slice(0, verifyIndex)));
+    const multisigScript = new Uint8Array(btcSigner.Script.encode(asm.slice(verifyIndex + 1)));
+    let multisig;
+    try {
+      multisig = exports.MultisigTapscript.decode(multisigScript);
+    } catch (error) {
+      throw new Error(
+        `Invalid multisig script: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    const reconstructed = encode2({
+      conditionScript,
+      ...multisig.params
+    });
+    if (base.hex.encode(reconstructed.script) !== base.hex.encode(script)) {
+      throw new Error("Invalid script format: script reconstruction mismatch");
+    }
+    return {
+      type: "condition-multisig" /* ConditionMultisig */,
+      params: {
+        conditionScript,
+        ...multisig.params
+      },
+      script
+    };
+  }
+  ConditionMultisigTapscript2.decode = decode2;
+  function is(tapscript) {
+    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;
+  }
+  ConditionMultisigTapscript2.isScriptValid = isScriptValid;
+})(exports.ConditionMultisigTapscript || (exports.ConditionMultisigTapscript = {}));
+exports.CLTVMultisigTapscript = void 0;
+((CLTVMultisigTapscript2) => {
+  function encode2(params) {
+    const locktime = MinimalScriptNum.encode(params.absoluteTimelock);
+    const asm = [
+      locktime.length === 1 ? locktime[0] : locktime,
+      "CHECKLOCKTIMEVERIFY",
+      "DROP"
+    ];
+    const timelockedScript = btcSigner.Script.encode(asm);
+    const script = new Uint8Array([
+      ...timelockedScript,
+      ...exports.MultisigTapscript.encode(params).script
+    ]);
+    return {
+      type: "cltv-multisig" /* CLTVMultisig */,
+      params,
+      script
+    };
+  }
+  CLTVMultisigTapscript2.encode = encode2;
+  function decode2(script) {
+    if (script.length === 0) {
+      throw new Error("Failed to decode: script is empty");
+    }
+    const isValid = isScriptValid(script);
+    if (isValid instanceof Error) {
+      throw isValid;
+    }
+    const asm = btcSigner.Script.decode(script);
+    const locktime = asm[0];
+    if (typeof locktime === "string") {
+      throw new Error("Invalid script: expected locktime number");
+    }
+    if (asm[1] !== "CHECKLOCKTIMEVERIFY" || asm[2] !== "DROP") {
+      throw new Error("Invalid script: expected CHECKLOCKTIMEVERIFY DROP");
+    }
+    const multisigScript = new Uint8Array(btcSigner.Script.encode(asm.slice(3)));
+    let multisig;
+    try {
+      multisig = exports.MultisigTapscript.decode(multisigScript);
+    } catch (error) {
+      throw new Error(
+        `Invalid multisig script: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    let absoluteTimelock;
+    if (typeof locktime === "number") {
+      absoluteTimelock = BigInt(locktime);
+    } else {
+      absoluteTimelock = MinimalScriptNum.decode(locktime);
+    }
+    const reconstructed = encode2({
+      absoluteTimelock,
+      ...multisig.params
+    });
+    if (base.hex.encode(reconstructed.script) !== base.hex.encode(script)) {
+      throw new Error("Invalid script format: script reconstruction mismatch");
+    }
+    return {
+      type: "cltv-multisig" /* CLTVMultisig */,
+      params: {
+        absoluteTimelock,
+        ...multisig.params
+      },
+      script
+    };
+  }
+  CLTVMultisigTapscript2.decode = decode2;
+  function is(tapscript) {
+    return tapscript.type === "cltv-multisig" /* CLTVMultisig */;
+  }
+  CLTVMultisigTapscript2.is = is;
+  function isScriptValid(script) {
+    const asm = btcSigner.Script.decode(script);
+    if (asm.length < 3) {
+      return new Error(`Invalid script: too short (expected at least 3)`);
+    }
+    const locktime = asm[0];
+    if (typeof locktime === "string") {
+      return new Error("Invalid script: expected locktime as number or bytes");
+    }
+    if (asm[1] !== "CHECKLOCKTIMEVERIFY" || asm[2] !== "DROP") {
+      return new Error("Invalid script: expected CHECKLOCKTIMEVERIFY DROP");
+    }
+    return true;
+  }
+  CLTVMultisigTapscript2.isScriptValid = isScriptValid;
+})(exports.CLTVMultisigTapscript || (exports.CLTVMultisigTapscript = {}));
+function assembleBtcdTaprootTree(scripts) {
+  if (scripts.length === 0) {
+    throw new Error("assembleBtcdTaprootTree: empty scripts list");
+  }
+  const leaves = scripts.map((script) => ({
+    script,
+    leafVersion: payment_js.TAP_LEAF_VERSION
+  }));
+  if (leaves.length === 1) {
+    return leaves[0];
+  }
+  const branches = [];
+  for (let i = 0; i < leaves.length; i += 2) {
+    if (i === leaves.length - 1) {
+      const last = branches.pop();
+      if (last === void 0) {
+        throw new Error(
+          `assembleBtcdTaprootTree: unexpected odd leaf at i=${i} with no prior branch`
+        );
+      }
+      branches.push([last, leaves[i]]);
+    } else {
+      branches.push([leaves[i], leaves[i + 1]]);
+    }
+  }
+  while (branches.length >= 2) {
+    const left = branches.shift();
+    const right = branches.shift();
+    branches.push([left, right]);
+  }
+  return branches[0];
+}
+var TapTreeCoder = psbt_js.PSBTOutput.tapTree[2];
+function scriptFromTapLeafScript(leaf) {
+  return leaf[1].subarray(0, leaf[1].length - 1);
+}
+var VtxoScript = class _VtxoScript {
+  /**
+   * Create a virtual output script from its tapleaf scripts.
+   *
+   * The Taproot script tree is assembled using btcd's algorithm
+   * (`txscript.AssembleTaprootScriptTree`) so the derived taproot output
+   * key agrees with arkd for any leaf count. `@scure/btc-signer`'s
+   * default `taprootListToTree` is a Huffman builder that only agrees
+   * with arkd for power-of-2 leaf counts.
+   *
+   * @param scripts - Raw tapscript bytes for each leaf
+   * @throws Error if the provided leaves cannot produce a valid Taproot tree
+   */
+  constructor(scripts) {
+    this.scripts = scripts;
+    const tapTree = assembleBtcdTaprootTree(scripts);
+    const payment = btcSigner.p2tr(btcSigner.TAPROOT_UNSPENDABLE_KEY, tapTree, void 0, true);
+    if (!payment.tapLeafScript || payment.tapLeafScript.length !== scripts.length) {
+      throw new Error("invalid scripts");
+    }
+    this.leaves = payment.tapLeafScript;
+    this.tweakedPublicKey = payment.tweakedPubkey;
+    this.pkScript = payment.script;
+  }
+  scripts;
+  leaves;
+  tweakedPublicKey;
+  pkScript;
+  /**
+   * Decode a virtual output script from an encoded TapTree.
+   *
+   * @param tapTree - Encoded TapTree bytes
+   * @returns Decoded virtual output script
+   * @throws Error if the TapTree cannot be decoded into a valid script set
+   * @see encode
+   */
+  static decode(tapTree) {
+    const leaves = TapTreeCoder.decode(tapTree);
+    const scripts = leaves.map((leaf) => leaf.script);
+    return new _VtxoScript(scripts);
+  }
+  /**
+   * Encode the virtual output script to a TapTree byte representation.
+   *
+   * @returns Encoded TapTree bytes
+   * @see decode
+   */
+  encode() {
+    const tapTree = TapTreeCoder.encode(
+      this.scripts.map((script) => ({
+        depth: 1,
+        version: payment_js.TAP_LEAF_VERSION,
+        script
+      }))
+    );
+    return tapTree;
+  }
+  /**
+   * Build the Arkade address corresponding to this virtual output script.
+   *
+   * @param prefix - Bech32 human-readable prefix
+   * @param serverPubKey - 32-byte Arkade server public key
+   * @returns Arkade address for this script
+   * @see ArkAddress
+   */
+  address(prefix = DEFAULT_NETWORK.hrp, serverPubKey) {
+    return new ArkAddress(serverPubKey, this.tweakedPublicKey, prefix);
+  }
+  /**
+   * Build the Taproot onchain address corresponding to this virtual output script.
+   *
+   * @param network - Bitcoin network descriptor
+   * @returns Taproot onchain address
+   * @see address
+   */
+  onchainAddress(network = DEFAULT_NETWORK) {
+    return btcSigner.Address(network).encode({
+      type: "tr",
+      pubkey: this.tweakedPublicKey
+    });
+  }
+  /**
+   * Look up a tapleaf script by its hex-encoded tapscript body.
+   *
+   * @param scriptHex - Hex-encoded tapscript body without the leaf version byte
+   * @returns Matching tapleaf script
+   * @throws Error if no matching leaf exists
+   */
+  findLeaf(scriptHex) {
+    const leaf = this.leaves.find(
+      (leaf2) => base.hex.encode(scriptFromTapLeafScript(leaf2)) === scriptHex
+    );
+    if (!leaf) {
+      throw new Error(`leaf '${scriptHex}' not found`);
+    }
+    return leaf;
+  }
+  /**
+   * Return all unilateral exit paths embedded in the virtual output script.
+   *
+   * @returns CSV-based exit paths found in the leaves
+   * @see getSequence
+   */
+  exitPaths() {
+    const paths = [];
+    for (const leaf of this.leaves) {
+      try {
+        const script = scriptFromTapLeafScript(leaf);
+        if (exports.CSVMultisigTapscript.isScriptValid(script) === true) {
+          const tapScript = exports.CSVMultisigTapscript.decode(script);
+          paths.push(tapScript);
+        } else if (exports.ConditionCSVMultisigTapscript.isScriptValid(script) === true) {
+          const tapScript = exports.ConditionCSVMultisigTapscript.decode(script);
+          paths.push(tapScript);
+        }
+      } catch (e) {
+        console.debug("Failed to decode script", e);
+      }
+    }
+    return paths;
+  }
+};
+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;
+}
+
+// package.json
+var version = "0.4.55";
+
+// src/utils/fetch.ts
+var buildVersion = "0.9.9";
+var sdkVersion = `ts-sdk/${version}`;
+var FetchError = class extends Error {
+  /** The request URL that failed, when derivable from the `fetch` input. */
+  url;
+  /** The HTTP method of the failed request (defaults to `"GET"`). */
+  method;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.name = "FetchError";
+    this.url = options.url;
+    this.method = options.method;
+  }
+};
+function baseFetch(input, init) {
+  if (typeof globalThis.fetch !== "function") {
+    throw new Error("Fetch API is not available in this environment.");
+  }
+  return globalThis.fetch(input, init).catch((cause) => {
+    const { url, method } = describeRequest(input, init);
+    throw new FetchError(`Network request failed: ${method} ${url}`, { url, method, cause });
+  });
+}
+function fetch(input, init) {
+  const headers = new Headers(init?.headers);
+  headers.set("X-Build-Version", buildVersion);
+  headers.set("X-SDK-VERSION", sdkVersion);
+  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";
+  }
+  return { url, method };
+}
+
+// src/providers/errors.ts
+var ArkError = class extends Error {
+  constructor(code, message, name, metadata) {
+    super(message);
+    this.code = code;
+    this.message = message;
+    this.name = name;
+    this.metadata = metadata;
+  }
+  code;
+  message;
+  name;
+  metadata;
+};
+var ArkErrorName = {
+  DIGEST_MISMATCH: "DIGEST_MISMATCH",
+  VTXO_ALREADY_SPENT: "VTXO_ALREADY_SPENT",
+  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.
+   */
+  FORFEIT_CLOSURE_LOCKED: "FORFEIT_CLOSURE_LOCKED"
+};
+function isArkError(error, name) {
+  return error instanceof ArkError && (name === void 0 || error.name === name);
+}
+var ProviderUnavailableError = class extends Error {
+  /** Always `true`: this error type only ever wraps retryable conditions. */
+  retryable = true;
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "ProviderUnavailableError";
+  }
+};
+var ServerResponseMismatchError = class extends Error {
+  retryable = false;
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "ServerResponseMismatchError";
+  }
+};
+function throwIfHttpUnavailable(response, kind, body) {
+  if (body !== void 0 && maybeArkError(new Error(body))) return;
+  if (response.status === 429 || response.status >= 500) {
+    throw new ProviderUnavailableError(
+      `${kind} unavailable: ${response.status} ${response.statusText}`
+    );
+  }
+}
+function toProviderUnavailable(err, kind) {
+  if (err instanceof FetchError) {
+    return new ProviderUnavailableError(`${kind} request failed`, { cause: err });
+  }
+  return err;
+}
+function maybeArkError(error) {
+  try {
+    if (!(error instanceof Error)) return void 0;
+    const decoded = JSON.parse(error.message);
+    if (Array.isArray(decoded.details)) {
+      for (const details of decoded.details) {
+        if (!("@type" in details)) continue;
+        const type = details["@type"];
+        if (type !== "type.googleapis.com/ark.v1.ErrorDetails") continue;
+        if (!("code" in details)) continue;
+        const code = details.code;
+        if (!("message" in details)) continue;
+        const message = details.message;
+        if (!("name" in details)) continue;
+        const name = details.name;
+        let metadata;
+        if ("metadata" in details && isMetadata(details.metadata)) {
+          metadata = details.metadata;
+        }
+        return new ArkError(code, message, name, metadata);
+      }
+    }
+    if (typeof decoded.message === "string") {
+      const m = decoded.message.match(/^([A-Z][A-Z0-9_]*) \((\d+)\): ([\s\S]*)$/);
+      if (m) return new ArkError(Number(m[2]), m[3], m[1]);
+    }
+    return void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+function isMetadata(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+exports.Intent = void 0;
+((Intent2) => {
+  function create(message, ins, outputs = []) {
+    if (typeof message !== "string") {
+      message = encodeMessage(message);
+    }
+    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)) ;
+    const toSpend = craftToSpendTx(message, inputs[0].witnessUtxo.script);
+    return craftToSignTx(toSpend, inputs, outputs, message);
+  }
+  Intent2.create = create;
+  function fee(proof) {
+    let sumOfInputs = 0n;
+    for (let i = 0; i < proof.inputsLength; i++) {
+      const input = proof.getInput(i);
+      if (input.witnessUtxo === void 0)
+        throw new Error("intent proof input requires witness utxo");
+      sumOfInputs += input.witnessUtxo.amount;
+    }
+    let sumOfOutputs = 0n;
+    for (let i = 0; i < proof.outputsLength; i++) {
+      const output = proof.getOutput(i);
+      if (output.amount === void 0) throw new Error("intent proof output requires amount");
+      sumOfOutputs += output.amount;
+    }
+    if (sumOfOutputs > sumOfInputs) {
+      throw new Error(
+        `intent proof output amount is greater than input amount: ${sumOfOutputs} > ${sumOfInputs}`
+      );
+    }
+    return Number(sumOfInputs - sumOfOutputs);
+  }
+  Intent2.fee = fee;
+  function encodeMessage(message) {
+    switch (message.type) {
+      case "register":
+        return JSON.stringify({
+          type: "register",
+          onchain_output_indexes: message.onchain_output_indexes,
+          valid_at: message.valid_at,
+          expire_at: message.expire_at,
+          cosigners_public_keys: message.cosigners_public_keys
+        });
+      case "delete":
+        return JSON.stringify({
+          type: "delete",
+          expire_at: message.expire_at
+        });
+      case "get-pending-tx":
+        return JSON.stringify({
+          type: "get-pending-tx",
+          expire_at: message.expire_at
+        });
+    }
+  }
+  Intent2.encodeMessage = encodeMessage;
+})(exports.Intent || (exports.Intent = {}));
+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");
+  if (input.witnessUtxo === void 0)
+    throw new Error("intent proof input requires witness utxo");
+  return true;
+}
+function validateInputs(inputs) {
+  inputs.forEach(validateInput);
+  return true;
+}
+function validateOutput(output) {
+  if (output.amount === void 0) throw new Error("intent proof output requires amount");
+  if (output.script === void 0) throw new Error("intent proof output requires script");
+  return true;
+}
+function validateOutputs(outputs) {
+  outputs.forEach(validateOutput);
+  return true;
+}
+function craftToSpendTx(message, pkScript, tag = TAG_INTENT_PROOF) {
+  const messageHash = hashMessage(message, tag);
+  const tx = new Transaction({
+    version: 0
+  });
+  tx.addInput({
+    txid: ZERO_32,
+    // zero hash
+    index: MAX_INDEX,
+    sequence: 0
+  });
+  tx.addOutput({
+    amount: 0n,
+    script: pkScript
+  });
+  tx.updateInput(0, {
+    finalScriptSig: btcSigner.Script.encode(["OP_0", messageHash])
+  });
+  return tx;
+}
+function craftToSignTx(toSpend, inputs, outputs, message) {
+  const firstInput = inputs[0];
+  const tx = new Transaction({
+    version: 2,
+    lockTime: 0
+  });
+  tx.addInput({
+    ...firstInput,
+    txid: toSpend.id,
+    index: 0,
+    witnessUtxo: {
+      script: firstInput.witnessUtxo.script,
+      amount: 0n
+    },
+    sighashType: btcSigner.SigHash.ALL
+  });
+  for (const [i, input] of inputs.entries()) {
+    tx.addInput({
+      ...input,
+      sighashType: btcSigner.SigHash.ALL
+    });
+    if (input.unknown?.length) {
+      tx.updateInput(i + 1, {
+        unknown: input.unknown
+      });
+    }
+  }
+  if (outputs.length === 0) {
+    outputs = [
+      {
+        amount: 0n,
+        script: OP_RETURN_EMPTY_PKSCRIPT
+      }
+    ];
+  }
+  for (const output of outputs) {
+    tx.addOutput({
+      amount: output.amount,
+      script: output.script
+    });
+  }
+  const global = tx.global;
+  global.unknown = [
+    ...global.unknown ?? [],
+    [
+      { type: PSBT_GLOBAL_GENERIC_SIGNED_MESSAGE, key: new Uint8Array() },
+      new TextEncoder().encode(message)
+    ]
+  ];
+  return tx;
+}
+function hashMessage(message, tag = TAG_INTENT_PROOF) {
+  return secp256k1_js.schnorr.utils.taggedHash(tag, new TextEncoder().encode(message));
+}
+function prepareCoinAsIntentProofInput(coin) {
+  if (!("tapTree" in coin)) {
+    return coin;
+  }
+  const vtxoScript = VtxoScript.decode(coin.tapTree);
+  const sequence = getSequence(coin.intentTapLeafScript);
+  const unknown = [VtxoTaprootTree.encode(coin.tapTree)];
+  if (coin.extraWitness) {
+    unknown.push(ConditionWitness.encode(coin.extraWitness));
+  }
+  return {
+    txid: base.hex.decode(coin.txid),
+    index: coin.vout,
+    witnessUtxo: {
+      amount: BigInt(coin.value),
+      script: vtxoScript.pkScript
+    },
+    sequence,
+    tapLeafScript: [coin.intentTapLeafScript],
+    unknown
+  };
+}
+
+// src/providers/utils.ts
+function createAbortError() {
+  const error = new Error("EventSource closed");
+  error.name = "AbortError";
+  return error;
+}
+function eventSourceIterator(eventSource) {
+  const messageQueue = [];
+  const errorQueue = [];
+  let messageResolve = null;
+  let errorResolve = null;
+  let closed = false;
+  let cleanedUp = false;
+  const cleanup = () => {
+    if (cleanedUp) return;
+    cleanedUp = true;
+    eventSource.removeEventListener("message", messageHandler);
+    eventSource.removeEventListener("error", errorHandler);
+  };
+  const close = () => {
+    if (closed) return;
+    closed = true;
+    messageQueue.length = 0;
+    errorQueue.length = 0;
+    eventSource.close();
+    cleanup();
+    if (errorResolve) {
+      const reject = errorResolve;
+      messageResolve = null;
+      errorResolve = null;
+      reject(createAbortError());
+    }
+  };
+  const messageHandler = (event) => {
+    if (closed) return;
+    if (messageResolve) {
+      const resolve = messageResolve;
+      messageResolve = null;
+      errorResolve = null;
+      resolve(event);
+    } else {
+      messageQueue.push(event);
+    }
+  };
+  const errorHandler = () => {
+    if (closed) return;
+    const error = new Error("EventSource error");
+    error.name = "EventSourceError";
+    if (errorResolve) {
+      const reject = errorResolve;
+      messageResolve = null;
+      errorResolve = null;
+      reject(error);
+    } else {
+      errorQueue.push(error);
+    }
+  };
+  eventSource.addEventListener("message", messageHandler);
+  eventSource.addEventListener("error", errorHandler);
+  const gen = (async function* () {
+    try {
+      while (!closed) {
+        if (messageQueue.length > 0) {
+          yield messageQueue.shift();
+          continue;
+        }
+        if (errorQueue.length > 0) {
+          const error = errorQueue.shift();
+          throw error;
+        }
+        const result = await new Promise((resolve, reject) => {
+          messageResolve = resolve;
+          errorResolve = reject;
+        }).finally(() => {
+          messageResolve = null;
+          errorResolve = null;
+        });
+        if (!closed && result) {
+          yield result;
+        }
+      }
+    } finally {
+      closed = true;
+      cleanup();
+      eventSource.close();
+    }
+  })();
+  const origReturn = gen.return.bind(gen);
+  const managed = gen;
+  managed.close = close;
+  managed.return = (value) => {
+    close();
+    return origReturn(value);
+  };
+  return managed;
+}
+function isEventSourceError(error) {
+  return error instanceof Error && error.name === "EventSourceError";
+}
+
+// src/providers/rateGate.ts
+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));
+function parseRetryAfterMs(header) {
+  if (header === null || header === void 0) return void 0;
+  const trimmed = header.trim();
+  if (trimmed === "") return void 0;
+  const seconds = Number(trimmed);
+  if (Number.isFinite(seconds)) return seconds < 0 ? void 0 : seconds * 1e3;
+  const at = Date.parse(trimmed);
+  if (!Number.isNaN(at)) return Math.max(0, at - Date.now());
+  return void 0;
+}
+function requestOrigin(input) {
+  let url;
+  if (typeof input === "string") {
+    url = input;
+  } else if (input instanceof URL) {
+    url = input.href;
+  } else {
+    url = input.url;
+  }
+  try {
+    return new URL(url).origin;
+  } catch {
+    return url;
+  }
+}
+var OriginRateGate = class {
+  states = /* @__PURE__ */ new Map();
+  maxConcurrent;
+  defaultCooldownMs;
+  maxCooldownMs;
+  jitterMs;
+  constructor(options) {
+    this.maxConcurrent = options?.maxConcurrent ?? DEFAULT_MAX_CONCURRENT;
+    this.defaultCooldownMs = options?.defaultCooldownMs ?? DEFAULT_COOLDOWN_MS;
+    this.maxCooldownMs = options?.maxCooldownMs ?? MAX_COOLDOWN_MS;
+    this.jitterMs = options?.jitterMs ?? DEFAULT_JITTER_MS;
+  }
+  /**
+   * Run `fn` under the origin's concurrency cap and behind any active
+   * cooldown. Put only the request in `fn`: the slot is released as soon as
+   * it settles, so body parsing doesn't hold one.
+   */
+  async run(input, fn) {
+    const state = this.stateFor(requestOrigin(input));
+    await this.acquire(state);
+    try {
+      for (; ; ) {
+        const remaining = state.blockedUntil - Date.now();
+        if (remaining <= 0) break;
+        await sleep(remaining + Math.random() * this.jitterMs);
+      }
+      return await fn();
+    } finally {
+      this.release(state);
+    }
+  }
+  /**
+   * {@link run} for a request whose response the gate should inspect: a `429`
+   * is recorded *before* the slot is released. Reporting after `run()` resolves
+   * is too late — `release()` hands the slot to the next queued waiter, which
+   * resumes, sees no cooldown, and sends into the limiter that just refused us.
+   *
+   * Prefer this over `run` for anything returning a `Response`.
+   */
+  runHttp(input, fn) {
+    return this.run(input, async () => {
+      const response = await fn();
+      if (response.status === 429) {
+        this.reportRateLimited(input, response.headers?.get("retry-after"));
+      }
+      return response;
+    });
+  }
+  /**
+   * Record an observed `429`, pausing every gated request to that origin.
+   * Monotonic: a shorter cooldown never shortens one already in effect.
+   */
+  reportRateLimited(input, retryAfterHeader) {
+    const cooldown = Math.min(
+      parseRetryAfterMs(retryAfterHeader) ?? this.defaultCooldownMs,
+      this.maxCooldownMs
+    );
+    const state = this.stateFor(requestOrigin(input));
+    state.blockedUntil = Math.max(state.blockedUntil, Date.now() + cooldown);
+  }
+  /** Milliseconds left on `input` origin's cooldown; `0` when not cooling down. */
+  cooldownRemainingMs(input) {
+    const state = this.states.get(requestOrigin(input));
+    if (!state) return 0;
+    return Math.max(0, state.blockedUntil - Date.now());
+  }
+  /**
+   * Drop all per-origin state, so test suites don't inherit each other's
+   * cooldowns. Waiters queued on the discarded state still drain normally.
+   */
+  reset() {
+    this.states.clear();
+  }
+  stateFor(origin) {
+    let state = this.states.get(origin);
+    if (!state) {
+      state = { blockedUntil: 0, active: 0, queue: [] };
+      this.states.set(origin, state);
+    }
+    return state;
+  }
+  acquire(state) {
+    if (state.active < this.maxConcurrent) {
+      state.active += 1;
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      state.queue.push(() => {
+        state.active += 1;
+        resolve();
+      });
+    });
+  }
+  release(state) {
+    state.active -= 1;
+    const next = state.queue.shift();
+    if (next) next();
+  }
+};
+var rateGate = new OriginRateGate();
+
+// src/providers/ark.ts
+var DigestMismatchError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DigestMismatchError";
+  }
+};
+var SettlementEventType = /* @__PURE__ */ ((SettlementEventType2) => {
+  SettlementEventType2["BatchStarted"] = "batch_started";
+  SettlementEventType2["BatchFinalization"] = "batch_finalization";
+  SettlementEventType2["BatchFinalized"] = "batch_finalized";
+  SettlementEventType2["BatchFailed"] = "batch_failed";
+  SettlementEventType2["TreeSigningStarted"] = "tree_signing_started";
+  SettlementEventType2["TreeNonces"] = "tree_nonces";
+  SettlementEventType2["TreeTx"] = "tree_tx";
+  SettlementEventType2["TreeSignature"] = "tree_signature";
+  SettlementEventType2["StreamStarted"] = "stream_started";
+  return SettlementEventType2;
+})(SettlementEventType || {});
+var RestArkProvider = class {
+  constructor(serverUrl = DEFAULT_ARKADE_SERVER_URL) {
+    this.serverUrl = serverUrl;
+  }
+  serverUrl;
+  /**
+   * Last server-info digest seen (from {@link getInfo}). Sent as `X-Digest`
+   * on outgoing requests so arkd can reject a client whose cached info is
+   * stale. Empty until the first {@link getInfo}.
+   */
+  _digest = "";
+  _serverInfoListeners = /* @__PURE__ */ new Set();
+  /**
+   * Subscribe to server-info changes. Fired when a request is rejected with
+   * `DIGEST_MISMATCH` and fresh info is re-fetched, so consumers (the wallet)
+   * can re-derive signer-dependent state mid-session without polling. Returns
+   * an unsubscribe function.
+   */
+  onServerInfoChanged(listener) {
+    this._serverInfoListeners.add(listener);
+    return () => {
+      this._serverInfoListeners.delete(listener);
+    };
+  }
+  emitServerInfoChanged(info) {
+    for (const listener of this._serverInfoListeners) {
+      try {
+        listener(info);
+      } catch (e) {
+        console.warn("onServerInfoChanged listener threw", e);
+      }
+    }
+  }
+  /**
+   * `fetch` wrapper for arkd requests that participates in server-info digest
+   * negotiation. Sends the cached `X-Digest`; when arkd rejects a request with
+   * `DIGEST_MISMATCH`, refreshes {@link getInfo} (updating the digest), fires
+   * {@link onServerInfoChanged}, and THROWS {@link DigestMismatchError} — it
+   * never silently retries, since the in-flight request was built against the
+   * now-stale config. Dormant until arkd returns the error — then it is the
+   * instant, event-driven signer-rotation trigger. {@link getInfo} itself never
+   * routes through here: it is the refresh path and must not be digest-gated.
+   */
+  async authedFetch(url, init) {
+    const digest = this._digest;
+    const headers = {
+      ...init.headers
+    };
+    if (digest) headers["X-Digest"] = digest;
+    let response;
+    try {
+      response = await fetch(url, { ...init, headers });
+    } catch (err) {
+      throw toProviderUnavailable(err, "arkade");
+    }
+    if (response.ok) return response;
+    if (response.status === 429) {
+      rateGate.reportRateLimited(url, response.headers?.get("retry-after"));
+    }
+    let body;
+    try {
+      body = await response.clone().text();
+    } catch (e) {
+      console.warn("authedFetch could not read response body for digest check", e);
+      throwIfHttpUnavailable(response, "arkade");
+      return response;
+    }
+    const arkError = maybeArkError(new Error(body));
+    if (!arkError) throwIfHttpUnavailable(response, "arkade");
+    if (!isArkError(arkError, ArkErrorName.DIGEST_MISMATCH)) return response;
+    this._digest = "";
+    const info = await this.getInfo();
+    this.emitServerInfoChanged(info);
+    throw new DigestMismatchError(
+      "Arkade server reported a configuration digest mismatch; server info was refreshed. Rebuild and retry the request under the new server info."
+    );
+  }
+  async getInfo() {
+    const url = `${this.serverUrl}/v1/info`;
+    const response = await rateGate.runHttp(url, () => fetch(url));
+    if (!response.ok) {
+      const errorText = await response.text();
+      throwIfHttpUnavailable(response, "arkade", errorText);
+      handleError(errorText, `Failed to get server info: ${response.statusText}`);
+    }
+    const fromServer = await response.json();
+    const info = {
+      boardingExitDelay: BigInt(fromServer.boardingExitDelay ?? 0),
+      checkpointTapscript: fromServer.checkpointTapscript ?? "",
+      deprecatedSigners: fromServer.deprecatedSigners?.map((signer) => ({
+        // arkd advertises `cutoffDate` as a non-nullable field, so it
+        // is always a bigint here — `0n` is the sentinel for "no
+        // cutoff" (the classifier maps it to DUE_NOW). The grpc-gateway
+        // marshals with EmitUnpopulated, so an unset `cutoff_date`
+        // already arrives as `"0"`; a genuinely missing field defaults
+        // to `0n` too. Never collapse to `undefined`.
+        cutoffDate: BigInt(signer.cutoffDate ?? 0),
+        pubkey: signer.pubkey ?? ""
+      })) ?? [],
+      digest: fromServer.digest ?? "",
+      dust: BigInt(fromServer.dust ?? 0),
+      fees: {
+        intentFee: fromServer.fees?.intentFee ?? {},
+        txFeeRate: fromServer?.fees?.txFeeRate ?? ""
+      },
+      forfeitAddress: fromServer.forfeitAddress ?? "",
+      forfeitPubkey: fromServer.forfeitPubkey ?? "",
+      network: fromServer.network ?? "",
+      scheduledSession: "scheduledSession" in fromServer && fromServer.scheduledSession != null ? {
+        duration: BigInt(fromServer.scheduledSession.duration ?? 0),
+        nextStartTime: BigInt(fromServer.scheduledSession.nextStartTime ?? 0),
+        nextEndTime: BigInt(fromServer.scheduledSession.nextEndTime ?? 0),
+        period: BigInt(fromServer.scheduledSession.period ?? 0),
+        fees: fromServer.scheduledSession.fees ?? {}
+      } : void 0,
+      serviceStatus: fromServer.serviceStatus ?? {},
+      sessionDuration: BigInt(fromServer.sessionDuration ?? 0),
+      signerPubkey: fromServer.signerPubkey ?? "",
+      unilateralExitDelay: BigInt(fromServer.unilateralExitDelay ?? 0),
+      utxoMaxAmount: BigInt(fromServer.utxoMaxAmount ?? -1),
+      utxoMinAmount: BigInt(fromServer.utxoMinAmount ?? 0),
+      version: fromServer.version ?? "",
+      vtxoMaxAmount: BigInt(fromServer.vtxoMaxAmount ?? -1),
+      vtxoMinAmount: BigInt(fromServer.vtxoMinAmount ?? 0)
+    };
+    this._digest = info.digest;
+    return info;
+  }
+  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({
+        signedArkTx,
+        checkpointTxs
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      handleError(errorText, `Failed to submit virtual transaction: ${errorText}`);
+    }
+    const data = await response.json();
+    return {
+      arkTxid: data.arkTxid,
+      finalArkTx: data.finalArkTx,
+      signedCheckpointTxs: data.signedCheckpointTxs
+    };
+  }
+  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({
+        arkTxid,
+        finalCheckpointTxs
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      handleError(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({
+        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}`);
+    }
+    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({
+        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}`);
+    }
+  }
+  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({
+        intentId
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      handleError(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({
+        batchId,
+        pubkey,
+        treeNonces: encodeMusig2Nonces(nonces)
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      handleError(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({
+        batchId,
+        pubkey,
+        treeSignatures: encodeMusig2Signatures(signatures)
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      handleError(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({
+        signedForfeitTxs,
+        signedCommitmentTx
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      handleError(errorText, `Failed to submit forfeit transactions: ${response.statusText}`);
+    }
+  }
+  getEventStream(signal, topics) {
+    const url = `${this.serverUrl}/v1/batch/events`;
+    const queryParams = topics.length > 0 ? `?${topics.map((topic) => `topics=${encodeURIComponent(topic)}`).join("&")}` : "";
+    let iterator = null;
+    const closeIterator = () => iterator?.close();
+    const self = this;
+    const gen = (async function* () {
+      const abortHandler = closeIterator;
+      signal?.addEventListener("abort", abortHandler);
+      try {
+        while (!signal?.aborted) {
+          const currentIterator = eventSourceIterator(new EventSource(url + queryParams));
+          iterator = currentIterator;
+          try {
+            for await (const event of currentIterator) {
+              if (signal?.aborted) break;
+              try {
+                const data = JSON.parse(event.data);
+                const settlementEvent = self.parseSettlementEvent(data);
+                if (settlementEvent) {
+                  yield settlementEvent;
+                }
+              } catch (err) {
+                console.error("Failed to parse event:", err);
+                throw err;
+              }
+            }
+          } catch (error) {
+            if (signal?.aborted || error instanceof Error && error.name === "AbortError") {
+              break;
+            }
+            if (isFetchTimeoutError(error)) {
+              console.debug("Timeout error ignored");
+              continue;
+            }
+            if (isEventSourceError(error)) {
+              throw error;
+            }
+            console.error("Event stream error:", error);
+            throw error;
+          } finally {
+            currentIterator.close();
+            iterator = null;
+          }
+        }
+      } finally {
+        signal?.removeEventListener("abort", abortHandler);
+        closeIterator();
+      }
+    })();
+    const origReturn = gen.return.bind(gen);
+    gen.return = (value) => {
+      closeIterator();
+      return origReturn(value);
+    };
+    return gen;
+  }
+  getTransactionsStream(signal) {
+    const url = `${this.serverUrl}/v1/txs`;
+    let iterator = null;
+    const closeIterator = () => iterator?.close();
+    const self = this;
+    const gen = (async function* () {
+      const abortHandler = closeIterator;
+      signal?.addEventListener("abort", abortHandler);
+      try {
+        while (!signal?.aborted) {
+          try {
+            const currentIterator = eventSourceIterator(new EventSource(url));
+            iterator = currentIterator;
+            for await (const event of currentIterator) {
+              if (signal?.aborted) break;
+              try {
+                const data = JSON.parse(event.data);
+                const txNotification = self.parseTransactionNotification(data);
+                if (txNotification) {
+                  yield txNotification;
+                }
+              } catch (err) {
+                console.error("Failed to parse transaction notification:", err);
+                throw err;
+              }
+            }
+          } catch (error) {
+            if (signal?.aborted || error instanceof Error && error.name === "AbortError") {
+              break;
+            }
+            if (isFetchTimeoutError(error)) {
+              console.debug("Timeout error ignored");
+              continue;
+            }
+            if (isEventSourceError(error)) {
+              throw error;
+            }
+            console.error("Transaction stream error:", error);
+            throw error;
+          } finally {
+            closeIterator();
+            iterator = null;
+          }
+        }
+      } finally {
+        signal?.removeEventListener("abort", abortHandler);
+        closeIterator();
+      }
+    })();
+    const origReturn = gen.return.bind(gen);
+    gen.return = (value) => {
+      closeIterator();
+      return origReturn(value);
+    };
+    return gen;
+  }
+  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({
+        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}`);
+    }
+    const data = await response.json();
+    return data.pendingTxs;
+  }
+  parseSettlementEvent(data) {
+    if (data.batchStarted) {
+      return {
+        type: "batch_started" /* BatchStarted */,
+        id: data.batchStarted.id,
+        intentIdHashes: data.batchStarted.intentIdHashes,
+        batchExpiry: BigInt(data.batchStarted.batchExpiry)
+      };
+    }
+    if (data.batchFinalization) {
+      return {
+        type: "batch_finalization" /* BatchFinalization */,
+        id: data.batchFinalization.id,
+        commitmentTx: data.batchFinalization.commitmentTx
+      };
+    }
+    if (data.batchFinalized) {
+      return {
+        type: "batch_finalized" /* BatchFinalized */,
+        id: data.batchFinalized.id,
+        commitmentTxid: data.batchFinalized.commitmentTxid
+      };
+    }
+    if (data.batchFailed) {
+      return {
+        type: "batch_failed" /* BatchFailed */,
+        id: data.batchFailed.id,
+        reason: data.batchFailed.reason
+      };
+    }
+    if (data.treeSigningStarted) {
+      return {
+        type: "tree_signing_started" /* TreeSigningStarted */,
+        id: data.treeSigningStarted.id,
+        cosignersPublicKeys: data.treeSigningStarted.cosignersPubkeys,
+        unsignedCommitmentTx: data.treeSigningStarted.unsignedCommitmentTx
+      };
+    }
+    if (data.treeNoncesAggregated) {
+      return null;
+    }
+    if (data.treeNonces) {
+      return {
+        type: "tree_nonces" /* TreeNonces */,
+        id: data.treeNonces.id,
+        topic: data.treeNonces.topic,
+        txid: data.treeNonces.txid,
+        nonces: decodeMusig2Nonces(data.treeNonces.nonces)
+        // pubkey -> public nonce
+      };
+    }
+    if (data.treeTx) {
+      const children = Object.fromEntries(
+        Object.entries(data.treeTx.children).map(([outputIndex, txid]) => {
+          return [parseInt(outputIndex), txid];
+        })
+      );
+      return {
+        type: "tree_tx" /* TreeTx */,
+        id: data.treeTx.id,
+        topic: data.treeTx.topic,
+        batchIndex: data.treeTx.batchIndex,
+        chunk: {
+          txid: data.treeTx.txid,
+          tx: data.treeTx.tx,
+          children
+        }
+      };
+    }
+    if (data.treeSignature) {
+      return {
+        type: "tree_signature" /* TreeSignature */,
+        id: data.treeSignature.id,
+        topic: data.treeSignature.topic,
+        batchIndex: data.treeSignature.batchIndex,
+        txid: data.treeSignature.txid,
+        signature: data.treeSignature.signature
+      };
+    }
+    if (data.streamStarted) {
+      return {
+        type: "stream_started" /* StreamStarted */,
+        id: data.streamStarted.id
+      };
+    }
+    if (data.heartbeat) {
+      return null;
+    }
+    console.warn("Unknown event type:", data);
+    return null;
+  }
+  parseTransactionNotification(data) {
+    if (data.commitmentTx) {
+      return {
+        commitmentTx: {
+          txid: data.commitmentTx.txid,
+          tx: data.commitmentTx.tx,
+          spentVtxos: data.commitmentTx.spentVtxos.map(mapVtxo),
+          spendableVtxos: data.commitmentTx.spendableVtxos.map(mapVtxo),
+          checkpointTxs: data.commitmentTx.checkpointTxs
+        }
+      };
+    }
+    if (data.arkTx) {
+      return {
+        arkTx: {
+          txid: data.arkTx.txid,
+          tx: data.arkTx.tx,
+          spentVtxos: data.arkTx.spentVtxos.map(mapVtxo),
+          spendableVtxos: data.arkTx.spendableVtxos.map(mapVtxo),
+          checkpointTxs: data.arkTx.checkpointTxs
+        }
+      };
+    }
+    if (data.heartbeat) {
+      return null;
+    }
+    console.warn("Unknown transaction notification type:", data);
+    return null;
+  }
+};
+function encodeMusig2Nonces(nonces) {
+  const noncesObject = {};
+  for (const [txid, nonce] of nonces) {
+    noncesObject[txid] = base.hex.encode(nonce.pubNonce);
+  }
+  return noncesObject;
+}
+function encodeMusig2Signatures(signatures) {
+  const sigObject = {};
+  for (const [txid, sig] of signatures) {
+    sigObject[txid] = base.hex.encode(sig.encode());
+  }
+  return sigObject;
+}
+function decodeMusig2Nonces(noncesObject) {
+  return new Map(
+    Object.entries(noncesObject).map(([txid, nonce]) => {
+      if (typeof nonce !== "string") {
+        throw new Error("invalid nonce");
+      }
+      return [txid, { pubNonce: base.hex.decode(nonce) }];
+    })
+  );
+}
+function isFetchTimeoutError(err) {
+  const checkError = (error) => {
+    if (!(error instanceof Error)) return false;
+    const isCloudflare524 = error.name === "TypeError" && error.message === "Failed to fetch";
+    return isCloudflare524 || error.name === "HeadersTimeoutError" || error.name === "BodyTimeoutError" || error.code === "UND_ERR_HEADERS_TIMEOUT" || error.code === "UND_ERR_BODY_TIMEOUT";
+  };
+  return checkError(err) || checkError(err.cause);
+}
+function mapVtxo(vtxo) {
+  return {
+    outpoint: {
+      txid: vtxo.outpoint.txid,
+      vout: vtxo.outpoint.vout
+    },
+    amount: vtxo.amount,
+    script: vtxo.script,
+    createdAt: vtxo.createdAt,
+    expiresAt: vtxo.expiresAt,
+    commitmentTxids: vtxo.commitmentTxids,
+    isPreconfirmed: vtxo.isPreconfirmed,
+    isSwept: vtxo.isSwept,
+    isUnrolled: vtxo.isUnrolled,
+    isSpent: vtxo.isSpent,
+    spentBy: vtxo.spentBy,
+    settledBy: vtxo.settledBy,
+    arkTxid: vtxo.arkTxid
+  };
+}
+function handleError(errorText, defaultMessage) {
+  const error = new Error(errorText);
+  const arkError = maybeArkError(error);
+  throw arkError ?? new Error(defaultMessage);
+}
+
+// src/providers/availability.ts
+function isRetryableProviderError(error) {
+  return error instanceof ProviderUnavailableError || error instanceof FetchError || isFetchTimeoutError(error);
+}
+
+// src/contracts/constants.ts
+var DEFAULT_PAGE_SIZE = 500;
+var SCRIPT_QUERY_CHUNK_SIZE = 32;
+var OUTPOINT_QUERY_CHUNK_SIZE = 64;
+
+// src/wallet/vtxo.ts
+var EXPIRY_MIN_PLAUSIBLE_MS = Date.UTC(2025, 0, 1);
+async function resolveTimeHeight(provider) {
+  const timestamp = /* @__PURE__ */ new Date();
+  if (!provider) return { timestamp };
+  try {
+    const tip = await provider.getChainTip();
+    return { timestamp, height: tip.height };
+  } catch (e) {
+    console.warn("Failed to fetch chain tip; height-based expiry will not be evaluated", e);
+    return { timestamp };
+  }
+}
+function parseWireExpiry(raw) {
+  if (raw === null || raw === void 0 || raw === "") return {};
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n <= 0) return {};
+  const ms = n * 1e3;
+  if (ms >= EXPIRY_MIN_PLAUSIBLE_MS) return { expiresAt: new Date(ms) };
+  return { expiresAtHeight: n };
+}
+function toBatchExpiry(c) {
+  if (c.expiresAt !== void 0) return c.expiresAt.getTime();
+  if (c.expiresAtHeight !== void 0) return c.expiresAtHeight * 1e3;
+  return void 0;
+}
+function parseLegacyExpiry(batchExpiry) {
+  if (batchExpiry === void 0 || batchExpiry <= 0) return {};
+  if (batchExpiry >= EXPIRY_MIN_PLAUSIBLE_MS) return { expiresAt: new Date(batchExpiry) };
+  return { expiresAtHeight: batchExpiry / 1e3 };
+}
+function toVirtualStatus(c) {
+  return {
+    // Precedence is load-bearing: consumers bucket on this label, so any other order silently
+    // moves VTXOs between buckets.
+    state: c.isSpent ? "spent" : c.isSwept ? "swept" : c.isPreconfirmed ? "preconfirmed" : "settled",
+    commitmentTxIds: c.commitmentTxIds,
+    batchExpiry: toBatchExpiry(c)
+  };
+}
+function normalizeVtxo(v) {
+  const state = v.virtualStatus?.state;
+  const canonicalExpiry = v.expiresAt !== void 0 || v.expiresAtHeight !== void 0;
+  const expiry = canonicalExpiry ? (
+    // Coerce: a backend that persists through JSON hands back an ISO string, which typechecks
+    // as `Date` but returns NaN from `.getTime()` — comparing false against everything.
+    {
+      expiresAt: v.expiresAt === void 0 ? void 0 : new Date(v.expiresAt),
+      expiresAtHeight: v.expiresAtHeight
+    }
+  ) : parseLegacyExpiry(v.virtualStatus?.batchExpiry);
+  const isSpent = v.isSpent ?? state === "spent";
+  const isSwept = v.isSwept ?? state === "swept";
+  const isPreconfirmed = v.isPreconfirmed ?? state === "preconfirmed";
+  const commitmentTxIds = v.commitmentTxIds ?? v.virtualStatus?.commitmentTxIds ?? [];
+  return {
+    ...v,
+    isSpent,
+    isSwept,
+    isPreconfirmed,
+    spentBy: v.spentBy ?? "",
+    commitmentTxIds,
+    ...expiry,
+    virtualStatus: v.virtualStatus ?? toVirtualStatus({ isSpent, isSwept, isPreconfirmed, commitmentTxIds, ...expiry })
+  };
+}
+function convertVtxo(vtxo) {
+  const expiry = parseWireExpiry(vtxo.expiresAt);
+  const facts = {
+    isSpent: vtxo.isSpent,
+    isSwept: vtxo.isSwept,
+    isPreconfirmed: vtxo.isPreconfirmed,
+    commitmentTxIds: vtxo.commitmentTxids,
+    ...expiry
+  };
+  return {
+    txid: vtxo.outpoint.txid,
+    vout: vtxo.outpoint.vout,
+    value: Number(vtxo.amount),
+    status: {
+      confirmed: !vtxo.isSwept && !vtxo.isPreconfirmed,
+      isLeaf: !vtxo.isPreconfirmed
+    },
+    ...facts,
+    virtualStatus: toVirtualStatus(facts),
+    spentBy: vtxo.spentBy ?? "",
+    settledBy: vtxo.settledBy,
+    arkTxId: vtxo.arkTxid,
+    createdAt: new Date(Number(vtxo.createdAt) * 1e3),
+    isUnrolled: vtxo.isUnrolled,
+    script: vtxo.script,
+    assets: vtxo.assets?.map((a) => ({
+      assetId: a.assetId,
+      amount: BigInt(a.amount)
+    }))
+  };
+}
+async function getNormalizedVtxos(provider, opts) {
+  const { vtxos, page } = await provider.getVtxos(opts);
+  return { vtxos: vtxos.map(normalizeVtxo), page };
+}
+async function getAllNormalizedVtxos(provider, scripts, opts = {}) {
+  const { pageSize = DEFAULT_PAGE_SIZE, ...filters } = opts;
+  const all = [];
+  for (let i = 0; i < scripts.length; i += SCRIPT_QUERY_CHUNK_SIZE) {
+    const chunk = scripts.slice(i, i + SCRIPT_QUERY_CHUNK_SIZE);
+    let pageIndex = 0;
+    let hasMore = true;
+    while (hasMore) {
+      const { vtxos, page } = await getNormalizedVtxos(provider, {
+        ...filters,
+        scripts: chunk,
+        pageIndex,
+        pageSize
+      });
+      all.push(...vtxos);
+      hasMore = page ? vtxos.length === pageSize : false;
+      pageIndex++;
+      if (hasMore) await new Promise((r) => setTimeout(r, 500));
+    }
+  }
+  return all;
+}
+async function fetchVtxoCreatedAtByTxid(provider, txids) {
+  const unique = [...new Set(txids)].filter((txid) => txid !== "");
+  const createdAt = /* @__PURE__ */ new Map();
+  for (let i = 0; i < unique.length; i += OUTPOINT_QUERY_CHUNK_SIZE) {
+    const chunk = unique.slice(i, i + OUTPOINT_QUERY_CHUNK_SIZE);
+    try {
+      const { vtxos } = await getNormalizedVtxos(provider, {
+        outpoints: chunk.map((txid) => ({ txid, vout: 0 })),
+        pageSize: DEFAULT_PAGE_SIZE
+      });
+      for (const v of vtxos) {
+        createdAt.set(v.txid, v.createdAt.getTime());
+      }
+    } catch (err) {
+      if (!isRetryableProviderError(err)) throw err;
+    }
+  }
+  return createdAt;
+}
+function hasTerminalSpend(vtxo) {
+  const n = normalizeVtxo(vtxo);
+  return !!n.isSpent || !!n.spentBy || !!n.settledBy;
+}
+function isPastExpiry(vtxo, now) {
+  const n = normalizeVtxo(vtxo);
+  if (n.expiresAt !== void 0 && now.timestamp.getTime() >= n.expiresAt.getTime()) return true;
+  return n.expiresAtHeight !== void 0 && now.height !== void 0 && now.height >= n.expiresAtHeight;
+}
+function canSpendOffchain(vtxo, now) {
+  const n = normalizeVtxo(vtxo);
+  return !hasTerminalSpend(n) && !(n.isSwept || isPastExpiry(n, now));
+}
+function canRecoverOnchain(vtxo, now) {
+  const n = normalizeVtxo(vtxo);
+  return !hasTerminalSpend(n) && (n.isSwept || isPastExpiry(n, now));
+}
+function toOffchainInputFeeParams(vtxo) {
+  const batchExpiry = toBatchExpiry(vtxo);
+  return {
+    amount: BigInt(vtxo.value),
+    type: vtxo.isSwept ? "recoverable" : "vtxo",
+    weight: 0,
+    birth: vtxo.createdAt,
+    expiry: batchExpiry ? new Date(batchExpiry) : void 0
+  };
+}
+function isVirtualCoin(input) {
+  return typeof input === "object" && input !== null && typeof input.script === "string";
+}
+function isSpendable(vtxo) {
+  return !hasTerminalSpend(vtxo);
+}
+function isRecoverable(vtxo) {
+  const n = normalizeVtxo(vtxo);
+  return n.isSwept && !hasTerminalSpend(n);
+}
+function isExpired(vtxo) {
+  const n = normalizeVtxo(vtxo);
+  return n.isSwept || n.expiresAt !== void 0 && n.expiresAt.getTime() <= Date.now();
+}
+
+exports.ArkAddress = ArkAddress;
+exports.ArkError = ArkError;
+exports.ArkErrorName = ArkErrorName;
+exports.ArkPsbtFieldKey = ArkPsbtFieldKey;
+exports.ArkPsbtFieldKeyType = ArkPsbtFieldKeyType;
+exports.ConditionWitness = ConditionWitness;
+exports.CosignerPublicKey = CosignerPublicKey;
+exports.DEFAULT_ARKADE_SERVER_URL = DEFAULT_ARKADE_SERVER_URL;
+exports.DEFAULT_NETWORK = DEFAULT_NETWORK;
+exports.DEFAULT_NETWORK_NAME = DEFAULT_NETWORK_NAME;
+exports.DEFAULT_PAGE_SIZE = DEFAULT_PAGE_SIZE;
+exports.DigestMismatchError = DigestMismatchError;
+exports.FetchError = FetchError;
+exports.OP_RETURN_EMPTY_PKSCRIPT = OP_RETURN_EMPTY_PKSCRIPT;
+exports.PrevArkTxField = PrevArkTxField;
+exports.PrevoutTxField = PrevoutTxField;
+exports.ProviderUnavailableError = ProviderUnavailableError;
+exports.RestArkProvider = RestArkProvider;
+exports.SCRIPT_QUERY_CHUNK_SIZE = SCRIPT_QUERY_CHUNK_SIZE;
+exports.ServerResponseMismatchError = ServerResponseMismatchError;
+exports.SettlementEventType = SettlementEventType;
+exports.TapTreeCoder = TapTreeCoder;
+exports.Transaction = Transaction;
+exports.VtxoScript = VtxoScript;
+exports.VtxoTaprootTree = VtxoTaprootTree;
+exports.VtxoTreeExpiry = VtxoTreeExpiry;
+exports.assembleBtcdTaprootTree = assembleBtcdTaprootTree;
+exports.baseFetch = baseFetch;
+exports.buildVersion = buildVersion;
+exports.canRecoverOnchain = canRecoverOnchain;
+exports.canSpendOffchain = canSpendOffchain;
+exports.convertVtxo = convertVtxo;
+exports.craftToSpendTx = craftToSpendTx;
+exports.decodeTapscript = decodeTapscript;
+exports.eventSourceIterator = eventSourceIterator;
+exports.fetch = fetch;
+exports.fetchVtxoCreatedAtByTxid = fetchVtxoCreatedAtByTxid;
+exports.getAllNormalizedVtxos = getAllNormalizedVtxos;
+exports.getArkPsbtFields = getArkPsbtFields;
+exports.getNetwork = getNetwork;
+exports.getNormalizedVtxos = getNormalizedVtxos;
+exports.getSequence = getSequence;
+exports.hasTerminalSpend = hasTerminalSpend;
+exports.isArkError = isArkError;
+exports.isEventSourceError = isEventSourceError;
+exports.isExpired = isExpired;
+exports.isFetchTimeoutError = isFetchTimeoutError;
+exports.isPastExpiry = isPastExpiry;
+exports.isRecoverable = isRecoverable;
+exports.isRetryableProviderError = isRetryableProviderError;
+exports.isSpendable = isSpendable;
+exports.isVirtualCoin = isVirtualCoin;
+exports.maybeArkError = maybeArkError;
+exports.networks = networks;
+exports.normalizeVtxo = normalizeVtxo;
+exports.parseLegacyExpiry = parseLegacyExpiry;
+exports.rateGate = rateGate;
+exports.resolveTimeHeight = resolveTimeHeight;
+exports.scriptFromTapLeafScript = scriptFromTapLeafScript;
+exports.sdkVersion = sdkVersion;
+exports.sequenceToTimelock = sequenceToTimelock;
+exports.setArkPsbtField = setArkPsbtField;
+exports.throwIfHttpUnavailable = throwIfHttpUnavailable;
+exports.timelockToSequence = timelockToSequence;
+exports.toBatchExpiry = toBatchExpiry;
+exports.toOffchainInputFeeParams = toOffchainInputFeeParams;
+exports.toProviderUnavailable = toProviderUnavailable;
+exports.toVirtualStatus = toVirtualStatus;
+//# sourceMappingURL=chunk-OWCPXRGP.cjs.map
+//# sourceMappingURL=chunk-OWCPXRGP.cjs.map