@xyo-network/chain-sdk 4.1.0 → 4.3.0

package/dist/neutral/ethereum.mjs

@@ -182,21 +182,19 @@ function blockRangeChunks(fromBlock, toBlock, chunkSize) {
 }
 
 // src/modules/ethereum/block/estimateBlockNumberAt.ts
-import { assertEx } from "@ariestools/sdk";
-var DEFAULT_EVM_BLOCK_TIME_SEC = 12;
-var DEFAULT_ESTIMATE_BLOCK_DATE = new Date(Date.UTC(2025, 5, 1));
-function estimateBlockNumberFromHead(headNumber, headTimestampSec, targetDate = DEFAULT_ESTIMATE_BLOCK_DATE, avgBlockTimeSec = DEFAULT_EVM_BLOCK_TIME_SEC) {
-  const targetTimestampSec = Math.floor(targetDate.getTime() / 1e3);
-  if (targetTimestampSec >= headTimestampSec) {
-    return headNumber;
-  }
-  const blocksBack = Math.ceil((headTimestampSec - targetTimestampSec) / avgBlockTimeSec);
-  return Math.max(0, headNumber - blocksBack);
-}
-async function estimateBlockNumberAt(provider, targetDate = DEFAULT_ESTIMATE_BLOCK_DATE, avgBlockTimeSec = DEFAULT_EVM_BLOCK_TIME_SEC) {
-  const head = assertEx(await provider.getBlock("latest"), () => new Error("Failed to get latest eth block"));
-  return estimateBlockNumberFromHead(head.number, head.timestamp, targetDate, avgBlockTimeSec);
-}
+import {
+  DEFAULT_ESTIMATE_BLOCK_DATE,
+  DEFAULT_EVM_BLOCK_TIME_SEC,
+  estimateBlockNumberAt,
+  estimateBlockNumberFromHead
+} from "@xyo-network/xl1-sdk";
+
+// src/modules/ethereum/block/findContractDeploymentBlock.ts
+import {
+  configuredDeploymentBlock,
+  findContractDeploymentBlock,
+  resolveContractDeploymentBlock
+} from "@xyo-network/xl1-sdk";
 
 // src/modules/ethereum/block/rate/blockRate.ts
 import { isDefined, isFalsy } from "@ariestools/sdk";
@@ -246,7 +244,7 @@ var calculateEthBlockRate = async (provider, range, timeUnit) => {
 
 // src/modules/ethereum/block/rate/timeRate.ts
 import {
-  assertEx as assertEx2,
+  assertEx,
   isDefined as isDefined2,
   isDefinedNotNull
 } from "@ariestools/sdk";
@@ -258,12 +256,12 @@ import {
 var DEFAULT_TOLERANCE_MS = 3e4;
 var DEFAULT_MAX_ATTEMPTS = 20;
 var calculateEthTimeRate = async (provider, timeConfig, startBlockNumber, timeUnit, toleranceMs = DEFAULT_TOLERANCE_MS, maxAttempts = DEFAULT_MAX_ATTEMPTS) => {
-  assertEx2(Object.keys(timeConfig ?? {}).length === 1, () => "Only one time unit should be specified in timeConfig");
+  assertEx(Object.keys(timeConfig ?? {}).length === 1, () => "Only one time unit should be specified in timeConfig");
   const startBlock = isDefinedNotNull(startBlockNumber) ? await provider.getBlock(BigInt(startBlockNumber)) : null;
-  assertEx2(isDefinedNotNull(startBlockNumber) && isDefinedNotNull(startBlock), () => "Start block could not be resolved");
-  const resolvedStartBlock = isDefinedNotNull(startBlock) ? startBlock : assertEx2(await provider.getBlock("latest"));
+  assertEx(isDefinedNotNull(startBlockNumber) && isDefinedNotNull(startBlock), () => "Start block could not be resolved");
+  const resolvedStartBlock = isDefinedNotNull(startBlock) ? startBlock : assertEx(await provider.getBlock("latest"));
   const timeInMilliseconds = getTimeConfigInMilliseconds(timeConfig);
-  assertEx2(timeInMilliseconds > 0, () => "Time duration must be greater than zero");
+  assertEx(timeInMilliseconds > 0, () => "Time duration must be greater than zero");
   const blocksPerMillisecondRate = 1 / (12 * 1e3);
   const initialBlocksInDuration = Math.floor(blocksPerMillisecondRate * timeInMilliseconds);
   const endBlockNumber = await findEndBlockRecursive(
@@ -282,14 +280,14 @@ var calculateEthTimeRate = async (provider, timeConfig, startBlockNumber, timeUn
 };
 var findEndBlockRecursive = async (provider, startBlock, targetTimeMs, estimatedBlocksBack, toleranceMs, attemptsRemaining) => {
   console.log(`Attempts remaining: ${attemptsRemaining}, Estimated blocks back: ${estimatedBlocksBack}`);
-  assertEx2(attemptsRemaining > 0, () => "Maximum attempts reached while searching for end block");
+  assertEx(attemptsRemaining > 0, () => "Maximum attempts reached while searching for end block");
   const startBlockEpoch = startBlock.timestamp;
   const estimatedEndBlockNumber = startBlock.number - estimatedBlocksBack;
   if (estimatedEndBlockNumber < 0) {
     throw new Error("Estimated end block number is less than zero");
   }
   const endBlock = await provider.getBlock(estimatedEndBlockNumber);
-  const resolvedEndBlock = assertEx2(
+  const resolvedEndBlock = assertEx(
     isDefined2(endBlock) ? endBlock : void 0,
     () => `Could not retrieve block ${estimatedEndBlockNumber} for time rate calculation`
   );
@@ -332,7 +330,7 @@ import { createGenesisBlock } from "#protocol";
 // src/modules/ethereum/createChainContract.ts
 import {
   asAddress,
-  assertEx as assertEx3,
+  assertEx as assertEx2,
   ETH_ZERO_ADDRESS,
   hexToBigInt,
   toEthAddress
@@ -360,7 +358,7 @@ var createChainContract = async (signer, stakingTokenAddress, genesisBlockHash,
     );
     await deployResponse.waitForDeployment();
     const xyoChainContractAddress = await deployResponse.getAddress();
-    return assertEx3(asAddress(xyoChainContractAddress), () => "Invalid staking contract address");
+    return assertEx2(asAddress(xyoChainContractAddress), () => "Invalid staking contract address");
   } catch (ex) {
     console.log(ex);
     throw ex;
@@ -370,7 +368,7 @@ var createChainContract = async (signer, stakingTokenAddress, genesisBlockHash,
 // src/modules/ethereum/createChainRewardsContract.ts
 import {
   asAddress as asAddress2,
-  assertEx as assertEx4,
+  assertEx as assertEx3,
   toFixedPoint
 } from "@ariestools/sdk";
 import { XyoChainRewards__factory as XyoChainRewardsFactory } from "@xyo-network/typechain";
@@ -397,7 +395,7 @@ var createChainRewardsContract = async (signer, genesisReward = 0n, gas = gasCon
     );
     await deployResponse.waitForDeployment();
     const xyoChainRewardsAddress = await deployResponse.getAddress();
-    return assertEx4(asAddress2(xyoChainRewardsAddress), () => "Invalid rewards contract address");
+    return assertEx3(asAddress2(xyoChainRewardsAddress), () => "Invalid rewards contract address");
   } catch (ex) {
     console.log(ex);
     throw ex;
@@ -407,7 +405,7 @@ var createChainRewardsContract = async (signer, genesisReward = 0n, gas = gasCon
 // src/modules/ethereum/nextContractAddress.ts
 import {
   asAddress as asAddress3,
-  assertEx as assertEx5,
+  assertEx as assertEx4,
   toEthAddress as toEthAddress2
 } from "@ariestools/sdk";
 import { getCreateAddress } from "ethers/address";
@@ -415,11 +413,11 @@ var nextContractAddressForAddress = async (address, provider) => {
   const deployerAddress = toEthAddress2(address);
   const nonce = await provider.getTransactionCount(deployerAddress);
   const contractAddress = getCreateAddress({ from: deployerAddress, nonce });
-  return assertEx5(asAddress3(contractAddress), () => "Unable to convert contract address to address");
+  return assertEx4(asAddress3(contractAddress), () => "Unable to convert contract address to address");
 };
 var nextContractAddress = async (signer) => {
-  const provider = assertEx5(signer.provider, () => "Unable to obtain provider from signer");
-  const address = assertEx5(asAddress3(await signer.getAddress()), () => "Unable to obtain address from signer");
+  const provider = assertEx4(signer.provider, () => "Unable to obtain provider from signer");
+  const address = assertEx4(asAddress3(await signer.getAddress()), () => "Unable to obtain address from signer");
   return await nextContractAddressForAddress(address, provider);
 };
 
@@ -450,178 +448,287 @@ 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
-} from "@ariestools/sdk";
-import {
-  IAddressStakingEvents__factory
-} from "@xyo-network/typechain";
-import {
-  creatableProvider as creatableProvider4,
-  EvmChainViewerMoniker as EvmChainViewerMoniker4,
-  StakeEventsViewerMoniker
+  DEFAULT_EVENT_QUERY_INITIAL_DELAY_MS,
+  DEFAULT_EVENT_QUERY_MAX_ATTEMPTS,
+  DEFAULT_EVENT_QUERY_START_CHUNK_SIZE,
+  EvmStakeEventsViewer,
+  MIN_EVENT_QUERY_BLOCK_CHUNK_SIZE
 } from "@xyo-network/xl1-sdk";
-import { asAttoXL1 } from "@xyo-network/xl1-sdk";
 
-// src/modules/ethereum/providers/AbstractEvmProvider.ts
+// src/modules/ethereum/drivers/EvmStakeEventZod.ts
 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._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);
-  }
-};
+  asEvmStakeAddedEvent,
+  asEvmStakeEvent,
+  asEvmStakeRemovedEvent,
+  asEvmStakeWithdrawnEvent,
+  EthHashRegEx,
+  EthHashZod,
+  EvmStakeAddedEventNameZod,
+  EvmStakeAddedEventZod,
+  EvmStakeEventArgsZod,
+  EvmStakeEventNameZod,
+  EvmStakeEventZod,
+  EvmStakeRemovedEventNameZod,
+  EvmStakeRemovedEventZod,
+  EvmStakeWithdrawnEventNameZod,
+  EvmStakeWithdrawnEventZod,
+  isEvmStakeAddedEvent,
+  isEvmStakeEvent,
+  isEvmStakeRemovedEvent,
+  isEvmStakeWithdrawnEvent,
+  toEvmStakeAddedEvent,
+  toEvmStakeEvent,
+  toEvmStakeRemovedEvent,
+  toEvmStakeWithdrawnEvent
+} from "@xyo-network/xl1-sdk";
 
-// src/modules/ethereum/providers/AbstractEvmRunner.ts
-import { assertEx as assertEx8 } from "@ariestools/sdk";
+// src/modules/ethereum/drivers/EvmStakeViewer.ts
+import { EvmStakeViewer } from "@xyo-network/xl1-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/ethereum.ts
+import { parseUnits as parseUnits2 } from "ethers/utils";
+var getDefaultGasConfig = () => {
+  return {
+    gasLimit: 2e6,
+    // Set the gas limit
+    gasPrice: parseUnits2("100", "gwei")
+  };
 };
 
-// src/modules/ethereum/providers/AbstractEvmRunner.ts
-var AbstractEvmRunner = class extends AbstractEvmViewer {
-  static async paramsHandler(params) {
-    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 };
-  }
-};
+// src/modules/ethereum/indexing/EvmEventIndexModel.ts
+import {
+  EthAddressZod,
+  HexRegExMinMaxMixedCaseWithPrefix,
+  zodAsFactory
+} from "@ariestools/sdk";
+import { z } from "zod/mini";
+var EvmHashZod = z.string().check(z.regex(HexRegExMinMaxMixedCaseWithPrefix(32, 32)));
+var EvmDataZod = z.string().check(z.regex(/^0x[\dA-Fa-f]*$/));
+var EvmEventIndexLogZod = z.object({
+  address: EthAddressZod,
+  blockHash: EvmHashZod,
+  blockNumber: z.number(),
+  data: EvmDataZod,
+  index: z.number(),
+  topics: z.array(EvmHashZod),
+  transactionHash: EvmHashZod,
+  transactionIndex: z.number()
+});
+var EvmEventIndexFrameZod = z.object({
+  fromBlock: z.number(),
+  logs: z.array(EvmEventIndexLogZod),
+  toBlock: z.number()
+});
+var EvmEventIndexManifestZod = z.object({
+  address: EthAddressZod,
+  chainId: z.string(),
+  deploymentBlock: z.number(),
+  frameSize: z.number(),
+  layout: z.literal("evm-contract-events-v1")
+});
+var EvmEventIndexHeadZod = z.object({
+  address: EthAddressZod,
+  block: z.number(),
+  chainId: z.string(),
+  hash: EvmHashZod
+});
+var asEvmEventIndexFrame = zodAsFactory(EvmEventIndexFrameZod, "asEvmEventIndexFrame");
+var asEvmEventIndexHead = zodAsFactory(EvmEventIndexHeadZod, "asEvmEventIndexHead");
+var asEvmEventIndexManifest = zodAsFactory(EvmEventIndexManifestZod, "asEvmEventIndexManifest");
 
-// src/modules/ethereum/providers/EvmChainContractViewer.ts
+// 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 {
-  asHash,
-  assertEx as assertEx9,
+  assertEx as assertEx5,
+  isDefined as isDefined3,
   toAddress as toAddress2,
-  toEthAddress as toEthAddress5,
-  toHex
+  toEthAddress as toEthAddress4
 } from "@ariestools/sdk";
-import { IStakedXyoChain__factory } from "@xyo-network/typechain";
+import { IAddressStakingEvents__factory } from "@xyo-network/typechain";
 import {
-  ChainContractViewerMoniker,
+  AbstractCreatableProvider,
+  asAttoXL1,
   creatableProvider,
-  EvmChainViewerMoniker as EvmChainViewerMoniker2,
-  toXL1BlockNumber,
-  withContextCacheResponse
+  resolveRestConnectionEndpoint,
+  StakeEventsViewerMoniker
 } from "@xyo-network/xl1-sdk";
-var EvmChainContractViewer = class extends AbstractEvmViewer {
-  moniker = EvmChainContractViewer.defaultMoniker;
-  _forkedAtBlockNumber;
-  _forkedAtHash;
-  _forkedChainContractViewer;
-  _forkedChainId;
-  _minWithdrawalBlocks;
-  _rewardsContract;
-  _stakingTokenAddress;
-  chainId() {
-    return toHex(this.address, { prefix: false });
-  }
-  async chainIdAtBlockNumber(blockNumber) {
-    return await withContextCacheResponse(this.context, "chainIdAtBlockNumber", String(blockNumber), async () => {
-      let chainId = this.chainId();
-      let contractViewer = this;
-      let forkedAtBlockNumber = await contractViewer.forkedAtBlockNumber();
-      while (forkedAtBlockNumber !== null && blockNumber <= forkedAtBlockNumber) {
-        contractViewer = assertEx9(await contractViewer.forkedChainContractViewer(), () => "Forked chain contract viewer is undefined");
-        forkedAtBlockNumber = await contractViewer.forkedAtBlockNumber();
-        chainId = await contractViewer.chainId();
-      }
-      return chainId;
-    });
+import { Interface } from "ethers";
+var STAKE_EVENT_NAMES = /* @__PURE__ */ new Set(["StakeAdded", "StakeRemoved", "StakeWithdrawn"]);
+var RestStakeEventsViewer = class extends AbstractCreatableProvider {
+  moniker = RestStakeEventsViewer.defaultMoniker;
+  completeFrames = /* @__PURE__ */ new Map();
+  contractInterface = new Interface(IAddressStakingEvents__factory.abi);
+  currentHead;
+  manifestPromise;
+  stakeEventCache = [];
+  syncPromise;
+  tailFrame;
+  get address() {
+    return this.params.address;
   }
-  async forkedAtBlockNumber() {
-    const contractAddress = this.contract.getAddress();
-    try {
-      this._forkedAtBlockNumber = this._forkedAtBlockNumber ?? (async () => toXL1BlockNumber(await this.contract.forkedAtBlockNumber(), true))();
-      return await this._forkedAtBlockNumber;
-    } catch {
-      this.logger?.warn("Failed to fetch forkedAtBlockNumber, returning null", contractAddress);
-      this._forkedAtBlockNumber = Promise.resolve(null);
-      return await this._forkedAtBlockNumber;
-    }
+  get eventIndexBaseUrl() {
+    return this.params.eventIndexBaseUrl;
   }
-  async forkedAtHash() {
-    this._forkedAtHash = this._forkedAtHash ?? (async () => asHash(toHex(await this.contract.forkedAtHash()), true))();
-    return await this._forkedAtHash;
-  }
-  async forkedChainContractViewer() {
-    this._forkedChainContractViewer = this._forkedChainContractViewer ?? (async () => {
-      const address = await this.forkedChainId();
-      return EvmChainContractViewer.create({
-        ...this.params,
-        address: toEthAddress5(address),
-        provider: this.provider
-      });
-    })();
-    return await this._forkedChainContractViewer;
+  get fetchFn() {
+    return this.params.fetchFn ?? fetch.bind(globalThis);
   }
-  async forkedChainId() {
-    this._forkedChainId = this._forkedChainId ?? (async () => {
-      return toAddress2(await this.contract.forkedChainId());
-    })();
-    return await this._forkedChainId;
+  static async paramsHandler(params) {
+    const contextConfig = params.context?.config;
+    const address = params.address ?? toEthAddress4(assertEx5(contextConfig?.chain?.id, () => "RestStakeEventsViewer requires an address param or config.chain.id"));
+    const moniker = this.defaultMoniker;
+    const eventIndexBaseUrl = isDefined3(params.eventIndexBaseUrl) && params.eventIndexBaseUrl !== "" ? params.eventIndexBaseUrl : resolveRestConnectionEndpoint(
+      assertEx5(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 minWithdrawalBlocks() {
-    this._minWithdrawalBlocks = this._minWithdrawalBlocks ?? (async () => Number(await this.contract.minWithdrawalBlocks()))();
-    return await this._minWithdrawalBlocks;
+  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 rewardsContract() {
-    this._rewardsContract = this._rewardsContract ?? (async () => {
-      return toAddress2(await this.contract.rewardsContract());
-    })();
-    return await this._rewardsContract;
+  async fetchJson(path) {
+    const response = await this.fetchFn(`${this.eventIndexBaseUrl}/${path}`);
+    assertEx5(response.ok, () => `EVM event index request failed [${response.status}] for ${path}`);
+    return await response.json();
   }
-  async stakingTokenAddress() {
-    this._stakingTokenAddress = this._stakingTokenAddress ?? (async () => {
-      return toAddress2(await this.contract.stakingTokenAddress());
+  async getManifest() {
+    this.manifestPromise ??= (async () => {
+      const manifest = asEvmEventIndexManifest(await this.fetchJson(evmEventIndexManifestPath(this.address)), true);
+      assertEx5(manifest.address.toLowerCase() === this.address.toLowerCase(), () => "EVM event index manifest address mismatch");
+      return manifest;
     })();
-    return await this._stakingTokenAddress;
+    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 (isDefined3(filter?.name) && event.name !== filter.name) return false;
+    if (isDefined3(filter?.args?.id) && event.args.id !== filter.args.id) return false;
+    if (isDefined3(filter?.args?.staked) && event.args.staked !== filter.args.staked) return false;
+    if (isDefined3(filter?.args?.staker) && event.args.staker !== filter.args.staker) return false;
+    return true;
   }
-  connectContract(address) {
-    return IStakedXyoChain__factory.connect(address, this.provider);
+  stakeEventFromLog(log) {
+    const parsed = this.contractInterface.parseLog({ data: log.data, topics: log.topics });
+    if (parsed === null || !STAKE_EVENT_NAMES.has(parsed.name)) return;
+    const [staked, staker, id, amount] = parsed.args;
+    return {
+      name: parsed.name,
+      args: {
+        amount: asAttoXL1(amount),
+        id: Number(id),
+        staked: toAddress2(staked),
+        staker: toAddress2(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);
+    assertEx5(head.address.toLowerCase() === this.address.toLowerCase(), () => "EVM event index head address mismatch");
+    assertEx5(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;
+      assertEx5(frame.fromBlock === expectedFrom, () => `EVM event index frame ${index} starts at the wrong block`);
+      assertEx5(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) {
+      assertEx5(this.tailFrame.fromBlock === tailStart, () => "EVM event index tail starts at the wrong block");
+      assertEx5(this.tailFrame.toBlock === head.block, () => "EVM event index tail is stale relative to its head");
+    }
+    this.stakeEventCache = this.decodeIndexedStakeEvents();
+    this.currentHead = head;
   }
 };
-__publicField(EvmChainContractViewer, "connectionTypes", ["evm-rpc"]);
-__publicField(EvmChainContractViewer, "defaultMoniker", ChainContractViewerMoniker);
-__publicField(EvmChainContractViewer, "dependencies", [EvmChainViewerMoniker2]);
-__publicField(EvmChainContractViewer, "monikers", [ChainContractViewerMoniker]);
-__publicField(EvmChainContractViewer, "surface", "node");
-EvmChainContractViewer = __decorateClass([
+__publicField(RestStakeEventsViewer, "connectionTypes", ["rest"]);
+__publicField(RestStakeEventsViewer, "defaultMoniker", StakeEventsViewerMoniker);
+__publicField(RestStakeEventsViewer, "dependencies", []);
+__publicField(RestStakeEventsViewer, "monikers", [StakeEventsViewerMoniker]);
+__publicField(RestStakeEventsViewer, "surface", "node");
+RestStakeEventsViewer = __decorateClass([
   creatableProvider()
-], EvmChainContractViewer);
+], RestStakeEventsViewer);
+
+// src/modules/ethereum/providers/AbstractEvmProvider.ts
+import { AbstractEvmProvider } from "@xyo-network/xl1-sdk";
+
+// src/modules/ethereum/providers/AbstractEvmRunner.ts
+import { assertEx as assertEx6 } from "@ariestools/sdk";
+
+// src/modules/ethereum/providers/AbstractEvmViewer.ts
+import { AbstractEvmViewer } from "@xyo-network/xl1-sdk";
+
+// 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"));
+    return { ...await super.paramsHandler({ ...params, provider }), runner };
+  }
+};
+
+// src/modules/ethereum/providers/EvmChainContractViewer.ts
+import { EvmChainContractViewer } from "@xyo-network/xl1-sdk";
 
 // src/modules/ethereum/providers/EvmStakeRunner.ts
-import { toEthAddress as toEthAddress6 } from "@ariestools/sdk";
-import { IStakedXyoChain__factory as IStakedXyoChain__factory2 } from "@xyo-network/typechain";
+import { toEthAddress as toEthAddress5 } from "@ariestools/sdk";
+import { IStakedXyoChain__factory } from "@xyo-network/typechain";
 import {
   creatableProvider as creatableProvider2,
   StakeRunnerMoniker
@@ -630,7 +737,7 @@ import { getAddress } from "ethers/address";
 var EvmStakeRunner = class extends AbstractEvmRunner {
   moniker = EvmStakeRunner.defaultMoniker;
   async addStake(staked, amount) {
-    const result = await this.contract.addStake(getAddress(toEthAddress6(staked)), amount);
+    const result = await this.contract.addStake(getAddress(toEthAddress5(staked)), amount);
     await result.wait();
     return true;
   }
@@ -645,7 +752,7 @@ var EvmStakeRunner = class extends AbstractEvmRunner {
     return true;
   }
   connectContract(address) {
-    return IStakedXyoChain__factory2.connect(address, this.params.runner);
+    return IStakedXyoChain__factory.connect(address, this.params.runner);
   }
 };
 __publicField(EvmStakeRunner, "connectionTypes", ["evm-rpc"]);
@@ -658,620 +765,34 @@ EvmStakeRunner = __decorateClass([
 ], EvmStakeRunner);
 
 // src/modules/ethereum/providers/EvmStakeTotalsViewer.ts
-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";
-var EvmStakeTotalsViewer = class extends AbstractEvmViewer {
-  moniker = EvmStakeTotalsViewer.defaultMoniker;
-  async active() {
-    return await this.contract.active();
-  }
-  async activeByStaked(staked) {
-    return await this.contract.activeByAddressStaked(getAddress2(toEthAddress7(staked)));
-  }
-  async activeByStaker(address) {
-    return await this.contract.activeByStaker(getAddress2(toEthAddress7(address)));
-  }
-  async pending() {
-    return await this.contract.pending();
-  }
-  async pendingByStaker(staker) {
-    return await this.contract.pendingByStaker(getAddress2(toEthAddress7(staker)));
-  }
-  async withdrawn() {
-    return await this.contract.withdrawn();
-  }
-  async withdrawnByStaker(staker) {
-    return await this.contract.withdrawnByStaker(getAddress2(staker));
-  }
-  connectContract(address) {
-    return IStakedXyoChain__factory3.connect(address, this.provider);
-  }
-};
-__publicField(EvmStakeTotalsViewer, "connectionTypes", ["evm-rpc"]);
-__publicField(EvmStakeTotalsViewer, "defaultMoniker", StakeTotalsViewerMoniker);
-__publicField(EvmStakeTotalsViewer, "dependencies", [EvmChainViewerMoniker3]);
-__publicField(EvmStakeTotalsViewer, "monikers", [StakeTotalsViewerMoniker]);
-__publicField(EvmStakeTotalsViewer, "surface", "node");
-EvmStakeTotalsViewer = __decorateClass([
-  creatableProvider3()
-], EvmStakeTotalsViewer);
+import { EvmStakeTotalsViewer } from "@xyo-network/xl1-sdk";
 
-// src/modules/ethereum/rpc/withRpcRateLimitBackoff.ts
-import { delay } from "@ariestools/sdk";
+// src/modules/ethereum/rpc/isRpcRangeLimitError.ts
+import { isRpcRangeLimitError, rpcRangeLimitFromError } from "@xyo-network/xl1-sdk";
 
 // src/modules/ethereum/rpc/isRpcRateLimitError.ts
-function isRpcRateLimitError(error) {
-  const seen = /* @__PURE__ */ new Set();
-  const queue = [error];
-  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") {
-      if (matchesRateLimitText(current)) {
-        return true;
-      }
-      continue;
-    }
-    if (typeof current === "number") {
-      if (isRateLimitCode(current)) {
-        return true;
-      }
-      continue;
-    }
-    if (typeof current !== "object") {
-      continue;
-    }
-    if (Array.isArray(current)) {
-      const items = current;
-      queue.push(...items);
-      continue;
-    }
-    const record = current;
-    for (const key of ["code", "message", "shortMessage", "reason", "status", "statusCode"]) {
-      if (key in record) {
-        queue.push(record[key]);
-      }
-    }
-    for (const key of ["error", "info", "data", "value", "body", "payload"]) {
-      if (key in record) {
-        queue.push(record[key]);
-      }
-    }
-  }
-  return false;
-}
-function isRateLimitCode(code) {
-  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("request limit") || normalized.includes("exceeded the quota");
-}
+import { isRpcRateLimitError } from "@xyo-network/xl1-sdk";
 
 // src/modules/ethereum/rpc/withRpcRateLimitBackoff.ts
-async function withRpcRateLimitBackoff(fn, options = {}) {
-  const {
-    backoff = 2,
-    initialDelayMs = 1e3,
-    maxAttempts = 8,
-    maxDelayMs = 3e4,
-    onRetry
-  } = options;
-  if (!Number.isInteger(maxAttempts) || maxAttempts < 1) {
-    throw new TypeError(`maxAttempts must be an integer >= 1, got ${maxAttempts}`);
-  }
-  let delayMs = initialDelayMs;
-  let lastError;
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error;
-      const isLastAttempt = attempt >= maxAttempts;
-      if (!isRpcRateLimitError(error) || isLastAttempt) {
-        throw error;
-      }
-      const waitMs = Math.min(delayMs, maxDelayMs);
-      onRetry?.(error, attempt, waitMs);
-      await delay(waitMs);
-      delayMs = Math.min(delayMs * backoff, maxDelayMs);
-    }
-  }
-  throw lastError;
-}
-
-// src/modules/ethereum/drivers/EvmStakeEventZod.ts
-import {
-  EthAddressZod,
-  HexRegExMinMaxMixedCaseWithPrefix,
-  zodAsFactory,
-  zodIsFactory,
-  zodToFactory
-} from "@ariestools/sdk";
-import { z } from "zod/mini";
-var EthHashRegEx = HexRegExMinMaxMixedCaseWithPrefix(32, 32);
-var EthHashZod = z.string().check(z.regex(EthHashRegEx, { error: "Invalid address format" }));
-var EvmStakeAddedEventNameZod = z.literal("StakeAdded");
-var EvmStakeRemovedEventNameZod = z.literal("StakeRemoved");
-var EvmStakeWithdrawnEventNameZod = z.literal("StakeWithdrawn");
-var EvmStakeEventNameZod = z.union([
-  EvmStakeAddedEventNameZod,
-  EvmStakeRemovedEventNameZod,
-  EvmStakeWithdrawnEventNameZod
-]);
-var EvmStakeEventArgsZod = z.tuple([
-  EthAddressZod,
-  // staker
-  EthAddressZod,
-  // staked
-  z.bigint(),
-  // id
-  z.bigint()
-  // amount
-]);
-var EvmStakeEventZod = z.object({
-  address: EthAddressZod,
-  args: EvmStakeEventArgsZod,
-  blockHash: EthHashZod,
-  blockNumber: z.number(),
-  eventName: EvmStakeEventNameZod,
-  transactionHash: EthHashZod,
-  transactionIndex: z.number()
-});
-var isEvmStakeEvent = zodIsFactory(EvmStakeEventZod);
-var asEvmStakeEvent = zodAsFactory(EvmStakeEventZod, "asEvmStakeEvent");
-var toEvmStakeEvent = zodToFactory(EvmStakeEventZod, "toEvmStakeEvent");
-var EvmStakeAddedEventZod = z.extend(EvmStakeEventZod, { eventName: EvmStakeAddedEventNameZod });
-var isEvmStakeAddedEvent = zodIsFactory(EvmStakeAddedEventZod);
-var asEvmStakeAddedEvent = zodAsFactory(EvmStakeAddedEventZod, "asEvmStakeAddedEvent");
-var toEvmStakeAddedEvent = zodToFactory(EvmStakeAddedEventZod, "toEvmStakeAddedEvent");
-var EvmStakeRemovedEventZod = z.extend(EvmStakeEventZod, { eventName: EvmStakeRemovedEventNameZod });
-var isEvmStakeRemovedEvent = zodIsFactory(EvmStakeRemovedEventZod);
-var asEvmStakeRemovedEvent = zodAsFactory(EvmStakeRemovedEventZod, "asEvmStakeRemovedEvent");
-var toEvmStakeRemovedEvent = zodToFactory(EvmStakeRemovedEventZod, "toEvmStakeRemovedEvent");
-var EvmStakeWithdrawnEventZod = z.extend(EvmStakeEventZod, { eventName: EvmStakeWithdrawnEventNameZod });
-var isEvmStakeWithdrawnEvent = zodIsFactory(EvmStakeWithdrawnEventZod);
-var asEvmStakeWithdrawnEvent = zodAsFactory(EvmStakeWithdrawnEventZod, "asEvmStakeWithdrawnEvent");
-var toEvmStakeWithdrawnEvent = zodToFactory(EvmStakeWithdrawnEventZod, "toEvmStakeWithdrawnEvent");
-
-// src/modules/ethereum/drivers/EvmStakeEventsViewer.ts
-var DEFAULT_EVENT_QUERY_BLOCK_CHUNK_SIZE = 2e3;
-var DEFAULT_EVENT_QUERY_MAX_ATTEMPTS = 8;
-var DEFAULT_EVENT_QUERY_INITIAL_DELAY_MS = 1e3;
-var EvmStakeEventsViewer = class extends AbstractEvmViewer {
-  moniker = EvmStakeEventsViewer.defaultMoniker;
-  /** Set at start when `params.deploymentBlock` is omitted (estimated 2025-06-01). */
-  defaultDeploymentBlock = 0;
-  eventCache = /* @__PURE__ */ new Map();
-  get deploymentBlock() {
-    return this.params.deploymentBlock ?? this.defaultDeploymentBlock;
-  }
-  get eventQueryBlockChunkSize() {
-    return this.params.eventQueryBlockChunkSize ?? DEFAULT_EVENT_QUERY_BLOCK_CHUNK_SIZE;
-  }
-  get eventQueryInitialDelayMs() {
-    return this.params.eventQueryInitialDelayMs ?? DEFAULT_EVENT_QUERY_INITIAL_DELAY_MS;
-  }
-  get eventQueryMaxAttempts() {
-    return this.params.eventQueryMaxAttempts ?? DEFAULT_EVENT_QUERY_MAX_ATTEMPTS;
-  }
-  async positionCount(range) {
-    const events = await this.stakeEvents(range);
-    const positionIds = events.map((e) => e.args.id);
-    return Math.max(-1, ...positionIds) + 1;
-  }
-  stakeEvents(range = [0, "latest"], filter) {
-    const allEvents = this.eventCache.values().toArray();
-    const result = allEvents.filter((e) => {
-      if (range[1] !== "latest" && e.time > range[1]) {
-        return false;
-      }
-      if (e.time < range[0]) {
-        return false;
-      }
-      if (isDefined3(filter?.name) && e.name !== filter.name) {
-        return false;
-      }
-      if (isDefined3(filter?.args?.id) && e.args.id !== filter.args.id) {
-        return false;
-      }
-      if (isDefined3(filter?.args?.staked) && e.args.staked !== filter.args.staked) {
-        return false;
-      }
-      if (isDefined3(filter?.args?.staker) && e.args.staker !== filter.args.staker) {
-        return false;
-      }
-      return true;
-    });
-    return result;
-  }
-  connectContract(address) {
-    return IAddressStakingEvents__factory.connect(address, this.provider);
-  }
-  onEventHandler(staked, staker, id, amount, event, throwOnInvalid = false) {
-    const validatedEventResult = EvmStakeEventZod.safeParse(event);
-    if (validatedEventResult.error) {
-      this.logger?.warn(`Received invalid stake event [${event.eventName}/${event.blockNumber}], ignoring...`);
-      this.logger?.warn(` - ${validatedEventResult.error.message}`);
-      if (throwOnInvalid) {
-        throw new Error(`Invalid stake event: ${validatedEventResult.error.message}`);
-      }
-      return;
-    }
-    const validatedEvent = validatedEventResult.data;
-    const { eventName, blockNumber } = validatedEvent;
-    const cacheKey = `${Number(id)}|${eventName}|${staker}`;
-    const stakeEvent = {
-      name: eventName,
-      args: {
-        id: Number(id),
-        staked: toAddress3(staked),
-        staker: toAddress3(staker),
-        amount: asAttoXL1(amount)
-      },
-      time: blockNumber
-    };
-    this.eventCache.set(cacheKey, stakeEvent);
-    return stakeEvent;
-  }
-  async startHandler() {
-    try {
-      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);
-      }
-      await this.loadHistoricalEvents(this.deploymentBlock, historyEndBlock);
-      await this.attachLiveListeners();
-      const latestBlock = assertEx10(await provider.getBlockNumber(), () => new Error("Failed to get latestEthBlock"));
-      if (latestBlock > historyEndBlock) {
-        await this.loadHistoricalEvents(historyEndBlock + 1, latestBlock);
-      }
-    } catch (error) {
-      this.logger?.error("EthereumChainStakeEvents failed to start:", error);
-      throw error;
-    }
-  }
-  async attachLiveListeners() {
-    await this.contract.on(this.contract.getEvent("StakeAdded"), (staked, staker, id, amount, event) => {
-      this.onEventHandler(staked, staker, id, amount, event);
-    });
-    await this.contract.on(this.contract.getEvent("StakeRemoved"), (staked, staker, id, amount, event) => {
-      this.onEventHandler(staked, staker, id, amount, event);
-    });
-    await this.contract.on(this.contract.getEvent("StakeWithdrawn"), (staked, staker, id, amount, event) => {
-      this.onEventHandler(staked, staker, id, amount, event);
-    });
-  }
-  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) {
-      try {
-        ethEventGroups.push(await withRpcRateLimitBackoff(
-          () => this.contract.queryFilter(ethFilter, chunkFrom, 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`
-              );
-            }
-          }
-        ));
-      } catch (error) {
-        this.logger?.error(
-          `eth_getLogs failed for ${name} blocks ${chunkFrom}-${chunkTo} after rate-limit retries (from=${fromBlock} to=${toBlock}):`,
-          error
-        );
-        throw error;
-      }
-    }
-    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);
-  }
-};
-__publicField(EvmStakeEventsViewer, "connectionTypes", ["evm-rpc"]);
-__publicField(EvmStakeEventsViewer, "defaultMoniker", StakeEventsViewerMoniker);
-__publicField(EvmStakeEventsViewer, "dependencies", [EvmChainViewerMoniker4]);
-__publicField(EvmStakeEventsViewer, "monikers", [StakeEventsViewerMoniker]);
-__publicField(EvmStakeEventsViewer, "surface", "node");
-EvmStakeEventsViewer = __decorateClass([
-  creatableProvider4()
-], EvmStakeEventsViewer);
-
-// src/modules/ethereum/drivers/EvmStakeViewer.ts
-import {
-  assertEx as assertEx11,
-  isDefined as isDefined4,
-  toAddress as toAddress4,
-  toEthAddress as toEthAddress9
-} 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";
-import { asAttoXL1 as asAttoXL12 } from "@xyo-network/xl1-sdk";
-import { Mutex } from "async-mutex";
-var ethStakeToStake = (ethStake) => {
-  const stake = {
-    id: Number(ethStake.id),
-    staked: toAddress4(ethStake.staked),
-    staker: toAddress4(ethStake.staker),
-    amount: asAttoXL12(ethStake.amount),
-    addBlock: Number(ethStake.addBlock),
-    removeBlock: Number(ethStake.removeBlock),
-    withdrawBlock: Number(ethStake.withdrawBlock)
-  };
-  return stake;
-};
-var EvmStakeViewer = class extends AbstractEvmViewer {
-  moniker = EvmStakeViewer.defaultMoniker;
-  _callMutex = new Mutex();
-  _deploymentBlock = 0;
-  _stakeCache = /* @__PURE__ */ new Map();
-  _stakeEventsViewer;
-  get stakeEvents() {
-    return this._stakeEventsViewer;
-  }
-  async active() {
-    return await this._callMutex.runExclusive(async () => {
-      return await this.contract.active();
-    });
-  }
-  async activeByAddressStaked(address) {
-    return await this._callMutex.runExclusive(async () => {
-      return await this.contract.activeByAddressStaked(toEthAddress9(address));
-    });
-  }
-  async activeByStaker(address) {
-    return await this._callMutex.runExclusive(async () => {
-      return await this.contract.activeByStaker(toEthAddress9(address));
-    });
-  }
-  activeStakes() {
-    return this._stakeCache.values().filter((stake) => stake.removeBlock === 0 && stake.withdrawBlock === 0).toArray();
-  }
-  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);
-  }
-  minWithdrawalBlocks() {
-    return 0;
-  }
-  async pending() {
-    return await this._callMutex.runExclusive(async () => {
-      return await this.contract.pending();
-    });
-  }
-  async pendingByStaker(staker) {
-    return await this._callMutex.runExclusive(async () => {
-      return await this.contract.pendingByStaker(toEthAddress9(staker));
-    });
-  }
-  removedStakes() {
-    return this._stakeCache.values().filter((stake) => stake.removeBlock !== 0 && stake.withdrawBlock === 0).toArray();
-  }
-  rewardsContract() {
-    return toAddress4("0x000000000000000000000000000000");
-  }
-  async stakeById(id) {
-    return await this._callMutex.runExclusive(async () => {
-      const startTime = Date.now();
-      const cachedStake = this._stakeCache.get(id);
-      if (cachedStake) {
-        return cachedStake;
-      }
-      const ethResult = await this.contract.getStakeById(id);
-      const stake = ethStakeToStake(ethResult);
-      this._stakeCache.set(stake.id, stake);
-      this.logger?.log(`EthereumChainStake: stakeById(${id}) took ${Date.now() - startTime}ms`);
-      return stake;
-    });
-  }
-  async stakeByStaker(staker, slot) {
-    return await this._callMutex.runExclusive(async () => {
-      const ethResult = await this.contract.getStake(toEthAddress9(staker), slot);
-      const stake = ethStakeToStake(ethResult);
-      this._stakeCache.set(stake.id, stake);
-      return stake;
-    });
-  }
-  async stakesByStaked(staked, range = [0, void 0]) {
-    const events = await this.stakeEvents.stakeEvents([Math.max(
-      range[0],
-      this._deploymentBlock
-    ), range.at(1) ?? "latest"], { name: "StakeAdded", args: { staked } });
-    const result = [];
-    for (const event of events) {
-      if (toAddress4(event.args.staked) === toAddress4(staked)) {
-        result.push(await this.stakeById(event.args.id));
-      }
-    }
-    return result;
-  }
-  async stakesByStaker(staker, range = [0, void 0]) {
-    const events = await this.stakeEvents.stakeEvents([Math.max(
-      range[0],
-      this._deploymentBlock
-    ), range.at(1) ?? "latest"], { name: "StakeAdded", args: { staker } });
-    const result = [];
-    for (const event of events) {
-      if (toAddress4(event.args.staker) === toAddress4(staker)) {
-        result.push(await this.stakeById(event.args.id));
-      }
-    }
-    return result;
-  }
-  stakingTokenAddress() {
-    return toAddress4("0x000000000000000000000000000011");
-  }
-  async withdrawn() {
-    return await this._callMutex.runExclusive(async () => {
-      return await this.contract.withdrawn();
-    });
-  }
-  async withdrawnByStaker(staker) {
-    return await this._callMutex.runExclusive(async () => {
-      return await this.contract.withdrawnByStaker(toEthAddress9(staker));
-    });
-  }
-  withdrawnStakes() {
-    return this._stakeCache.values().filter((stake) => stake.removeBlock !== 0 && stake.withdrawBlock !== 0).toArray();
-  }
-  connectContract(address) {
-    return IAddressStaking__factory.connect(address, this.provider);
-  }
-  async startHandler() {
-    await this.contract.on(this.contract.getEvent("StakeAdded"), (staked, staker, id, amount, event) => {
-      this._stakeCache.set(Number(id), {
-        id: Number(id),
-        staked: toAddress4(staked),
-        staker: toAddress4(staker),
-        amount: asAttoXL12(amount),
-        addBlock: event.blockNumber,
-        removeBlock: 0,
-        withdrawBlock: 0
-      });
-    });
-    await this.contract.on(this.contract.getEvent("StakeRemoved"), (staked, staker, id, amount, event) => {
-      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 = assertEx11(this._stakeCache.get(Number(id)));
-      this._stakeCache.set(Number(id), {
-        ...stake,
-        withdrawBlock: event.blockNumber
-      });
-    });
-    const stakeEventGroups = await Promise.all([
-      this.stakeEvents.stakeEvents([this._deploymentBlock, "latest"], { name: "StakeAdded" }),
-      this.stakeEvents.stakeEvents([this._deploymentBlock, "latest"], { name: "StakeRemoved" }),
-      this.stakeEvents.stakeEvents([this._deploymentBlock, "latest"], { name: "StakeWithdrawn" })
-    ]);
-    const allStakeEvents = stakeEventGroups.flat().toSorted((a, b) => a.time - b.time);
-    for (const event of allStakeEvents) {
-      this.applyHistoricalStakeEvent(event);
-    }
-    for (const event of allStakeEvents) {
-      await this.stakeById(event.args.id);
-    }
-  }
-  applyHistoricalStakeEvent(event) {
-    if (event.name === "StakeAdded") {
-      this._stakeCache.set(event.args.id, {
-        id: event.args.id,
-        staked: event.args.staked,
-        staker: event.args.staker,
-        amount: event.args.amount,
-        addBlock: event.time,
-        removeBlock: 0,
-        withdrawBlock: 0
-      });
-      return;
-    }
-    if (event.name === "StakeRemoved") {
-      const stake = assertEx11(this._stakeCache.get(event.args.id));
-      this._stakeCache.set(event.args.id, {
-        ...stake,
-        removeBlock: event.time
-      });
-      return;
-    }
-    if (event.name === "StakeWithdrawn") {
-      const stake = assertEx11(this._stakeCache.get(event.args.id));
-      this._stakeCache.set(event.args.id, {
-        ...stake,
-        withdrawBlock: event.time
-      });
-    }
-  }
-};
-__publicField(EvmStakeViewer, "connectionTypes", ["evm-rpc"]);
-__publicField(EvmStakeViewer, "defaultMoniker", StakeViewerMoniker);
-__publicField(EvmStakeViewer, "dependencies", [EvmChainViewerMoniker5]);
-__publicField(EvmStakeViewer, "monikers", [StakeViewerMoniker]);
-__publicField(EvmStakeViewer, "surface", "node");
-EvmStakeViewer = __decorateClass([
-  creatableProvider5()
-], EvmStakeViewer);
-
-// src/modules/ethereum/ethereum.ts
-import { parseUnits as parseUnits2 } from "ethers/utils";
-var getDefaultGasConfig = () => {
-  return {
-    gasLimit: 2e6,
-    // Set the gas limit
-    gasPrice: parseUnits2("100", "gwei")
-  };
-};
+import { withRpcRateLimitBackoff } from "@xyo-network/xl1-sdk";
 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 +806,11 @@ export {
   EvmStakeViewer,
   EvmStakeWithdrawnEventNameZod,
   EvmStakeWithdrawnEventZod,
+  MIN_EVENT_QUERY_BLOCK_CHUNK_SIZE,
+  RestStakeEventsViewer,
+  asEvmEventIndexFrame,
+  asEvmEventIndexHead,
+  asEvmEventIndexManifest,
   asEvmStakeAddedEvent,
   asEvmStakeEvent,
   asEvmStakeRemovedEvent,
@@ -1292,23 +818,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