@arkade-os/sdk 0.4.60 → 0.4.62

package/dist/{chunk-Y54MUBT7.js → chunk-2IZW6AEK.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-RMBI6P4N.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-L7S5KC5B.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, TapTreeCoder, resolveTimeHeight, canSpendOffchain, parseLegacyExpiry, isExpired, DEFAULT_ARKADE_SERVER_URL, ProviderUnavailableError, networks as networks$1, isPastExpiry, fetchVtxoCreatedAtByTxid } from './chunk-URT2RVGB.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';
@@ -332,6 +332,18 @@ var SingleKey = class _SingleKey {
     if (signatureType === "ecdsa") return signAsync(message, this.key, { prehash: false });
     return schnorr$1.signAsync(message, this.key);
   }
+  /**
+   * BIP-340 sign `messageHash` with aux_rand = 0, so the signature — and
+   * anything derived from it — is reproducible from the key alone.
+   *
+   * What lets a static wallet derive a swap preimage instead of storing one
+   * (see `wallet/contractSecrets.ts`). Deliberately NOT `signMessage`, whose
+   * schnorr branch draws a random aux_rand: a preimage derived from that is
+   * unrecoverable, and the loss would only surface at claim time.
+   */
+  async signSchnorrDeterministic(messageHash) {
+    return schnorr$1.signAsync(messageHash, this.key, new Uint8Array(32));
+  }
   async toReadonly() {
     return new ReadonlySingleKey(await this.compressedPublicKey());
   }
@@ -461,6 +473,19 @@ var SeedIdentity = class _SeedIdentity {
   async signMessage(message, signatureType = "schnorr") {
     return this.signMessageWithKey(this.derivedKey, message, signatureType);
   }
+  /**
+   * BIP-340 sign `messageHash` with this identity's own key, aux_rand = 0.
+   *
+   * The descriptor-less sibling of
+   * {@link signSchnorrDeterministicWithDescriptor}, for an `auto`-mode wallet
+   * whose bare `tr(pubkey)` resolves to the identity itself rather than to a
+   * {@link DescriptorIdentity}. Deliberately NOT routed through
+   * `signMessage`, whose schnorr branch draws a random aux_rand and would
+   * make the "deterministic" signature unreproducible.
+   */
+  async signSchnorrDeterministic(messageHash) {
+    return schnorr$1.signAsync(messageHash, this.derivedKey, new Uint8Array(32));
+  }
   signerSession() {
     return TreeSignerSession.random();
   }
@@ -879,8 +904,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 +942,478 @@ 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";
+var ARKADE_SALTED_PREIMAGE_TAG = "Arkade-Contract-Preimage-Salted-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;
+}
+function buildSaltedPreimageMessage(xonly, salt) {
+  if (xonly.length !== 32) {
+    throw new Error(`x-only pubkey must be 32 bytes, got ${xonly.length}`);
+  }
+  if (salt.length !== 32) {
+    throw new Error(`preimage salt must be 32 bytes, got ${salt.length}`);
+  }
+  const tag = new TextEncoder().encode(ARKADE_SALTED_PREIMAGE_TAG);
+  const message = new Uint8Array(tag.length + 32 + 32);
+  message.set(tag, 0);
+  message.set(xonly, tag.length);
+  message.set(salt, tag.length + 32);
+  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 claim = async () => {
+    if (opts.preimage) return { preimage: opts.preimage, mustPersistPreimage: true };
+    if (isPerArtifactDescriptor(descriptor)) {
+      return {
+        preimage: await derivePreimage(wallet, descriptor),
+        mustPersistPreimage: false
+      };
+    }
+    const preimageSalt2 = randomBytes(32);
+    try {
+      return {
+        preimage: await derivePreimage(wallet, descriptor, preimageSalt2),
+        preimageSalt: preimageSalt2,
+        mustPersistPreimage: false
+      };
+    } catch (cause) {
+      if (cause instanceof ForeignDescriptorError || cause instanceof WalletCannotSignError) {
+        throw cause;
+      }
+      return { preimage: randomBytes(32), mustPersistPreimage: true };
+    }
+  };
+  const { preimage, preimageSalt, mustPersistPreimage } = await claim();
+  return {
+    descriptor,
+    pubkey,
+    preimage,
+    paymentHash: sha256(preimage),
+    ...preimageSalt ? { preimageSalt } : {},
+    mustPersistPreimage
+  };
+}
+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, opts = {}) {
+  if (opts.stored) {
+    if (opts.stored.length !== 32) {
+      throw new Error(`stored preimage must be 32 bytes, got ${opts.stored.length}`);
+    }
+    return opts.stored;
+  }
+  if (isPerArtifactDescriptor(descriptor)) return derivePreimage(wallet, descriptor);
+  if (opts.salt) return derivePreimage(wallet, descriptor, opts.salt);
+  throw new Error(
+    `descriptor ${descriptor} names no single artifact, so its preimage cannot be derived; no salt and no stored preimage were given`
+  );
+}
+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, salt) {
+  const signer = await contractSigner(wallet, descriptor);
+  if (!isDeterministicSigner(signer)) {
+    throw new Error(
+      `wallet cannot sign deterministically for ${descriptor}; its preimage is not derivable`
+    );
+  }
+  const xonly = await signer.xOnlyPublicKey();
+  const message = salt ? buildSaltedPreimageMessage(xonly, salt) : buildPreimageMessage(xonly, 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();
@@ -3094,6 +3616,21 @@ function assertRecipientArkAddress(encoded, address, context) {
     );
   }
 }
+function assertTapTreeDerivesAddress(encoded, tapTree, address) {
+  let derived;
+  try {
+    derived = VtxoScript.decode(tapTree).pkScript;
+  } catch (e) {
+    throw new Error(
+      `Invalid tapTree for ${encoded}: ${e instanceof Error ? e.message : String(e)}`
+    );
+  }
+  if (hex.encode(derived) !== hex.encode(address.pkScript)) {
+    throw new Error(
+      `Invalid tapTree for ${encoded}: derives ${hex.encode(derived)}, address is ${hex.encode(address.pkScript)}. Expected VtxoScript.encode() form: leaf depths are ignored and the tree is rebuilt in arkd's canonical shape.`
+    );
+  }
+}
 function validateRecipients(recipients, dustAmount, context) {
   const validatedRecipients = [];
   for (const recipient of recipients) {
@@ -3108,16 +3645,58 @@ function validateRecipients(recipients, dustAmount, context) {
     if (amount <= 0) {
       throw new Error("Amount must be positive");
     }
+    if (recipient.tapTree) {
+      assertTapTreeDerivesAddress(recipient.address, recipient.tapTree, address);
+    }
     validatedRecipients.push({
       address: recipient.address,
       assets: recipient.assets ?? [],
       amount,
-      script: amount < dustAmount ? address.subdustPkScript : address.pkScript
+      script: amount < dustAmount ? address.subdustPkScript : address.pkScript,
+      tapTree: recipient.tapTree
     });
   }
   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 +3979,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 +4012,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 +4045,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 +4128,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 +4154,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 +5413,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 +8233,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 +9673,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 +9692,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 +9714,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
@@ -11219,6 +11845,8 @@ function computeOffchainBalance(vtxos, caps) {
   let settled = 0;
   let preconfirmed = 0;
   let available = 0;
+  let gated = 0;
+  let intentLocked = 0;
   let recoverable = 0;
   let pendingRecovery = 0;
   const owned = /* @__PURE__ */ new Map();
@@ -11245,7 +11873,11 @@ function computeOffchainBalance(vtxos, caps) {
     } else {
       settled += vtxo.value;
     }
-    if (isGenericallySpendable(vtxo) && isUnlocked(vtxo)) {
+    if (!isGenericallySpendable(vtxo)) {
+      gated += vtxo.value;
+    } else if (!isUnlocked(vtxo)) {
+      intentLocked += vtxo.value;
+    } else {
       available += vtxo.value;
       addAssets(spendable, vtxo);
     }
@@ -11255,6 +11887,8 @@ function computeOffchainBalance(vtxos, caps) {
     settled,
     preconfirmed,
     available,
+    gated,
+    intentLocked,
     recoverable,
     pendingRecovery,
     total: settled + preconfirmed + recoverable + pendingRecovery,
@@ -11411,6 +12045,17 @@ function intentProofJobs(coins) {
   }));
   return [{ index: 0, lookupScript: coinJobs[0].lookupScript }, ...coinJobs];
 }
+function asSendParams(args) {
+  const [first] = args;
+  if (args.length === 1 && first && "recipients" in first) {
+    const params = first;
+    if (params.recipients.length === 0) {
+      throw new Error("At least one receiver is required");
+    }
+    return params;
+  }
+  return { recipients: args };
+}
 function extractArkProviderUrl(provider) {
   const serverUrl = provider.serverUrl;
   return typeof serverUrl === "string" && serverUrl.length > 0 ? serverUrl : void 0;
@@ -12007,6 +12652,8 @@ var ReadonlyWallet = class _ReadonlyWallet {
       settled: offchain.settled,
       preconfirmed: offchain.preconfirmed,
       available: offchain.available,
+      gated: offchain.gated,
+      intentLocked: offchain.intentLocked,
       recoverable: offchain.recoverable,
       pendingRecovery: offchain.pendingRecovery,
       total: totalBoarding + offchain.total,
@@ -13049,15 +13696,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 +13766,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 +13981,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 +14758,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) {
@@ -14734,10 +15393,13 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     return total;
   }
   /**
-   * Send BTC and/or assets to one or more recipients.
+   * Send BTC and/or assets to one or more recipients, passed either as
+   * variadic `Recipient`s or as a single `SendParams` object — the latter
+   * also carries the virtual outputs to spend.
    *
-   * @param args - Recipients with their addresses, BTC amounts, and assets
+   * @param args - Recipients, or a `SendParams` object
    * @returns Promise resolving to the Arkade transaction ID
+   * @see SendParams
    *
    * @example
    * ```typescript
@@ -14746,15 +15408,28 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
    *     amount: 1000, // (optional, default to dust) btc amount to send to the output
    *     assets: [{ assetId: 'abc123...', amount: 50n }] // (optional) list of assets to send
    * });
+   *
+   * // choosing the inputs as well as the outputs
+   * const txid = await wallet.send({
+   *     recipients: [{ address: 'ark1q...', amount: 1000 }],
+   *     selectedVtxos: mine, // spent as given, nothing added
+   * });
    * ```
    */
   async send(...args) {
-    return this._withTxLock(() => this._sendImpl(...args));
+    const params = asSendParams(args);
+    return this._withTxLock(() => this._sendImpl(params));
   }
-  async _sendImpl(...args) {
+  async _sendImpl({ recipients: args, selectedVtxos }) {
     if (args.length === 0) {
       throw new Error("At least one receiver is required");
     }
+    if (selectedVtxos && selectedVtxos.length === 0) {
+      throw new Error("send({ selectedVtxos }): no inputs");
+    }
+    if (selectedVtxos) {
+      void this.logUngatedInputs("send({ selectedVtxos })", selectedVtxos);
+    }
     const offchainTapscript = this.offchainTapscript;
     const serverPubKey = this.arkServerPublicKey;
     const serverUnrollScript = this.serverUnrollScript;
@@ -14765,84 +15440,123 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
       Number(this.dustAmount),
       this.recipientAddressContext(serverPubKey)
     );
-    const virtualCoins = await this.getSpendableVtxos({
-      withRecoverable: false
-    });
+    let virtualCoins = [];
+    if (!selectedVtxos) {
+      virtualCoins = await this.getSpendableVtxos({
+        withRecoverable: false
+      });
+    }
     const assetChanges = /* @__PURE__ */ new Map();
-    let selectedCoins = [];
+    let selectedCoins = selectedVtxos ? [...selectedVtxos] : [];
     let btcAmountToSelect = 0;
     for (const recipient of recipients) {
       btcAmountToSelect += Math.max(recipient.amount, Number(this.dustAmount));
     }
-    for (const recipient of recipients) {
-      if (!recipient.assets) {
-        continue;
+    if (selectedVtxos) {
+      for (const coin of selectedCoins) {
+        for (const asset of coin.assets ?? []) {
+          const existing = assetChanges.get(asset.assetId) ?? 0n;
+          assetChanges.set(asset.assetId, existing + asset.amount);
+        }
       }
-      for (const receiverAsset of recipient.assets) {
-        let amountToSelect = receiverAsset.amount;
-        const existingChange = assetChanges.get(receiverAsset.assetId) ?? 0n;
-        if (existingChange >= amountToSelect) {
-          assetChanges.set(receiverAsset.assetId, existingChange - amountToSelect);
-          if (assetChanges.get(receiverAsset.assetId) === 0n) {
-            assetChanges.delete(receiverAsset.assetId);
+      for (const recipient of recipients) {
+        for (const asset of recipient.assets) {
+          const remaining = (assetChanges.get(asset.assetId) ?? 0n) - asset.amount;
+          if (remaining < 0n) {
+            throw new Error(
+              `send({ selectedVtxos }): inputs are short ${-remaining} of asset ${asset.assetId}`
+            );
+          }
+          if (remaining === 0n) {
+            assetChanges.delete(asset.assetId);
+          } else {
+            assetChanges.set(asset.assetId, remaining);
           }
+        }
+      }
+    } else {
+      for (const recipient of recipients) {
+        if (!recipient.assets) {
           continue;
         }
-        if (existingChange > 0n) {
-          amountToSelect -= existingChange;
-          assetChanges.delete(receiverAsset.assetId);
+        for (const receiverAsset of recipient.assets) {
+          let amountToSelect = receiverAsset.amount;
+          const existingChange = assetChanges.get(receiverAsset.assetId) ?? 0n;
+          if (existingChange >= amountToSelect) {
+            assetChanges.set(receiverAsset.assetId, existingChange - amountToSelect);
+            if (assetChanges.get(receiverAsset.assetId) === 0n) {
+              assetChanges.delete(receiverAsset.assetId);
+            }
+            continue;
+          }
+          if (existingChange > 0n) {
+            amountToSelect -= existingChange;
+            assetChanges.delete(receiverAsset.assetId);
+          }
+          const availableCoins = virtualCoins.filter(
+            (c) => !selectedCoins.find((sc) => sc.txid === c.txid && sc.vout === c.vout)
+          );
+          const { selected, totalAssetAmount } = selectCoinsWithAsset(
+            availableCoins,
+            receiverAsset.assetId,
+            amountToSelect
+          );
+          for (const coin of selected) {
+            selectedCoins.push(coin);
+            btcAmountToSelect -= coin.value;
+            if (coin.assets) {
+              for (const a of coin.assets) {
+                if (a.assetId === receiverAsset.assetId) {
+                  continue;
+                }
+                const existing = assetChanges.get(a.assetId) ?? 0n;
+                assetChanges.set(a.assetId, existing + a.amount);
+              }
+            }
+          }
+          const assetChangeAmount = totalAssetAmount - amountToSelect;
+          if (assetChangeAmount > 0n) {
+            const existing = assetChanges.get(receiverAsset.assetId) ?? 0n;
+            assetChanges.set(receiverAsset.assetId, existing + assetChangeAmount);
+          }
         }
+      }
+      if (btcAmountToSelect > 0) {
         const availableCoins = virtualCoins.filter(
           (c) => !selectedCoins.find((sc) => sc.txid === c.txid && sc.vout === c.vout)
         );
-        const { selected, totalAssetAmount } = selectCoinsWithAsset(
-          availableCoins,
-          receiverAsset.assetId,
-          amountToSelect
-        );
-        for (const coin of selected) {
-          selectedCoins.push(coin);
-          btcAmountToSelect -= coin.value;
+        const { inputs: btcCoins } = selectVirtualCoins(availableCoins, btcAmountToSelect);
+        for (const coin of btcCoins) {
           if (coin.assets) {
-            for (const a of coin.assets) {
-              if (a.assetId === receiverAsset.assetId) {
-                continue;
-              }
-              const existing = assetChanges.get(a.assetId) ?? 0n;
-              assetChanges.set(a.assetId, existing + a.amount);
+            for (const asset of coin.assets) {
+              const existing = assetChanges.get(asset.assetId) ?? 0n;
+              assetChanges.set(asset.assetId, existing + asset.amount);
             }
           }
         }
-        const assetChangeAmount = totalAssetAmount - amountToSelect;
-        if (assetChangeAmount > 0n) {
-          const existing = assetChanges.get(receiverAsset.assetId) ?? 0n;
-          assetChanges.set(receiverAsset.assetId, existing + assetChangeAmount);
-        }
-      }
-    }
-    if (btcAmountToSelect > 0) {
-      const availableCoins = virtualCoins.filter(
-        (c) => !selectedCoins.find((sc) => sc.txid === c.txid && sc.vout === c.vout)
-      );
-      const { inputs: btcCoins } = selectVirtualCoins(availableCoins, btcAmountToSelect);
-      for (const coin of btcCoins) {
-        if (coin.assets) {
-          for (const asset of coin.assets) {
-            const existing = assetChanges.get(asset.assetId) ?? 0n;
-            assetChanges.set(asset.assetId, existing + asset.amount);
-          }
-        }
+        selectedCoins = [...selectedCoins, ...btcCoins];
       }
-      selectedCoins = [...selectedCoins, ...btcCoins];
     }
     let totalBtcSelected = selectedCoins.reduce((sum, c) => sum + c.value, 0);
     const outputs = recipients.map((recipient) => ({
       script: recipient.script,
-      amount: BigInt(recipient.amount)
+      amount: BigInt(recipient.amount),
+      // Already checked against the recipient address in `validateRecipients`.
+      ...recipient.tapTree ? { tapTree: TapTreeCoder.decode(recipient.tapTree) } : {}
     }));
     const totalBtcOutput = outputs.reduce((sum, o) => sum + Number(o.amount), 0);
     let changeAmount = totalBtcSelected - totalBtcOutput;
+    if (changeAmount < 0) {
+      throw new Error(
+        `send({ selectedVtxos }): inputs total ${totalBtcSelected} sats, outputs need ${totalBtcOutput}`
+      );
+    }
     if (assetChanges.size > 0 && changeAmount < Number(this.dustAmount)) {
+      if (selectedVtxos) {
+        throw new Error(
+          `send({ selectedVtxos }): ${changeAmount} sats of change cannot carry ${assetChanges.size} asset change(s), needs ${this.dustAmount}`
+        );
+      }
       const availableCoins = virtualCoins.filter(
         (c) => !selectedCoins.find((sc) => sc.txid === c.txid && sc.vout === c.vout)
       );
@@ -16605,8 +17319,8 @@ var WalletMessageHandler = class {
           });
         }
         case "SEND": {
-          const { recipients } = message.payload;
-          const txid = await this.wallet.send(...recipients);
+          const { recipients, selectedVtxos } = message.payload;
+          const txid = await (selectedVtxos ? this.wallet.send({ recipients, selectedVtxos }) : this.wallet.send(...recipients));
           return this.tagged({
             id,
             type: "SEND_SUCCESS",
@@ -16854,6 +17568,8 @@ var WalletMessageHandler = class {
       settled: offchain.settled,
       preconfirmed: offchain.preconfirmed,
       available: offchain.available,
+      gated: offchain.gated,
+      intentLocked: offchain.intentLocked,
       recoverable: offchain.recoverable,
       pendingRecovery: offchain.pendingRecovery,
       total: totalBoarding + offchain.total,
@@ -17298,10 +18014,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 +18721,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 +18955,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 +19115,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 = {
@@ -18469,12 +19193,16 @@ var ServiceWorkerWallet = class _ServiceWorkerWallet extends ServiceWorkerReadon
       throw error;
     }
   }
-  async send(...recipients) {
+  async send(...args) {
+    const [first] = args;
+    const { recipients, selectedVtxos } = args.length === 1 && first && "recipients" in first ? first : { recipients: args, selectedVtxos: void 0 };
     const message = {
       tag: this.messageTag,
       type: "SEND",
       id: getRandomId(),
-      payload: { recipients }
+      // Omitted rather than sent as `undefined`, so an older worker sees
+      // exactly the payload it saw before.
+      payload: selectedVtxos ? { recipients, selectedVtxos } : { recipients }
     };
     try {
       const response = await this.sendMessage(message);
@@ -18975,8 +19703,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 +20322,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 +21763,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 +22748,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_SALTED_PREIMAGE_TAG, 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, buildSaltedPreimageMessage, 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-2IZW6AEK.js.map
+//# sourceMappingURL=chunk-2IZW6AEK.js.map