@xyo-network/chain-sdk 4.0.5 → 4.1.0

package/dist/neutral/ethereum.mjs

@@ -162,6 +162,42 @@ var BaseEthProvider = class {
   }
 };
 
+// src/modules/ethereum/block/blockRangeChunks.ts
+function blockRangeChunks(fromBlock, toBlock, chunkSize) {
+  if (!Number.isInteger(chunkSize) || chunkSize < 1) {
+    throw new TypeError(`chunkSize must be an integer >= 1, got ${chunkSize}`);
+  }
+  if (!Number.isFinite(fromBlock) || !Number.isFinite(toBlock)) {
+    throw new TypeError(`fromBlock and toBlock must be finite numbers, got [${fromBlock}, ${toBlock}]`);
+  }
+  if (fromBlock > toBlock) {
+    return [];
+  }
+  const chunks = [];
+  for (let start = fromBlock; start <= toBlock; start += chunkSize) {
+    const end = Math.min(start + chunkSize - 1, toBlock);
+    chunks.push([start, end]);
+  }
+  return chunks;
+}
+
+// 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);
+}
+
 // src/modules/ethereum/block/rate/blockRate.ts
 import { isDefined, isFalsy } from "@ariestools/sdk";
 import {
@@ -210,7 +246,7 @@ var calculateEthBlockRate = async (provider, range, timeUnit) => {
 
 // src/modules/ethereum/block/rate/timeRate.ts
 import {
-  assertEx,
+  assertEx as assertEx2,
   isDefined as isDefined2,
   isDefinedNotNull
 } from "@ariestools/sdk";
@@ -222,12 +258,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) => {
-  assertEx(Object.keys(timeConfig ?? {}).length === 1, () => "Only one time unit should be specified in timeConfig");
+  assertEx2(Object.keys(timeConfig ?? {}).length === 1, () => "Only one time unit should be specified in timeConfig");
   const startBlock = isDefinedNotNull(startBlockNumber) ? await provider.getBlock(BigInt(startBlockNumber)) : null;
-  assertEx(isDefinedNotNull(startBlockNumber) && isDefinedNotNull(startBlock), () => "Start block could not be resolved");
-  const resolvedStartBlock = isDefinedNotNull(startBlock) ? startBlock : assertEx(await provider.getBlock("latest"));
+  assertEx2(isDefinedNotNull(startBlockNumber) && isDefinedNotNull(startBlock), () => "Start block could not be resolved");
+  const resolvedStartBlock = isDefinedNotNull(startBlock) ? startBlock : assertEx2(await provider.getBlock("latest"));
   const timeInMilliseconds = getTimeConfigInMilliseconds(timeConfig);
-  assertEx(timeInMilliseconds > 0, () => "Time duration must be greater than zero");
+  assertEx2(timeInMilliseconds > 0, () => "Time duration must be greater than zero");
   const blocksPerMillisecondRate = 1 / (12 * 1e3);
   const initialBlocksInDuration = Math.floor(blocksPerMillisecondRate * timeInMilliseconds);
   const endBlockNumber = await findEndBlockRecursive(
@@ -246,14 +282,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}`);
-  assertEx(attemptsRemaining > 0, () => "Maximum attempts reached while searching for end block");
+  assertEx2(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 = assertEx(
+  const resolvedEndBlock = assertEx2(
     isDefined2(endBlock) ? endBlock : void 0,
     () => `Could not retrieve block ${estimatedEndBlockNumber} for time rate calculation`
   );
@@ -296,7 +332,7 @@ import { createGenesisBlock } from "#protocol";
 // src/modules/ethereum/createChainContract.ts
 import {
   asAddress,
-  assertEx as assertEx2,
+  assertEx as assertEx3,
   ETH_ZERO_ADDRESS,
   hexToBigInt,
   toEthAddress
@@ -324,7 +360,7 @@ var createChainContract = async (signer, stakingTokenAddress, genesisBlockHash,
     );
     await deployResponse.waitForDeployment();
     const xyoChainContractAddress = await deployResponse.getAddress();
-    return assertEx2(asAddress(xyoChainContractAddress), () => "Invalid staking contract address");
+    return assertEx3(asAddress(xyoChainContractAddress), () => "Invalid staking contract address");
   } catch (ex) {
     console.log(ex);
     throw ex;
@@ -334,7 +370,7 @@ var createChainContract = async (signer, stakingTokenAddress, genesisBlockHash,
 // src/modules/ethereum/createChainRewardsContract.ts
 import {
   asAddress as asAddress2,
-  assertEx as assertEx3,
+  assertEx as assertEx4,
   toFixedPoint
 } from "@ariestools/sdk";
 import { XyoChainRewards__factory as XyoChainRewardsFactory } from "@xyo-network/typechain";
@@ -361,7 +397,7 @@ var createChainRewardsContract = async (signer, genesisReward = 0n, gas = gasCon
     );
     await deployResponse.waitForDeployment();
     const xyoChainRewardsAddress = await deployResponse.getAddress();
-    return assertEx3(asAddress2(xyoChainRewardsAddress), () => "Invalid rewards contract address");
+    return assertEx4(asAddress2(xyoChainRewardsAddress), () => "Invalid rewards contract address");
   } catch (ex) {
     console.log(ex);
     throw ex;
@@ -371,7 +407,7 @@ var createChainRewardsContract = async (signer, genesisReward = 0n, gas = gasCon
 // src/modules/ethereum/nextContractAddress.ts
 import {
   asAddress as asAddress3,
-  assertEx as assertEx4,
+  assertEx as assertEx5,
   toEthAddress as toEthAddress2
 } from "@ariestools/sdk";
 import { getCreateAddress } from "ethers/address";
@@ -379,11 +415,11 @@ var nextContractAddressForAddress = async (address, provider) => {
   const deployerAddress = toEthAddress2(address);
   const nonce = await provider.getTransactionCount(deployerAddress);
   const contractAddress = getCreateAddress({ from: deployerAddress, nonce });
-  return assertEx4(asAddress3(contractAddress), () => "Unable to convert contract address to address");
+  return assertEx5(asAddress3(contractAddress), () => "Unable to convert contract address to address");
 };
 var nextContractAddress = async (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");
+  const provider = assertEx5(signer.provider, () => "Unable to obtain provider from signer");
+  const address = assertEx5(asAddress3(await signer.getAddress()), () => "Unable to obtain address from signer");
   return await nextContractAddressForAddress(address, provider);
 };
 
@@ -414,7 +450,7 @@ async function createChain(signer, stakingTokenAddress, initialBlockProducer, re
 
 // src/modules/ethereum/drivers/EvmStakeEventsViewer.ts
 import {
-  assertEx as assertEx7,
+  assertEx as assertEx10,
   exists,
   isDefined as isDefined3,
   toAddress as toAddress3,
@@ -425,36 +461,58 @@ import {
 } from "@xyo-network/typechain";
 import {
   creatableProvider as creatableProvider4,
+  EvmChainViewerMoniker as EvmChainViewerMoniker4,
   StakeEventsViewerMoniker
 } from "@xyo-network/xl1-sdk";
 import { asAttoXL1 } from "@xyo-network/xl1-sdk";
 
 // 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 assertEx5 } 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 = assertEx5(params?.runner, () => new Error("No runner defined"));
-    const provider = assertEx5(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 };
   }
 };
@@ -462,7 +520,7 @@ var AbstractEvmRunner = class extends AbstractEvmViewer {
 // src/modules/ethereum/providers/EvmChainContractViewer.ts
 import {
   asHash,
-  assertEx as assertEx6,
+  assertEx as assertEx9,
   toAddress as toAddress2,
   toEthAddress as toEthAddress5,
   toHex
@@ -471,6 +529,7 @@ import { IStakedXyoChain__factory } from "@xyo-network/typechain";
 import {
   ChainContractViewerMoniker,
   creatableProvider,
+  EvmChainViewerMoniker as EvmChainViewerMoniker2,
   toXL1BlockNumber,
   withContextCacheResponse
 } from "@xyo-network/xl1-sdk";
@@ -483,11 +542,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 () => {
@@ -495,7 +551,7 @@ var EvmChainContractViewer = class extends AbstractEvmViewer {
       let contractViewer = this;
       let forkedAtBlockNumber = await contractViewer.forkedAtBlockNumber();
       while (forkedAtBlockNumber !== null && blockNumber <= forkedAtBlockNumber) {
-        contractViewer = assertEx6(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();
       }
@@ -520,7 +576,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;
   }
@@ -547,12 +607,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([
@@ -602,6 +662,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";
@@ -629,18 +690,105 @@ 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/withRpcRateLimitBackoff.ts
+import { delay } from "@ariestools/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");
+}
+
+// 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,
@@ -696,11 +844,25 @@ 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_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 ?? 0;
+    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);
@@ -733,7 +895,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);
@@ -747,9 +909,7 @@ var EvmStakeEventsViewer = class extends AbstractEvmViewer {
     }
     const validatedEvent = validatedEventResult.data;
     const { eventName, blockNumber } = validatedEvent;
-    this.logger?.log(`Processing ${eventName} event for stake ID ${id} at block ${blockNumber}`);
     const cacheKey = `${Number(id)}|${eventName}|${staker}`;
-    const existingStakeEvent = this.eventCache.get(cacheKey);
     const stakeEvent = {
       name: eventName,
       args: {
@@ -760,67 +920,106 @@ var EvmStakeEventsViewer = class extends AbstractEvmViewer {
       },
       time: blockNumber
     };
-    if (isDefined3(existingStakeEvent)) {
-      this.logger?.warn(`Received ${eventName} event for stake ID ${id} that is already cached, updating cache...`);
-      this.logger?.warn("1");
-      this.logger?.warn("Previous event", existingStakeEvent);
-      this.logger?.warn("2");
-      this.logger?.warn("New event", stakeEvent);
-      this.logger?.warn("3");
-    }
     this.eventCache.set(cacheKey, stakeEvent);
     return stakeEvent;
   }
   async startHandler() {
     try {
-      const currentEthBlock = assertEx7(await this.contract.runner?.provider?.getBlockNumber(), () => new Error("Failed to egt currentEthBlock"));
-      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);
-      });
-      await this.loadHistoricalEvents(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);
+      }
+      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 loadHistoricalEvents(currentEthBlock) {
+  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([this.deploymentBlock, currentEthBlock], { name: "StakeAdded" }),
-      this.stakeEventsNative([this.deploymentBlock, currentEthBlock], { name: "StakeRemoved" }),
-      this.stakeEventsNative([this.deploymentBlock, currentEthBlock], { name: "StakeWithdrawn" })
+      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);
-    console.warn(`Caching ${allStakeEvents.length} stake events from chain starting at block ${this.deploymentBlock}`);
+    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)) {
-      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 ethEvents = await this.contract.queryFilter(ethFilter, range[0], range[1]);
-      return ethEvents.map((e) => {
-        assertEx7(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);
+    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;
+      }
     }
-    throw new Error("Only filtered stake events (by name) are supported");
+    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", []);
+__publicField(EvmStakeEventsViewer, "dependencies", [EvmChainViewerMoniker4]);
 __publicField(EvmStakeEventsViewer, "monikers", [StakeEventsViewerMoniker]);
 __publicField(EvmStakeEventsViewer, "surface", "node");
 EvmStakeEventsViewer = __decorateClass([
@@ -829,13 +1028,15 @@ EvmStakeEventsViewer = __decorateClass([
 
 // src/modules/ethereum/drivers/EvmStakeViewer.ts
 import {
-  assertEx as assertEx8,
+  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";
@@ -883,6 +1084,7 @@ var EvmStakeViewer = class extends AbstractEvmViewer {
   async createHandler() {
     await super.createHandler();
     this._stakeEventsViewer = await this.locator.getInstance(StakeEventsViewerMoniker2);
+    this._deploymentBlock = isDefined4(this.params.deploymentBlock) ? this.params.deploymentBlock : await estimateBlockNumberAt(this.provider);
   }
   minWithdrawalBlocks() {
     return 0;
@@ -968,7 +1170,7 @@ var EvmStakeViewer = class extends AbstractEvmViewer {
     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) => {
@@ -983,14 +1185,14 @@ var EvmStakeViewer = class extends AbstractEvmViewer {
       });
     });
     await this.contract.on(this.contract.getEvent("StakeRemoved"), (staked, staker, id, amount, event) => {
-      const stake = assertEx8(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 = assertEx8(this._stakeCache.get(Number(id)));
+      const stake = assertEx11(this._stakeCache.get(Number(id)));
       this._stakeCache.set(Number(id), {
         ...stake,
         withdrawBlock: event.blockNumber
@@ -1023,7 +1225,7 @@ var EvmStakeViewer = class extends AbstractEvmViewer {
       return;
     }
     if (event.name === "StakeRemoved") {
-      const stake = assertEx8(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
@@ -1031,7 +1233,7 @@ var EvmStakeViewer = class extends AbstractEvmViewer {
       return;
     }
     if (event.name === "StakeWithdrawn") {
-      const stake = assertEx8(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
@@ -1041,7 +1243,7 @@ var EvmStakeViewer = class extends AbstractEvmViewer {
 };
 __publicField(EvmStakeViewer, "connectionTypes", ["evm-rpc"]);
 __publicField(EvmStakeViewer, "defaultMoniker", StakeViewerMoniker);
-__publicField(EvmStakeViewer, "dependencies", []);
+__publicField(EvmStakeViewer, "dependencies", [EvmChainViewerMoniker5]);
 __publicField(EvmStakeViewer, "monikers", [StakeViewerMoniker]);
 __publicField(EvmStakeViewer, "surface", "node");
 EvmStakeViewer = __decorateClass([
@@ -1062,6 +1264,11 @@ export {
   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_EVM_BLOCK_TIME_SEC,
   EthHashRegEx,
   EthHashZod,
   EvmChainContractViewer,
@@ -1082,11 +1289,14 @@ export {
   asEvmStakeEvent,
   asEvmStakeRemovedEvent,
   asEvmStakeWithdrawnEvent,
+  blockRangeChunks,
   calculateEthBlockRate,
   calculateEthTimeRate,
   createChain,
   createChainContract,
   createChainRewardsContract,
+  estimateBlockNumberAt,
+  estimateBlockNumberFromHead,
   ethBlockRate,
   getDefaultGasConfig,
   getEthBlockRateBlocks,