@arkade-os/sdk 0.4.70 → 0.4.72

package/dist/{chunk-JVHO6XHG.js → chunk-BHLYB44A.js}

@@ -1,6 +1,6 @@
-import { AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, BufferReader, BufferWriter, AssetRef, RestIndexerProvider } from './chunk-F5E7LI6G.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, parseHDDescriptor, identityDescriptor, DefaultVtxo, speculativeReceiveMetadata, DelegateVtxo, WALLET_RECEIVE_SOURCE, BoardingContractHandler } from './chunk-6UM55KPZ.js';
-import { VtxoScript, Transaction, isRecoverable, CSVMultisigTapscript, DEFAULT_NETWORK, resolveEmulatorPubkey, hasTerminalSpend, getNormalizedVtxos, setArkPsbtField, PrevArkTxField, ConditionWitness, craftToSpendTx, ArkAddress, isVirtualCoin, getArkPsbtFields, CosignerPublicKey, ServerResponseMismatchError, OP_RETURN_EMPTY_PKSCRIPT, canSweepOnchain, sequenceToTimelock, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, VtxoTaprootTree, timelockToSequence, assertAllowedSighashTypes, baseFetch, Intent, rateGate, DEFAULT_NETWORK_NAME, formatSighash, 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, PrevoutTxField, DEFAULT_ARKADE_SERVER_URL, ProviderUnavailableError, networks as networks$1, isPastExpiry, fetchVtxoCreatedAtByTxid } from './chunk-TXSF2DKX.js';
+import { AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, BufferReader, BufferWriter, AssetRef, RestIndexerProvider } from './chunk-IGER5FPC.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, parseHDDescriptor, identityDescriptor, DefaultVtxo, speculativeReceiveMetadata, DelegateVtxo, WALLET_RECEIVE_SOURCE, BoardingContractHandler } from './chunk-CB6QPAO5.js';
+import { VtxoScript, Transaction, isRecoverable, CSVMultisigTapscript, DEFAULT_NETWORK, resolveEmulatorPubkey, hasTerminalSpend, getNormalizedVtxos, setArkPsbtField, PrevArkTxField, ConditionWitness, craftToSpendTx, ArkAddress, isVirtualCoin, getArkPsbtFields, CosignerPublicKey, ServerResponseMismatchError, OP_RETURN_EMPTY_PKSCRIPT, canSweepOnchain, sequenceToTimelock, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, VtxoTaprootTree, timelockToSequence, assertAllowedSighashTypes, baseFetch, Intent, rateGate, DEFAULT_NETWORK_NAME, formatSighash, normalizeVtxo, getSequence, toBatchExpiry, maybeArkError, isArkError, ArkErrorName, toOffchainInputFeeParams, canRecoverOnchain, getNetwork, MultisigTapscript, isEventSourceError, isEventSourceUnavailableError, getAllNormalizedVtxos, isPastExpiry, isRetryableProviderError, DEFAULT_PAGE_SIZE, RestArkProvider, toVirtualStatus, ArkError, TapTreeCoder, resolveTimeHeight, canSpendOffchain, parseLegacyExpiry, isExpired, PrevoutTxField, fetchVtxoCreatedAtByTxid, DEFAULT_ARKADE_SERVER_URL, ProviderUnavailableError, networks as networks$1 } from './chunk-5GQFYVWP.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';
@@ -2983,6 +2983,39 @@ function createDefaultActivityRegistry() {
   return registry;
 }
 
+// src/wallet/restoreHooks.ts
+var restoreHooks = /* @__PURE__ */ new WeakMap();
+function registerWalletRestoreHook(wallet, hook) {
+  const hooks = restoreHooks.get(wallet) ?? [];
+  const entry = { ...hook };
+  const existing = hooks.findIndex(({ id }) => id === hook.id);
+  if (existing === -1) hooks.push(entry);
+  else hooks[existing] = entry;
+  restoreHooks.set(wallet, hooks);
+  return () => {
+    const current = restoreHooks.get(wallet);
+    if (!current) return;
+    const index = current.indexOf(entry);
+    if (index === -1) return;
+    current.splice(index, 1);
+    if (current.length === 0) restoreHooks.delete(wallet);
+  };
+}
+async function runWalletRestoreHooks(wallet) {
+  const snapshot = [...restoreHooks.get(wallet) ?? []];
+  const errors = [];
+  for (const hook of snapshot) {
+    try {
+      await hook.restore(wallet);
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  if (errors.length > 0) {
+    throw new AggregateError(errors, "Wallet restore hooks failed");
+  }
+}
+
 // src/wallet/index.ts
 var TxType = /* @__PURE__ */ ((TxType2) => {
   TxType2["TxSent"] = "SENT";
@@ -3618,6 +3651,26 @@ function claimWithPreimageIdentity(identity, preimage) {
     }
   };
 }
+
+// src/contracts/types.ts
+function watchStateOf(contract) {
+  return contract.watch ?? "watched";
+}
+function isWatchedContract(contract) {
+  return watchStateOf(contract) !== "retained";
+}
+function hasCandidates(handler) {
+  return !!handler && typeof handler.candidatesAt === "function";
+}
+function isDiscoverable(handler) {
+  return !!handler && typeof handler.discoverAt === "function";
+}
+function isTapscriptDeriving(handler) {
+  return !!handler && typeof handler.deriveTapscripts === "function";
+}
+function isContractVtxoEvent(event) {
+  return "contract" in event && event.contract !== void 0;
+}
 var AmountVariableName = "amount";
 var ExpiryVariableName = "expiry";
 var BirthVariableName = "birth";
@@ -3773,23 +3826,6 @@ function parseProgram(text, env) {
   }
   return { program, text };
 }
-
-// src/contracts/types.ts
-function watchStateOf(contract) {
-  return contract.watch ?? "watched";
-}
-function isWatchedContract(contract) {
-  return watchStateOf(contract) !== "retained";
-}
-function hasCandidates(handler) {
-  return !!handler && typeof handler.candidatesAt === "function";
-}
-function isDiscoverable(handler) {
-  return !!handler && typeof handler.discoverAt === "function";
-}
-function isTapscriptDeriving(handler) {
-  return !!handler && typeof handler.deriveTapscripts === "function";
-}
 var DUST_AMOUNT = 546;
 var FALLBACK_WALLET_DUST_AMOUNT = 330n;
 function getDustAmount(wallet) {
@@ -3954,9 +3990,18 @@ function gatedContracts(contracts) {
   }
   return gated;
 }
+function gatedFrom(snapshot) {
+  return gatedContracts(snapshot.map((entry) => entry.contract));
+}
+function gatedTypeOf(vtxo, gated) {
+  return vtxo.script === void 0 ? void 0 : gated.get(vtxo.script);
+}
+function isGatedVtxo(vtxo, gated) {
+  return gatedTypeOf(vtxo, gated) !== void 0;
+}
 function gateExclusion(gated) {
   return (vtxo) => {
-    const type = vtxo.script === void 0 ? void 0 : gated.get(vtxo.script);
+    const type = gatedTypeOf(vtxo, gated);
     if (type === void 0) return void 0;
     if (!contractHandlers.has(type)) {
       return `at ${vtxo.script} (contract type '${type}') has no handler registered in this build`;
@@ -5339,7 +5384,7 @@ var VtxoManager = class _VtxoManager {
         this.wallet.getAddress()
       ]);
       const stopWatching = contractManager.onContractEvent((event) => {
-        if (event.type !== "vtxo_received") {
+        if (event.type !== "vtxo_received" || !isContractVtxoEvent(event)) {
           return;
         }
         const msSinceLastRenewal = Date.now() - this.lastRenewalTimestamp;
@@ -6934,6 +6979,24 @@ var Batch;
 })(Batch || (Batch = {}));
 
 // src/utils/transactionHistory.ts
+function localCreatedAtByTxid(vtxos) {
+  const createdAt = /* @__PURE__ */ new Map();
+  for (const vtxo of vtxos) {
+    if (vtxo.txid && !createdAt.has(vtxo.txid)) {
+      createdAt.set(vtxo.txid, vtxo.createdAt.getTime());
+    }
+  }
+  return createdAt;
+}
+function gatedTouchpoints(gated) {
+  const paidIn = /* @__PURE__ */ new Set();
+  const paidOut = /* @__PURE__ */ new Set();
+  for (const vtxo of gated) {
+    if (vtxo.txid) paidIn.add(vtxo.txid);
+    if (vtxo.isSpent && vtxo.arkTxId) paidOut.add(vtxo.arkTxId);
+  }
+  return { paidIn, paidOut };
+}
 var txKey = {
   commitmentTxid: "",
   boardingTxid: "",
@@ -6985,24 +7048,27 @@ function subtractAssets(spent, change) {
   if (map.size === 0) return void 0;
   return Array.from(map, ([assetId, amount]) => ({ assetId, amount }));
 }
-function collectArkTxidsNeedingCreatedAt(vtxos) {
-  const ownTxids = new Set(vtxos.map((v) => v.txid));
+function collectArkTxidsNeedingCreatedAt(vtxos, localCreatedAt) {
   const txids = /* @__PURE__ */ new Set();
   for (const vtxo of vtxos) {
-    if (vtxo.isSpent && vtxo.arkTxId && !ownTxids.has(vtxo.arkTxId)) {
+    if (vtxo.isSpent && vtxo.arkTxId && !localCreatedAt.has(vtxo.arkTxId)) {
       txids.add(vtxo.arkTxId);
     }
   }
   return [...txids];
 }
-async function buildTransactionHistory(vtxos, allBoardingTxs, commitmentsToIgnore, resolveTxCreatedAt) {
-  const fromOldestVtxo = vtxos.map(normalizeVtxo).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
-  const txidsNeedingCreatedAt = resolveTxCreatedAt ? collectArkTxidsNeedingCreatedAt(fromOldestVtxo) : [];
+async function buildTransactionHistory(vtxos, allBoardingTxs, commitmentsToIgnore, resolveTxCreatedAt, gatedScripts = /* @__PURE__ */ new Map()) {
+  const normalized = vtxos.map(normalizeVtxo).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+  const localCreatedAt = localCreatedAtByTxid(normalized);
+  const gatedVtxos = normalized.filter((vtxo) => isGatedVtxo(vtxo, gatedScripts));
+  const ownVtxos = normalized.filter((vtxo) => !isGatedVtxo(vtxo, gatedScripts));
+  const { paidIn: paidIntoGated, paidOut: paidOutOfGated } = gatedTouchpoints(gatedVtxos);
+  const txidsNeedingCreatedAt = resolveTxCreatedAt ? collectArkTxidsNeedingCreatedAt(ownVtxos, localCreatedAt) : [];
   const resolvedCreatedAt = resolveTxCreatedAt && txidsNeedingCreatedAt.length > 0 ? await resolveTxCreatedAt(txidsNeedingCreatedAt) : /* @__PURE__ */ new Map();
   const unmatchedSettledBoardingTxs = allBoardingTxs.filter(isSettledBoardingReceive).sort((a, b) => a.createdAt - b.createdAt);
   const sent = [];
   let received = [];
-  for (const vtxo of fromOldestVtxo) {
+  for (const vtxo of ownVtxos) {
     if (vtxo.status.isLeaf) {
       const commitmentTxid = vtxo.commitmentTxIds[0];
       const vtxoCreatedAt = vtxo.createdAt.getTime();
@@ -7012,7 +7078,7 @@ async function buildTransactionHistory(vtxos, allBoardingTxs, commitmentsToIgnor
           unmatchedSettledBoardingTxs,
           (tx) => tx.createdAt <= vtxoCreatedAt && (tx.key.commitmentTxid === commitmentTxid || tx.key.commitmentTxid === vtxo.settledBy)
         );
-      } else if (fromOldestVtxo.filter((v) => v.settledBy === vtxo.commitmentTxIds[0]).length === 0) {
+      } else if (ownVtxos.filter((v) => v.settledBy === vtxo.commitmentTxIds[0]).length === 0) {
         const duplicateBoardingReceive = consumeBoardingReceive(
           unmatchedSettledBoardingTxs,
           (tx) => tx.amount === vtxo.value && tx.createdAt <= vtxoCreatedAt
@@ -7033,11 +7099,14 @@ async function buildTransactionHistory(vtxos, allBoardingTxs, commitmentsToIgnor
           });
         }
       }
-    } else if (fromOldestVtxo.filter((v) => v.arkTxId === vtxo.txid).length === 0) {
+    } else if (ownVtxos.filter((v) => v.arkTxId === vtxo.txid).length === 0) {
       const assets = collectAssets([vtxo]);
       received.push({
         key: { ...txKey, arkTxid: vtxo.txid },
-        tag: "offchain",
+        // The escrow paying out: a swap fill or a cancel spends the
+        // gated coin and lands the proceeds here. Nothing else about
+        // the row changes — the tag only names the counterparty.
+        tag: paidOutOfGated.has(vtxo.txid) ? "gated" : "offchain",
         type: "RECEIVED" /* TxReceived */,
         amount: vtxo.value,
         settled: vtxo.status.isLeaf || vtxo.isSpent,
@@ -7047,8 +7116,8 @@ async function buildTransactionHistory(vtxos, allBoardingTxs, commitmentsToIgnor
     }
     if (vtxo.isSpent) {
       if (vtxo.arkTxId && !sent.some((s) => s.key.arkTxid === vtxo.arkTxId)) {
-        const changes = fromOldestVtxo.filter((_) => _.txid === vtxo.arkTxId);
-        const allSpent = fromOldestVtxo.filter((v) => v.arkTxId === vtxo.arkTxId);
+        const changes = ownVtxos.filter((_) => _.txid === vtxo.arkTxId);
+        const allSpent = ownVtxos.filter((v) => v.arkTxId === vtxo.arkTxId);
         const spentAmount = allSpent.reduce((acc, v) => acc + v.value, 0);
         let txAmount = 0;
         let txTime = 0;
@@ -7058,13 +7127,16 @@ async function buildTransactionHistory(vtxos, allBoardingTxs, commitmentsToIgnor
           txTime = changes[0].createdAt.getTime();
         } else {
           txAmount = spentAmount;
-          txTime = resolvedCreatedAt.get(vtxo.arkTxId) ?? vtxo.createdAt.getTime() + 1;
+          txTime = localCreatedAt.get(vtxo.arkTxId) ?? resolvedCreatedAt.get(vtxo.arkTxId) ?? vtxo.createdAt.getTime() + 1;
         }
         const assets = subtractAssets(allSpent, changes);
         if (txAmount !== 0 || assets) {
           sent.push({
             key: { ...txKey, arkTxid: vtxo.arkTxId },
-            tag: "offchain",
+            // Funding the escrow: an output of this tx landed on a
+            // gated contract of the wallet's, so the send is to the
+            // user's own covenant rather than to a stranger.
+            tag: paidIntoGated.has(vtxo.arkTxId) ? "gated" : "offchain",
             type: "SENT" /* TxSent */,
             amount: txAmount,
             settled: true,
@@ -7074,10 +7146,10 @@ async function buildTransactionHistory(vtxos, allBoardingTxs, commitmentsToIgnor
         }
       }
       if (vtxo.settledBy && !commitmentsToIgnore.has(vtxo.settledBy) && !sent.some((s) => s.key.commitmentTxid === vtxo.settledBy)) {
-        const changes = fromOldestVtxo.filter(
+        const changes = ownVtxos.filter(
           (v) => v.status.isLeaf && v.commitmentTxIds.length > 0 && v.commitmentTxIds.every((_) => vtxo.settledBy === _)
         );
-        const forfeitVtxos = fromOldestVtxo.filter((v) => v.settledBy === vtxo.settledBy);
+        const forfeitVtxos = ownVtxos.filter((v) => v.settledBy === vtxo.settledBy);
         const forfeitAmount = forfeitVtxos.reduce((acc, v) => acc + v.value, 0);
         if (changes.length > 0) {
           const settledAmount = changes.reduce((acc, v) => acc + v.value, 0);
@@ -8711,6 +8783,8 @@ var DEFAULT_CONTRACT_WATCHER_CONFIG = {
 var ContractWatcher = class {
   config;
   contracts = /* @__PURE__ */ new Map();
+  /** In-memory and process-lifetime; never persisted. */
+  watchedScripts = /* @__PURE__ */ new Map();
   subscriptionId;
   abortController;
   isWatching = false;
@@ -8831,6 +8905,47 @@ var ContractWatcher = class {
   getWatchedContracts() {
     return this.getAllContracts().filter(isWatchedContract);
   }
+  /**
+   * Every script the subscription must carry. Wider than
+   * {@link getWatchedContracts}, which stays the sync scope.
+   */
+  getSubscribedScripts() {
+    const scripts = new Set(this.getWatchedContracts().map((c) => c.script));
+    for (const script of this.watchedScripts.keys()) {
+      scripts.add(script);
+    }
+    return Array.from(scripts);
+  }
+  /** @see IContractManager.watchScript for the delivery and filter contract. */
+  async addWatchedScript(script, options) {
+    const existing = this.watchedScripts.get(script);
+    if (existing) {
+      if (options?.label !== void 0) existing.label = options.label;
+      return;
+    }
+    this.watchedScripts.set(script, {
+      label: options?.label,
+      lastKnownVtxos: /* @__PURE__ */ new Map()
+    });
+    if (this.isWatching) {
+      await this.pollWatchedScripts([script]);
+      await this.tryUpdateSubscription();
+    }
+  }
+  /** Stop watching a script added by {@link addWatchedScript}. */
+  async removeWatchedScript(script) {
+    if (!this.watchedScripts.delete(script)) return;
+    if (this.isWatching) {
+      await this.tryUpdateSubscription();
+    }
+  }
+  /** Every script registered via {@link addWatchedScript}. */
+  getWatchedScripts() {
+    return Array.from(this.watchedScripts.entries()).map(([script, state]) => ({
+      script,
+      label: state.label
+    }));
+  }
   /**
    * Get virtual outputs for contracts, grouped by contract script.
    * @see WalletRepository for `repo`
@@ -9022,8 +9137,72 @@ var ContractWatcher = class {
   }
   async pollAllContracts() {
     const scripts = this.getWatchedContracts().map((c) => c.script);
+    if (scripts.length > 0) {
+      await this.pollContracts(scripts);
+    }
+    await this.pollWatchedScripts(Array.from(this.watchedScripts.keys()));
+  }
+  /**
+   * Poll watch-only scripts against the indexer and emit the delta.
+   *
+   * Separate from {@link pollContracts} because that one diffs the wallet
+   * repository, which is permanently empty for a script this wallet does not
+   * own — reusing it would report every live output as spent on every tick.
+   * Not a second poll loop: same timer and callers, different source.
+   */
+  async pollWatchedScripts(candidates) {
+    if (!this.eventCallback) return;
+    const scripts = candidates.filter((s) => {
+      const state = this.contracts.get(s);
+      return this.watchedScripts.has(s) && (state === void 0 || !isWatchedContract(state.contract));
+    });
     if (scripts.length === 0) return;
-    await this.pollContracts(scripts);
+    const now = Date.now();
+    let current;
+    try {
+      current = await getAllNormalizedVtxos(this.config.indexerProvider, scripts, {
+        spendableOnly: true
+      });
+    } catch (error) {
+      console.error("ContractWatcher watch-only poll failed:", error);
+      return;
+    }
+    const byScript = /* @__PURE__ */ new Map();
+    for (const vtxo of current) {
+      let bucket = byScript.get(vtxo.script);
+      if (!bucket) {
+        bucket = [];
+        byScript.set(vtxo.script, bucket);
+      }
+      bucket.push(vtxo);
+    }
+    for (const script of scripts) {
+      const state = this.watchedScripts.get(script);
+      if (!state) continue;
+      const currentVtxos = byScript.get(script) || [];
+      const currentKeys = new Set(currentVtxos.map((v) => `${v.txid}:${v.vout}`));
+      const newVtxos = [];
+      for (const vtxo of currentVtxos) {
+        const key = `${vtxo.txid}:${vtxo.vout}`;
+        if (!state.lastKnownVtxos.has(key)) {
+          newVtxos.push(vtxo);
+          state.lastKnownVtxos.set(key, vtxo);
+        }
+      }
+      const spentVtxos = [];
+      for (const [key, vtxo] of state.lastKnownVtxos) {
+        if (!currentKeys.has(key)) {
+          spentVtxos.push(vtxo);
+          state.lastKnownVtxos.delete(key);
+        }
+      }
+      if (newVtxos.length > 0) {
+        this.emitWatchedScriptEvent(script, newVtxos, "vtxo_received", now);
+      }
+      if (spentVtxos.length > 0) {
+        this.emitWatchedScriptEvent(script, spentVtxos, "vtxo_spent", now);
+      }
+    }
   }
   /**
    * Poll specific contracts and emit events for changes.
@@ -9034,13 +9213,14 @@ var ContractWatcher = class {
     try {
       const vtxosMap = await this.getContractVtxos({
         contractScripts,
-        includeSpent: false
-        // only spendable ones!
+        includeSpent: true
       });
       for (const contractScript of contractScripts) {
         const state = this.contracts.get(contractScript);
         if (!state) continue;
-        const currentVtxos = vtxosMap.get(contractScript) || [];
+        const known = vtxosMap.get(contractScript) || [];
+        const knownByKey = new Map(known.map((v) => [`${v.txid}:${v.vout}`, v]));
+        const currentVtxos = known.filter((v) => !v.isSpent);
         const currentKeys = new Set(currentVtxos.map((v) => `${v.txid}:${v.vout}`));
         const newVtxos = [];
         for (const vtxo of currentVtxos) {
@@ -9053,7 +9233,7 @@ var ContractWatcher = class {
         const spentVtxos = [];
         for (const [key, vtxo] of state.lastKnownVtxos) {
           if (!currentKeys.has(key)) {
-            spentVtxos.push(vtxo);
+            spentVtxos.push(knownByKey.get(key) ?? vtxo);
             state.lastKnownVtxos.delete(key);
           }
         }
@@ -9124,10 +9304,10 @@ var ContractWatcher = class {
   /**
    * Update the subscription with scripts that should be watched.
    *
-   * @see getWatchedContracts
+   * @see getSubscribedScripts
    */
   async updateSubscription() {
-    const scriptsToWatch = this.getWatchedContracts().map((c) => c.script);
+    const scriptsToWatch = this.getSubscribedScripts();
     if (scriptsToWatch.length === 0) {
       if (this.subscriptionId) {
         try {
@@ -9211,16 +9391,26 @@ var ContractWatcher = class {
    */
   processSubscriptionVtxos(vtxos, eventType, timestamp) {
     const byContract = /* @__PURE__ */ new Map();
+    const byWatchedScript = /* @__PURE__ */ new Map();
     let unknownScript = 0;
+    const now = { timestamp: /* @__PURE__ */ new Date() };
     for (const vtxo of vtxos) {
-      if (!this.contracts.has(vtxo.script)) {
+      const state = this.contracts.get(vtxo.script);
+      const watchOnly = this.watchedScripts.has(vtxo.script);
+      const preferContract = state !== void 0 && (!watchOnly || isWatchedContract(state.contract));
+      const target = preferContract ? byContract : watchOnly ? byWatchedScript : void 0;
+      if (!target) {
         unknownScript++;
         continue;
       }
-      let bucket = byContract.get(vtxo.script);
+      if (target === byWatchedScript && eventType === "vtxo_received") {
+        const n = normalizeVtxo(vtxo);
+        if (hasTerminalSpend(n) || n.isSwept || isPastExpiry(n, now)) continue;
+      }
+      let bucket = target.get(vtxo.script);
       if (!bucket) {
         bucket = [];
-        byContract.set(vtxo.script, bucket);
+        target.set(vtxo.script, bucket);
       }
       bucket.push(vtxo);
     }
@@ -9243,6 +9433,29 @@ var ContractWatcher = class {
       }
       this.emitVtxoEvent(contractScript, bucketVtxos, eventType, timestamp);
     }
+    for (const [script, bucketVtxos] of byWatchedScript) {
+      const state = this.watchedScripts.get(script);
+      if (state) {
+        for (const vtxo of bucketVtxos) {
+          const key = `${vtxo.txid}:${vtxo.vout}`;
+          if (eventType === "vtxo_received") {
+            state.lastKnownVtxos.set(key, vtxo);
+          } else {
+            state.lastKnownVtxos.delete(key);
+          }
+        }
+      }
+      this.emitWatchedScriptEvent(script, bucketVtxos, eventType, timestamp);
+    }
+  }
+  /** As {@link emitVtxoEvent}, less the `contract` and the annotation. */
+  emitWatchedScriptEvent(script, vtxos, eventType, timestamp) {
+    if (!this.eventCallback) return;
+    if (eventType === "vtxo_received") {
+      this.eventCallback({ type: "vtxo_received", contractScript: script, vtxos, timestamp });
+      return;
+    }
+    this.eventCallback({ type: "vtxo_spent", contractScript: script, vtxos, timestamp });
   }
   /**
    * Emit a virtual output event for a contract.
@@ -9414,6 +9627,7 @@ var ContractManager = class _ContractManager {
   syncDegradedReason;
   /** Epoch-ms of the last successful provider sync, if any. */
   lastSyncedAt;
+  syncedAtByScript = /* @__PURE__ */ new Map();
   /** 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. */
@@ -9467,6 +9681,10 @@ var ContractManager = class _ContractManager {
       lastSyncedAt: this.lastSyncedAt
     };
   }
+  /** @see ContractManagerConfig.vtxoSyncMaxAgeMs — for factory-built managers. */
+  setVtxoSyncMaxAge(maxAgeMs) {
+    this.config.vtxoSyncMaxAgeMs = maxAgeMs;
+  }
   markSyncOnline() {
     this.lastSyncedAt = Date.now();
     this.syncDegradedReason = this.annotationDegradedReason();
@@ -9770,6 +9988,41 @@ var ContractManager = class _ContractManager {
     }
     return contract;
   }
+  /**
+   * `createContract`'s step order, fetch batched: persist all, hydrate once,
+   * then watch. Hydrating first keeps it equivalent — the watcher seeds from
+   * the repository, so an unhydrated row reads as all-new. A part-way failure
+   * still watches what it wrote; a retry reports those rows as existing.
+   */
+  async createContracts(paramsList) {
+    if (paramsList.length === 0) return [];
+    return this.watcher.withCoalescedSubscription(async () => {
+      const upserted = [];
+      try {
+        for (const params of paramsList) upserted.push(await this.upsertContract(params));
+      } catch (err) {
+        for (const u of upserted) {
+          if (!u.persisted) continue;
+          await this.watcher.addContract(u.contract).catch(
+            (e) => console.error(`ContractManager: ${u.contract.script} left dark`, e)
+          );
+        }
+        throw err;
+      }
+      const fresh = upserted.filter((u) => u.persisted).map((u) => u.contract);
+      if (fresh.length > 0) {
+        try {
+          await this.fetchContractVxosFromIndexer(fresh);
+          this.markSyncOnline();
+        } catch (err) {
+          if (!isRetryableProviderError(err)) throw err;
+          this.markSyncDegraded(err);
+        }
+        for (const contract of fresh) await this.watcher.addContract(contract);
+      }
+      return upserted.map((u) => u.contract);
+    });
+  }
   /**
    * Lightweight variant of {@link createContract} for batch discovery
    * paths (currently: {@link scanContracts}). Validates, dedupes, persists,
@@ -10031,12 +10284,16 @@ var ContractManager = class _ContractManager {
   }
   async getContractsWithVtxos(filter, pageSize) {
     const contracts = await this.getContracts(filter);
-    try {
-      await this.syncContracts({ contracts, pageSize });
-      this.markSyncOnline();
-    } catch (err) {
-      if (!isRetryableProviderError(err)) throw err;
-      this.markSyncDegraded(err);
+    if (this.syncedWithin(contracts, this.config.vtxoSyncMaxAgeMs ?? 0)) {
+      await this.demoteFundedAwaitingContracts(contracts);
+    } else {
+      try {
+        await this.syncContracts({ contracts, pageSize });
+        this.markSyncOnline();
+      } catch (err) {
+        if (!isRetryableProviderError(err)) throw err;
+        this.markSyncDegraded(err);
+      }
     }
     const vtxos = await this.getVtxosForContracts(contracts);
     return contracts.map((contract) => ({
@@ -10398,6 +10655,18 @@ var ContractManager = class _ContractManager {
   async isWatching() {
     return this.watcher.isCurrentlyWatching();
   }
+  /** @see IContractManager.watchScript */
+  async watchScript(script, options) {
+    await this.watcher.addWatchedScript(script, options);
+  }
+  /** @see IContractManager.unwatchScript */
+  async unwatchScript(script) {
+    await this.watcher.removeWatchedScript(script);
+  }
+  /** @see IContractManager.getWatchedScripts */
+  async getWatchedScripts() {
+    return this.watcher.getWatchedScripts();
+  }
   /**
    * Emit an event to all registered callbacks.
    */
@@ -10418,11 +10687,15 @@ var ContractManager = class _ContractManager {
     try {
       switch (event.type) {
         // Delta-sync only the changed virtual outputs for this contract.
+        // The guard below is the ownership boundary: a watch-only script
+        // reports these same types, so it must precede `syncContracts`.
         case "vtxo_received":
+          if (!isContractVtxoEvent(event)) break;
           await this.syncContracts({ contracts: [event.contract] });
           this.markSyncOnline();
           break;
         case "vtxo_spent":
+          if (!isContractVtxoEvent(event)) break;
           await this.syncContracts({ contracts: [event.contract] });
           this.markSyncOnline();
           if (this.config.onVtxosSpent) {
@@ -10435,6 +10708,7 @@ var ContractManager = class _ContractManager {
           }
           break;
         case "connection_reset":
+          this.syncedAtByScript.clear();
           await this.scheduleLookAheadDrain();
           await this.reconcileWatched();
           this.markSyncOnline();
@@ -10481,9 +10755,21 @@ var ContractManager = class _ContractManager {
       const cutoff = cursorCutoff(requestStartedAt);
       await advanceSyncCursor(this.config.walletRepository, cutoff);
     }
+    if (options.window === void 0) {
+      for (const contract of contracts) {
+        this.syncedAtByScript.set(contract.script, requestStartedAt);
+      }
+    }
     await this.demoteFundedAwaitingContracts(contracts);
     return result;
   }
+  syncedWithin(contracts, maxAgeMs) {
+    if (maxAgeMs <= 0) return false;
+    const floor = Date.now() - maxAgeMs;
+    return contracts.every(
+      (contract) => (this.syncedAtByScript.get(contract.script) ?? 0) >= floor
+    );
+  }
   /**
    * Demote every `awaiting-funds` contract in `contracts` that has been
    * funded — the automatic half of {@link ContractWatchState}.
@@ -12889,7 +13175,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
     const vtxos = filterSnapshotVtxos(snapshot, filter, this._pendingSpendOutpoints);
     const { gated, pendingRecovery } = this.spendabilityView(snapshot);
     const selectable = vtxos.filter(
-      (vtxo) => !gated.has(vtxo.script) && !pendingRecovery.has(`${vtxo.txid}:${vtxo.vout}`)
+      (vtxo) => !isGatedVtxo(vtxo, gated) && !pendingRecovery.has(`${vtxo.txid}:${vtxo.vout}`)
     );
     const unlocked = await spendableVtxosExcludingLocked(selectable, this.intentRepository);
     logExcludedVtxos("getSpendableVtxos", vtxos, [
@@ -12987,7 +13273,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
    */
   spendabilityView(snapshot) {
     return {
-      gated: gatedContracts(snapshot.map((_) => _.contract)),
+      gated: gatedFrom(snapshot),
       pendingRecovery: this.selectPendingRecovery(snapshot)
     };
   }
@@ -13002,7 +13288,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
     return {
       now: { timestamp: /* @__PURE__ */ new Date() },
       isPendingRecovery: (vtxo) => pendingRecovery.has(`${vtxo.txid}:${vtxo.vout}`),
-      isGenericallySpendable: (vtxo) => !gated.has(vtxo.script),
+      isGenericallySpendable: (vtxo) => !isGatedVtxo(vtxo, gated),
       isUnlocked: (vtxo) => unlocked.has(`${vtxo.txid}:${vtxo.vout}`)
     };
   }
@@ -13042,16 +13328,18 @@ var ReadonlyWallet = class _ReadonlyWallet {
    * Return wallet transaction history derived from Arkade state and boarding transactions.
    */
   async getTransactionHistory() {
-    const contractManager = await this.getContractManager();
-    const response = await contractManager.getContractsWithVtxos();
-    const allVtxos = response.flatMap((_) => _.vtxos);
-    const { boardingTxs, commitmentsToIgnore } = await this.getBoardingTxs();
+    const [snapshot, { boardingTxs, commitmentsToIgnore }] = await Promise.all([
+      this.contractSnapshot(),
+      this.getBoardingTxs()
+    ]);
+    const allVtxos = snapshot.flatMap((_) => _.vtxos);
     const resolveTxCreatedAt = (txids) => fetchVtxoCreatedAtByTxid(this.indexerProvider, txids);
     return buildTransactionHistory(
       allVtxos,
       boardingTxs,
       commitmentsToIgnore,
-      resolveTxCreatedAt
+      resolveTxCreatedAt,
+      gatedFrom(snapshot)
     );
   }
   /**
@@ -13349,7 +13637,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
       const cm = await this.getContractManager();
       let annotationQueue = Promise.resolve();
       indexerStopFunc = cm.onContractEvent((event) => {
-        if (event.type !== "vtxo_received" && event.type !== "vtxo_spent") {
+        if (!isContractVtxoEvent(event)) {
           return;
         }
         if (event.contract.type !== "default" && event.contract.type !== "delegate") {
@@ -14411,7 +14699,10 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
         `restore: gapLimit must be a positive integer (got ${String(opts?.gapLimit)})`
       );
     }
-    this._restoreInFlight = this._runRestore(gapLimit).finally(() => {
+    this._restoreInFlight = (async () => {
+      await this._runRestore(gapLimit);
+      await runWalletRestoreHooks(this);
+    })().finally(() => {
       this._restoreInFlight = void 0;
     });
     return this._restoreInFlight;
@@ -17421,6 +17712,9 @@ var DelegateNotConfiguredError = class extends Error {
 };
 var DelegatorNotConfiguredError = DelegateNotConfiguredError;
 var DEFAULT_MESSAGE_TAG = "WALLET_UPDATER";
+function unsupportedByManager(method) {
+  return new Error(`Contract manager does not support ${method}`);
+}
 var serializeMigrationVtxoRef = (ref) => ({
   txid: ref.txid,
   vout: ref.vout,
@@ -17728,8 +18022,7 @@ var WalletMessageHandler = class {
           });
         }
         case "GET_TRANSACTION_HISTORY": {
-          const allVtxos = await this.getVtxosFromRepo();
-          const transactions = await this.buildTransactionHistoryFromCache(allVtxos) ?? [];
+          const transactions = await this.buildTransactionHistoryFromCache() ?? [];
           return this.tagged({
             id,
             type: "TRANSACTION_HISTORY",
@@ -17805,6 +18098,39 @@ var WalletMessageHandler = class {
             payload: { contracts }
           });
         }
+        case "WATCH_SCRIPT": {
+          const manager = await this.readonlyWallet.getContractManager();
+          if (!manager.watchScript) throw unsupportedByManager("watchScript");
+          await manager.watchScript(message.payload.script, {
+            label: message.payload.label
+          });
+          return this.tagged({
+            id,
+            type: "SCRIPT_WATCHED",
+            payload: { script: message.payload.script }
+          });
+        }
+        case "UNWATCH_SCRIPT": {
+          const manager = await this.readonlyWallet.getContractManager();
+          if (!manager.unwatchScript) throw unsupportedByManager("unwatchScript");
+          await manager.unwatchScript(message.payload.script);
+          return this.tagged({
+            id,
+            type: "SCRIPT_UNWATCHED",
+            payload: { script: message.payload.script }
+          });
+        }
+        case "GET_WATCHED_SCRIPTS": {
+          const manager = await this.readonlyWallet.getContractManager();
+          if (!manager.getWatchedScripts) {
+            throw unsupportedByManager("getWatchedScripts");
+          }
+          return this.tagged({
+            id,
+            type: "WATCHED_SCRIPTS",
+            payload: { scripts: await manager.getWatchedScripts() }
+          });
+        }
         case "ANNOTATE_VTXOS": {
           const manager = await this.readonlyWallet.getContractManager();
           const annotated = await manager.annotateVtxos(message.payload.vtxos);
@@ -18178,7 +18504,7 @@ var WalletMessageHandler = class {
         unconfirmed += utxo.value;
       }
     }
-    const gated = gatedContracts(snapshot.map((_) => _.contract));
+    const gated = gatedFrom(snapshot);
     const unlocked = new Set(
       (await spendableVtxosExcludingLocked(allVtxos, this.readonlyWallet?.intentRepository)).map((vtxo) => `${vtxo.txid}:${vtxo.vout}`)
     );
@@ -18186,7 +18512,7 @@ var WalletMessageHandler = class {
     const offchain = computeOffchainBalance(allVtxos, {
       now: { timestamp: /* @__PURE__ */ new Date() },
       isPendingRecovery: (vtxo) => pendingOutpoints.has(`${vtxo.txid}:${vtxo.vout}`),
-      isGenericallySpendable: (vtxo) => !gated.has(vtxo.script),
+      isGenericallySpendable: (vtxo) => !isGatedVtxo(vtxo, gated),
       isUnlocked: (vtxo) => unlocked.has(`${vtxo.txid}:${vtxo.vout}`)
     });
     return {
@@ -18326,7 +18652,6 @@ var WalletMessageHandler = class {
     if (!this.readonlyWallet || !this.walletRepository) {
       return;
     }
-    const vtxos = await this.getVtxosFromRepo();
     const boardingAddresses = await this.readonlyWallet.getBoardingAddresses();
     const fresh = await this.readonlyWallet.getBoardingUtxos();
     const freshKeys = new Set(fresh.map((u) => `${u.txid}:${u.vout}`));
@@ -18338,7 +18663,7 @@ var WalletMessageHandler = class {
       if (kept.length > 0) await this.walletRepository.saveUtxos(addr, kept);
     }
     const address = await this.readonlyWallet.getAddress();
-    const txs = await this.buildTransactionHistoryFromCache(vtxos);
+    const txs = await this.buildTransactionHistoryFromCache();
     if (txs) await this.walletRepository.saveTransactions(address, txs);
   }
   /**
@@ -18546,13 +18871,29 @@ var WalletMessageHandler = class {
   /**
    * Build transaction history from cached virtual outputs, hitting the indexer only for
    * uncached timestamps. Best-effort, like the plain Wallet path.
-   */
-  async buildTransactionHistoryFromCache(vtxos) {
+   *
+   * Takes its own {@link repoSnapshot} rather than a caller-supplied VTXO
+   * list: the coins and the gate that judges them have to come off one read
+   * or they answer about different instants, and being the worker's only
+   * history builder means neither caller can supply one without the other.
+   * The snapshot and the boarding read are independent, so they run together
+   * — the same pairing `handleGetBalance` makes.
+   */
+  async buildTransactionHistoryFromCache() {
     if (!this.readonlyWallet) return null;
-    const { boardingTxs, commitmentsToIgnore } = await this.readonlyWallet.getBoardingTxs();
+    const [{ snapshot, vtxos }, { boardingTxs, commitmentsToIgnore }] = await Promise.all([
+      this.repoSnapshot(),
+      this.readonlyWallet.getBoardingTxs()
+    ]);
     const indexerProvider = this.indexerProvider;
     const resolveTxCreatedAt = indexerProvider ? (txids) => fetchVtxoCreatedAtByTxid(indexerProvider, txids) : void 0;
-    return buildTransactionHistory(vtxos, boardingTxs, commitmentsToIgnore, resolveTxCreatedAt);
+    return buildTransactionHistory(
+      vtxos,
+      boardingTxs,
+      commitmentsToIgnore,
+      resolveTxCreatedAt,
+      gatedFrom(snapshot)
+    );
   }
   async ensureContractEventBroadcasting() {
     const wallet = this.readonlyWallet;
@@ -18608,6 +18949,7 @@ var DEFAULT_MESSAGE_TIMEOUTS = {
   GET_TRANSACTION_HISTORY: 2e4,
   GET_CONTRACTS: 2e4,
   GET_CONTRACTS_WITH_VTXOS: 2e4,
+  GET_WATCHED_SCRIPTS: 1e4,
   ANNOTATE_VTXOS: 2e4,
   GET_SPENDABLE_PATHS: 2e4,
   GET_ALL_SPENDING_PATHS: 2e4,
@@ -18644,6 +18986,10 @@ var DEFAULT_MESSAGE_TIMEOUTS = {
   SIGN_TRANSACTION: 3e4,
   CREATE_CONTRACT: 3e4,
   UPDATE_CONTRACT: 3e4,
+  // Registering a watch is an in-memory map write plus one subscription
+  // update — no indexer round trip on the request path.
+  WATCH_SCRIPT: 1e4,
+  UNWATCH_SCRIPT: 1e4,
   DELETE_CONTRACT: 1e4,
   REFRESH_VTXOS: 3e4,
   REFRESH_OUTPOINTS: 3e4
@@ -18664,6 +19010,7 @@ var DEDUPABLE_REQUEST_TYPES = /* @__PURE__ */ new Set([
   "GET_SPENDABLE_VTXOS",
   "GET_CONTRACTS",
   "GET_CONTRACTS_WITH_VTXOS",
+  "GET_WATCHED_SCRIPTS",
   "ANNOTATE_VTXOS",
   "GET_SPENDABLE_PATHS",
   "GET_ALL_SPENDING_PATHS",
@@ -19372,6 +19719,46 @@ var ServiceWorkerReadonlyWallet = class _ServiceWorkerReadonlyWallet {
           throw new Error("Failed to get contracts with vtxos");
         }
       },
+      async watchScript(script, options) {
+        const message = {
+          type: "WATCH_SCRIPT",
+          id: getRandomId(),
+          tag: messageTag,
+          payload: { script, label: options?.label }
+        };
+        try {
+          await sendContractMessage(message);
+        } catch (e) {
+          throw new Error("Failed to watch script");
+        }
+      },
+      async unwatchScript(script) {
+        const message = {
+          type: "UNWATCH_SCRIPT",
+          id: getRandomId(),
+          tag: messageTag,
+          payload: { script }
+        };
+        try {
+          await sendContractMessage(message);
+        } catch (e) {
+          throw new Error("Failed to unwatch script");
+        }
+      },
+      async getWatchedScripts() {
+        const message = {
+          type: "GET_WATCHED_SCRIPTS",
+          id: getRandomId(),
+          tag: messageTag,
+          payload: {}
+        };
+        try {
+          const response = await sendContractMessage(message);
+          return response.payload.scripts;
+        } catch (e) {
+          throw new Error("Failed to get watched scripts");
+        }
+      },
       getSyncState() {
         return syncState;
       },
@@ -19602,6 +19989,7 @@ var ServiceWorkerWallet = class _ServiceWorkerWallet extends ServiceWorkerReadon
   identity;
   _assetManager;
   hasDelegate;
+  _restoreInFlight;
   get assetManager() {
     return this._assetManager;
   }
@@ -19864,6 +20252,16 @@ var ServiceWorkerWallet = class _ServiceWorkerWallet extends ServiceWorkerReadon
    * reconstructed here so callers can inspect `.errors`.
    */
   async restore(opts) {
+    if (this._restoreInFlight) return this._restoreInFlight;
+    this._restoreInFlight = (async () => {
+      await this._restoreWorkerWallet(opts);
+      await runWalletRestoreHooks(this);
+    })().finally(() => {
+      this._restoreInFlight = void 0;
+    });
+    return this._restoreInFlight;
+  }
+  async _restoreWorkerWallet(opts) {
     const message = {
       id: getRandomId(),
       tag: this.messageTag,
@@ -21453,7 +21851,7 @@ var RestEmulatorProvider = class {
   serverUrl;
   async getInfo() {
     const url = `${this.serverUrl}/v1/info`;
-    const response = await fetch(url);
+    const response = await baseFetch(url);
     if (!response.ok) {
       const errorText2 = await response.text();
       throw new Error(`Failed to get emulator info: ${errorText2}`);
@@ -23888,6 +24286,6 @@ function createDefaultPaymentRouter(wallet) {
   (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 */
 
-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, ContractRepositoryImpl, ContractWatcher, DB_VERSION, DEFAULT_MESSAGE_TIMEOUTS, DEFAULT_MIN_BATCH_EXPIRY_SECONDS, DEFAULT_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, DatabaseUpgradeBlockedError, 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, PrevTxUnavailableError, 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, WalletCannotAllocateAddressError, WalletCannotSignError, WalletMessageHandler, WalletNotInitializedError, WalletRepositoryImpl, WsElectrumChainSource, adoptContractDescriptor, arkAssetRail, arkRail, arkTarget, arkade_exports, assertFinalCommitmentMatchesValidated, assertIntentIdUnique, assertNoAssets, assertSendableAmount, assertSubmittedArkTxid, assertValidBatchExpiry, assertValidServerUnrollScript, assetMintResolver, assetsOf, attachPrevArkTxs, attachPrevoutTxs, awaitTransaction, boardingResolver, btcTarget, buildForfeitTx, buildOffchainTx, buildPreimageMessage, buildSaltedPreimageMessage, claimWithPreimageIdentity, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, collabExitResolver, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, contractPreimage, contractSigner, createAssetPacket, createDefaultActivityRegistry, createDefaultPaymentRouter, createExitChainResolver, createManagedConnection, decodeArkContract, defaultBatchExpiryPolicy, defaultCheckpointExitDelayPolicy, deleteByIndex, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, exitObserverFor, extendVirtualCoinForContract, extractArkProviderUrl, gateExclusion, gatedContracts, getAllByIndexValues, getMigrationStatus, getRandomId, hasBoardingTxExpired, hasCandidates, intentMatchesFilter, intentPageBounds, invoiceTarget, isAddressAllocationCapable, 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, notifyExitObserved, onchainRail, openDatabase, outpointExclusion, outpointReasons, promisifyRequest, provisionClaimSecret, provisionRefundKey, requiresMigration, resolveAssetAmount, resolveBatchExpiryPolicy, resolveCheckpointExitDelayPolicy, resolveDescriptorSigner, resolvePrevTxs, resolveSendAmount, rollbackMigration, saveVtxosForContract, scriptFromArkAddress, selectCoinsWithAsset, selectVirtualCoins, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signAndSubmitOffchainTx, signerSetFromInfo, signingDescriptorIndex, strictSigningDescriptorIndex, toXOnlySignerHex, tryResolveSendAmount, validateBatchRecipients, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, walletFeeSource, warnAndFilterVtxosForScript, withPrevTxs };
-//# sourceMappingURL=chunk-JVHO6XHG.js.map
-//# sourceMappingURL=chunk-JVHO6XHG.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, ContractRepositoryImpl, ContractWatcher, DB_VERSION, DEFAULT_MESSAGE_TIMEOUTS, DEFAULT_MIN_BATCH_EXPIRY_SECONDS, DEFAULT_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, DatabaseUpgradeBlockedError, 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, PrevTxUnavailableError, 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, WalletCannotAllocateAddressError, WalletCannotSignError, WalletMessageHandler, WalletNotInitializedError, WalletRepositoryImpl, WsElectrumChainSource, adoptContractDescriptor, arkAssetRail, arkRail, arkTarget, arkade_exports, assertFinalCommitmentMatchesValidated, assertIntentIdUnique, assertNoAssets, assertSendableAmount, assertSubmittedArkTxid, assertValidBatchExpiry, assertValidServerUnrollScript, assetMintResolver, assetsOf, attachPrevArkTxs, attachPrevoutTxs, awaitTransaction, boardingResolver, btcTarget, buildForfeitTx, buildOffchainTx, buildPreimageMessage, buildSaltedPreimageMessage, claimWithPreimageIdentity, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, collabExitResolver, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, contractPreimage, contractSigner, createAssetPacket, createDefaultActivityRegistry, createDefaultPaymentRouter, createExitChainResolver, createManagedConnection, decodeArkContract, defaultBatchExpiryPolicy, defaultCheckpointExitDelayPolicy, deleteByIndex, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, exitObserverFor, extendVirtualCoinForContract, extractArkProviderUrl, gateExclusion, gatedContracts, getAllByIndexValues, getMigrationStatus, getRandomId, hasBoardingTxExpired, hasCandidates, intentMatchesFilter, intentPageBounds, invoiceTarget, isAddressAllocationCapable, isArkContract, isBatchSignable, isBtcAddress, isContractGenericallySpendable, isContractVtxoEvent, isCooperativelyMigratable, isDeterministicSigner, isDiscoverable, isHDAllocationCapable, isHDDeterministicSignCapable, isHDWalletCapable, isLightningInvoice, isLnurl, isMessageBusInitializingError, isMessageBusNotInitializedError, isPerArtifactDescriptor, isSigningIdentity, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, isVtxoForScript, isWatchedContract, logExcludedVtxos, makeHandle, matchServerCheckpoints, mergeChainedTxType, migrateWalletRepository, notifyExitObserved, onchainRail, openDatabase, outpointExclusion, outpointReasons, promisifyRequest, provisionClaimSecret, provisionRefundKey, registerWalletRestoreHook, requiresMigration, resolveAssetAmount, resolveBatchExpiryPolicy, resolveCheckpointExitDelayPolicy, resolveDescriptorSigner, resolvePrevTxs, resolveSendAmount, rollbackMigration, saveVtxosForContract, scriptFromArkAddress, selectCoinsWithAsset, selectVirtualCoins, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signAndSubmitOffchainTx, signerSetFromInfo, signingDescriptorIndex, strictSigningDescriptorIndex, toXOnlySignerHex, tryResolveSendAmount, validateBatchRecipients, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, walletFeeSource, warnAndFilterVtxosForScript, withPrevTxs };
+//# sourceMappingURL=chunk-BHLYB44A.js.map
+//# sourceMappingURL=chunk-BHLYB44A.js.map