@xyo-network/chain-sdk 4.1.0 → 4.2.1

package/dist/neutral/ethereum.mjs

@@ -198,6 +198,59 @@ async function estimateBlockNumberAt(provider, targetDate = DEFAULT_ESTIMATE_BLO
   return estimateBlockNumberFromHead(head.number, head.timestamp, targetDate, avgBlockTimeSec);
 }
 
+// src/modules/ethereum/block/findContractDeploymentBlock.ts
+var deploymentBlockSearches = /* @__PURE__ */ new WeakMap();
+async function findContractDeploymentBlock(provider, address) {
+  let byAddress = deploymentBlockSearches.get(provider);
+  if (byAddress === void 0) {
+    byAddress = /* @__PURE__ */ new Map();
+    deploymentBlockSearches.set(provider, byAddress);
+  }
+  const key = address.toLowerCase();
+  const existing = byAddress.get(key);
+  if (existing !== void 0) return await existing;
+  const search = searchDeploymentBlock(provider, address);
+  byAddress.set(key, search);
+  const result = await search;
+  if (result === void 0) byAddress.delete(key);
+  return result;
+}
+function configuredDeploymentBlock(config) {
+  const chain = config?.chain;
+  const value = chain?.deploymentBlock;
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+}
+async function resolveContractDeploymentBlock(provider, address, logger) {
+  const found = await findContractDeploymentBlock(provider, address);
+  if (found !== void 0) {
+    logger?.log(`Resolved deployment block ${found} for ${address} via getCode search`);
+    return found;
+  }
+  const estimated = await estimateBlockNumberAt(provider);
+  logger?.warn(`Could not resolve deployment block for ${address} via getCode search; using date estimate ${estimated}`);
+  return estimated;
+}
+async function searchDeploymentBlock(provider, address) {
+  try {
+    const head = await provider.getBlockNumber();
+    if (await provider.getCode(address, head) === "0x") return void 0;
+    let lo = 0;
+    let hi = head;
+    while (lo < hi) {
+      const mid = Math.floor((lo + hi) / 2);
+      const code = await provider.getCode(address, mid);
+      if (code === "0x") {
+        lo = mid + 1;
+      } else {
+        hi = mid;
+      }
+    }
+    return lo;
+  } catch {
+    return void 0;
+  }
+}
+
 // src/modules/ethereum/block/rate/blockRate.ts
 import { isDefined, isFalsy } from "@ariestools/sdk";
 import {
@@ -451,20 +504,17 @@ async function createChain(signer, stakingTokenAddress, initialBlockProducer, re
 // src/modules/ethereum/drivers/EvmStakeEventsViewer.ts
 import {
   assertEx as assertEx10,
-  exists,
   isDefined as isDefined3,
-  toAddress as toAddress3,
-  toEthAddress as toEthAddress8
+  toAddress as toAddress3
 } from "@ariestools/sdk";
-import {
-  IAddressStakingEvents__factory
-} from "@xyo-network/typechain";
+import { IAddressStakingEvents__factory } from "@xyo-network/typechain";
 import {
   creatableProvider as creatableProvider4,
   EvmChainViewerMoniker as EvmChainViewerMoniker4,
   StakeEventsViewerMoniker
 } from "@xyo-network/xl1-sdk";
 import { asAttoXL1 } from "@xyo-network/xl1-sdk";
+import { EventLog } from "ethers";
 
 // src/modules/ethereum/providers/AbstractEvmProvider.ts
 import {
@@ -702,6 +752,56 @@ EvmStakeTotalsViewer = __decorateClass([
   creatableProvider3()
 ], EvmStakeTotalsViewer);
 
+// src/modules/ethereum/rpc/isRpcRangeLimitError.ts
+function collectErrorTexts(error) {
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [error];
+  const texts = [];
+  while (queue.length > 0) {
+    const current = queue.pop();
+    if (current === void 0 || current === null || seen.has(current)) {
+      continue;
+    }
+    seen.add(current);
+    if (typeof current === "string") {
+      texts.push(current);
+      continue;
+    }
+    if (typeof current !== "object") {
+      continue;
+    }
+    if (Array.isArray(current)) {
+      const items = current;
+      queue.push(...items);
+      continue;
+    }
+    const record = current;
+    for (const key of ["message", "shortMessage", "reason", "error", "info", "data", "value", "body", "payload"]) {
+      if (key in record) {
+        queue.push(record[key]);
+      }
+    }
+  }
+  return texts;
+}
+function matchesRangeLimitText(text) {
+  const normalized = text.toLowerCase();
+  return /range \d+ exceeds limit/.test(normalized) || /exceeds? (?:the )?max(?:imum)? (?:block )?range/.test(normalized) || normalized.includes("block range is too") || normalized.includes("log response size exceeded") || normalized.includes("query returned more than") || normalized.includes("response size exceeded") || /getlogs (?:is )?limited to/.test(normalized);
+}
+function isRpcRangeLimitError(error) {
+  return collectErrorTexts(error).some((text) => matchesRangeLimitText(text));
+}
+function rpcRangeLimitFromError(error) {
+  for (const text of collectErrorTexts(error)) {
+    const match = /(?:exceeds )?limit(?:ed)? (?:of|to) (\d+)/i.exec(text);
+    if (match !== null) {
+      const limit = Number(match[1]);
+      if (Number.isSafeInteger(limit) && limit > 0) return limit;
+    }
+  }
+  return void 0;
+}
+
 // src/modules/ethereum/rpc/withRpcRateLimitBackoff.ts
 import { delay } from "@ariestools/sdk";
 
@@ -844,19 +944,26 @@ var asEvmStakeWithdrawnEvent = zodAsFactory(EvmStakeWithdrawnEventZod, "asEvmSta
 var toEvmStakeWithdrawnEvent = zodToFactory(EvmStakeWithdrawnEventZod, "toEvmStakeWithdrawnEvent");
 
 // src/modules/ethereum/drivers/EvmStakeEventsViewer.ts
-var DEFAULT_EVENT_QUERY_BLOCK_CHUNK_SIZE = 2e3;
+var DEFAULT_EVENT_QUERY_START_CHUNK_SIZE = 1e5;
+var MIN_EVENT_QUERY_BLOCK_CHUNK_SIZE = 1e3;
 var DEFAULT_EVENT_QUERY_MAX_ATTEMPTS = 8;
 var DEFAULT_EVENT_QUERY_INITIAL_DELAY_MS = 1e3;
+var STAKE_EVENT_NAMES = /* @__PURE__ */ new Set(["StakeAdded", "StakeRemoved", "StakeWithdrawn"]);
 var EvmStakeEventsViewer = class extends AbstractEvmViewer {
   moniker = EvmStakeEventsViewer.defaultMoniker;
-  /** Set at start when `params.deploymentBlock` is omitted (estimated 2025-06-01). */
+  /**
+   * Current adaptive chunk size — shrinks when the provider rejects a range
+   * and persists across loads so the tail catch-up reuses the learned limit.
+   */
+  adaptiveChunkSize;
+  /** Set at start when `params.deploymentBlock` is omitted (getCode binary search, date-estimate fallback). */
   defaultDeploymentBlock = 0;
   eventCache = /* @__PURE__ */ new Map();
   get deploymentBlock() {
-    return this.params.deploymentBlock ?? this.defaultDeploymentBlock;
+    return this.params.deploymentBlock ?? this.config.chain?.deploymentBlock ?? this.defaultDeploymentBlock;
   }
   get eventQueryBlockChunkSize() {
-    return this.params.eventQueryBlockChunkSize ?? DEFAULT_EVENT_QUERY_BLOCK_CHUNK_SIZE;
+    return this.fixedEventQueryBlockChunkSize ?? this.adaptiveChunkSize ?? DEFAULT_EVENT_QUERY_START_CHUNK_SIZE;
   }
   get eventQueryInitialDelayMs() {
     return this.params.eventQueryInitialDelayMs ?? DEFAULT_EVENT_QUERY_INITIAL_DELAY_MS;
@@ -864,6 +971,15 @@ var EvmStakeEventsViewer = class extends AbstractEvmViewer {
   get eventQueryMaxAttempts() {
     return this.params.eventQueryMaxAttempts ?? DEFAULT_EVENT_QUERY_MAX_ATTEMPTS;
   }
+  /**
+   * Fixed eth_getLogs range: explicit param (deprecated), else the bound evm-rpc
+   * connection profile's `eventQueryBlockChunkSize`. Undefined → adaptive sizing.
+   */
+  get fixedEventQueryBlockChunkSize() {
+    if (isDefined3(this.params.eventQueryBlockChunkSize)) return this.params.eventQueryBlockChunkSize;
+    const bound = this.boundConnection;
+    return bound?.config.type === "evm-rpc" ? bound.config.eventQueryBlockChunkSize : void 0;
+  }
   async positionCount(range) {
     const events = await this.stakeEvents(range);
     const positionIds = events.map((e) => e.args.id);
@@ -928,7 +1044,7 @@ var EvmStakeEventsViewer = class extends AbstractEvmViewer {
       const provider = assertEx10(this.contract.runner?.provider, () => new Error("Failed to get provider"));
       const historyEndBlock = assertEx10(await provider.getBlockNumber(), () => new Error("Failed to get currentEthBlock"));
       if (!isDefined3(this.params.deploymentBlock)) {
-        this.defaultDeploymentBlock = await estimateBlockNumberAt(provider);
+        this.defaultDeploymentBlock = configuredDeploymentBlock(this.config) ?? await resolveContractDeploymentBlock(provider, this.address, this.logger);
       }
       await this.loadHistoricalEvents(this.deploymentBlock, historyEndBlock);
       await this.attachLiveListeners();
@@ -952,69 +1068,71 @@ var EvmStakeEventsViewer = class extends AbstractEvmViewer {
       this.onEventHandler(staked, staker, id, amount, event);
     });
   }
+  /**
+   * Loads all stake events for the range with a single address-only sweep —
+   * one eth_getLogs pass per chunk covers all three event types (demuxed by
+   * event name client-side) instead of three filtered sweeps over the same
+   * blocks. Chunk size adapts to the provider: on a range/result-limit error
+   * the chunk shrinks (to the advertised limit when the error states one,
+   * halving otherwise) and the window is retried; rate limits retry at the
+   * same size with backoff.
+   */
   async loadHistoricalEvents(fromBlock, toBlock) {
     if (fromBlock > toBlock) {
       return;
     }
-    const stakeEventGroups = await Promise.all([
-      this.stakeEventsNative([fromBlock, toBlock], { name: "StakeAdded" }),
-      this.stakeEventsNative([fromBlock, toBlock], { name: "StakeRemoved" }),
-      this.stakeEventsNative([fromBlock, toBlock], { name: "StakeWithdrawn" })
-    ]);
-    const allStakeEvents = stakeEventGroups.flat().toSorted((a, b) => a.time - b.time);
-    const chunks = blockRangeChunks(fromBlock, toBlock, this.eventQueryBlockChunkSize);
-    this.logger?.log(
-      `Cached ${allStakeEvents.length} stake events from blocks ${fromBlock}-${toBlock} (${chunks.length} chunk(s) of up to ${this.eventQueryBlockChunkSize} blocks)`
-    );
-    for (const event of allStakeEvents) {
-      this.eventCache.set(`${Number(event.args.id)}|${event.name}|${event.args.staker}`, event);
-    }
-  }
-  async stakeEventsNative(range = [0, "latest"], filter) {
-    const name = filter?.name;
-    if (!isDefined3(name)) {
-      throw new Error("Only filtered stake events (by name) are supported");
-    }
-    const stakedFilter = filter?.args?.staked;
-    const stakerFilter = filter?.args?.staker;
-    const stakedFilterEth = isDefined3(stakedFilter) ? toEthAddress8(stakedFilter) : void 0;
-    const stakerFilterEth = isDefined3(stakerFilter) ? toEthAddress8(stakerFilter) : void 0;
-    const ethFilter = this.contract.filters[name](stakedFilterEth, stakerFilterEth);
-    const fromBlock = range[0];
-    const toBlock = range[1] === "latest" ? assertEx10(await this.contract.runner?.provider?.getBlockNumber(), () => new Error("Failed to resolve latest block")) : range[1];
-    if (fromBlock > toBlock) {
-      return [];
-    }
-    const chunkSize = this.eventQueryBlockChunkSize;
-    const chunks = blockRangeChunks(fromBlock, toBlock, chunkSize);
-    const ethEventGroups = [];
-    for (const [chunkFrom, chunkTo] of chunks) {
+    let eventCount = 0;
+    let chunkCount = 0;
+    let cursor = fromBlock;
+    while (cursor <= toBlock) {
+      const chunkSize = this.eventQueryBlockChunkSize;
+      const chunkTo = Math.min(cursor + chunkSize - 1, toBlock);
+      let logs;
       try {
-        ethEventGroups.push(await withRpcRateLimitBackoff(
-          () => this.contract.queryFilter(ethFilter, chunkFrom, chunkTo),
+        logs = await withRpcRateLimitBackoff(
+          // '*' = every event on the contract address; parsed against the ABI
+          () => this.contract.queryFilter("*", cursor, chunkTo),
           {
             initialDelayMs: this.eventQueryInitialDelayMs,
             maxAttempts: this.eventQueryMaxAttempts,
             onRetry: (_error, attempt, delayMs) => {
               this.logger?.warn(
-                `Rate limited fetching ${name} logs for blocks ${chunkFrom}-${chunkTo} (attempt ${attempt}/${this.eventQueryMaxAttempts}); backing off ${delayMs}ms`
+                `Rate limited fetching logs for blocks ${cursor}-${chunkTo} (attempt ${attempt}/${this.eventQueryMaxAttempts}); backing off ${delayMs}ms`
               );
             }
           }
-        ));
+        );
       } catch (error) {
+        const isFixedSize = isDefined3(this.fixedEventQueryBlockChunkSize);
+        if (!isFixedSize && isRpcRangeLimitError(error) && chunkSize > MIN_EVENT_QUERY_BLOCK_CHUNK_SIZE) {
+          const advertised = rpcRangeLimitFromError(error);
+          const nextSize = Math.max(
+            MIN_EVENT_QUERY_BLOCK_CHUNK_SIZE,
+            Math.min(advertised ?? Number.MAX_SAFE_INTEGER, Math.floor(chunkSize / 2))
+          );
+          this.adaptiveChunkSize = nextSize;
+          this.logger?.log(`eth_getLogs rejected a ${chunkSize}-block range; retrying at ${nextSize}`);
+          continue;
+        }
         this.logger?.error(
-          `eth_getLogs failed for ${name} blocks ${chunkFrom}-${chunkTo} after rate-limit retries (from=${fromBlock} to=${toBlock}):`,
+          `eth_getLogs failed for blocks ${cursor}-${chunkTo} (from=${fromBlock} to=${toBlock}):`,
           error
         );
         throw error;
       }
+      chunkCount++;
+      for (const log of logs) {
+        if (log instanceof EventLog && STAKE_EVENT_NAMES.has(log.eventName)) {
+          const [staked, by, id, amount] = log.args;
+          const event = this.onEventHandler(staked, by, id, amount, log, true);
+          if (event !== void 0) eventCount++;
+        }
+      }
+      cursor = chunkTo + 1;
     }
-    const ethEvents = ethEventGroups.flat();
-    return ethEvents.map((e) => {
-      assertEx10(e.eventName === name, () => `Event name mismatch expected '${name}' but got '${e.eventName}'`);
-      return this.onEventHandler(e.args.staked, e.args.by, e.args.id, e.args.amount, e, true);
-    }).filter(exists);
+    this.logger?.log(
+      `Cached ${eventCount} stake events from blocks ${fromBlock}-${toBlock} (${chunkCount} chunk(s), final chunk size ${this.eventQueryBlockChunkSize})`
+    );
   }
 };
 __publicField(EvmStakeEventsViewer, "connectionTypes", ["evm-rpc"]);
@@ -1029,9 +1147,8 @@ EvmStakeEventsViewer = __decorateClass([
 // src/modules/ethereum/drivers/EvmStakeViewer.ts
 import {
   assertEx as assertEx11,
-  isDefined as isDefined4,
   toAddress as toAddress4,
-  toEthAddress as toEthAddress9
+  toEthAddress as toEthAddress8
 } from "@ariestools/sdk";
 import { IAddressStaking__factory } from "@xyo-network/typechain";
 import {
@@ -1070,12 +1187,12 @@ var EvmStakeViewer = class extends AbstractEvmViewer {
   }
   async activeByAddressStaked(address) {
     return await this._callMutex.runExclusive(async () => {
-      return await this.contract.activeByAddressStaked(toEthAddress9(address));
+      return await this.contract.activeByAddressStaked(toEthAddress8(address));
     });
   }
   async activeByStaker(address) {
     return await this._callMutex.runExclusive(async () => {
-      return await this.contract.activeByStaker(toEthAddress9(address));
+      return await this.contract.activeByStaker(toEthAddress8(address));
     });
   }
   activeStakes() {
@@ -1084,7 +1201,7 @@ var EvmStakeViewer = class extends AbstractEvmViewer {
   async createHandler() {
     await super.createHandler();
     this._stakeEventsViewer = await this.locator.getInstance(StakeEventsViewerMoniker2);
-    this._deploymentBlock = isDefined4(this.params.deploymentBlock) ? this.params.deploymentBlock : await estimateBlockNumberAt(this.provider);
+    this._deploymentBlock = this.params.deploymentBlock ?? configuredDeploymentBlock(this.config) ?? await resolveContractDeploymentBlock(this.provider, this.address, this.logger);
   }
   minWithdrawalBlocks() {
     return 0;
@@ -1096,7 +1213,7 @@ var EvmStakeViewer = class extends AbstractEvmViewer {
   }
   async pendingByStaker(staker) {
     return await this._callMutex.runExclusive(async () => {
-      return await this.contract.pendingByStaker(toEthAddress9(staker));
+      return await this.contract.pendingByStaker(toEthAddress8(staker));
     });
   }
   removedStakes() {
@@ -1121,7 +1238,7 @@ var EvmStakeViewer = class extends AbstractEvmViewer {
   }
   async stakeByStaker(staker, slot) {
     return await this._callMutex.runExclusive(async () => {
-      const ethResult = await this.contract.getStake(toEthAddress9(staker), slot);
+      const ethResult = await this.contract.getStake(toEthAddress8(staker), slot);
       const stake = ethStakeToStake(ethResult);
       this._stakeCache.set(stake.id, stake);
       return stake;
@@ -1163,7 +1280,7 @@ var EvmStakeViewer = class extends AbstractEvmViewer {
   }
   async withdrawnByStaker(staker) {
     return await this._callMutex.runExclusive(async () => {
-      return await this.contract.withdrawnByStaker(toEthAddress9(staker));
+      return await this.contract.withdrawnByStaker(toEthAddress8(staker));
     });
   }
   withdrawnStakes() {
@@ -1243,7 +1360,7 @@ var EvmStakeViewer = class extends AbstractEvmViewer {
 };
 __publicField(EvmStakeViewer, "connectionTypes", ["evm-rpc"]);
 __publicField(EvmStakeViewer, "defaultMoniker", StakeViewerMoniker);
-__publicField(EvmStakeViewer, "dependencies", [EvmChainViewerMoniker5]);
+__publicField(EvmStakeViewer, "dependencies", [EvmChainViewerMoniker5, StakeEventsViewerMoniker2]);
 __publicField(EvmStakeViewer, "monikers", [StakeViewerMoniker]);
 __publicField(EvmStakeViewer, "surface", "node");
 EvmStakeViewer = __decorateClass([
@@ -1259,19 +1376,234 @@ var getDefaultGasConfig = () => {
     gasPrice: parseUnits2("100", "gwei")
   };
 };
+
+// src/modules/ethereum/indexing/EvmEventIndexModel.ts
+import {
+  EthAddressZod as EthAddressZod2,
+  HexRegExMinMaxMixedCaseWithPrefix as HexRegExMinMaxMixedCaseWithPrefix2,
+  zodAsFactory as zodAsFactory2
+} from "@ariestools/sdk";
+import { z as z2 } from "zod/mini";
+var EvmHashZod = z2.string().check(z2.regex(HexRegExMinMaxMixedCaseWithPrefix2(32, 32)));
+var EvmDataZod = z2.string().check(z2.regex(/^0x[\dA-Fa-f]*$/));
+var EvmEventIndexLogZod = z2.object({
+  address: EthAddressZod2,
+  blockHash: EvmHashZod,
+  blockNumber: z2.number(),
+  data: EvmDataZod,
+  index: z2.number(),
+  topics: z2.array(EvmHashZod),
+  transactionHash: EvmHashZod,
+  transactionIndex: z2.number()
+});
+var EvmEventIndexFrameZod = z2.object({
+  fromBlock: z2.number(),
+  logs: z2.array(EvmEventIndexLogZod),
+  toBlock: z2.number()
+});
+var EvmEventIndexManifestZod = z2.object({
+  address: EthAddressZod2,
+  chainId: z2.string(),
+  deploymentBlock: z2.number(),
+  frameSize: z2.number(),
+  layout: z2.literal("evm-contract-events-v1")
+});
+var EvmEventIndexHeadZod = z2.object({
+  address: EthAddressZod2,
+  block: z2.number(),
+  chainId: z2.string(),
+  hash: EvmHashZod
+});
+var asEvmEventIndexFrame = zodAsFactory2(EvmEventIndexFrameZod, "asEvmEventIndexFrame");
+var asEvmEventIndexHead = zodAsFactory2(EvmEventIndexHeadZod, "asEvmEventIndexHead");
+var asEvmEventIndexManifest = zodAsFactory2(EvmEventIndexManifestZod, "asEvmEventIndexManifest");
+
+// src/modules/ethereum/indexing/EvmEventIndexPaths.ts
+function root(address) {
+  return `evm/events/${address.toLowerCase()}`;
+}
+function evmEventIndexFramePath(address, frameIndex) {
+  return `${root(address)}/frames/${frameIndex}.json`;
+}
+function evmEventIndexHeadPath(address) {
+  return `${root(address)}/head.json`;
+}
+function evmEventIndexManifestPath(address) {
+  return `${root(address)}/manifest.json`;
+}
+function evmEventIndexTailPath(address) {
+  return `${root(address)}/tail.json`;
+}
+
+// src/modules/ethereum/indexing/EvmEventIndexPublishRunner.ts
+var EvmEventIndexPublishRunnerMoniker = "EvmEventIndexPublishRunner";
+
+// src/modules/ethereum/indexing/RestStakeEventsViewer.ts
+import {
+  assertEx as assertEx12,
+  isDefined as isDefined4,
+  toAddress as toAddress5,
+  toEthAddress as toEthAddress9
+} from "@ariestools/sdk";
+import { IAddressStakingEvents__factory as IAddressStakingEvents__factory2 } from "@xyo-network/typechain";
+import {
+  AbstractCreatableProvider as AbstractCreatableProvider2,
+  asAttoXL1 as asAttoXL13,
+  creatableProvider as creatableProvider6,
+  resolveRestConnectionEndpoint,
+  StakeEventsViewerMoniker as StakeEventsViewerMoniker3
+} from "@xyo-network/xl1-sdk";
+import { Interface } from "ethers";
+var STAKE_EVENT_NAMES2 = /* @__PURE__ */ new Set(["StakeAdded", "StakeRemoved", "StakeWithdrawn"]);
+var RestStakeEventsViewer = class extends AbstractCreatableProvider2 {
+  moniker = RestStakeEventsViewer.defaultMoniker;
+  completeFrames = /* @__PURE__ */ new Map();
+  contractInterface = new Interface(IAddressStakingEvents__factory2.abi);
+  currentHead;
+  manifestPromise;
+  stakeEventCache = [];
+  syncPromise;
+  tailFrame;
+  get address() {
+    return this.params.address;
+  }
+  get eventIndexBaseUrl() {
+    return this.params.eventIndexBaseUrl;
+  }
+  get fetchFn() {
+    return this.params.fetchFn ?? fetch.bind(globalThis);
+  }
+  static async paramsHandler(params) {
+    const contextConfig = params.context?.config;
+    const address = params.address ?? toEthAddress9(assertEx12(contextConfig?.chain?.id, () => "RestStakeEventsViewer requires an address param or config.chain.id"));
+    const moniker = this.defaultMoniker;
+    const eventIndexBaseUrl = isDefined4(params.eventIndexBaseUrl) && params.eventIndexBaseUrl !== "" ? params.eventIndexBaseUrl : resolveRestConnectionEndpoint(
+      assertEx12(contextConfig, () => "Context config is required to resolve the EVM event index endpoint"),
+      moniker
+    );
+    return {
+      ...await super.paramsHandler(params),
+      address,
+      eventIndexBaseUrl: eventIndexBaseUrl.replace(/\/+$/, ""),
+      fetchFn: params.fetchFn
+    };
+  }
+  async positionCount(range) {
+    const events = await this.stakeEvents(range);
+    return Math.max(-1, ...events.map((event) => event.args.id)) + 1;
+  }
+  async stakeEvents(range = [0, "latest"], filter) {
+    await this.sync();
+    return this.stakeEventCache.filter((event) => this.matchesFilter(event, range, filter));
+  }
+  decodeIndexedStakeEvents() {
+    const frames = [...this.completeFrames.entries()].sort(([a], [b]) => a - b).map(([, frame]) => frame);
+    const logs = [...frames, ...this.tailFrame === void 0 ? [] : [this.tailFrame]].flatMap((frame) => frame.logs).sort((a, b) => a.blockNumber - b.blockNumber || a.transactionIndex - b.transactionIndex || a.index - b.index);
+    return logs.flatMap((log) => {
+      const event = this.stakeEventFromLog(log);
+      return event === void 0 ? [] : [event];
+    });
+  }
+  async fetchJson(path) {
+    const response = await this.fetchFn(`${this.eventIndexBaseUrl}/${path}`);
+    assertEx12(response.ok, () => `EVM event index request failed [${response.status}] for ${path}`);
+    return await response.json();
+  }
+  async getManifest() {
+    this.manifestPromise ??= (async () => {
+      const manifest = asEvmEventIndexManifest(await this.fetchJson(evmEventIndexManifestPath(this.address)), true);
+      assertEx12(manifest.address.toLowerCase() === this.address.toLowerCase(), () => "EVM event index manifest address mismatch");
+      return manifest;
+    })();
+    return await this.manifestPromise;
+  }
+  // eslint-disable-next-line complexity
+  matchesFilter(event, range, filter) {
+    if (range[1] !== "latest" && event.time > range[1]) return false;
+    if (event.time < range[0]) return false;
+    if (isDefined4(filter?.name) && event.name !== filter.name) return false;
+    if (isDefined4(filter?.args?.id) && event.args.id !== filter.args.id) return false;
+    if (isDefined4(filter?.args?.staked) && event.args.staked !== filter.args.staked) return false;
+    if (isDefined4(filter?.args?.staker) && event.args.staker !== filter.args.staker) return false;
+    return true;
+  }
+  stakeEventFromLog(log) {
+    const parsed = this.contractInterface.parseLog({ data: log.data, topics: log.topics });
+    if (parsed === null || !STAKE_EVENT_NAMES2.has(parsed.name)) return;
+    const [staked, staker, id, amount] = parsed.args;
+    return {
+      name: parsed.name,
+      args: {
+        amount: asAttoXL13(amount),
+        id: Number(id),
+        staked: toAddress5(staked),
+        staker: toAddress5(staker)
+      },
+      time: log.blockNumber
+    };
+  }
+  async sync() {
+    this.syncPromise ??= this.syncFromHead().finally(() => {
+      this.syncPromise = void 0;
+    });
+    await this.syncPromise;
+  }
+  async syncFromHead() {
+    const manifest = await this.getManifest();
+    const head = asEvmEventIndexHead(await this.fetchJson(evmEventIndexHeadPath(this.address)), true);
+    assertEx12(head.address.toLowerCase() === this.address.toLowerCase(), () => "EVM event index head address mismatch");
+    assertEx12(head.chainId === manifest.chainId, () => "EVM event index chain mismatch");
+    if (this.currentHead?.block === head.block && this.currentHead.hash === head.hash) return;
+    if (this.currentHead !== void 0 && (head.block < this.currentHead.block || head.block === this.currentHead.block && head.hash !== this.currentHead.hash)) {
+      this.completeFrames.clear();
+      this.tailFrame = void 0;
+    }
+    const indexedBlockCount = Math.max(0, head.block - manifest.deploymentBlock + 1);
+    const completeFrameCount = Math.floor(indexedBlockCount / manifest.frameSize);
+    const missingFrameIndexes = Array.from({ length: completeFrameCount }, (_, index) => index).filter((index) => !this.completeFrames.has(index));
+    await Promise.all(missingFrameIndexes.map(async (index) => {
+      const frame = asEvmEventIndexFrame(await this.fetchJson(evmEventIndexFramePath(this.address, index)), true);
+      const expectedFrom = manifest.deploymentBlock + index * manifest.frameSize;
+      assertEx12(frame.fromBlock === expectedFrom, () => `EVM event index frame ${index} starts at the wrong block`);
+      assertEx12(frame.toBlock === expectedFrom + manifest.frameSize - 1, () => `EVM event index frame ${index} is incomplete`);
+      this.completeFrames.set(index, frame);
+    }));
+    const tailStart = manifest.deploymentBlock + completeFrameCount * manifest.frameSize;
+    this.tailFrame = tailStart <= head.block ? asEvmEventIndexFrame(await this.fetchJson(`${evmEventIndexTailPath(this.address)}?head=${head.hash}`), true) : void 0;
+    if (this.tailFrame !== void 0) {
+      assertEx12(this.tailFrame.fromBlock === tailStart, () => "EVM event index tail starts at the wrong block");
+      assertEx12(this.tailFrame.toBlock === head.block, () => "EVM event index tail is stale relative to its head");
+    }
+    this.stakeEventCache = this.decodeIndexedStakeEvents();
+    this.currentHead = head;
+  }
+};
+__publicField(RestStakeEventsViewer, "connectionTypes", ["rest"]);
+__publicField(RestStakeEventsViewer, "defaultMoniker", StakeEventsViewerMoniker3);
+__publicField(RestStakeEventsViewer, "dependencies", []);
+__publicField(RestStakeEventsViewer, "monikers", [StakeEventsViewerMoniker3]);
+__publicField(RestStakeEventsViewer, "surface", "node");
+RestStakeEventsViewer = __decorateClass([
+  creatableProvider6()
+], RestStakeEventsViewer);
 export {
   AbstractEvmProvider,
   AbstractEvmRunner,
   AbstractEvmViewer,
   BaseEthProvider,
   DEFAULT_ESTIMATE_BLOCK_DATE,
-  DEFAULT_EVENT_QUERY_BLOCK_CHUNK_SIZE,
   DEFAULT_EVENT_QUERY_INITIAL_DELAY_MS,
   DEFAULT_EVENT_QUERY_MAX_ATTEMPTS,
+  DEFAULT_EVENT_QUERY_START_CHUNK_SIZE,
   DEFAULT_EVM_BLOCK_TIME_SEC,
   EthHashRegEx,
   EthHashZod,
   EvmChainContractViewer,
+  EvmEventIndexFrameZod,
+  EvmEventIndexHeadZod,
+  EvmEventIndexLogZod,
+  EvmEventIndexManifestZod,
+  EvmEventIndexPublishRunnerMoniker,
   EvmStakeAddedEventNameZod,
   EvmStakeAddedEventZod,
   EvmStakeEventArgsZod,
@@ -1285,6 +1617,11 @@ export {
   EvmStakeViewer,
   EvmStakeWithdrawnEventNameZod,
   EvmStakeWithdrawnEventZod,
+  MIN_EVENT_QUERY_BLOCK_CHUNK_SIZE,
+  RestStakeEventsViewer,
+  asEvmEventIndexFrame,
+  asEvmEventIndexHead,
+  asEvmEventIndexManifest,
   asEvmStakeAddedEvent,
   asEvmStakeEvent,
   asEvmStakeRemovedEvent,
@@ -1292,23 +1629,34 @@ export {
   blockRangeChunks,
   calculateEthBlockRate,
   calculateEthTimeRate,
+  configuredDeploymentBlock,
   createChain,
   createChainContract,
   createChainRewardsContract,
   estimateBlockNumberAt,
   estimateBlockNumberFromHead,
   ethBlockRate,
+  evmEventIndexFramePath,
+  evmEventIndexHeadPath,
+  evmEventIndexManifestPath,
+  evmEventIndexTailPath,
+  findContractDeploymentBlock,
   getDefaultGasConfig,
   getEthBlockRateBlocks,
   isEvmStakeAddedEvent,
   isEvmStakeEvent,
   isEvmStakeRemovedEvent,
   isEvmStakeWithdrawnEvent,
+  isRpcRangeLimitError,
+  isRpcRateLimitError,
   nextContractAddress,
   nextContractAddressForAddress,
+  resolveContractDeploymentBlock,
+  rpcRangeLimitFromError,
   toEvmStakeAddedEvent,
   toEvmStakeEvent,
   toEvmStakeRemovedEvent,
-  toEvmStakeWithdrawnEvent
+  toEvmStakeWithdrawnEvent,
+  withRpcRateLimitBackoff
 };
 //# sourceMappingURL=ethereum.mjs.map