@arkade-os/sdk 0.5.0-rc.21 → 0.5.0-rc.23

package/dist/{chunk-EXFU6MTA.js → chunk-ENGV6VZF.js}

@@ -1,6 +1,6 @@
-import { AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, BufferReader, BufferWriter, AssetRef, RestIndexerProvider } from './chunk-JZAEFOE4.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, toXOnly, inputName, contractHandlers, isMainnetDescriptor, descriptorIsOurs, deriveDescriptorLeafPubKey, deriveDescriptorLeafCompressedPubKey, normalizeToDescriptor, extractPubKey, parseHDDescriptor, identityDescriptor, DefaultVtxo, speculativeReceiveMetadata, DelegateVtxo, WALLET_RECEIVE_SOURCE, BoardingContractHandler } from './chunk-CXHJGED6.js';
-import { VtxoScript, __export, Transaction, requiresForfeit, CSVMultisigTapscript, networks, getNetwork, DEFAULT_NETWORK, resolveEmulatorPubkey, isVtxoSpent, getNormalizedVtxos, setArkPsbtField, PrevArkTxField, ConditionWitness, craftToSpendTx, ArkAddress, isVirtualCoin, getArkPsbtFields, CosignerPublicKey, ServerResponseMismatchError, OP_RETURN_EMPTY_PKSCRIPT, canSweepOnchain, sequenceToTimelock, sequenceToCanonicalTimelock, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, VtxoTaprootTree, timelockToSequence, assertAllowedSighashTypes, baseFetch, Intent, rateGate, DEFAULT_NETWORK_NAME, formatSighash, normalizeVtxo, assertTimerMs, getSequence, maybeArkError, isArkError, ArkErrorName, toOffchainInputFeeParams, canRecoverOnchain, MultisigTapscript, isEventSourceError, isEventSourceUnavailableError, getAllNormalizedVtxos, isPastExpiry, assertNonNegativeMs, isRetryableProviderError, DEFAULT_PAGE_SIZE, RestArkProvider, DEFAULT_ARKADE_SERVER_URL, networkFromArkadeInfo, ArkError, toBIP371TapTree, resolveTimeHeight, canSpendOffchain, INFO_FETCH_TIMEOUT_MS, PrevoutTxField, fetchVtxoCreatedAtByTxid, EXPIRY_MIN_PLAUSIBLE_MS, ProviderUnavailableError } from './chunk-4FDNOLBO.js';
+import { AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, BufferReader, BufferWriter, AssetRef, RestIndexerProvider } from './chunk-SPJA7XMU.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, toXOnly, inputName, contractHandlers, isMainnetDescriptor, descriptorIsOurs, deriveDescriptorLeafPubKey, deriveDescriptorLeafCompressedPubKey, normalizeToDescriptor, extractPubKey, parseHDDescriptor, identityDescriptor, DefaultVtxo, speculativeReceiveMetadata, DelegateVtxo, WALLET_RECEIVE_SOURCE, BoardingContractHandler } from './chunk-UDQ3QE4C.js';
+import { VtxoScript, __export, Transaction, requiresForfeit, CSVMultisigTapscript, networks, getNetwork, DEFAULT_NETWORK, resolveEmulatorPubkey, isVtxoSpent, getNormalizedVtxos, setArkPsbtField, PrevArkTxField, ConditionWitness, craftToSpendTx, ArkAddress, isVirtualCoin, getArkPsbtFields, CosignerPublicKey, ServerResponseMismatchError, OP_RETURN_EMPTY_PKSCRIPT, canSweepOnchain, sequenceToTimelock, sequenceToCanonicalTimelock, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, VtxoTaprootTree, timelockToSequence, assertAllowedSighashTypes, baseFetch, Intent, rateGate, DEFAULT_NETWORK_NAME, formatSighash, normalizeVtxo, assertTimerMs, getSequence, maybeArkError, isArkError, ArkErrorName, toOffchainInputFeeParams, canRecoverOnchain, MultisigTapscript, isEventSourceError, isEventSourceUnavailableError, getAllNormalizedVtxos, isPastExpiry, assertNonNegativeMs, isRetryableProviderError, DEFAULT_PAGE_SIZE, RestArkProvider, DEFAULT_ARKADE_SERVER_URL, networkFromArkadeInfo, ArkError, toBIP371TapTree, resolveTimeHeight, canSpendOffchain, INFO_FETCH_TIMEOUT_MS, PrevoutTxField, fetchVtxoCreatedAtByTxid, EXPIRY_MIN_PLAUSIBLE_MS, ProviderUnavailableError } from './chunk-XZEQV5FE.js';
 import { sha256, 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$1 } from '@scure/btc-signer';
 import { hex, base58, base64, bech32m } from '@scure/base';
@@ -3337,6 +3337,53 @@ function selectedCoinsToAssetInputs(selectedCoins) {
   }
   return assetInputs;
 }
+
+// src/wallet/sendDeadline.ts
+var SendDeadlineExceededError = class extends Error {
+  constructor(validUntil) {
+    super(`Send deadline ${validUntil} expired before provider submission`);
+    this.name = "SendDeadlineExceededError";
+  }
+};
+function captureSendDeadline(value, required = false) {
+  if (value === void 0 && !required) return void 0;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
+    throw new TypeError("validUntil must be a positive safe integer UNIX timestamp in seconds");
+  }
+  return value;
+}
+function assertSendDeadline(validUntil) {
+  if (validUntil !== void 0 && Date.now() / 1e3 >= validUntil) {
+    throw new SendDeadlineExceededError(validUntil);
+  }
+}
+
+// src/wallet/sendInputExpiry.ts
+function captureInputExpiryFloor(value, required = false) {
+  if (value === void 0 && !required) return void 0;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new TypeError(
+      "inputExpiryFloor must specify a time or height and positive bigint value"
+    );
+  }
+  const { kind, value: floor } = value;
+  if (kind !== "time" && kind !== "height" || typeof floor !== "bigint" || floor <= 0n) {
+    throw new TypeError(
+      "inputExpiryFloor must specify a time or height and positive bigint value"
+    );
+  }
+  return Object.freeze({ kind, value: floor });
+}
+function meetsInputExpiryFloor(coin, floor) {
+  if (coin.expiresAt === void 0 === (coin.expiresAtHeight === void 0)) return false;
+  if (floor.kind === "height") {
+    const height = coin.expiresAtHeight;
+    return typeof height === "number" && Number.isSafeInteger(height) && height > 0 && BigInt(height) >= floor.value;
+  }
+  if (!(coin.expiresAt instanceof Date)) return false;
+  const milliseconds = coin.expiresAt.getTime();
+  return Number.isSafeInteger(milliseconds) && milliseconds > 0 && BigInt(milliseconds) >= floor.value * 1000n;
+}
 function toXOnlySignerHex(pubkeyHex) {
   const bytes = hex.decode(pubkeyHex);
   if (bytes.length === 32 || bytes.length === 33) return hex.encode(toXOnly(bytes, "signer key"));
@@ -9550,11 +9597,18 @@ var ContractManager = class _ContractManager {
   initialized = false;
   eventCallbacks = /* @__PURE__ */ new Set();
   stopWatcherFn;
+  /** Watcher events still being handled. They write VTXO rows, so {@link dispose} waits for them. */
+  inFlightEvents = /* @__PURE__ */ new Set();
   /** `undefined` while online; the failure reason once a sync degrades. */
   syncDegradedReason;
   /** Epoch-ms of the last successful provider sync, if any. */
   lastSyncedAt;
   syncedAtByScript = /* @__PURE__ */ new Map();
+  syncsInFlight = 0;
+  /** The off-critical-path boot sequence, if one is running. @see runBootSequence */
+  bootTask;
+  /** A catch-up sync requested behind a stored read. @see requestCatchUpSync */
+  catchUpSync;
   /** Last chain tip read, with the epoch-ms it was read at. @see currentChainTip */
   chainTipCache;
   /** In-flight chain tip read, so concurrent cache misses share one. */
@@ -9595,12 +9649,18 @@ var ContractManager = class _ContractManager {
    * {@link initialize}, {@link getContractsWithVtxos} and {@link createContract}.
    */
   getSyncState() {
-    return this.syncDegradedReason === void 0 ? { mode: "online", lastSyncedAt: this.lastSyncedAt } : {
+    const syncing = this.syncsInFlight > 0;
+    return this.syncDegradedReason === void 0 ? { mode: "online", syncing, lastSyncedAt: this.lastSyncedAt } : {
       mode: "degraded",
+      syncing,
       reason: this.syncDegradedReason,
       lastSyncedAt: this.lastSyncedAt
     };
   }
+  /** @inheritdoc */
+  whenBooted() {
+    return this.bootTask ?? Promise.resolve();
+  }
   /** @see ContractManagerConfig.vtxoSyncMaxAgeMs — for factory-built managers. */
   setVtxoSyncMaxAge(maxAgeMs) {
     assertNonNegativeMs("vtxoSyncMaxAgeMs", maxAgeMs);
@@ -9623,9 +9683,14 @@ var ContractManager = class _ContractManager {
   syncGapReason() {
     const annotations = this.annotationDegradedReason();
     const owedRefill = this.lookAheadRefillOwed ? "the look-ahead band is behind the allocation watermark, so a funded address inside it is not being watched yet" : void 0;
-    const reasons = [annotations, owedRefill].filter((r) => r !== void 0);
+    const watcher = this.watcherStartFailure === void 0 ? void 0 : `the contract watcher failed to start, so incoming funds are not being observed \u2014 ${this.watcherStartFailure}`;
+    const reasons = [annotations, owedRefill, watcher].filter(
+      (r) => r !== void 0
+    );
     return reasons.length === 0 ? void 0 : reasons.join("; ");
   }
+  /** Why the lazy boot's watcher start failed; nothing retries it, so no sync may clear it. */
+  watcherStartFailure;
   /** Contracts a sync could not annotate, as `script → reason`. */
   annotationFailures = /* @__PURE__ */ new Map();
   annotationDegradedReason() {
@@ -9670,21 +9735,75 @@ var ContractManager = class _ContractManager {
     for (const contract of contracts) {
       await this.watcher.addContract(contract);
     }
-    try {
-      await this.scheduleLookAheadDrain();
-    } catch (err) {
-      if (!isRetryableProviderError(err)) throw err;
-      this.lookAheadRefillOwed = true;
-      this.markSyncDegraded(err);
+    if (!this.config.lazyInitialization) {
+      try {
+        await this.scheduleLookAheadDrain();
+      } catch (err) {
+        if (!isRetryableProviderError(err)) throw err;
+        this.lookAheadRefillOwed = true;
+        this.markSyncDegraded(err);
+      }
+      await this.trySync(() => this.reconcileWatched());
+      this.initialized = true;
+      this.stopWatcherFn = await this.watcher.startWatching(
+        (event) => this.onWatcherEvent(event)
+      );
+      return;
     }
-    await this.trySync(() => this.reconcileWatched());
     this.initialized = true;
-    this.stopWatcherFn = await this.watcher.startWatching((event) => {
-      this.handleContractEvent(event).catch((error) => {
-        console.error("Error handling contract event:", error);
-      });
+    const boot = this.runBootSequence();
+    this.bootTask = boot;
+    void boot.catch(() => {
+    }).finally(() => {
+      if (this.bootTask === boot) this.bootTask = void 0;
     });
   }
+  async runBootSequence() {
+    this.syncsInFlight++;
+    this.watcherStartFailure = void 0;
+    try {
+      try {
+        await this.scheduleLookAheadDrain();
+      } catch (err) {
+        this.lookAheadRefillOwed = true;
+        this.reportBackgroundFailure("look-ahead drain", err);
+      }
+      try {
+        await this.reconcileWatched();
+        this.markSyncOnline();
+      } catch (err) {
+        this.reportBackgroundFailure("boot sync", err);
+      }
+      if (this.disposed) return;
+      try {
+        const stopWatching = await this.watcher.startWatching(
+          (event) => this.onWatcherEvent(event)
+        );
+        if (this.disposed) stopWatching();
+        else this.stopWatcherFn = stopWatching;
+      } catch (err) {
+        this.watcherStartFailure = err instanceof Error ? err.message : String(err);
+        this.reportBackgroundFailure("watcher start", err);
+      }
+    } finally {
+      this.syncsInFlight--;
+    }
+  }
+  /** Tracked so {@link dispose} can wait for handlers still writing. */
+  onWatcherEvent(event) {
+    const handled = this.handleContractEvent(event).catch((error) => {
+      console.error("Error handling contract event:", error);
+    });
+    this.inFlightEvents.add(handled);
+    void handled.finally(() => this.inFlightEvents.delete(handled));
+  }
+  /** No throw: construction returned long ago, so the state is the channel. */
+  reportBackgroundFailure(stage, err) {
+    this.markSyncDegraded(err);
+    if (!isRetryableProviderError(err)) {
+      console.error(`[contracts] background ${stage} failed`, err);
+    }
+  }
   /**
    * Delta-sync the watched set (boot and reconnect), then reconcile the pending frontier, which
    * catches not-yet-finalized virtual outputs that can sit outside any delta window.
@@ -10165,6 +10284,32 @@ var ContractManager = class _ContractManager {
       vtxos: vtxosByScript.get(contract.script)?.slice() ?? []
     }));
   }
+  async getStoredContractsWithVtxos(filter) {
+    const contracts = await this.getContracts(filter);
+    if (!this.syncedWithin(contracts, this.config.vtxoSyncMaxAgeMs ?? 0)) {
+      this.requestCatchUpSync(contracts);
+    }
+    const vtxos = await this.getVtxosForContracts(contracts);
+    return contracts.map((contract) => ({
+      contract,
+      vtxos: vtxos.filter((vtxo) => vtxo.contractScript === contract.script)
+    }));
+  }
+  requestCatchUpSync(contracts) {
+    if (this.disposed || this.bootTask || this.catchUpSync || contracts.length === 0) return;
+    const run = (async () => {
+      try {
+        await this.syncContracts({ contracts });
+        this.markSyncOnline();
+      } catch (err) {
+        this.reportBackgroundFailure("catch-up sync", err);
+      }
+    })();
+    this.catchUpSync = run;
+    void run.finally(() => {
+      if (this.catchUpSync === run) this.catchUpSync = void 0;
+    });
+  }
   async annotateVtxos(vtxos, tapscripts) {
     if (vtxos.length === 0) return [];
     const scripts = Array.from(new Set(vtxos.map((v) => v.script)));
@@ -10481,6 +10626,7 @@ var ContractManager = class _ContractManager {
     }
   }
   async handleContractEvent(event) {
+    if (this.disposed) return;
     if (this.lookAheadRefillOwed) this.requestLookAheadDrain();
     try {
       switch (event.type) {
@@ -10534,6 +10680,14 @@ var ContractManager = class _ContractManager {
   }
   /** Sync virtual outputs for the given contracts (default: the watched set). */
   async syncContracts(options) {
+    this.syncsInFlight++;
+    try {
+      return await this.performContractSync(options);
+    } finally {
+      this.syncsInFlight--;
+    }
+  }
+  async performContractSync(options) {
     const cursor = await getSyncCursor(this.config.walletRepository);
     const window2 = options.window ?? computeSyncWindow(cursor, this.config.vtxoSyncOverlapMs);
     const mustUpdateCursor = options.contracts === void 0 && options.window === void 0 && (window2.after ?? 0) <= cursor;
@@ -10702,34 +10856,49 @@ var ContractManager = class _ContractManager {
     }
     return { vtxosByScript: result, promoted };
   }
-  /** Stop the watcher, clear callbacks, and mark the manager uninitialized. */
+  /**
+   * Stop the watcher, clear callbacks, and mark the manager uninitialized.
+   *
+   * Teardown is synchronous. The returned promise settles once watcher events already being
+   * handled, any look-ahead drain, and any lazy boot sequence finish; after that nothing more is written to the
+   * repositories.
+   */
   dispose() {
     this.disposed = true;
     const pendingDrain = this.lookAheadDrain;
+    const pendingBoot = this.bootTask;
     this.stopWatcherFn?.();
     this.stopWatcherFn = void 0;
     this.eventCallbacks.clear();
     this.lookAheadEntries.clear();
-    if (pendingDrain) {
-      void pendingDrain.catch(() => {
-      }).then(() => {
-        if (this.disposed) this.lookAheadEntries.clear();
-      });
-    }
+    const drainUnwound = pendingDrain?.catch(() => {
+    }).then(() => {
+      if (this.disposed) this.lookAheadEntries.clear();
+    });
     this.initialized = false;
+    return Promise.all([...this.inFlightEvents, drainUnwound, pendingBoot]).then(
+      () => void 0
+    );
   }
   /**
-   * Symbol.dispose implementation for the `using` keyword.
+   * Symbol.dispose implementation for the `using` keyword. Teardown is immediate, but it does
+   * not wait for in-flight work; use `await using` for that.
+   */
+  [Symbol.dispose]() {
+    void this.dispose();
+  }
+  /**
+   * Symbol.asyncDispose implementation for the `await using` keyword; waits like {@link dispose}.
    * @example
    * ```typescript
    * {
-   *   using manager = await wallet.getContractManager();
+   *   await using manager = await wallet.getContractManager();
    *   // ... use manager
-   * } // automatically disposed
+   * } // disposed, with in-flight events finished
    * ```
    */
-  [Symbol.dispose]() {
-    this.dispose();
+  async [Symbol.asyncDispose]() {
+    await this.dispose();
   }
 };
 
@@ -12473,6 +12642,8 @@ var ReadonlyWallet = class _ReadonlyWallet {
   walletRepository;
   contractRepository;
   delegateProvider;
+  lazyInitialization = false;
+  boardingLoaded = false;
   _contractManager;
   _contractManagerInitializing;
   watcherConfig;
@@ -12535,9 +12706,11 @@ var ReadonlyWallet = class _ReadonlyWallet {
    * construct, so it is safe for readonly callers.
    */
   getProviderConnectionState() {
+    const syncing = this._contractManager?.getSyncState().syncing ?? false;
     if (this._serverInfoSource === "cache") {
       return {
         mode: "degraded",
+        syncing,
         source: "cache",
         provider: "arkade",
         reason: "constructed from cached server-info; operator was unreachable at boot",
@@ -12548,6 +12721,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
     if (sync?.mode === "degraded") {
       return {
         mode: "degraded",
+        syncing,
         source: "repository",
         provider: "indexer",
         reason: sync.reason,
@@ -12556,6 +12730,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
     }
     return {
       mode: "online",
+      syncing,
       source: "live",
       lastOnlineAt: sync?.lastSyncedAt ?? this._serverInfoLastOnlineAt ?? 0
     };
@@ -12802,6 +12977,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
     );
     wallet.vtxoSyncOverlapMs = config.vtxoSyncOverlapMs;
     wallet.intentRepository = config.storage?.intentRepository;
+    wallet.lazyInitialization = config.lazyInitialization ?? false;
     wallet.virtualTxRepository = config.storage?.virtualTxRepository;
     wallet.exitDataCapture = config.storage?.exitDataCapture;
     wallet._serverInfoSource = setup.serverInfoSource;
@@ -12842,6 +13018,19 @@ var ReadonlyWallet = class _ReadonlyWallet {
       // The bucketer drops every spent coin and the gate reads contracts only.
       this.contractSnapshot(void 0, { unspentOnly: true })
     ]);
+    return this.balanceFromSnapshot(boardingUtxos, snapshot);
+  }
+  /** Cached balance; inspect connection state and boarding.loaded before displaying zeros. */
+  async getStoredBalance() {
+    const [boardingUtxos, snapshot] = await Promise.all([
+      this.getStoredBoardingUtxos(),
+      this.contractSnapshotStored()
+    ]);
+    const balance = await this.balanceFromSnapshot(boardingUtxos, snapshot);
+    balance.boarding.loaded = this.boardingLoaded;
+    return balance;
+  }
+  async balanceFromSnapshot(boardingUtxos, snapshot) {
     const vtxos = filterSnapshotVtxos(
       snapshot,
       { withRecoverable: true, withUnrolled: true },
@@ -12868,6 +13057,14 @@ var ReadonlyWallet = class _ReadonlyWallet {
       this._pendingSpendOutpoints
     );
   }
+  /** Cached VTXOs; may be empty before the first sync. Never use for coin selection. */
+  async getStoredVtxos(filter) {
+    return filterSnapshotVtxos(
+      await this.contractSnapshotStored(),
+      filter,
+      this._pendingSpendOutpoints
+    );
+  }
   /** @inheritdoc */
   async getSpendableVtxos(filter) {
     const snapshot = await this.contractSnapshot(filter, {
@@ -12972,6 +13169,10 @@ var ReadonlyWallet = class _ReadonlyWallet {
       requireSynced: filter?.requireSynced
     });
   }
+  async contractSnapshotStored() {
+    const contractManager = await this.getContractManager();
+    return contractManager.getStoredContractsWithVtxos ? contractManager.getStoredContractsWithVtxos() : contractManager.getContractsWithVtxos();
+  }
   /**
    * The two exclusion sets the gate is made of, derived from one snapshot so
    * {@link getSpendableVtxos} and the balance answer about the same instant.
@@ -13236,6 +13437,14 @@ var ReadonlyWallet = class _ReadonlyWallet {
     await this.walletRepository.saveUtxos(
       new Map(groups.map((group, i) => [addresses[i], group.coins]))
     );
+    for (const [i, group] of groups.entries()) {
+      const fresh = new Set(group.coins.map((coin) => `${coin.txid}:${coin.vout}`));
+      const cached = await collectUtxos(this.walletRepository, addresses[i]);
+      const kept = cached.filter((coin) => fresh.has(`${coin.txid}:${coin.vout}`));
+      if (kept.length === cached.length) continue;
+      await this.walletRepository.deleteUtxos(addresses[i]);
+      if (kept.length > 0) await this.walletRepository.saveUtxos(addresses[i], kept);
+    }
     return groups;
   }
   /**
@@ -13249,8 +13458,21 @@ var ReadonlyWallet = class _ReadonlyWallet {
       toXOnlySignerHex(hex.encode(this.boardingTapscript.options.serverPubKey))
     ]);
     const groups = await this.getBoardingUtxosForSigners(currentOnly);
+    this.boardingLoaded = true;
     return groups.flatMap((g) => g.coins);
   }
+  async getStoredBoardingUtxos() {
+    const currentOnly = /* @__PURE__ */ new Set([
+      toXOnlySignerHex(hex.encode(this.boardingTapscript.options.serverPubKey))
+    ]);
+    const tapscripts = await this.getBoardingTapscripts(currentOnly);
+    const perAddress = await Promise.all(
+      tapscripts.map(
+        (tapscript) => collectUtxos(this.walletRepository, tapscript.onchainAddress(this.network))
+      )
+    );
+    return perAddress.flat();
+  }
   /**
    * Subscribe to onchain and offchain notifications for newly received funds.
    *
@@ -13477,6 +13699,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
       onVtxosSpent = (vtxos) => pruneExitBranches(virtualTxRepository, vtxos);
     }
     const manager = await ContractManager.create({
+      lazyInitialization: this.lazyInitialization,
       indexerProvider: this.indexerProvider,
       contractRepository: this.contractRepository,
       walletRepository: this.walletRepository,
@@ -13576,7 +13799,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
   /** Dispose wallet-owned managers and release background resources. */
   async dispose() {
     const manager = this._contractManager ?? (this._contractManagerInitializing ? await this._contractManagerInitializing.catch(() => void 0) : void 0);
-    manager?.dispose();
+    await manager?.dispose();
     this._contractManager = void 0;
     this._contractManagerInitializing = void 0;
   }
@@ -14419,6 +14642,7 @@ var Wallet2 = class extends ReadonlyWallet {
       },
       checkpointExitDelayOverrides
     );
+    wallet.lazyInitialization = config.lazyInitialization ?? false;
     wallet._serverInfoSource = setup.serverInfoSource;
     if (setup.serverInfoSource === "live") {
       const now = Date.now();
@@ -14505,12 +14729,17 @@ var Wallet2 = class extends ReadonlyWallet {
    *
    * @param params - Optional settlement inputs and outputs. When omitted, the wallet settles all eligible funds.
    * @param eventCallback - Optional callback invoked for settlement stream events.
+   * @param hooks - Optional phases for preparation and intent registration.
    * @returns The finalized Arkade transaction id
    */
-  async settle(params, eventCallback) {
-    return this._withTxLock(() => this._settleImpl(params, eventCallback));
+  async settle(params, eventCallback, hooks) {
+    return this._withTxLock(() => {
+      hooks?.onPhase?.("preparing");
+      const onRegistrationAttempt = hooks?.onPhase ? () => hooks.onPhase?.("registration_attempt") : void 0;
+      return this._settleImpl(params, eventCallback, onRegistrationAttempt);
+    });
   }
-  async _settleImpl(params, eventCallback) {
+  async _settleImpl(params, eventCallback, onRegistrationAttempt) {
     if (params?.inputs) {
       for (const input of params.inputs) {
         if (typeof input === "string") {
@@ -14725,6 +14954,7 @@ var Wallet2 = class extends ReadonlyWallet {
         }
         yield* stream;
       })();
+      onRegistrationAttempt?.();
       const intentId = await this.safeRegisterIntent(intent, params.inputs);
       await this.persistIntentSnapshot(
         intentTxId,
@@ -15736,13 +15966,13 @@ var Wallet2 = class extends ReadonlyWallet {
    */
   async send(...args) {
     const params = asSendParams(args);
-    return this._withTxLock(() => this._sendImpl(params));
+    const validUntil = captureSendDeadline(params.validUntil);
+    const inputExpiryFloor = captureInputExpiryFloor(params.inputExpiryFloor);
+    assertSendDeadline(validUntil);
+    return this._withTxLock(() => this._sendImpl(params, validUntil, inputExpiryFloor));
   }
-  async _sendImpl({
-    recipients: args,
-    selectedVtxos,
-    maxChangeFee
-  }) {
+  async _sendImpl({ recipients: args, selectedVtxos, maxChangeFee }, validUntil, inputExpiryFloor) {
+    assertSendDeadline(validUntil);
     if (args.length === 0) {
       throw new Error("At least one receiver is required");
     }
@@ -15753,6 +15983,10 @@ var Wallet2 = class extends ReadonlyWallet {
       throw new Error("send({ maxChangeFee }): expected a non-negative safe integer");
     }
     if (selectedVtxos) {
+      if (inputExpiryFloor) selectedVtxos = selectedVtxos.map(normalizeVtxo);
+      if (inputExpiryFloor && selectedVtxos.some((coin) => !meetsInputExpiryFloor(coin, inputExpiryFloor))) {
+        throw new Error("send({ selectedVtxos }): input expiry floor not met");
+      }
       void this.logUngatedInputs("send({ selectedVtxos })", selectedVtxos);
     }
     const offchainTapscript = this.offchainTapscript;
@@ -15771,6 +16005,11 @@ var Wallet2 = class extends ReadonlyWallet {
         withRecoverable: false,
         genericallySpendableOnly: true
       });
+      if (inputExpiryFloor) {
+        virtualCoins = virtualCoins.filter(
+          (coin) => meetsInputExpiryFloor(coin, inputExpiryFloor)
+        );
+      }
     }
     const assetChanges = /* @__PURE__ */ new Map();
     let selectedCoins = selectedVtxos ? [...selectedVtxos] : [];
@@ -16005,27 +16244,33 @@ var Wallet2 = class extends ReadonlyWallet {
       outputs.push(Extension.create(allExtPackets).txOut());
     }
     const sentAmount = recipients.reduce((sum, r) => sum + r.amount, 0);
-    return this._submitOffchainSpend(selectedCoins, outputs, {
-      sentAmount,
-      changeAmount: BigInt(changeAmount),
-      changeVout: changeReceiver ? changeIndex : 0,
-      offchainTapscript,
-      serverPubKey,
-      serverUnrollScript,
-      changeAssets: changeReceiver?.assets
-    });
+    return this._submitOffchainSpend(
+      selectedCoins,
+      outputs,
+      {
+        sentAmount,
+        changeAmount: BigInt(changeAmount),
+        changeVout: changeReceiver ? changeIndex : 0,
+        offchainTapscript,
+        serverPubKey,
+        serverUnrollScript,
+        changeAssets: changeReceiver?.assets
+      },
+      { validUntil }
+    );
   }
   /**
    * Shared submit/persist tail of `send` and {@link sendSelectedVtxosToSelf}; callers own coin
    * selection, outputs and the synchronous epoch snapshot.
    */
-  async _submitOffchainSpend(inputs, outputs, persist) {
+  async _submitOffchainSpend(inputs, outputs, persist, options) {
     this._addPendingSpends(inputs);
     try {
-      const { arkTxid, signedCheckpointTxs } = await this.buildAndSubmitOffchainTx(
+      const { arkTxid, signedCheckpointTxs } = await this._buildAndSubmitOffchainTx(
         inputs,
         outputs,
-        persist.serverUnrollScript
+        persist.serverUnrollScript,
+        options
       );
       await this.updateDbAfterOffchainTx(
         inputs,
@@ -16118,7 +16363,16 @@ var Wallet2 = class extends ReadonlyWallet {
    *
    * @returns The Arkade transaction id and server-signed checkpoint PSBTs (for bookkeeping)
    */
-  async buildAndSubmitOffchainTx(inputs, outputs, serverUnrollScript = this.serverUnrollScript) {
+  async buildAndSubmitOffchainTx(inputs, outputs, serverUnrollScript = this.serverUnrollScript, options) {
+    const validUntil = captureSendDeadline(options?.validUntil);
+    assertSendDeadline(validUntil);
+    return this._withTxLock(
+      () => this._buildAndSubmitOffchainTx(inputs, outputs, serverUnrollScript, { validUntil })
+    );
+  }
+  async _buildAndSubmitOffchainTx(inputs, outputs, serverUnrollScript, options) {
+    const validUntil = captureSendDeadline(options?.validUntil);
+    assertSendDeadline(validUntil);
     void this.logUngatedInputs("buildAndSubmitOffchainTx", inputs);
     await (await this.getContractManager()).assertAnnotatable(inputs);
     const offchainTx = buildOffchainTx(
@@ -16176,7 +16430,25 @@ var Wallet2 = class extends ReadonlyWallet {
       {
         // Mark pending before submitting — if we crash between submit and
         // finalize, the next init recovers via finalizePendingTxs.
-        beforeSubmit: () => this.setPendingTxFlag(true),
+        beforeSubmit: async () => {
+          const ownsPendingFlag = validUntil !== void 0 && !await this.hasPendingTxFlag();
+          await this.setPendingTxFlag(true);
+          try {
+            assertSendDeadline(validUntil);
+          } catch (error) {
+            if (ownsPendingFlag) {
+              try {
+                await this.setPendingTxFlag(false);
+              } catch (clearError) {
+                console.error(
+                  "Failed to clear pending tx flag after deadline expiry:",
+                  clearError
+                );
+              }
+            }
+            throw error;
+          }
+        },
         afterFinalize: async () => {
           try {
             await this.setPendingTxFlag(false);
@@ -16811,6 +17083,7 @@ var MessageBus = class {
         delegateProvider,
         settlementConfig: config.settlementConfig,
         walletMode: config.walletMode,
+        lazyInitialization: config.lazyInitialization,
         watcherConfig: config.watcherConfig,
         lookAheadWindow: config.lookAheadWindow,
         minBatchExpirySeconds: config.minBatchExpirySeconds,
@@ -16820,6 +17093,7 @@ var MessageBus = class {
     }
     const identity = hydrateIdentity(serialized);
     const readonlyWallet = await ReadonlyWallet.create({
+      lazyInitialization: config.lazyInitialization,
       identity,
       arkProvider,
       arkServerPublicKey: config.arkServer.publicKey,
@@ -17406,8 +17680,6 @@ var Ramps = class {
     return { change, changeAddress };
   }
 };
-
-// src/wallet/serviceWorker/wallet-message-handler.ts
 var WalletNotInitializedError = class extends Error {
   constructor() {
     super("Wallet handler not initialized");
@@ -17550,9 +17822,11 @@ var WalletMessageHandler = class {
   // `onWalletInitialized` re-subscribes incoming funds while
   // `ensureContractEventBroadcasting` deliberately keeps its subscription, so
   // a shared bump would leave the live contract-event emitter permanently
-  // stale, and folding requests in would truncate an in-flight settle.
+  // stale, folding requests in would truncate an in-flight settle, and
+  // sharing with boarding would kill every lazy refresh (see `boardingEpoch`).
   incomingFundsEpoch = 0;
   contractEventsEpoch = 0;
+  boardingEpoch = 0;
   /** Per-request progress callbacks: ends with the handler, not with a re-init. */
   requestEpoch = 0;
   /**
@@ -17577,6 +17851,7 @@ var WalletMessageHandler = class {
     this.requestEpoch++;
     this.incomingFundsEpoch++;
     this.contractEventsEpoch++;
+    this.boardingEpoch++;
     this.channel = void 0;
     this.onNextTick = [];
     if (this.incomingFundsSubscription) {
@@ -17618,6 +17893,8 @@ var WalletMessageHandler = class {
         return this.incomingFundsEpoch;
       case "contractEvents":
         return this.contractEventsEpoch;
+      case "boarding":
+        return this.boardingEpoch;
       case "request":
         return this.requestEpoch;
       default: {
@@ -17790,7 +18067,10 @@ var WalletMessageHandler = class {
           });
         }
         case "GET_BOARDING_UTXOS": {
-          const utxos = await this.getAllBoardingUtxos();
+          if (!this.readonlyWallet) {
+            throw new WalletNotInitializedError();
+          }
+          const utxos = await this.readonlyWallet.getBoardingUtxos();
           return this.tagged({
             id,
             type: "BOARDING_UTXOS",
@@ -18066,6 +18346,43 @@ var WalletMessageHandler = class {
             payload: { txid }
           });
         }
+        case "SEND_WITH_DEADLINE":
+        case "SEND_WITH_INPUT_EXPIRY_FLOOR": {
+          const wallet = this.requireWallet();
+          const {
+            recipients,
+            selectedVtxos,
+            maxChangeFee,
+            validUntil: wireDeadline
+          } = message.payload;
+          const inputExpiryFloor = message.type === "SEND_WITH_INPUT_EXPIRY_FLOOR" ? captureInputExpiryFloor(
+            message.payload.inputExpiryFloor,
+            true
+          ) : void 0;
+          const validUntil = captureSendDeadline(
+            wireDeadline,
+            message.type === "SEND_WITH_DEADLINE"
+          );
+          try {
+            const txid = await wallet.send({
+              recipients,
+              ...selectedVtxos ? { selectedVtxos } : {},
+              ...maxChangeFee !== void 0 ? { maxChangeFee } : {},
+              validUntil,
+              ...inputExpiryFloor ? { inputExpiryFloor } : {}
+            });
+            return this.tagged({ id, type: "SEND_SUCCESS", payload: { txid } });
+          } catch (error) {
+            if (validUntil === void 0 || !(error instanceof SendDeadlineExceededError))
+              throw error;
+            return this.tagged({
+              id,
+              type: "SEND_DEADLINE_EXCEEDED",
+              error,
+              payload: { validUntil }
+            });
+          }
+        }
         case "GET_ASSET_DETAILS": {
           const { assetId } = message.payload;
           const assetDetails = await this.readonlyWallet.assetManager.getAssetDetails(assetId);
@@ -18261,9 +18578,16 @@ var WalletMessageHandler = class {
   // Wallet methods
   async handleInitWallet({ payload }) {
     const { arkServerUrl } = payload;
+    this.lazyBoardingInit = payload.lazyBoarding ?? false;
+    this.boardingEpoch++;
+    this.boardingLoaded = false;
     this.indexerProvider = new RestIndexerProvider(arkServerUrl);
     await this.onWalletInitialized();
   }
+  /** @see RequestInitWallet.payload.lazyBoarding */
+  lazyBoardingInit = false;
+  /** Set once this session has actually fetched the boarding addresses. */
+  boardingLoaded = false;
   /**
    * The worker's own balance. Same bucketing rules as `Wallet.getBalance` —
    * both call {@link computeOffchainBalance} — but deliberately a different
@@ -18274,7 +18598,7 @@ var WalletMessageHandler = class {
    */
   async handleGetBalance() {
     const [boardingUtxos, { snapshot, vtxos: allVtxos }] = await Promise.all([
-      this.getAllBoardingUtxos(),
+      this.getBoardingUtxosForBalance(),
       // The bucketer drops every spent coin and the gate reads contracts only.
       this.repoSnapshot({ unspentOnly: true })
     ]);
@@ -18290,11 +18614,14 @@ var WalletMessageHandler = class {
       isUnlocked: (vtxo) => unlocked.has(`${vtxo.txid}:${vtxo.vout}`),
       dustCarrier: getDustAmount(this.readonlyWallet)
     });
-    return toWalletBalance(boardingUtxos, offchain);
+    const balance = toWalletBalance(boardingUtxos, offchain);
+    balance.boarding.loaded = this.boardingLoaded;
+    return balance;
   }
-  async getAllBoardingUtxos() {
+  async getBoardingUtxosForBalance() {
     if (!this.readonlyWallet) return [];
-    return this.readonlyWallet.getBoardingUtxos();
+    if (!this.lazyBoardingInit) return this.readonlyWallet.getBoardingUtxos();
+    return this.readonlyWallet.getStoredBoardingUtxos ? this.readonlyWallet.getStoredBoardingUtxos() : this.readonlyWallet.getBoardingUtxos();
   }
   async onWalletInitialized() {
     const wallet = this.readonlyWallet;
@@ -18304,7 +18631,7 @@ var WalletMessageHandler = class {
     const init = this.newGeneration("incomingFunds");
     await this.ensureContractEventBroadcasting();
     if (init.stale) return;
-    await this.refreshCachedData();
+    await this.refreshCachedData({ lazyBoarding: this.lazyBoardingInit });
     if (init.stale) return;
     if (this.wallet) {
       try {
@@ -18402,27 +18729,75 @@ var WalletMessageHandler = class {
     }
   }
   /**
-   * Refresh virtual outputs, boarding inputs, and transaction history from cache.
-   * Shared by onWalletInitialized (full bootstrap) and reloadWallet
-   * (post-refresh), avoiding duplicate subscriptions and VtxoManager restarts.
+   * Refresh boarding inputs and transaction history. The virtual outputs come
+   * from the contract manager, which runs before this. Shared by
+   * onWalletInitialized (full bootstrap) and reloadWallet (post-refresh),
+   * avoiding duplicate subscriptions and VtxoManager restarts.
+   *
+   * Both legs reach the onchain provider, so `lazyBoarding` moves them both
+   * off the caller's path. @see RequestInitWallet.payload.lazyBoarding
    */
-  async refreshCachedData() {
+  async refreshCachedData(opts) {
     if (!this.readonlyWallet || !this.walletRepository) {
       return;
     }
-    const boardingAddresses = await this.readonlyWallet.getBoardingAddresses();
-    const fresh = await this.readonlyWallet.getBoardingUtxos();
-    const freshKeys = new Set(fresh.map((u) => `${u.txid}:${u.vout}`));
-    for (const addr of boardingAddresses) {
-      const cached = await collectUtxos(this.walletRepository, addr);
-      const kept = cached.filter((u) => freshKeys.has(`${u.txid}:${u.vout}`));
-      if (kept.length === cached.length) continue;
-      await this.walletRepository.deleteUtxos(addr);
-      if (kept.length > 0) await this.walletRepository.saveUtxos(addr, kept);
+    if (opts?.lazyBoarding) {
+      const emitter = this.newEmitter("boarding");
+      void (async () => {
+        await this.refreshBoardingCache(emitter);
+        if (emitter.stale) return;
+        this.boardingLoaded = true;
+        const coins = await this.readonlyWallet?.getStoredBoardingUtxos?.() ?? [];
+        emitter.emit(
+          this.tagged({
+            type: "UTXO_UPDATE",
+            broadcast: true,
+            payload: { coins }
+          })
+        );
+        await this.refreshHistoryCache(emitter);
+      })().catch((error) => {
+        console.warn("[wallet] background refresh failed", error);
+      });
+      return;
     }
-    const address = await this.readonlyWallet.getAddress();
+    await this.refreshBoardingCache();
+    this.boardingLoaded = true;
+    await this.refreshHistoryCache();
+  }
+  /** @param gen - set by a background caller; each write is skipped once it goes stale. */
+  async refreshHistoryCache(gen) {
+    const wallet = this.readonlyWallet;
+    const repository = this.walletRepository;
+    if (!wallet || !repository) return;
+    const address = await wallet.getAddress();
     const txs = await this.buildTransactionHistoryFromCache();
-    if (txs) await this.walletRepository.saveTransactions(address, txs);
+    if (txs && !gen?.stale) await repository.saveTransactions(address, txs);
+  }
+  /**
+   * @param gen - set by a background caller; each write here is skipped once it goes stale.
+   *   The fetch saves the fetched rows itself, before control returns, so that one write is
+   *   outside this check.
+   */
+  async refreshBoardingCache(gen) {
+    const wallet = this.readonlyWallet;
+    const repository = this.walletRepository;
+    if (!wallet || !repository) return;
+    const currentSigner = toXOnlySignerHex(
+      hex.encode(wallet.boardingTapscript.options.serverPubKey)
+    );
+    const groups = await wallet.getBoardingUtxosForSigners(/* @__PURE__ */ new Set([currentSigner]));
+    for (const { tapscript, coins } of groups) {
+      if (gen?.stale) return;
+      const address = tapscript.onchainAddress(wallet.network);
+      const freshKeys = new Set(coins.map((coin) => `${coin.txid}:${coin.vout}`));
+      const cached = await collectUtxos(repository, address);
+      const kept = cached.filter((coin) => freshKeys.has(`${coin.txid}:${coin.vout}`));
+      if (kept.length === cached.length) continue;
+      if (gen?.stale) return;
+      await repository.deleteUtxos(address);
+      if (kept.length > 0) await repository.saveUtxos(address, kept);
+    }
   }
   /**
    * Force a full VTXO refresh from the indexer, then refresh cached data.
@@ -18516,6 +18891,8 @@ var WalletMessageHandler = class {
     this.requestEpoch++;
     this.incomingFundsEpoch++;
     this.contractEventsEpoch++;
+    this.boardingEpoch++;
+    this.boardingLoaded = false;
     this.onNextTick = [];
     if (this.incomingFundsSubscription) {
       this.incomingFundsSubscription();
@@ -18719,6 +19096,8 @@ var DEFAULT_MESSAGE_TIMEOUTS = {
   // are treated as long-running on both sides of the bus: the values below
   // are retained only for type completeness and are never enforced.
   SEND: 5e4,
+  SEND_WITH_DEADLINE: 5e4,
+  SEND_WITH_INPUT_EXPIRY_FLOOR: 5e4,
   SETTLE: 5e4,
   // Broadcast: the server round-trip a spend ends in, so it belongs
   // with the writes rather than the reads above.
@@ -18916,6 +19295,7 @@ var ServiceWorkerReadonlyWallet = class _ServiceWorkerReadonlyWallet {
     const serializedWallet = await serializeReadonlyIdentity(options.identity);
     return _ServiceWorkerReadonlyWallet.bootstrap(wallet, options, serializedWallet, {
       delegateUrl: options.delegateUrl,
+      lazyInitialization: options.lazyInitialization,
       watcherConfig: options.watcherConfig
     });
   }
@@ -18923,6 +19303,7 @@ var ServiceWorkerReadonlyWallet = class _ServiceWorkerReadonlyWallet {
   static async bootstrap(wallet, options, serializedWallet, busConfig) {
     const arkServer = options.arkServer ?? { url: DEFAULT_ARKADE_SERVER_URL };
     const initWalletPayload = {
+      lazyBoarding: options.lazyBoarding,
       arkServerUrl: arkServer.url,
       arkServerPublicKey: arkServer.publicKey
     };
@@ -19005,6 +19386,16 @@ var ServiceWorkerReadonlyWallet = class _ServiceWorkerReadonlyWallet {
         if (request.id !== response.id) {
           return;
         }
+        if (response.type === "SEND_DEADLINE_EXCEEDED") {
+          if (event.source !== this.serviceWorker || response.tag !== request.tag) return;
+          cleanup();
+          if ((request.type === "SEND_WITH_DEADLINE" || request.type === "SEND_WITH_INPUT_EXPIRY_FLOOR") && response.error instanceof Error && (response.broadcast === void 0 || response.broadcast === false) && Number.isSafeInteger(response.payload?.validUntil) && response.payload.validUntil > 0 && response.payload.validUntil === request.payload.validUntil) {
+            reject(new SendDeadlineExceededError(request.payload.validUntil));
+          } else {
+            reject(new Error("Invalid timed-send refusal response"));
+          }
+          return;
+        }
         cleanup();
         if (response.error) {
           reject(restoreErrorName(response));
@@ -19747,8 +20138,7 @@ var ServiceWorkerReadonlyWallet = class _ServiceWorkerReadonlyWallet {
           });
         }
       },
-      dispose() {
-        return;
+      async dispose() {
       },
       [Symbol.dispose]() {
         return;
@@ -19808,6 +20198,7 @@ var ServiceWorkerWallet = class _ServiceWorkerWallet extends ServiceWorkerReadon
       delegateUrl: options.delegateUrl,
       settlementConfig: options.settlementConfig,
       walletMode: options.walletMode,
+      lazyInitialization: options.lazyInitialization,
       watcherConfig: options.watcherConfig,
       lookAheadWindow: options.lookAheadWindow,
       minBatchExpirySeconds: options.minBatchExpirySeconds,
@@ -20045,27 +20436,51 @@ var ServiceWorkerWallet = class _ServiceWorkerWallet extends ServiceWorkerReadon
   }
   async send(...args) {
     const [first] = args;
-    const { recipients, selectedVtxos, maxChangeFee } = args.length === 1 && first && "recipients" in first ? first : {
+    const {
+      recipients,
+      selectedVtxos,
+      maxChangeFee,
+      validUntil: wireDeadline,
+      inputExpiryFloor: wireInputExpiryFloor
+    } = args.length === 1 && first && "recipients" in first ? first : {
       recipients: args,
       selectedVtxos: void 0,
-      maxChangeFee: void 0
+      maxChangeFee: void 0,
+      validUntil: void 0,
+      inputExpiryFloor: void 0
     };
-    const message = {
+    const validUntil = captureSendDeadline(wireDeadline);
+    const inputExpiryFloor = captureInputExpiryFloor(wireInputExpiryFloor);
+    const options = {
+      ...selectedVtxos ? { selectedVtxos } : {},
+      ...maxChangeFee !== void 0 ? { maxChangeFee } : {}
+    };
+    const message = inputExpiryFloor !== void 0 ? {
       tag: this.messageTag,
-      type: "SEND",
+      type: "SEND_WITH_INPUT_EXPIRY_FLOOR",
       id: getRandomId(),
-      // Omitted rather than sent as `undefined`, so an older worker sees
-      // exactly the payload it saw before.
       payload: {
         recipients,
-        ...selectedVtxos ? { selectedVtxos } : {},
-        ...maxChangeFee !== void 0 ? { maxChangeFee } : {}
+        ...options,
+        inputExpiryFloor,
+        ...validUntil === void 0 ? {} : { validUntil }
       }
+    } : validUntil === void 0 ? {
+      tag: this.messageTag,
+      type: "SEND",
+      id: getRandomId(),
+      payload: { recipients, ...options }
+    } : {
+      tag: this.messageTag,
+      type: "SEND_WITH_DEADLINE",
+      id: getRandomId(),
+      payload: { recipients, ...options, validUntil }
     };
     try {
       const response = await this.sendMessage(message);
       return response.payload.txid;
     } catch (error) {
+      if (error instanceof SendDeadlineExceededError) throw error;
       throw new Error(`Send failed: ${error}`);
     }
   }
@@ -23615,6 +24030,7 @@ var ArkadeTransactionBuilder = class {
   outputs = [];
   fundingCoins = [];
   assetSpecs = [];
+  extraPackets = [];
   coin;
   changeScript;
   from(coin) {
@@ -23634,6 +24050,11 @@ var ArkadeTransactionBuilder = class {
     this.assetSpecs.push(spec);
     return this;
   }
+  /** Add an extension packet; reusing the asset or emulator packet's type fails at build. */
+  withPacket(packet) {
+    this.extraPackets.push(packet);
+    return this;
+  }
   /** Destination for any surplus (inputs − outputs). Required when the spend is not exact. */
   change(script) {
     this.changeScript = script;
@@ -23725,6 +24146,7 @@ var ArkadeTransactionBuilder = class {
         ])
       );
     }
+    packets.push(...this.extraPackets);
     if (packets.length > 0) {
       attachExtension(arkTx, packets);
     }
@@ -24320,6 +24742,6 @@ function createDefaultPaymentRouter(wallet) {
   }).use(arkRail()).use(arkAssetRail()).use(onchainRail({ feeInfo: walletFeeSource(wallet) }));
 }
 
-export { ARKADE_MAGIC, ARKADE_SALTED_PREIMAGE_TAG, ARKADE_SWAP_PREIMAGE_TAG, ASSET_CARRIER_SATS, AbortError, ActivityRegistry, AmbiguousRouteError, ArkNote, ArkadeCash, ArkadeCashCreateError, AssetManager, BIP21, BIP21Error, BIP322, BLOCKED_UPGRADE_TIMEOUT_MS, Batch, CachingArkProvider, ChainedTxType, ConnectionDisposedError, ContractManager, ContractWatcher, DEFAULT_MESSAGE_TIMEOUTS, DEFAULT_MIN_BATCH_EXPIRY_SECONDS, DEFAULT_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, DatabaseUpgradeBlockedError, DelegateManagerImpl, DelegateNotConfiguredError, 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, KeyringDescriptorProvider, MAX_PAGE_SIZE, MAX_USED_SIGNING_DESCRIPTORS_LOOK_AHEAD, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, MUTINYNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, OversizedChangeError, P2A, PaymentRouter, PrevTxUnavailableError, REGTEST_MIN_BATCH_EXPIRY_SECONDS, REGTEST_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestEmulatorProvider, SIGNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, SeedIdentity, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, StaticDescriptorProvider, TxTree, TxType, TxWeightEstimator, UnannotatableInputError, UnilateralExit, UnknownPacket, Unroll, VtxoManager, Wallet2 as Wallet, WalletCannotAllocateAddressError, WalletCannotSignError, WalletMessageHandler, WalletNotInitializedError, WsElectrumChainSource, adoptContractDescriptor, arkAssetRail, arkRail, arkTarget, arkade_exports, assertFinalCommitmentMatchesValidated, assertHistoryPageFilter, assertIntentIdUnique, assertNoAssets, assertNoSelection, assertPageRequest, assertRecipientArkadeAddress, assertSendableAmount, assertSubmittedArkTxid, assertValidBatchExpiry, assertValidServerUnrollScript, assetMintResolver, assetsOf, attachPrevArkTxs, attachPrevoutTxs, awaitTransaction, boardingResolver, btcTarget, buildForfeitTx, buildOffchainTx, buildPreimageMessage, buildSaltedPreimageMessage, checkSaveVtxosForScript, claimWithPreimageIdentity, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, collabExitResolver, collectContracts, collectIntents, collectPages, collectScriptVtxos, collectTransactionHistory, collectUtxos, collectVtxos, combineTapscriptSigs, compareHistoryCursors, contractFilterMatchesNothing, contractFromArkContract, contractFromArkContractWithAddress, contractPreimage, contractSigner, createAssetPacket, createDefaultActivityRegistry, createDefaultPaymentRouter, createExitChainResolver, createManagedConnection, createdAtToIso, decodeArkContract, defaultBatchExpiryPolicy, defaultCheckpointExitDelayPolicy, deleteByIndex, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, exitObserverFor, extendVirtualCoinForContract, extractArkProviderUrl, gateExclusion, gatedContracts, getAllByIndexValues, getRandomId, hasBoardingTxExpired, hasCandidates, intentMatchesFilter, invoiceTarget, isAddressAllocationCapable, isArkContract, isBatchSignable, isBtcAddress, isContractGenericallySpendable, isContractVtxoEvent, isCooperativelyMigratable, isDeterministicSigner, isDiscoverable, isHDAllocationCapable, isHDDeterministicSignCapable, isHDWalletCapable, isLightningInvoice, isLnurl, isMessageBusInitializingError, isMessageBusNotInitializedError, isPerArtifactDescriptor, isSigningIdentity, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, iteratePages, legacyVtxoFacts, logExcludedVtxos, makeHandle, matchServerCheckpoints, mergeChainedTxType, notifyExitObserved, onchainRail, openDatabase, outpointExclusion, outpointReasons, pageResult, promisifyRequest, provisionClaimSecret, provisionRefundKey, registerWalletRestoreHook, resolveAssetAmount, resolveBatchExpiryPolicy, resolveCheckpointExitDelayPolicy, resolveDescriptorSigner, resolvePrevTxs, resolveSendAmount, saveVtxosForContract, scriptFromArkAddress, selectCoinsWithAsset, selectVirtualCoins, selectionOf, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signAndSubmitOffchainTx, signerSetFromInfo, signingDescriptorIndex, strictSigningDescriptorIndex, toXOnlySignerHex, tryResolveSendAmount, utxoEntries, validateBatchRecipients, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, walletFeeSource, warnAndFilterVtxosForScript, withPrevTxs };
-//# sourceMappingURL=chunk-EXFU6MTA.js.map
-//# sourceMappingURL=chunk-EXFU6MTA.js.map
+export { ARKADE_MAGIC, ARKADE_SALTED_PREIMAGE_TAG, ARKADE_SWAP_PREIMAGE_TAG, ASSET_CARRIER_SATS, AbortError, ActivityRegistry, AmbiguousRouteError, ArkNote, ArkadeCash, ArkadeCashCreateError, AssetManager, BIP21, BIP21Error, BIP322, BLOCKED_UPGRADE_TIMEOUT_MS, Batch, CachingArkProvider, ChainedTxType, ConnectionDisposedError, ContractManager, ContractWatcher, DEFAULT_MESSAGE_TIMEOUTS, DEFAULT_MIN_BATCH_EXPIRY_SECONDS, DEFAULT_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, DatabaseUpgradeBlockedError, DelegateManagerImpl, DelegateNotConfiguredError, 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, KeyringDescriptorProvider, MAX_PAGE_SIZE, MAX_USED_SIGNING_DESCRIPTORS_LOOK_AHEAD, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, MUTINYNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, OversizedChangeError, P2A, PaymentRouter, PrevTxUnavailableError, REGTEST_MIN_BATCH_EXPIRY_SECONDS, REGTEST_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestEmulatorProvider, SIGNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, SeedIdentity, SendDeadlineExceededError, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, StaticDescriptorProvider, TxTree, TxType, TxWeightEstimator, UnannotatableInputError, UnilateralExit, UnknownPacket, Unroll, VtxoManager, Wallet2 as Wallet, WalletCannotAllocateAddressError, WalletCannotSignError, WalletMessageHandler, WalletNotInitializedError, WsElectrumChainSource, adoptContractDescriptor, arkAssetRail, arkRail, arkTarget, arkade_exports, assertFinalCommitmentMatchesValidated, assertHistoryPageFilter, assertIntentIdUnique, assertNoAssets, assertNoSelection, assertPageRequest, assertRecipientArkadeAddress, assertSendDeadline, assertSendableAmount, assertSubmittedArkTxid, assertValidBatchExpiry, assertValidServerUnrollScript, assetMintResolver, assetsOf, attachPrevArkTxs, attachPrevoutTxs, awaitTransaction, boardingResolver, btcTarget, buildForfeitTx, buildOffchainTx, buildPreimageMessage, buildSaltedPreimageMessage, captureSendDeadline, checkSaveVtxosForScript, claimWithPreimageIdentity, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, collabExitResolver, collectContracts, collectIntents, collectPages, collectScriptVtxos, collectTransactionHistory, collectUtxos, collectVtxos, combineTapscriptSigs, compareHistoryCursors, contractFilterMatchesNothing, contractFromArkContract, contractFromArkContractWithAddress, contractPreimage, contractSigner, createAssetPacket, createDefaultActivityRegistry, createDefaultPaymentRouter, createExitChainResolver, createManagedConnection, createdAtToIso, decodeArkContract, defaultBatchExpiryPolicy, defaultCheckpointExitDelayPolicy, deleteByIndex, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, exitObserverFor, extendVirtualCoinForContract, extractArkProviderUrl, gateExclusion, gatedContracts, getAllByIndexValues, getRandomId, hasBoardingTxExpired, hasCandidates, intentMatchesFilter, invoiceTarget, isAddressAllocationCapable, isArkContract, isBatchSignable, isBtcAddress, isContractGenericallySpendable, isContractVtxoEvent, isCooperativelyMigratable, isDeterministicSigner, isDiscoverable, isHDAllocationCapable, isHDDeterministicSignCapable, isHDWalletCapable, isLightningInvoice, isLnurl, isMessageBusInitializingError, isMessageBusNotInitializedError, isPerArtifactDescriptor, isSigningIdentity, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, iteratePages, legacyVtxoFacts, logExcludedVtxos, makeHandle, matchServerCheckpoints, mergeChainedTxType, notifyExitObserved, onchainRail, openDatabase, outpointExclusion, outpointReasons, pageResult, promisifyRequest, provisionClaimSecret, provisionRefundKey, registerWalletRestoreHook, resolveAssetAmount, resolveBatchExpiryPolicy, resolveCheckpointExitDelayPolicy, resolveDescriptorSigner, resolvePrevTxs, resolveSendAmount, saveVtxosForContract, scriptFromArkAddress, selectCoinsWithAsset, selectVirtualCoins, selectionOf, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signAndSubmitOffchainTx, signerSetFromInfo, signingDescriptorIndex, strictSigningDescriptorIndex, toXOnlySignerHex, tryResolveSendAmount, utxoEntries, validateBatchRecipients, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, walletFeeSource, warnAndFilterVtxosForScript, withPrevTxs };
+//# sourceMappingURL=chunk-ENGV6VZF.js.map
+//# sourceMappingURL=chunk-ENGV6VZF.js.map