@arkade-os/sdk 0.4.61 → 0.4.62

package/dist/adapters/expo.cjs

@@ -1,19 +1,19 @@
 'use strict';
 
-var chunkXFYFREPH_cjs = require('../chunk-XFYFREPH.cjs');
-require('../chunk-2JHN5RCY.cjs');
-require('../chunk-FNCQJLR2.cjs');
+var chunkQRSR4HV4_cjs = require('../chunk-QRSR4HV4.cjs');
+require('../chunk-I6EDUE75.cjs');
+require('../chunk-OH2XLTXE.cjs');
 require('../chunk-5BLDMQED.cjs');
 
 
 
 Object.defineProperty(exports, "ExpoArkProvider", {
   enumerable: true,
-  get: function () { return chunkXFYFREPH_cjs.ExpoArkProvider; }
+  get: function () { return chunkQRSR4HV4_cjs.ExpoArkProvider; }
 });
 Object.defineProperty(exports, "ExpoIndexerProvider", {
   enumerable: true,
-  get: function () { return chunkXFYFREPH_cjs.ExpoIndexerProvider; }
+  get: function () { return chunkQRSR4HV4_cjs.ExpoIndexerProvider; }
 });
 //# sourceMappingURL=expo.cjs.map
 //# sourceMappingURL=expo.cjs.map

package/dist/adapters/expo.d.cts

@@ -1,5 +1,5 @@
-import { k as RestArkProvider, i as SettlementEvent, T as TxNotification, l as RestIndexerProvider, m as SubscriptionResponse } from '../index-BcRCHnzN.cjs';
-export { n as ArkProvider, o as IndexerProvider } from '../index-BcRCHnzN.cjs';
+import { l as RestArkProvider, i as SettlementEvent, T as TxNotification, m as RestIndexerProvider, n as SubscriptionResponse } from '../index-CwBr7qzV.cjs';
+export { o as ArkProvider, p as IndexerProvider } from '../index-CwBr7qzV.cjs';
 import '@scure/btc-signer/utils.js';
 import '@scure/btc-signer/transaction.js';
 import '@scure/btc-signer';

package/dist/adapters/expo.d.ts

@@ -1,5 +1,5 @@
-import { k as RestArkProvider, i as SettlementEvent, T as TxNotification, l as RestIndexerProvider, m as SubscriptionResponse } from '../index-BcRCHnzN.js';
-export { n as ArkProvider, o as IndexerProvider } from '../index-BcRCHnzN.js';
+import { l as RestArkProvider, i as SettlementEvent, T as TxNotification, m as RestIndexerProvider, n as SubscriptionResponse } from '../index-CwBr7qzV.js';
+export { o as ArkProvider, p as IndexerProvider } from '../index-CwBr7qzV.js';
 import '@scure/btc-signer/utils.js';
 import '@scure/btc-signer/transaction.js';
 import '@scure/btc-signer';

package/dist/adapters/expo.js

@@ -1,6 +1,6 @@
-export { ExpoArkProvider, ExpoIndexerProvider } from '../chunk-GDI2A65Z.js';
-import '../chunk-YVQNHELA.js';
-import '../chunk-PVY6DMN5.js';
+export { ExpoArkProvider, ExpoIndexerProvider } from '../chunk-H2ZAJOQA.js';
+import '../chunk-RMBI6P4N.js';
+import '../chunk-URT2RVGB.js';
 import '../chunk-NSBPE2FW.js';
 //# sourceMappingURL=expo.js.map
 //# sourceMappingURL=expo.js.map

package/dist/adapters/indexedDB.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
-var chunk3NUDA3MB_cjs = require('../chunk-3NUDA3MB.cjs');
-require('../chunk-2JHN5RCY.cjs');
-require('../chunk-SF5NKAUA.cjs');
-require('../chunk-FNCQJLR2.cjs');
+var chunkZ2OZMKFV_cjs = require('../chunk-Z2OZMKFV.cjs');
+require('../chunk-I6EDUE75.cjs');
+require('../chunk-G53HASDV.cjs');
+require('../chunk-OH2XLTXE.cjs');
 require('../chunk-5BLDMQED.cjs');
 
 // src/storage/indexedDB.ts
@@ -11,7 +11,7 @@ var IndexedDBStorageAdapter = class {
   dbName;
   version;
   db = null;
-  constructor(dbName, version = chunk3NUDA3MB_cjs.DB_VERSION) {
+  constructor(dbName, version = chunkZ2OZMKFV_cjs.DB_VERSION) {
     this.dbName = dbName;
     this.version = version;
   }

package/dist/adapters/indexedDB.js

@@ -1,7 +1,7 @@
-import { DB_VERSION } from '../chunk-AUEXB42T.js';
-import '../chunk-YVQNHELA.js';
-import '../chunk-6O5OLYTZ.js';
-import '../chunk-PVY6DMN5.js';
+import { DB_VERSION } from '../chunk-2IZW6AEK.js';
+import '../chunk-RMBI6P4N.js';
+import '../chunk-L7S5KC5B.js';
+import '../chunk-URT2RVGB.js';
 import '../chunk-NSBPE2FW.js';
 
 // src/storage/indexedDB.ts

package/dist/{asyncStorageTaskQueue-BWDxp3Dr.d.cts → asyncStorageTaskQueue-B53mOTCw.d.cts}

@@ -1,4 +1,4 @@
-import { a as TaskQueue, c as TaskItem, d as TaskResult } from './taskRunner-BTq3rMpI.cjs';
+import { a as TaskQueue, c as TaskItem, d as TaskResult } from './taskRunner-BMUndClz.cjs';
 
 /**
  * Minimal async key-value storage interface.

package/dist/{asyncStorageTaskQueue-Cq9FpKv6.d.ts → asyncStorageTaskQueue-Df-CTfTE.d.ts}

@@ -1,4 +1,4 @@
-import { a as TaskQueue, c as TaskItem, d as TaskResult } from './taskRunner-DxMJYJ7Y.js';
+import { a as TaskQueue, c as TaskItem, d as TaskResult } from './taskRunner-DZWUsSzA.js';
 
 /**
  * Minimal async key-value storage interface.

package/dist/{chunk-AUEXB42T.js → chunk-2IZW6AEK.js}

@@ -1,6 +1,6 @@
-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 { 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 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';
@@ -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();
   }
@@ -1239,6 +1264,7 @@ var sha256 = /* @__PURE__ */ createHasher(
   /* @__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}`);
@@ -1253,6 +1279,20 @@ function buildPreimageMessage(xonly, index) {
   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;
@@ -1271,14 +1311,36 @@ async function provisionClaimSecret(wallet, opts = {}) {
     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));
+  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),
-    mustPersistPreimage: !derivable
+    ...preimageSalt ? { preimageSalt } : {},
+    mustPersistPreimage
   };
 }
 async function contractSigner(wallet, descriptor) {
@@ -1302,33 +1364,33 @@ var WalletCannotSignError = class extends Error {
   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}`);
+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 stored;
-  }
-  if (!isPerArtifactDescriptor(descriptor)) {
-    throw new Error(
-      `descriptor ${descriptor} names no single artifact, so its preimage cannot be derived; none was stored`
-    );
+    return opts.stored;
   }
-  return derivePreimage(wallet, descriptor);
+  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) {
+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 message = buildPreimageMessage(await signer.xOnlyPublicKey(), PREIMAGE_INDEX);
+  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) {
@@ -3554,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) {
@@ -3568,11 +3645,15 @@ 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;
@@ -11764,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();
@@ -11790,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);
     }
@@ -11800,6 +11887,8 @@ function computeOffchainBalance(vtxos, caps) {
     settled,
     preconfirmed,
     available,
+    gated,
+    intentLocked,
     recoverable,
     pendingRecovery,
     total: settled + preconfirmed + recoverable + pendingRecovery,
@@ -11956,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;
@@ -12552,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,
@@ -15291,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
@@ -15303,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;
@@ -15322,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);
-        }
+        selectedCoins = [...selectedCoins, ...btcCoins];
       }
     }
-    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];
-    }
     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)
       );
@@ -17162,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",
@@ -17411,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,
@@ -19034,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);
@@ -22591,6 +22754,6 @@ function createDefaultPaymentRouter(wallet) {
   (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 */
 
-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
+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