@arkade-os/sdk 0.4.60 → 0.4.61

package/dist/{chunk-Y54MUBT7.js → chunk-AUEXB42T.js}

@@ -1,8 +1,8 @@
-import { AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, BufferReader, BufferWriter, AssetRef, RestIndexerProvider } from './chunk-FSKANUV4.js';
-import { witnessRefToBytes, validateProgram, toASM, stringifyArtifact, serializeArkadeContractParams, resolveAsm, parseArtifact, getOpcodeValue, getOpcodeName, fromASM, deserializeArkadeContractParams, computeArkadeScriptPublicKey, bytesToASM, asmToBytes, arkadeWitnessHash, arkadeScriptHash, SUPPORTED_PROGRAM_VERSION, OPCODE_VALUES, OPCODE_NAMES, bignum_exports, ArkadeScript, ArkadeProgramScript, ARKADE_OPS, ARKADE_OPCODE_VALUES, ARKADE_OPCODE_NAMES, ARKADE_OPCODES, ARKADE_OP, inputName, contractHandlers, isMainnetDescriptor, descriptorIsOurs, deriveDescriptorLeafPubKey, deriveDescriptorLeafCompressedPubKey, DefaultVtxo, speculativeReceiveMetadata, DelegateVtxo, WALLET_RECEIVE_SOURCE, BoardingContractHandler } from './chunk-2DINXHGQ.js';
-import { VtxoScript, Transaction, isRecoverable, CSVMultisigTapscript, DEFAULT_NETWORK, resolveEmulatorPubkey, hasTerminalSpend, getNormalizedVtxos, setArkPsbtField, PrevArkTxField, ConditionWitness, craftToSpendTx, ArkAddress, isVirtualCoin, getArkPsbtFields, CosignerPublicKey, ServerResponseMismatchError, OP_RETURN_EMPTY_PKSCRIPT, sequenceToTimelock, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, VtxoTaprootTree, timelockToSequence, baseFetch, Intent, rateGate, DEFAULT_NETWORK_NAME, normalizeVtxo, getSequence, toBatchExpiry, maybeArkError, isArkError, ArkErrorName, toOffchainInputFeeParams, canRecoverOnchain, getNetwork, MultisigTapscript, isEventSourceError, isEventSourceUnavailableError, isRetryableProviderError, getAllNormalizedVtxos, DEFAULT_PAGE_SIZE, RestArkProvider, toVirtualStatus, ArkError, resolveTimeHeight, canSpendOffchain, parseLegacyExpiry, isExpired, DEFAULT_ARKADE_SERVER_URL, ProviderUnavailableError, networks as networks$1, isPastExpiry, fetchVtxoCreatedAtByTxid } from './chunk-JBULXTCC.js';
+import { AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, BufferReader, BufferWriter, AssetRef, RestIndexerProvider } from './chunk-YVQNHELA.js';
+import { witnessRefToBytes, validateProgram, toASM, stringifyArtifact, serializeArkadeContractParams, resolveAsm, parseArtifact, getOpcodeValue, getOpcodeName, fromASM, deserializeArkadeContractParams, computeArkadeScriptPublicKey, bytesToASM, asmToBytes, arkadeWitnessHash, arkadeScriptHash, SUPPORTED_PROGRAM_VERSION, OPCODE_VALUES, OPCODE_NAMES, bignum_exports, ArkadeScript, ArkadeProgramScript, ARKADE_OPS, ARKADE_OPCODE_VALUES, ARKADE_OPCODE_NAMES, ARKADE_OPCODES, ARKADE_OP, inputName, contractHandlers, isMainnetDescriptor, descriptorIsOurs, deriveDescriptorLeafPubKey, deriveDescriptorLeafCompressedPubKey, parseHDDescriptor, DefaultVtxo, speculativeReceiveMetadata, DelegateVtxo, WALLET_RECEIVE_SOURCE, BoardingContractHandler, identityDescriptor } from './chunk-6O5OLYTZ.js';
+import { VtxoScript, Transaction, isRecoverable, CSVMultisigTapscript, DEFAULT_NETWORK, resolveEmulatorPubkey, hasTerminalSpend, getNormalizedVtxos, setArkPsbtField, PrevArkTxField, ConditionWitness, craftToSpendTx, ArkAddress, isVirtualCoin, getArkPsbtFields, CosignerPublicKey, ServerResponseMismatchError, OP_RETURN_EMPTY_PKSCRIPT, sequenceToTimelock, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, VtxoTaprootTree, timelockToSequence, baseFetch, Intent, rateGate, DEFAULT_NETWORK_NAME, normalizeVtxo, getSequence, toBatchExpiry, maybeArkError, isArkError, ArkErrorName, toOffchainInputFeeParams, canRecoverOnchain, getNetwork, MultisigTapscript, isEventSourceError, isEventSourceUnavailableError, isRetryableProviderError, getAllNormalizedVtxos, DEFAULT_PAGE_SIZE, RestArkProvider, toVirtualStatus, ArkError, resolveTimeHeight, canSpendOffchain, parseLegacyExpiry, isExpired, DEFAULT_ARKADE_SERVER_URL, ProviderUnavailableError, networks as networks$1, isPastExpiry, fetchVtxoCreatedAtByTxid } from './chunk-PVY6DMN5.js';
 import { __export } from './chunk-NSBPE2FW.js';
-import { sha256, equalBytes, hash160, sha256x2, concatBytes, randomPrivateKeyBytes, pubECDSA, pubSchnorr } from '@scure/btc-signer/utils.js';
+import { sha256 as sha256$1, equalBytes, hash160, sha256x2, concatBytes, randomPrivateKeyBytes, pubECDSA, pubSchnorr } from '@scure/btc-signer/utils.js';
 import { SigHash, Script, OP, OutScript, Address, RawWitness, p2tr, p2wpkh, TaprootControlBlock, DEFAULT_SEQUENCE, Transaction as Transaction$2 } from '@scure/btc-signer';
 import { hex, base58, base64, bech32m } from '@scure/base';
 import * as musig2 from '@scure/btc-signer/musig2.js';
@@ -879,8 +879,33 @@ function isHDCapableIdentity(value) {
 function isBatchSignable(identity) {
   return "signMultiple" in identity && typeof identity.signMultiple === "function";
 }
-
-// src/wallet/hdWalletCapable.ts
+function isSigningIdentity(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return typeof v.sign === "function" && typeof v.signMessage === "function" && typeof v.signerSession === "function" && typeof v.xOnlyPublicKey === "function";
+}
+var ForeignDescriptorError = class extends Error {
+  constructor(descriptor, options) {
+    super(`this wallet holds no key for descriptor: ${descriptor}`, options);
+    this.descriptor = descriptor;
+  }
+  descriptor;
+  name = "ForeignDescriptorError";
+};
+async function resolveDescriptorSigner(descriptor, identity, provider) {
+  const owner = provider?.isOurs(descriptor) ? provider : isHDCapableIdentity(identity) && identity.isOurs(descriptor) ? identity : void 0;
+  if (owner && parseHDDescriptor(descriptor)) {
+    return new DescriptorIdentity({ descriptor, signer: owner, base: identity });
+  }
+  let key;
+  try {
+    key = deriveDescriptorLeafPubKey(descriptor);
+  } catch {
+    throw new ForeignDescriptorError(descriptor);
+  }
+  if (equalBytes(await identity.xOnlyPublicKey(), key)) return identity;
+  throw new ForeignDescriptorError(descriptor);
+}
 function isHDWalletCapable(value) {
   if (typeof value !== "object" || value === null) return false;
   const v = value;
@@ -892,6 +917,441 @@ function isHDAllocationCapable(value) {
   return typeof v.getNextSigningDescriptor === "function" && typeof v.advanceSigningDescriptorWatermark === "function";
 }
 
+// ../../node_modules/@noble/hashes/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function abytes(value, length, title = "") {
+  const bytes = isBytes(value);
+  const len = value?.length;
+  const needsLen = length !== void 0;
+  if (!bytes || needsLen) {
+    const prefix = title && `"${title}" `;
+    const ofLen = "";
+    const got = bytes ? `length=${len}` : `type=${typeof value}`;
+    throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
+  }
+  return value;
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out, void 0, "digestInto() output");
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error('"digestInto() output" expected to be of length >=' + min);
+  }
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
+function createHasher(hashCons, info = {}) {
+  const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+  const tmp = hashCons(void 0);
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = (opts) => hashCons(opts);
+  Object.assign(hashC, info);
+  return Object.freeze(hashC);
+}
+function randomBytes(bytesLength = 32) {
+  const cr = typeof globalThis === "object" ? globalThis.crypto : null;
+  if (typeof cr?.getRandomValues !== "function")
+    throw new Error("crypto.getRandomValues must be defined");
+  return cr.getRandomValues(new Uint8Array(bytesLength));
+}
+var oidNist = (suffix) => ({
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
+});
+
+// ../../node_modules/@noble/hashes/_md.js
+function Chi(a, b, c) {
+  return a & b ^ ~a & c;
+}
+function Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
+}
+var HashMD = class {
+  blockLen;
+  outputLen;
+  padOffset;
+  isLE;
+  // For partial updates less than block size
+  buffer;
+  view;
+  finished = false;
+  length = 0;
+  pos = 0;
+  destroyed = false;
+  constructor(blockLen, outputLen, padOffset, isLE) {
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    aexists(this);
+    abytes(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    clean(this.buffer.subarray(pos));
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos; i < blockLen; i++)
+      buffer[i] = 0;
+    view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
+    this.process(view, 0);
+    const oview = createView(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen must be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i = 0; i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to ||= new this.constructor();
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+};
+var SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// ../../node_modules/@noble/hashes/sha2.js
+var SHA256_K = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+var SHA2_32B = class extends HashMD {
+  constructor(outputLen) {
+    super(64, outputLen, 8, false);
+  }
+  get() {
+    const { A, B, C, D, E, F, G, H } = this;
+    return [A, B, C, D, E, F, G, H];
+  }
+  // prettier-ignore
+  set(A, B, C, D, E, F, G, H) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G | 0;
+    this.H = H | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4)
+      SHA256_W[i] = view.getUint32(offset, false);
+    for (let i = 16; i < 64; i++) {
+      const W15 = SHA256_W[i - 15];
+      const W2 = SHA256_W[i - 2];
+      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+    }
+    let { A, B, C, D, E, F, G, H } = this;
+    for (let i = 0; i < 64; i++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = sigma0 + Maj(A, B, C) | 0;
+      H = G;
+      G = F;
+      F = E;
+      E = D + T1 | 0;
+      D = C;
+      C = B;
+      B = A;
+      A = T1 + T2 | 0;
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    F = F + this.F | 0;
+    G = G + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A, B, C, D, E, F, G, H);
+  }
+  roundClean() {
+    clean(SHA256_W);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    clean(this.buffer);
+  }
+};
+var _SHA256 = class extends SHA2_32B {
+  // We cannot use array here since array allows indexing by variable
+  // which means optimizer/compiler cannot use registers.
+  A = SHA256_IV[0] | 0;
+  B = SHA256_IV[1] | 0;
+  C = SHA256_IV[2] | 0;
+  D = SHA256_IV[3] | 0;
+  E = SHA256_IV[4] | 0;
+  F = SHA256_IV[5] | 0;
+  G = SHA256_IV[6] | 0;
+  H = SHA256_IV[7] | 0;
+  constructor() {
+    super(32);
+  }
+};
+var sha256 = /* @__PURE__ */ createHasher(
+  () => new _SHA256(),
+  /* @__PURE__ */ oidNist(1)
+);
+var ARKADE_SWAP_PREIMAGE_TAG = "Arkade-RFQ-Preimage-v1";
+function buildPreimageMessage(xonly, index) {
+  if (xonly.length !== 32) {
+    throw new Error(`x-only pubkey must be 32 bytes, got ${xonly.length}`);
+  }
+  if (!Number.isInteger(index) || index < 0 || index > 4294967295) {
+    throw new Error(`index must be a u32, got ${index}`);
+  }
+  const tag = new TextEncoder().encode(ARKADE_SWAP_PREIMAGE_TAG);
+  const message = new Uint8Array(tag.length + 32 + 4);
+  message.set(tag, 0);
+  message.set(xonly, tag.length);
+  new DataView(message.buffer).setUint32(tag.length + 32, index, true);
+  return message;
+}
+var PREIMAGE_INDEX = 0;
+function isPerArtifactDescriptor(descriptor) {
+  return parseHDDescriptor(descriptor) !== null;
+}
+async function provisionDescriptor(wallet) {
+  const allocated = isHDAllocationCapable(wallet) ? await wallet.getNextSigningDescriptor() : void 0;
+  return allocated ?? await identityDescriptor(wallet.identity);
+}
+async function provisionRefundKey(wallet) {
+  const descriptor = await provisionDescriptor(wallet);
+  const signer = await contractSigner(wallet, descriptor);
+  return { descriptor, pubkey: await signer.xOnlyPublicKey() };
+}
+async function provisionClaimSecret(wallet, opts = {}) {
+  if (opts.preimage && opts.preimage.length !== 32) {
+    throw new Error(`preimage must be 32 bytes, got ${opts.preimage.length}`);
+  }
+  const { descriptor, pubkey } = await provisionRefundKey(wallet);
+  const derivable = !opts.preimage && isPerArtifactDescriptor(descriptor);
+  const preimage = opts.preimage ?? (derivable ? await derivePreimage(wallet, descriptor) : randomBytes(32));
+  return {
+    descriptor,
+    pubkey,
+    preimage,
+    paymentHash: sha256(preimage),
+    mustPersistPreimage: !derivable
+  };
+}
+async function contractSigner(wallet, descriptor) {
+  const signer = isHDWalletCapable(wallet) ? await wallet.signerForDescriptor(descriptor) : wallet.identity;
+  let expected;
+  try {
+    expected = deriveDescriptorLeafPubKey(descriptor);
+  } catch (cause) {
+    throw new ForeignDescriptorError(descriptor, { cause });
+  }
+  const actual = await signer.xOnlyPublicKey();
+  if (!equalBytes(actual, expected)) throw new ForeignDescriptorError(descriptor);
+  if (!isSigningIdentity(signer)) throw new WalletCannotSignError(descriptor);
+  return signer;
+}
+var WalletCannotSignError = class extends Error {
+  constructor(descriptor) {
+    super(`this wallet holds the key for ${descriptor} but cannot sign with it`);
+    this.descriptor = descriptor;
+  }
+  descriptor;
+  name = "WalletCannotSignError";
+};
+async function contractPreimage(wallet, descriptor, stored) {
+  if (stored) {
+    if (stored.length !== 32) {
+      throw new Error(`stored preimage must be 32 bytes, got ${stored.length}`);
+    }
+    return stored;
+  }
+  if (!isPerArtifactDescriptor(descriptor)) {
+    throw new Error(
+      `descriptor ${descriptor} names no single artifact, so its preimage cannot be derived; none was stored`
+    );
+  }
+  return derivePreimage(wallet, descriptor);
+}
+function isDeterministicSigner(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return typeof v.signSchnorrDeterministic === "function" && typeof v.xOnlyPublicKey === "function";
+}
+async function derivePreimage(wallet, descriptor) {
+  const signer = await contractSigner(wallet, descriptor);
+  if (!isDeterministicSigner(signer)) {
+    throw new Error(
+      `wallet cannot sign deterministically for ${descriptor}; its preimage is not derivable`
+    );
+  }
+  const message = buildPreimageMessage(await signer.xOnlyPublicKey(), PREIMAGE_INDEX);
+  try {
+    return sha256(await signer.signSchnorrDeterministic(sha256(message)));
+  } catch (cause) {
+    throw new Error(
+      `wallet cannot sign deterministically for ${descriptor}; its preimage is not derivable`,
+      { cause }
+    );
+  }
+}
+async function adoptContractDescriptor(wallet, descriptor) {
+  if (!isHDAllocationCapable(wallet)) return;
+  if (!isPerArtifactDescriptor(descriptor)) return;
+  if (isHDWalletCapable(wallet)) {
+    try {
+      await wallet.signerForDescriptor(descriptor);
+    } catch (error) {
+      if (error instanceof ForeignDescriptorError) return;
+      throw error;
+    }
+  }
+  await wallet.advanceSigningDescriptorWatermark(descriptor);
+}
+
 // src/worker/browser/service-worker-manager.ts
 var registrations = /* @__PURE__ */ new Map();
 var handshakes = /* @__PURE__ */ new WeakSet();
@@ -3118,6 +3578,44 @@ function validateRecipients(recipients, dustAmount, context) {
   return validatedRecipients;
 }
 
+// src/contracts/spendability.ts
+function isContractGenericallySpendable(contract) {
+  return contractHandlers.get(contract.type)?.isGenericallySpendable?.(contract) === true;
+}
+function gatedContracts(contracts) {
+  const gated = /* @__PURE__ */ new Map();
+  for (const contract of contracts) {
+    if (!isContractGenericallySpendable(contract)) gated.set(contract.script, contract.type);
+  }
+  return gated;
+}
+function gateExclusion(gated) {
+  return (vtxo) => {
+    const type = vtxo.script === void 0 ? void 0 : gated.get(vtxo.script);
+    if (type === void 0) return void 0;
+    return `at ${vtxo.script} (contract type '${type}') is not generically spendable`;
+  };
+}
+function outpointExclusion(outpoints, reason) {
+  return (vtxo) => outpoints.has(`${vtxo.txid}:${vtxo.vout}`) ? reason : void 0;
+}
+function outpointReasons(reasons) {
+  return (vtxo) => reasons.get(`${vtxo.txid}:${vtxo.vout}`);
+}
+function logExcludedVtxos(source, vtxos, exclusions) {
+  if (exclusions.length === 0) return;
+  for (const vtxo of vtxos) {
+    for (const exclusion of exclusions) {
+      const reason = exclusion(vtxo);
+      if (reason === void 0) continue;
+      console.debug(`[spendability] ${source}: ${vtxo.txid}:${vtxo.vout} ${reason}`);
+    }
+  }
+}
+var UnannotatableInputError = class extends Error {
+  name = "UnannotatableInputError";
+};
+
 // src/wallet/vtxo-manager.ts
 function selectPendingRecoveryOutpoints(contractsWithVtxos, signerSet, nowSeconds = Math.floor(Date.now() / 1e3)) {
   const out = /* @__PURE__ */ new Set();
@@ -3400,6 +3898,27 @@ var VtxoManager = class _VtxoManager {
   static MIGRATION_COOLDOWN_MS = 3e4;
   static MIGRATION_MAX_BACKOFF_MS = 5 * 60 * 1e3;
   // ========== Recovery Methods ==========
+  /**
+   * Outpoints recovery must not name yet, with the reason each was refused.
+   * Empty when the manager offers no opinion — an embedder's may not implement
+   * the predicate, and every contract type but VHTLC never answers.
+   *
+   * Reaches only a lockup whose `sender` is this wallet's own key: role
+   * resolution matches that key against the contract's params, so a
+   * descriptor-derived sender (every RFQ lockup) is not matched and such a row
+   * still fails its batch at submit.
+   *
+   * The key stays a thunk so an ordinary recovery never touches the identity,
+   * and the full coins are passed rather than bare outpoints because only they
+   * carry the confirmation a relative timelock is measured from.
+   */
+  async unspendableNow(vtxos) {
+    const contractManager = await this.wallet.getContractManager();
+    return await contractManager.unspendableNowReasons?.(
+      vtxos,
+      async () => hex.encode(await this.wallet.identity.xOnlyPublicKey())
+    ) ?? /* @__PURE__ */ new Map();
+  }
   /**
    * Recover swept/expired virtual outputs by settling them back to the wallet's Arkade address.
    *
@@ -3412,6 +3931,11 @@ var VtxoManager = class _VtxoManager {
    * Note: Settled virtual outputs with long expiry are NOT recovered to avoid locking liquidity unnecessarily.
    * Only preconfirmed subdust is recovered to consolidate small amounts.
    *
+   * Inputs whose contract refuses a spend right now — an immature VHTLC refund
+   * path — are skipped rather than failing the batch that holds them, and
+   * {@link getRecoverableBalance} skips the same set. See
+   * {@link unspendableNow} for which rows that reaches.
+   *
    * @param eventCallback - Optional callback to receive settlement events
    * @returns Settlement transaction ID
    * @throws Error if no recoverable virtual outputs found
@@ -3440,6 +3964,26 @@ var VtxoManager = class _VtxoManager {
     if (vtxosToRecover.length === 0) {
       throw new Error("No recoverable VTXOs found");
     }
+    const refused = await this.unspendableNow(vtxosToRecover);
+    if (refused.size > 0) {
+      logExcludedVtxos("recoverVtxos", vtxosToRecover, [outpointReasons(refused)]);
+      const held = vtxosToRecover.length;
+      vtxosToRecover = vtxosToRecover.filter(
+        (vtxo) => !refused.has(`${vtxo.txid}:${vtxo.vout}`)
+      );
+      if (vtxosToRecover.length === 0) {
+        const why = refused.size === 1 ? [...refused.values()][0] : [...refused].map(([outpoint, reason]) => `${outpoint}: ${reason}`).join("; ");
+        throw new Error(
+          `All ${held} recoverable VTXO(s) are held by a contract that refuses a spend right now: ${why}`
+        );
+      }
+      ({ vtxosToRecover } = getRecoverableWithSubdust(vtxosToRecover, dustAmount, now));
+      if (vtxosToRecover.length === 0) {
+        throw new Error(
+          `Excluding ${refused.size} VTXO(s) not yet spendable, the remaining recoverable amount is below the dust threshold ${dustAmount}`
+        );
+      }
+    }
     const info = await this.getInfoProvider()?.getInfo();
     const vtxoMaxAmount = info?.vtxoMaxAmount ?? -1n;
     const estimator = new Estimator(info?.fees.intentFee ?? {});
@@ -3503,6 +4047,11 @@ var VtxoManager = class _VtxoManager {
    * The batch size caps are not applied here: they defer the overflow to the
    * next cycle rather than reducing what is recoverable.
    *
+   * Inputs a contract refuses right now are excluded, so this and
+   * {@link recoverVtxos} answer over the same set. `Balance.recoverable` still
+   * counts them: that field reports what the wallet owns, this one what a
+   * batch would hand back today.
+   *
    * @returns Object containing recoverable amounts and subdust information
    *
    * @example
@@ -3524,11 +4073,24 @@ var VtxoManager = class _VtxoManager {
       withUnrolled: false
     });
     const dustAmount = getDustAmount(this.wallet);
-    const { vtxosToRecover, includesSubdust } = getRecoverableWithSubdust(
+    const now = await fetchTimeHeight(this.wallet);
+    let { vtxosToRecover, includesSubdust } = getRecoverableWithSubdust(
       allVtxos,
       dustAmount,
-      await fetchTimeHeight(this.wallet)
+      now
     );
+    const refused = await this.unspendableNow(vtxosToRecover);
+    if (refused.size > 0) {
+      logExcludedVtxos("getRecoverableBalance", vtxosToRecover, [outpointReasons(refused)]);
+      const remaining = vtxosToRecover.filter(
+        (vtxo) => !refused.has(`${vtxo.txid}:${vtxo.vout}`)
+      );
+      ({ vtxosToRecover, includesSubdust } = getRecoverableWithSubdust(
+        remaining,
+        dustAmount,
+        now
+      ));
+    }
     const info = await this.getInfoProvider()?.getInfo();
     const estimator = new Estimator(info?.fees.intentFee ?? {});
     const { payable, net } = priceSettlementInputs(vtxosToRecover, estimator);
@@ -4770,7 +5332,7 @@ var ArkNote = class _ArkNote {
     this.preimage = preimage;
     this.value = value;
     this.HRP = HRP;
-    const preimageHash = sha256(this.preimage);
+    const preimageHash = sha256$1(this.preimage);
     this.vtxoScript = new VtxoScript([noteTapscript(preimageHash)]);
     const leaf = this.vtxoScript.leaves[0];
     this.txid = hex.encode(new Uint8Array(preimageHash).reverse());
@@ -7590,41 +8152,6 @@ function mergeByKey(existing, incoming, toKey) {
   });
   return Array.from(next.values());
 }
-
-// src/contracts/spendability.ts
-function isContractGenericallySpendable(contract) {
-  return contractHandlers.get(contract.type)?.isGenericallySpendable?.(contract) === true;
-}
-function gatedContracts(contracts) {
-  const gated = /* @__PURE__ */ new Map();
-  for (const contract of contracts) {
-    if (!isContractGenericallySpendable(contract)) gated.set(contract.script, contract.type);
-  }
-  return gated;
-}
-function gateExclusion(gated) {
-  return (vtxo) => {
-    const type = vtxo.script === void 0 ? void 0 : gated.get(vtxo.script);
-    if (type === void 0) return void 0;
-    return `at ${vtxo.script} (contract type '${type}') is not generically spendable`;
-  };
-}
-function outpointExclusion(outpoints, reason) {
-  return (vtxo) => outpoints.has(`${vtxo.txid}:${vtxo.vout}`) ? reason : void 0;
-}
-function logExcludedVtxos(source, vtxos, exclusions) {
-  if (exclusions.length === 0) return;
-  for (const vtxo of vtxos) {
-    for (const exclusion of exclusions) {
-      const reason = exclusion(vtxo);
-      if (reason === void 0) continue;
-      console.debug(`[spendability] ${source}: ${vtxo.txid}:${vtxo.vout} ${reason}`);
-    }
-  }
-}
-var UnannotatableInputError = class extends Error {
-  name = "UnannotatableInputError";
-};
 var ARKCONTRACT_PREFIX = "arkcontract";
 function encodeArkContract(contract) {
   const params = new URLSearchParams();
@@ -9065,7 +9592,17 @@ var ContractManager = class _ContractManager {
   }
   /** @inheritdoc */
   async assertSpendableNow(vtxos, walletPubKey) {
-    if (vtxos.length === 0) return;
+    const refused = await this.unspendableNowReasons(vtxos, walletPubKey);
+    if (refused.size === 0) return;
+    if (refused.size === 1) throw new Error([...refused.values()][0]);
+    throw new Error(
+      `refusing to spend ${refused.size} vtxo(s) that cannot be spent yet: ` + [...refused].map(([outpoint, why]) => `${outpoint}: ${why}`).join("; ")
+    );
+  }
+  /** @inheritdoc */
+  async unspendableNowReasons(vtxos, walletPubKey) {
+    const refused = /* @__PURE__ */ new Map();
+    if (vtxos.length === 0) return refused;
     const contracts = await this.config.contractRepository.getContracts({
       script: Array.from(new Set(vtxos.map((vtxo) => vtxo.script)))
     });
@@ -9074,7 +9611,7 @@ var ContractManager = class _ContractManager {
       const contract = byScript.get(vtxo.script);
       return contract !== void 0 && contractHandlers.get(contract.type)?.assertSpendableNow !== void 0;
     });
-    if (asking.length === 0) return;
+    if (asking.length === 0) return refused;
     const tip = await this.currentChainTip();
     const walletKey = await walletPubKey?.();
     for (const vtxo of asking) {
@@ -9096,12 +9633,20 @@ var ContractManager = class _ContractManager {
         // really is one.
         vtxo: isVirtualCoin(vtxo) && "status" in vtxo ? vtxo : void 0
       };
-      await handler.assertSpendableNow(
-        handler.createScript(contract.params),
-        contract,
-        context
-      );
+      try {
+        await handler.assertSpendableNow(
+          handler.createScript(contract.params),
+          contract,
+          context
+        );
+      } catch (err) {
+        refused.set(
+          `${vtxo.txid}:${vtxo.vout}`,
+          err instanceof Error ? err.message : String(err)
+        );
+      }
     }
+    return refused;
   }
   // Field-by-field, so every filter a caller can express reaches the
   // repository. A field missing here is not a narrower query — it is an
@@ -13049,15 +13594,24 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     return provider.getCurrentSigningDescriptor();
   }
   /**
-   * @see HDWalletCapable.getNextSigningDescriptor
+   * @see HDAllocationCapable.getNextSigningDescriptor
+   *
+   * Every `Wallet` answers — this is where the wallet's key-provisioning
+   * policy lives, so consumers never have to branch on wallet shape:
+   * - HD: allocate a fresh index through the contract manager (which owns
+   *   cross-context serialization and the look-ahead band).
+   * - custom provider: whatever the provider allocates.
+   * - static / `auto`: the identity key as a bare `tr(pubkey)` descriptor —
+   *   the same answer every call, because that IS the static policy.
    */
   async getNextSigningDescriptor() {
-    const provider = this._descriptorProvider;
-    if (!(provider instanceof HDDescriptorProvider)) return void 0;
-    return (await this.getContractManager()).getNextSigningDescriptor();
+    if (this._descriptorProvider instanceof HDDescriptorProvider) {
+      return (await this.getContractManager()).getNextSigningDescriptor();
+    }
+    return identityDescriptor(this.identity);
   }
   /**
-   * @see HDWalletCapable.advanceSigningDescriptorWatermark
+   * @see HDAllocationCapable.advanceSigningDescriptorWatermark
    */
   async advanceSigningDescriptorWatermark(descriptor) {
     const provider = this._descriptorProvider;
@@ -13110,13 +13664,16 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
   }
   /**
    * @see HDWalletCapable.signerForDescriptor
+   *
+   * Fail-loud contract: the returned identity is always the descriptor's
+   * own key. A descriptor this wallet cannot sign for throws
+   * {@link ForeignDescriptorError} instead of silently substituting the
+   * baseline identity — that identity would sign happily with the wrong
+   * key, and the failure would only surface as a rejected transaction or a
+   * dead script, far from the call that caused it.
    */
   async signerForDescriptor(descriptor) {
-    const provider = this._descriptorProvider;
-    if (!(provider instanceof HDDescriptorProvider) || !provider.isOurs(descriptor)) {
-      return this.identity;
-    }
-    return new DescriptorIdentity({ descriptor, signer: provider, base: this.identity });
+    return resolveDescriptorSigner(descriptor, this.identity, this._descriptorProvider);
   }
   /**
    * Mid-session server-signer rotation (plan §4). When arkd rotates its
@@ -13322,7 +13879,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     const manager = await this.getContractManager();
     const provider = this._descriptorProvider;
     const hd = provider instanceof HDDescriptorProvider;
-    const staticDescriptor = hd ? void 0 : `tr(${hex.encode(await this.identity.xOnlyPublicKey())})`;
+    const staticDescriptor = hd ? void 0 : await identityDescriptor(this.identity);
     const materialize = (index) => hd ? provider.materializeDescriptorAt(index) : staticDescriptor;
     const delegatePubKey = this.offchainTapscript instanceof DelegateVtxo.Script ? this.offchainTapscript.options.delegatePubKey : void 0;
     const arkInfo = await this.arkProvider.getInfo();
@@ -14099,7 +14656,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     return {
       onBatchStarted: async (event) => {
         const utf8IntentId = new TextEncoder().encode(intentId);
-        const intentIdHash = sha256(utf8IntentId);
+        const intentIdHash = sha256$1(utf8IntentId);
         const intentIdHashStr = hex.encode(intentIdHash);
         const skip = !event.intentIdHashes.includes(intentIdHashStr);
         if (skip) {
@@ -17298,10 +17855,6 @@ function getRequestDedupKey(request) {
   const { id, tag, ...rest } = request;
   return JSON.stringify(rest);
 }
-function isSigningCapable(identity) {
-  const candidate = identity;
-  return typeof candidate.signMessage === "function" && typeof candidate.sign === "function" && typeof candidate.signerSession === "function";
-}
 var ServiceWorkerReadonlyAssetManager = class {
   constructor(sendMessage, messageTag) {
     this.sendMessage = sendMessage;
@@ -18009,7 +18562,15 @@ var ServiceWorkerReadonlyWallet = class _ServiceWorkerReadonlyWallet {
        */
       async assertAnnotatable() {
       },
-      /** Same reasoning as {@link assertAnnotatable}: the worker checks it. */
+      /**
+       * Same reasoning as {@link assertAnnotatable}: the worker checks it.
+       *
+       * `unspendableNowReasons` is deliberately absent rather than stubbed
+       * alongside it. A stub returning an empty map reads as "nothing
+       * refused", and a filter acting on that silently drops its decision;
+       * absent, the optional call is skipped. Recovery — the only caller —
+       * runs inside the worker against the real manager anyway.
+       */
       async assertSpendableNow() {
       },
       async annotateVtxos(vtxos) {
@@ -18235,7 +18796,7 @@ var ServiceWorkerWallet = class _ServiceWorkerWallet extends ServiceWorkerReadon
     }
     const walletRepository = options.storage?.walletRepository ?? new IndexedDBWalletRepository();
     const contractRepository = options.storage?.contractRepository ?? new IndexedDBContractRepository();
-    if (!isSigningCapable(options.identity)) {
+    if (!isSigningIdentity(options.identity)) {
       throw new Error(
         "ServiceWorkerWallet.create() requires a signing Identity; got a ReadonlyIdentity"
       );
@@ -18395,17 +18956,21 @@ var ServiceWorkerWallet = class _ServiceWorkerWallet extends ServiceWorkerReadon
   /**
    * @see HDWalletCapable.signerForDescriptor
    *
-   * Runs page-side: an Identity cannot cross the message bus, and it does
-   * not need to — the page owns the signing identity, and derivation reads
-   * no allocation state. Mirrors {@link Wallet.signerForDescriptor}'s
-   * fallback: the wallet identity itself for a non-HD identity or a foreign
+   * Runs page-side: an `Identity` cannot cross the message bus, and it does
+   * not need to — the page owns the signing identity, and resolving a
+   * descriptor reads no allocation state. Shares
+   * {@link resolveDescriptorSigner} with {@link Wallet.signerForDescriptor}
+   * so the two sides of the bus cannot answer differently for one
    * descriptor.
+   *
+   * No provider is passed, and none is needed: `HDDescriptorProvider`'s
+   * `isOurs` and signing members all delegate to the identity, which the
+   * page holds. Building one here would only add a page-side read of the
+   * wallet state the worker allocates from — shared mutable state on a path
+   * that has no business touching it.
    */
   async signerForDescriptor(descriptor) {
-    if (!isHDCapableIdentity(this.identity)) return this.identity;
-    const provider = await HDDescriptorProvider.create(this.identity, this.walletRepository);
-    if (!provider.isOurs(descriptor)) return this.identity;
-    return new DescriptorIdentity({ descriptor, signer: provider, base: this.identity });
+    return resolveDescriptorSigner(descriptor, this.identity);
   }
   async sendBitcoin(params) {
     const message = {
@@ -18975,8 +19540,8 @@ function parseBlockHeader(headerHex) {
   }
   const view = new DataView(headerBytes.buffer, headerBytes.byteOffset);
   const timestamp = view.getUint32(68, true);
-  const hash1 = sha256(headerBytes);
-  const hash2 = sha256(hash1);
+  const hash1 = sha256$1(headerBytes);
+  const hash2 = sha256$1(hash1);
   const hashStr = hex.encode(new Uint8Array(hash2).reverse());
   return { hash: hashStr, timestamp };
 }
@@ -19594,7 +20159,7 @@ var ElectrumOnchainProvider = class {
   }
 };
 function toScriptHash(script) {
-  return hex.encode(sha256(script).reverse());
+  return hex.encode(sha256$1(script).reverse());
 }
 function isHeaderSubscribeResult(v) {
   if (typeof v !== "object" || v === null) return false;
@@ -21035,7 +21600,7 @@ function createArkadeBatchHandler(intentId, inputs, signer, signedProof, message
   return {
     onBatchStarted: async (event) => {
       const utf8IntentId = new TextEncoder().encode(intentId);
-      const intentIdHash = sha256(utf8IntentId);
+      const intentIdHash = sha256$1(utf8IntentId);
       const intentIdHashStr = hex.encode(intentIdHash);
       if (!event.intentIdHashes.includes(intentIdHashStr)) return { skip: true };
       const info = await arkProvider.getInfo();
@@ -22020,7 +22585,12 @@ function createDefaultPaymentRouter(wallet) {
     prefs: { priority: ["ark", "lightning", "onchain"] }
   }).use(arkRail()).use(onchainRail());
 }
+/*! Bundled license information:
+
+@noble/hashes/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
 
-export { ARKADE_MAGIC, ActivityRegistry, AmbiguousRouteError, ArkNote, ArkadeCash, ArkadeCashCreateError, AssetManager, BIP21, BIP21Error, BIP322, Batch, ChainedTxType, ContractManager, ContractRepositoryImpl, ContractWatcher, DB_VERSION, DEFAULT_MESSAGE_TIMEOUTS, DEFAULT_MIN_BATCH_EXPIRY_SECONDS, DEFAULT_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, DelegateManagerImpl, DelegateNotConfiguredError, DelegatorManagerImpl, DelegatorNotConfiguredError, DescriptorIdentity, DescriptorSigningProviderMissingError, DustChangeError, ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ESPLORA_URL, ElectrumOnchainProvider, EmulatorPacket, EsploraProvider, Estimator, Extension, ExtensionNotFoundError, HDDescriptorProvider, INTENT_TERMINAL_STATES, InMemoryContractRepository, InMemoryIntentRepository, InMemoryVirtualTxRepository, InMemoryWalletRepository, IndexedDBContractRepository, IndexedDBIntentRepository, IndexedDBVirtualTxRepository, IndexedDBWalletRepository, MAX_USED_SIGNING_DESCRIPTORS_LOOK_AHEAD, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, MIGRATION_KEY, MUTINYNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, P2A, PaymentRouter, REGTEST_MIN_BATCH_EXPIRY_SECONDS, REGTEST_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestDelegatorProvider, RestEmulatorProvider, SIGNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, SeedIdentity, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, TxTree, TxType, TxWeightEstimator, UnannotatableInputError, UnilateralExit, UnknownPacket, Unroll, VtxoManager, Wallet2 as Wallet, WalletMessageHandler, WalletNotInitializedError, WalletRepositoryImpl, WsElectrumChainSource, arkRail, arkTarget, arkade_exports, assertFinalCommitmentMatchesValidated, assertIntentIdUnique, assertSendableAmount, assertSubmittedArkTxid, assertValidBatchExpiry, assertValidServerUnrollScript, assetMintResolver, boardingResolver, btcTarget, buildForfeitTx, buildOffchainTx, claimWithPreimageIdentity, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, collabExitResolver, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, createAssetPacket, createDefaultActivityRegistry, createDefaultPaymentRouter, createExitChainResolver, decodeArkContract, defaultBatchExpiryPolicy, defaultCheckpointExitDelayPolicy, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, extendVirtualCoinForContract, gateExclusion, gatedContracts, getMigrationStatus, getRandomId, hasBoardingTxExpired, hasCandidates, intentMatchesFilter, intentPageBounds, invoiceTarget, isArkContract, isBatchSignable, isBtcAddress, isContractGenericallySpendable, isCooperativelyMigratable, isDiscoverable, isHDAllocationCapable, isHDDeterministicSignCapable, isHDWalletCapable, isLightningInvoice, isLnurl, isMessageBusInitializingError, isMessageBusNotInitializedError, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, isVtxoForScript, isWatchedContract, logExcludedVtxos, makeHandle, matchServerCheckpoints, mergeChainedTxType, migrateWalletRepository, onchainRail, openDatabase, outpointExclusion, requiresMigration, resolveBatchExpiryPolicy, resolveCheckpointExitDelayPolicy, resolveSendAmount, rollbackMigration, saveVtxosForContract, scriptFromArkAddress, selectCoinsWithAsset, selectVirtualCoins, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signAndSubmitOffchainTx, signerSetFromInfo, signingDescriptorIndex, strictSigningDescriptorIndex, toXOnlySignerHex, tryResolveSendAmount, validateBatchRecipients, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, warnAndFilterVtxosForScript };
-//# sourceMappingURL=chunk-Y54MUBT7.js.map
-//# sourceMappingURL=chunk-Y54MUBT7.js.map
+export { ARKADE_MAGIC, ARKADE_SWAP_PREIMAGE_TAG, ActivityRegistry, AmbiguousRouteError, ArkNote, ArkadeCash, ArkadeCashCreateError, AssetManager, BIP21, BIP21Error, BIP322, Batch, ChainedTxType, ContractManager, ContractRepositoryImpl, ContractWatcher, DB_VERSION, DEFAULT_MESSAGE_TIMEOUTS, DEFAULT_MIN_BATCH_EXPIRY_SECONDS, DEFAULT_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, DelegateManagerImpl, DelegateNotConfiguredError, DelegatorManagerImpl, DelegatorNotConfiguredError, DescriptorIdentity, DescriptorSigningProviderMissingError, DustChangeError, ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ESPLORA_URL, ElectrumOnchainProvider, EmulatorPacket, EsploraProvider, Estimator, Extension, ExtensionNotFoundError, ForeignDescriptorError, HDDescriptorProvider, INTENT_TERMINAL_STATES, InMemoryContractRepository, InMemoryIntentRepository, InMemoryVirtualTxRepository, InMemoryWalletRepository, IndexedDBContractRepository, IndexedDBIntentRepository, IndexedDBVirtualTxRepository, IndexedDBWalletRepository, MAX_USED_SIGNING_DESCRIPTORS_LOOK_AHEAD, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, MIGRATION_KEY, MUTINYNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, P2A, PaymentRouter, REGTEST_MIN_BATCH_EXPIRY_SECONDS, REGTEST_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestDelegatorProvider, RestEmulatorProvider, SIGNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, SeedIdentity, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, TxTree, TxType, TxWeightEstimator, UnannotatableInputError, UnilateralExit, UnknownPacket, Unroll, VtxoManager, Wallet2 as Wallet, WalletCannotSignError, WalletMessageHandler, WalletNotInitializedError, WalletRepositoryImpl, WsElectrumChainSource, adoptContractDescriptor, arkRail, arkTarget, arkade_exports, assertFinalCommitmentMatchesValidated, assertIntentIdUnique, assertSendableAmount, assertSubmittedArkTxid, assertValidBatchExpiry, assertValidServerUnrollScript, assetMintResolver, boardingResolver, btcTarget, buildForfeitTx, buildOffchainTx, buildPreimageMessage, claimWithPreimageIdentity, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, collabExitResolver, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, contractPreimage, contractSigner, createAssetPacket, createDefaultActivityRegistry, createDefaultPaymentRouter, createExitChainResolver, decodeArkContract, defaultBatchExpiryPolicy, defaultCheckpointExitDelayPolicy, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, extendVirtualCoinForContract, gateExclusion, gatedContracts, getMigrationStatus, getRandomId, hasBoardingTxExpired, hasCandidates, intentMatchesFilter, intentPageBounds, invoiceTarget, isArkContract, isBatchSignable, isBtcAddress, isContractGenericallySpendable, isCooperativelyMigratable, isDeterministicSigner, isDiscoverable, isHDAllocationCapable, isHDDeterministicSignCapable, isHDWalletCapable, isLightningInvoice, isLnurl, isMessageBusInitializingError, isMessageBusNotInitializedError, isPerArtifactDescriptor, isSigningIdentity, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, isVtxoForScript, isWatchedContract, logExcludedVtxos, makeHandle, matchServerCheckpoints, mergeChainedTxType, migrateWalletRepository, onchainRail, openDatabase, outpointExclusion, outpointReasons, provisionClaimSecret, provisionRefundKey, requiresMigration, resolveBatchExpiryPolicy, resolveCheckpointExitDelayPolicy, resolveDescriptorSigner, resolveSendAmount, rollbackMigration, saveVtxosForContract, scriptFromArkAddress, selectCoinsWithAsset, selectVirtualCoins, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signAndSubmitOffchainTx, signerSetFromInfo, signingDescriptorIndex, strictSigningDescriptorIndex, toXOnlySignerHex, tryResolveSendAmount, validateBatchRecipients, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, warnAndFilterVtxosForScript };
+//# sourceMappingURL=chunk-AUEXB42T.js.map
+//# sourceMappingURL=chunk-AUEXB42T.js.map