@xyo-network/chain-sdk 4.0.6 → 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 {
@@ -450,47 +503,66 @@ async function createChain(signer, stakingTokenAddress, initialBlockProducer, re
 
 // src/modules/ethereum/drivers/EvmStakeEventsViewer.ts
 import {
-  assertEx as assertEx8,
-  exists,
+  assertEx as assertEx10,
   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 { toEthAddress as toEthAddress4 } from "@ariestools/sdk";
+import {
+  assertEx as assertEx6,
+  toEthAddress as toEthAddress4
+} from "@ariestools/sdk";
 import { AbstractCreatableProvider } from "@xyo-network/xl1-sdk";
 var AbstractEvmProvider = class extends AbstractCreatableProvider {
   _contract;
+  _address;
+  get address() {
+    return assertEx6(this._address, () => "EVM contract address not initialized");
+  }
   get contract() {
     return this._contract;
   }
   async createHandler() {
     await super.createHandler();
-    this._contract = this.connectContract(toEthAddress4(this.params.address));
+    this._address = this.params.address ?? toEthAddress4(assertEx6(this.config?.chain?.id, () => "EVM provider requires an address param or config.chain.id"));
+    this._contract = this.connectContract(this._address);
   }
 };
 
 // src/modules/ethereum/providers/AbstractEvmRunner.ts
-import { assertEx as assertEx6 } from "@ariestools/sdk";
+import { assertEx as assertEx8 } from "@ariestools/sdk";
 
 // src/modules/ethereum/providers/AbstractEvmViewer.ts
+import { assertEx as assertEx7 } from "@ariestools/sdk";
+import { EvmChainViewerMoniker } from "@xyo-network/xl1-sdk";
 var AbstractEvmViewer = class extends AbstractEvmProvider {
+  _provider;
+  get provider() {
+    return assertEx7(this.params.provider ?? this._provider, () => "EVM provider not initialized");
+  }
+  async createHandler() {
+    if (this.params.provider === void 0) {
+      const evmChainViewer = await this.locateAndCreate(EvmChainViewerMoniker);
+      this._provider = await evmChainViewer.provider();
+    }
+    await super.createHandler();
+  }
 };
 
 // src/modules/ethereum/providers/AbstractEvmRunner.ts
 var AbstractEvmRunner = class extends AbstractEvmViewer {
   static async paramsHandler(params) {
-    const runner = assertEx6(params?.runner, () => new Error("No runner defined"));
-    const provider = assertEx6(runner.provider, () => new Error("Runner must have a provider defined"));
+    const runner = assertEx8(params?.runner, () => new Error("No runner defined"));
+    const provider = assertEx8(runner.provider, () => new Error("Runner must have a provider defined"));
     return { ...await super.paramsHandler({ ...params, provider }), runner };
   }
 };
@@ -498,7 +570,7 @@ var AbstractEvmRunner = class extends AbstractEvmViewer {
 // src/modules/ethereum/providers/EvmChainContractViewer.ts
 import {
   asHash,
-  assertEx as assertEx7,
+  assertEx as assertEx9,
   toAddress as toAddress2,
   toEthAddress as toEthAddress5,
   toHex
@@ -507,6 +579,7 @@ import { IStakedXyoChain__factory } from "@xyo-network/typechain";
 import {
   ChainContractViewerMoniker,
   creatableProvider,
+  EvmChainViewerMoniker as EvmChainViewerMoniker2,
   toXL1BlockNumber,
   withContextCacheResponse
 } from "@xyo-network/xl1-sdk";
@@ -519,11 +592,8 @@ var EvmChainContractViewer = class extends AbstractEvmViewer {
   _minWithdrawalBlocks;
   _rewardsContract;
   _stakingTokenAddress;
-  get address() {
-    return this.params.address;
-  }
   chainId() {
-    return toHex(this.params.address, { prefix: false });
+    return toHex(this.address, { prefix: false });
   }
   async chainIdAtBlockNumber(blockNumber) {
     return await withContextCacheResponse(this.context, "chainIdAtBlockNumber", String(blockNumber), async () => {
@@ -531,7 +601,7 @@ var EvmChainContractViewer = class extends AbstractEvmViewer {
       let contractViewer = this;
       let forkedAtBlockNumber = await contractViewer.forkedAtBlockNumber();
       while (forkedAtBlockNumber !== null && blockNumber <= forkedAtBlockNumber) {
-        contractViewer = assertEx7(await contractViewer.forkedChainContractViewer(), () => "Forked chain contract viewer is undefined");
+        contractViewer = assertEx9(await contractViewer.forkedChainContractViewer(), () => "Forked chain contract viewer is undefined");
         forkedAtBlockNumber = await contractViewer.forkedAtBlockNumber();
         chainId = await contractViewer.chainId();
       }
@@ -556,7 +626,11 @@ var EvmChainContractViewer = class extends AbstractEvmViewer {
   async forkedChainContractViewer() {
     this._forkedChainContractViewer = this._forkedChainContractViewer ?? (async () => {
       const address = await this.forkedChainId();
-      return EvmChainContractViewer.create({ ...this.params, address: toEthAddress5(address) });
+      return EvmChainContractViewer.create({
+        ...this.params,
+        address: toEthAddress5(address),
+        provider: this.provider
+      });
     })();
     return await this._forkedChainContractViewer;
   }
@@ -583,12 +657,12 @@ var EvmChainContractViewer = class extends AbstractEvmViewer {
     return await this._stakingTokenAddress;
   }
   connectContract(address) {
-    return IStakedXyoChain__factory.connect(address, this.params.provider);
+    return IStakedXyoChain__factory.connect(address, this.provider);
   }
 };
 __publicField(EvmChainContractViewer, "connectionTypes", ["evm-rpc"]);
 __publicField(EvmChainContractViewer, "defaultMoniker", ChainContractViewerMoniker);
-__publicField(EvmChainContractViewer, "dependencies", []);
+__publicField(EvmChainContractViewer, "dependencies", [EvmChainViewerMoniker2]);
 __publicField(EvmChainContractViewer, "monikers", [ChainContractViewerMoniker]);
 __publicField(EvmChainContractViewer, "surface", "node");
 EvmChainContractViewer = __decorateClass([
@@ -638,6 +712,7 @@ import { toEthAddress as toEthAddress7 } from "@ariestools/sdk";
 import { IStakedXyoChain__factory as IStakedXyoChain__factory3 } from "@xyo-network/typechain";
 import {
   creatableProvider as creatableProvider3,
+  EvmChainViewerMoniker as EvmChainViewerMoniker3,
   StakeTotalsViewerMoniker
 } from "@xyo-network/xl1-sdk";
 import { getAddress as getAddress2 } from "ethers/address";
@@ -665,18 +740,68 @@ var EvmStakeTotalsViewer = class extends AbstractEvmViewer {
     return await this.contract.withdrawnByStaker(getAddress2(staker));
   }
   connectContract(address) {
-    return IStakedXyoChain__factory3.connect(address, this.params.provider);
+    return IStakedXyoChain__factory3.connect(address, this.provider);
   }
 };
 __publicField(EvmStakeTotalsViewer, "connectionTypes", ["evm-rpc"]);
 __publicField(EvmStakeTotalsViewer, "defaultMoniker", StakeTotalsViewerMoniker);
-__publicField(EvmStakeTotalsViewer, "dependencies", []);
+__publicField(EvmStakeTotalsViewer, "dependencies", [EvmChainViewerMoniker3]);
 __publicField(EvmStakeTotalsViewer, "monikers", [StakeTotalsViewerMoniker]);
 __publicField(EvmStakeTotalsViewer, "surface", "node");
 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";
 
@@ -725,11 +850,11 @@ function isRpcRateLimitError(error) {
   return false;
 }
 function isRateLimitCode(code) {
-  return code === 429 || code === -32005 || code === -32016;
+  return code === 429 || code === -32005 || code === -32007 || code === -32016;
 }
 function matchesRateLimitText(text) {
   const normalized = text.toLowerCase();
-  return normalized.includes("too many requests") || normalized.includes("rate limit") || normalized.includes("rate exceeded") || normalized.includes("call rate limit") || normalized.includes("exceeded the quota");
+  return normalized.includes("too many requests") || normalized.includes("rate limit") || normalized.includes("rate exceeded") || normalized.includes("call rate limit") || normalized.includes("request limit") || normalized.includes("exceeded the quota");
 }
 
 // src/modules/ethereum/rpc/withRpcRateLimitBackoff.ts
@@ -819,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;
@@ -839,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);
@@ -870,7 +1011,7 @@ var EvmStakeEventsViewer = class extends AbstractEvmViewer {
     return result;
   }
   connectContract(address) {
-    return IAddressStakingEvents__factory.connect(address, this.params.provider);
+    return IAddressStakingEvents__factory.connect(address, this.provider);
   }
   onEventHandler(staked, staker, id, amount, event, throwOnInvalid = false) {
     const validatedEventResult = EvmStakeEventZod.safeParse(event);
@@ -900,14 +1041,14 @@ var EvmStakeEventsViewer = class extends AbstractEvmViewer {
   }
   async startHandler() {
     try {
-      const provider = assertEx8(this.contract.runner?.provider, () => new Error("Failed to get provider"));
-      const historyEndBlock = assertEx8(await provider.getBlockNumber(), () => new Error("Failed to get currentEthBlock"));
+      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();
-      const latestBlock = assertEx8(await provider.getBlockNumber(), () => new Error("Failed to get latestEthBlock"));
+      const latestBlock = assertEx10(await provider.getBlockNumber(), () => new Error("Failed to get latestEthBlock"));
       if (latestBlock > historyEndBlock) {
         await this.loadHistoricalEvents(historyEndBlock + 1, latestBlock);
       }
@@ -927,74 +1068,76 @@ 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" ? assertEx8(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) => {
-      assertEx8(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"]);
 __publicField(EvmStakeEventsViewer, "defaultMoniker", StakeEventsViewerMoniker);
-__publicField(EvmStakeEventsViewer, "dependencies", []);
+__publicField(EvmStakeEventsViewer, "dependencies", [EvmChainViewerMoniker4]);
 __publicField(EvmStakeEventsViewer, "monikers", [StakeEventsViewerMoniker]);
 __publicField(EvmStakeEventsViewer, "surface", "node");
 EvmStakeEventsViewer = __decorateClass([
@@ -1003,14 +1146,14 @@ EvmStakeEventsViewer = __decorateClass([
 
 // src/modules/ethereum/drivers/EvmStakeViewer.ts
 import {
-  assertEx as assertEx9,
-  isDefined as isDefined4,
+  assertEx as assertEx11,
   toAddress as toAddress4,
-  toEthAddress as toEthAddress9
+  toEthAddress as toEthAddress8
 } from "@ariestools/sdk";
 import { IAddressStaking__factory } from "@xyo-network/typechain";
 import {
   creatableProvider as creatableProvider5,
+  EvmChainViewerMoniker as EvmChainViewerMoniker5,
   StakeEventsViewerMoniker as StakeEventsViewerMoniker2,
   StakeViewerMoniker
 } from "@xyo-network/xl1-sdk";
@@ -1044,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() {
@@ -1058,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.params.provider);
+    this._deploymentBlock = this.params.deploymentBlock ?? configuredDeploymentBlock(this.config) ?? await resolveContractDeploymentBlock(this.provider, this.address, this.logger);
   }
   minWithdrawalBlocks() {
     return 0;
@@ -1070,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() {
@@ -1095,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;
@@ -1137,14 +1280,14 @@ 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() {
     return this._stakeCache.values().filter((stake) => stake.removeBlock !== 0 && stake.withdrawBlock !== 0).toArray();
   }
   connectContract(address) {
-    return IAddressStaking__factory.connect(address, this.params.provider);
+    return IAddressStaking__factory.connect(address, this.provider);
   }
   async startHandler() {
     await this.contract.on(this.contract.getEvent("StakeAdded"), (staked, staker, id, amount, event) => {
@@ -1159,14 +1302,14 @@ var EvmStakeViewer = class extends AbstractEvmViewer {
       });
     });
     await this.contract.on(this.contract.getEvent("StakeRemoved"), (staked, staker, id, amount, event) => {
-      const stake = assertEx9(this._stakeCache.get(Number(id)));
+      const stake = assertEx11(this._stakeCache.get(Number(id)));
       this._stakeCache.set(Number(id), {
         ...stake,
         removeBlock: event.blockNumber
       });
     });
     await this.contract.on(this.contract.getEvent("StakeWithdrawn"), (staked, staker, id, amount, event) => {
-      const stake = assertEx9(this._stakeCache.get(Number(id)));
+      const stake = assertEx11(this._stakeCache.get(Number(id)));
       this._stakeCache.set(Number(id), {
         ...stake,
         withdrawBlock: event.blockNumber
@@ -1199,7 +1342,7 @@ var EvmStakeViewer = class extends AbstractEvmViewer {
       return;
     }
     if (event.name === "StakeRemoved") {
-      const stake = assertEx9(this._stakeCache.get(event.args.id));
+      const stake = assertEx11(this._stakeCache.get(event.args.id));
       this._stakeCache.set(event.args.id, {
         ...stake,
         removeBlock: event.time
@@ -1207,7 +1350,7 @@ var EvmStakeViewer = class extends AbstractEvmViewer {
       return;
     }
     if (event.name === "StakeWithdrawn") {
-      const stake = assertEx9(this._stakeCache.get(event.args.id));
+      const stake = assertEx11(this._stakeCache.get(event.args.id));
       this._stakeCache.set(event.args.id, {
         ...stake,
         withdrawBlock: event.time
@@ -1217,7 +1360,7 @@ var EvmStakeViewer = class extends AbstractEvmViewer {
 };
 __publicField(EvmStakeViewer, "connectionTypes", ["evm-rpc"]);
 __publicField(EvmStakeViewer, "defaultMoniker", StakeViewerMoniker);
-__publicField(EvmStakeViewer, "dependencies", []);
+__publicField(EvmStakeViewer, "dependencies", [EvmChainViewerMoniker5, StakeEventsViewerMoniker2]);
 __publicField(EvmStakeViewer, "monikers", [StakeViewerMoniker]);
 __publicField(EvmStakeViewer, "surface", "node");
 EvmStakeViewer = __decorateClass([
@@ -1233,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,
@@ -1259,6 +1617,11 @@ export {
   EvmStakeViewer,
   EvmStakeWithdrawnEventNameZod,
   EvmStakeWithdrawnEventZod,
+  MIN_EVENT_QUERY_BLOCK_CHUNK_SIZE,
+  RestStakeEventsViewer,
+  asEvmEventIndexFrame,
+  asEvmEventIndexHead,
+  asEvmEventIndexManifest,
   asEvmStakeAddedEvent,
   asEvmStakeEvent,
   asEvmStakeRemovedEvent,
@@ -1266,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