@arkade-os/sdk 0.4.48 → 0.4.49

package/dist/{chunk-NYR5H6GR.js → chunk-5QVBJUOG.js}

@@ -1,6 +1,6 @@
-import { Transaction, setArkPsbtField, PrevArkTxField, ConditionWitness, AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, craftToSpendTx, getArkPsbtFields, CosignerPublicKey, BufferReader, BufferWriter, OP_RETURN_EMPTY_PKSCRIPT, VtxoTaprootTree, baseFetch, Intent, rateGate, maybeArkError, isArkError, ArkErrorName, ProviderUnavailableError, FetchError, isFetchTimeoutError, AssetRef, isEventSourceError, RestArkProvider, RestIndexerProvider, ArkError } from './chunk-BHHLRZCS.js';
-import { witnessRefToBytes, validateProgram, toASM, stringifyArtifact, serializeArkadeContractParams, resolveAsm, parseArtifact, getOpcodeValue, getOpcodeName, fromASM, deserializeArkadeContractParams, computeArkadeScriptPublicKey, bytesToASM, asmToBytes, arkadeWitnessHash, arkadeScriptHash, SUPPORTED_PROGRAM_VERSION, OPCODE_VALUES, OPCODE_NAMES, bignum_exports, ArkadeScript, ArkadeProgramScript, ARKADE_OPS, ARKADE_OPCODE_VALUES, ARKADE_OPCODE_NAMES, ARKADE_OPCODES, ARKADE_OP, inputName, contractHandlers, isMainnetDescriptor, descriptorIsOurs, DefaultVtxo, DEFAULT_PAGE_SIZE, DelegateVtxo, WALLET_RECEIVE_SOURCE, deriveDescriptorLeafPubKey, BoardingContractHandler } from './chunk-4VVTRPH3.js';
-import { VtxoScript, isRecoverable, CSVMultisigTapscript, DEFAULT_NETWORK, hasTerminalSpend, getNormalizedVtxos, isVirtualCoin, ArkAddress, sequenceToTimelock, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, timelockToSequence, DEFAULT_NETWORK_NAME, normalizeVtxo, getSequence, toBatchExpiry, toOffchainInputFeeParams, canRecoverOnchain, getNetwork, MultisigTapscript, canSpendOffchain, toVirtualStatus, resolveTimeHeight, parseLegacyExpiry, networks as networks$1, isExpired, DEFAULT_ARKADE_SERVER_URL, isPastExpiry } from './chunk-ZDDBTFVO.js';
+import { Transaction, setArkPsbtField, PrevArkTxField, ConditionWitness, AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, craftToSpendTx, getArkPsbtFields, CosignerPublicKey, BufferReader, BufferWriter, OP_RETURN_EMPTY_PKSCRIPT, VtxoTaprootTree, baseFetch, Intent, rateGate, maybeArkError, isArkError, ArkErrorName, ProviderUnavailableError, FetchError, isFetchTimeoutError, AssetRef, isEventSourceError, RestArkProvider, RestIndexerProvider, ArkError } from './chunk-CPO2UB7L.js';
+import { witnessRefToBytes, validateProgram, toASM, stringifyArtifact, serializeArkadeContractParams, resolveAsm, parseArtifact, getOpcodeValue, getOpcodeName, fromASM, deserializeArkadeContractParams, computeArkadeScriptPublicKey, bytesToASM, asmToBytes, arkadeWitnessHash, arkadeScriptHash, SUPPORTED_PROGRAM_VERSION, OPCODE_VALUES, OPCODE_NAMES, bignum_exports, ArkadeScript, ArkadeProgramScript, ARKADE_OPS, ARKADE_OPCODE_VALUES, ARKADE_OPCODE_NAMES, ARKADE_OPCODES, ARKADE_OP, inputName, contractHandlers, isMainnetDescriptor, descriptorIsOurs, DefaultVtxo, DelegateVtxo, WALLET_RECEIVE_SOURCE, deriveDescriptorLeafPubKey, BoardingContractHandler } from './chunk-MBSYQ3WX.js';
+import { VtxoScript, isRecoverable, CSVMultisigTapscript, DEFAULT_NETWORK, hasTerminalSpend, getNormalizedVtxos, isVirtualCoin, ArkAddress, sequenceToTimelock, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, timelockToSequence, DEFAULT_NETWORK_NAME, normalizeVtxo, getSequence, toBatchExpiry, toOffchainInputFeeParams, canRecoverOnchain, getNetwork, MultisigTapscript, getAllNormalizedVtxos, DEFAULT_PAGE_SIZE, canSpendOffchain, toVirtualStatus, resolveTimeHeight, parseLegacyExpiry, networks as networks$1, isExpired, DEFAULT_ARKADE_SERVER_URL, isPastExpiry } from './chunk-EFNLTS6Q.js';
 import { __export } from './chunk-NSBPE2FW.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$2 } from '@scure/btc-signer';
@@ -8096,6 +8096,9 @@ var ContractWatcher = class {
   reconnectAttempts = 0;
   reconnectTimeoutId;
   failsafePollIntervalId;
+  /** See {@link withCoalescedSubscription}. */
+  subscriptionBatchDepth = 0;
+  subscriptionUpdateDeferred = false;
   /**
    * Create a contract watcher with the given providers and polling settings.
    *
@@ -8405,7 +8408,40 @@ var ContractWatcher = class {
       console.error("ContractWatcher poll failed:", error);
     }
   }
+  /**
+   * Run `fn` with subscription updates coalesced into a single
+   * `subscribeForScripts` on the way out.
+   *
+   * {@link addContract} re-subscribes eagerly (the watcher may already be
+   * running), and every subscribe posts the *whole* accumulated script list —
+   * so a restore scan that discovers N contracts sends N growing POSTs,
+   * quadratic in script-slots. Inside this scope those updates are only
+   * marked dirty, flushed once on the way out (success and error path alike).
+   *
+   * A contract added inside the scope is therefore not streaming until the
+   * flush. Nothing in the watcher closes that window — the failsafe poll
+   * replays repository state and cannot see VTXOs no one has fetched yet. The
+   * one caller, `scanContracts`, is covered because `Wallet.restore` follows
+   * it with a bulk `refreshVtxos`. A new caller must provide its own
+   * equivalent catch-up, or keep the scope short enough not to need one.
+   */
+  async withCoalescedSubscription(fn) {
+    this.subscriptionBatchDepth++;
+    try {
+      return await fn();
+    } finally {
+      this.subscriptionBatchDepth--;
+      if (this.subscriptionBatchDepth === 0 && this.subscriptionUpdateDeferred) {
+        this.subscriptionUpdateDeferred = false;
+        if (this.isWatching) await this.tryUpdateSubscription();
+      }
+    }
+  }
   async tryUpdateSubscription() {
+    if (this.subscriptionBatchDepth > 0) {
+      this.subscriptionUpdateDeferred = true;
+      return;
+    }
     const hadSubscription = this.subscriptionId !== void 0;
     try {
       await this.updateSubscription();
@@ -8886,21 +8922,27 @@ var ContractManager = class _ContractManager {
    * Safety-critical invariants (spec §2.C / §4):
    * - `opts.materialize(i)` throwing is structural/fatal: it is NOT
    *   wrapped — it propagates and aborts the scan.
-   * - A `discoverAt` rejection is collected into `handlerErrors` and makes
-   *   its index *indeterminate*: it does NOT advance the gap counter, and
-   *   the scan stops verifying there, reporting `truncatedAt`. Only an index
+   * - A discovery rejection is collected into `handlerErrors` and makes its
+   *   index *indeterminate*: it does NOT advance the gap counter, and the
+   *   scan stops verifying there, reporting `truncatedAt`. Only an index
    *   every handler answered for can be a confirmed miss.
    * - `persistAndWatchContract` rejecting is operational/fatal and
-   *   propagates (only `discoverAt` is guarded).
-   * - Within an index the handler probes run concurrently (independent
-   *   network reads); their hits are persisted sequentially in
-   *   `discoverables` order to preserve the first-wins collision tie-break.
-   * - Indices are probed `batchSize` at a time (a second concurrency layer
-   *   over the per-index probes), but each window is CAPPED to
+   *   propagates (only the handler calls are guarded).
+   * - A handler exposing {@link Discoverable.discoverRange} is asked for the
+   *   whole window in ONE call instead of one per index — the batching that
+   *   keeps a large restore from bursting into an operator's rate limiter.
+   *   Its failures are therefore range-wide: every index in the window goes
+   *   indeterminate and truncation lands on the window's first index. Its
+   *   answer must cover every requested index; an incomplete map is treated
+   *   as a rejection (see `Discoverable.discoverRange`).
+   * - Handlers are probed concurrently (independent network reads); their
+   *   hits are persisted sequentially in `discoverables` order to preserve
+   *   the first-wins collision tie-break.
+   * - Indices are probed `batchSize` at a time, but each window is CAPPED to
    *   `gapLimit - unused` indices — the most a serial scan could still reach
    *   before the gap window is guaranteed to close. So every index probed in
    *   a window is one a one-index-at-a-time scan would also reach: nothing is
-   *   over-scanned, nothing is discarded, and `materialize`/`discoverAt` are
+   *   over-scanned, nothing is discarded, and `materialize`/discovery are
    *   invoked on exactly the same index set. The window's hits are still
    *   processed strictly in ascending index order, so the discovered set,
    *   persisted rows, `highestConfirmedUsedIndex`, and `handlerErrors` are
@@ -8909,8 +8951,14 @@ var ContractManager = class _ContractManager {
    *   can surface hits above the failed index that a serial scan would never
    *   have reached, so a truncated batched scan discovers a superset — never
    *   a subset — of the serial one.
+   * - The whole scan runs inside one coalesced subscription scope, so N
+   *   discovered contracts cost ONE `subscribeForScripts` instead of N
+   *   growing ones (see {@link ContractWatcher.withCoalescedSubscription}).
    */
-  async scanContracts(opts) {
+  scanContracts(opts) {
+    return this.watcher.withCoalescedSubscription(() => this.runScan(opts));
+  }
+  async runScan(opts) {
     const gapLimit = opts.gapLimit ?? 20;
     if (!Number.isInteger(gapLimit) || gapLimit <= 0) {
       throw new Error(
@@ -8934,43 +8982,80 @@ var ContractManager = class _ContractManager {
     let truncatedAt;
     let unused = 0;
     let i = 0;
-    const probeIndex = async (index) => {
-      const descriptor = opts.materialize(index);
-      return Promise.all(
-        discoverables.map(async (h) => {
-          try {
-            return {
-              ok: true,
-              found: await h.discoverAt(index, descriptor, opts.deps)
-            };
-          } catch (error) {
-            return { ok: false, error };
-          }
-        })
-      );
+    const probeHandler = async (h, entries) => {
+      const probe = {
+        found: /* @__PURE__ */ new Map(),
+        indeterminate: /* @__PURE__ */ new Set(),
+        // Keyed by the index the failure is ANCHORED at, so errors stay
+        // reported in ascending-index order below, exactly as the
+        // per-index path reports them.
+        errors: /* @__PURE__ */ new Map()
+      };
+      if (!h.discoverRange) {
+        await Promise.all(
+          entries.map(async ({ index, descriptor }) => {
+            try {
+              probe.found.set(
+                index,
+                await h.discoverAt(index, descriptor, opts.deps)
+              );
+            } catch (error) {
+              probe.indeterminate.add(index);
+              probe.errors.set(index, { handler: h.type, index, error });
+            }
+          })
+        );
+        return probe;
+      }
+      const from = entries[0].index;
+      const to = entries[entries.length - 1].index;
+      const failRange = (error) => {
+        for (const e of entries) probe.indeterminate.add(e.index);
+        probe.errors.set(from, {
+          handler: h.type,
+          index: from,
+          ...to > from && { toIndex: to },
+          error
+        });
+      };
+      let ranged;
+      try {
+        ranged = await h.discoverRange(entries, opts.deps);
+      } catch (error) {
+        failRange(error);
+        return probe;
+      }
+      for (const e of entries) {
+        const found = ranged.get(e.index);
+        if (found) probe.found.set(e.index, found);
+      }
+      const missing = entries.find((e) => !ranged.has(e.index));
+      if (missing) {
+        failRange(
+          new Error(
+            `${h.type}.discoverRange resolved without index ${missing.index} of the requested range [${from}..${to}]`
+          )
+        );
+      }
+      return probe;
     };
     while (i <= maxIdx && unused < gapLimit) {
       const windowEnd = Math.min(maxIdx, i + Math.min(batchSize, gapLimit - unused) - 1);
-      const windowIndices = [];
-      for (let idx = i; idx <= windowEnd; idx++) windowIndices.push(idx);
-      const windowProbes = await Promise.all(windowIndices.map(probeIndex));
-      for (let w = 0; w < windowIndices.length; w++) {
-        const index = windowIndices[w];
-        const probes = windowProbes[w];
+      const entries = [];
+      for (let idx = i; idx <= windowEnd; idx++) {
+        entries.push({ index: idx, descriptor: opts.materialize(idx) });
+      }
+      const windowProbes = await Promise.all(
+        discoverables.map((h) => probeHandler(h, entries))
+      );
+      for (const { index } of entries) {
         let hitAtThisIndex = false;
         let indeterminate = false;
-        for (let h = 0; h < discoverables.length; h++) {
-          const probe = probes[h];
-          if (!probe.ok) {
-            handlerErrors.push({
-              handler: discoverables[h].type,
-              index,
-              error: probe.error
-            });
-            indeterminate = true;
-            continue;
-          }
-          for (const c of probe.found) {
+        for (const probe of windowProbes) {
+          const error = probe.errors.get(index);
+          if (error) handlerErrors.push(error);
+          if (probe.indeterminate.has(index)) indeterminate = true;
+          for (const c of probe.found.get(index) ?? []) {
             await this.persistAndWatchContract(c);
             hitAtThisIndex = true;
           }
@@ -9337,12 +9422,12 @@ var ContractManager = class _ContractManager {
    * window (e.g. a spend that hasn't settled yet).
    */
   async reconcilePendingFrontier(contracts) {
-    const scripts = contracts.map((c) => c.script);
     const scriptToContract = new Map(contracts.map((c) => [c.script, c]));
-    const { vtxos } = await getNormalizedVtxos(this.config.indexerProvider, {
-      scripts,
-      pendingOnly: true
-    });
+    const vtxos = await getAllNormalizedVtxos(
+      this.config.indexerProvider,
+      contracts.map((c) => c.script),
+      { pendingOnly: true }
+    );
     const owned = vtxos.filter((v) => scriptToContract.has(v.script));
     const annotated = await this.annotateVtxos(owned);
     const byContract = /* @__PURE__ */ new Map();
@@ -9418,7 +9503,6 @@ var ContractManager = class _ContractManager {
     const result = new Map(
       contracts.map((c) => [c.script, []])
     );
-    const scripts = contracts.map((c) => c.script);
     const windowOpts = syncWindow ? {
       ...syncWindow.after !== void 0 && {
         after: syncWindow.after
@@ -9427,26 +9511,18 @@ var ContractManager = class _ContractManager {
         before: syncWindow.before
       }
     } : {};
-    let pageIndex = 0;
-    let hasMore = true;
-    while (hasMore) {
-      const { vtxos, page } = await getNormalizedVtxos(this.config.indexerProvider, {
-        scripts,
-        ...windowOpts,
-        pageIndex,
-        pageSize
+    const vtxos = await getAllNormalizedVtxos(
+      this.config.indexerProvider,
+      contracts.map((c) => c.script),
+      { ...windowOpts, pageSize }
+    );
+    const owned = vtxos.filter((v) => scriptToContract.has(v.script));
+    const annotated = await this.annotateVtxos(owned);
+    for (const vtxo of annotated) {
+      result.get(vtxo.script).push({
+        ...vtxo,
+        contractScript: vtxo.script
       });
-      const owned = vtxos.filter((v) => scriptToContract.has(v.script));
-      const annotated = await this.annotateVtxos(owned);
-      for (const vtxo of annotated) {
-        result.get(vtxo.script).push({
-          ...vtxo,
-          contractScript: vtxo.script
-        });
-      }
-      hasMore = page ? vtxos.length === pageSize : false;
-      pageIndex++;
-      if (hasMore) await new Promise((r) => setTimeout(r, 500));
     }
     return result;
   }
@@ -11142,9 +11218,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
   /** Fetch Arkade transaction ids that are still pending final settlement. */
   async fetchPendingTxs() {
     const scripts = await this.getWalletScripts();
-    let { vtxos } = await getNormalizedVtxos(this.indexerProvider, {
-      scripts
-    });
+    const vtxos = await getAllNormalizedVtxos(this.indexerProvider, scripts);
     return vtxos.filter(
       (vtxo) => (vtxo.isSpent || vtxo.isPreconfirmed && !vtxo.isSwept) && vtxo.arkTxId !== void 0
     ).map((_) => _.arkTxId);
@@ -11820,7 +11894,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     if (hd && result.highestConfirmedUsedIndex >= 0) {
       await provider.advanceLastIndexUsed(result.highestConfirmedUsedIndex);
     }
-    await manager.refreshVtxos({ includeInactive: true });
+    await manager.refreshVtxos({ includeInactive: true, after: 0 });
     const causes = result.handlerErrors.map(
       (e) => e.error instanceof Error ? e.error : new Error(String(e.error))
     );
@@ -12728,10 +12802,9 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     if (!vtxos || vtxos.length === 0) {
       const scriptMap = await this.getScriptMap();
       const allExtended = [];
-      const allScripts = [...scriptMap.keys()];
-      const { vtxos: fetchedVtxos } = await getNormalizedVtxos(this.indexerProvider, {
-        scripts: allScripts
-      });
+      const fetchedVtxos = await getAllNormalizedVtxos(this.indexerProvider, [
+        ...scriptMap.keys()
+      ]);
       for (const vtxo of fetchedVtxos) {
         const vtxoScript = scriptMap.get(vtxo.script);
         if (!vtxoScript) continue;
@@ -19814,5 +19887,5 @@ function isArkContract(str) {
 }
 
 export { ARKADE_MAGIC, ActivityRegistry, ArkNote, ArkadeCash, ArkadeCashCreateError, AssetManager, BIP322, Batch, ChainedTxType, ContractManager, ContractRepositoryImpl, ContractWatcher, DB_VERSION, DEFAULT_MESSAGE_TIMEOUTS, DelegateManagerImpl, DelegateNotConfiguredError, DelegatorManagerImpl, DelegatorNotConfiguredError, DescriptorSigningProviderMissingError, DustChangeError, ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ESPLORA_URL, ElectrumOnchainProvider, EmulatorPacket, EsploraProvider, Estimator, Extension, ExtensionNotFoundError, HDDescriptorProvider, INTENT_TERMINAL_STATES, InMemoryContractRepository, InMemoryIntentRepository, InMemoryVirtualTxRepository, InMemoryWalletRepository, IndexedDBContractRepository, IndexedDBIntentRepository, IndexedDBVirtualTxRepository, IndexedDBWalletRepository, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, MIGRATION_KEY, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, P2A, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestDelegatorProvider, RestEmulatorProvider, SeedIdentity, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, TxTree, TxType, TxWeightEstimator, UnilateralExit, UnknownPacket, Unroll, VtxoManager, Wallet2 as Wallet, WalletMessageHandler, WalletNotInitializedError, WalletRepositoryImpl, WsElectrumChainSource, arkade_exports, assertIntentIdUnique, boardingResolver, buildForfeitTx, buildOffchainTx, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, createAssetPacket, createDefaultActivityRegistry, createExitChainResolver, decodeArkContract, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, extendVirtualCoinForContract, getMigrationStatus, getRandomId, hasBoardingTxExpired, intentMatchesFilter, intentPageBounds, isArkContract, isBatchSignable, isCooperativelyMigratable, isDiscoverable, isRetryableProviderError, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, isVtxoForScript, mergeChainedTxType, migrateWalletRepository, openDatabase, requiresMigration, rollbackMigration, saveVtxosForContract, scriptFromArkAddress, selectCoinsWithAsset, selectVirtualCoins, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signerSetFromInfo, toXOnlySignerHex, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, warnAndFilterVtxosForScript };
-//# sourceMappingURL=chunk-NYR5H6GR.js.map
-//# sourceMappingURL=chunk-NYR5H6GR.js.map
+//# sourceMappingURL=chunk-5QVBJUOG.js.map
+//# sourceMappingURL=chunk-5QVBJUOG.js.map