@xyo-network/chain-sdk 4.2.1 → 4.3.0

package/dist/neutral/ethereum.mjs

@@ -182,74 +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
-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;
-  }
-}
+import {
+  configuredDeploymentBlock,
+  findContractDeploymentBlock,
+  resolveContractDeploymentBlock
+} from "@xyo-network/xl1-sdk";
 
 // src/modules/ethereum/block/rate/blockRate.ts
 import { isDefined, isFalsy } from "@ariestools/sdk";
@@ -299,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";
@@ -311,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(
@@ -335,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`
   );
@@ -385,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
@@ -413,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;
@@ -423,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";
@@ -450,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;
@@ -460,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";
@@ -468,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);
 };
 
@@ -503,869 +448,42 @@ async function createChain(signer, stakingTokenAddress, initialBlockProducer, re
 
 // src/modules/ethereum/drivers/EvmStakeEventsViewer.ts
 import {
-  assertEx as assertEx10,
-  isDefined as isDefined3,
-  toAddress as toAddress3
-} from "@ariestools/sdk";
-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 {
-  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);
-  }
-};
-
-// src/modules/ethereum/providers/AbstractEvmRunner.ts
-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 = 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/providers/EvmChainContractViewer.ts
-import {
-  asHash,
-  assertEx as assertEx9,
-  toAddress as toAddress2,
-  toEthAddress as toEthAddress5,
-  toHex
-} from "@ariestools/sdk";
-import { IStakedXyoChain__factory } from "@xyo-network/typechain";
-import {
-  ChainContractViewerMoniker,
-  creatableProvider,
-  EvmChainViewerMoniker as EvmChainViewerMoniker2,
-  toXL1BlockNumber,
-  withContextCacheResponse
-} 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;
-    });
-  }
-  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;
-    }
-  }
-  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;
-  }
-  async forkedChainId() {
-    this._forkedChainId = this._forkedChainId ?? (async () => {
-      return toAddress2(await this.contract.forkedChainId());
-    })();
-    return await this._forkedChainId;
-  }
-  async minWithdrawalBlocks() {
-    this._minWithdrawalBlocks = this._minWithdrawalBlocks ?? (async () => Number(await this.contract.minWithdrawalBlocks()))();
-    return await this._minWithdrawalBlocks;
-  }
-  async rewardsContract() {
-    this._rewardsContract = this._rewardsContract ?? (async () => {
-      return toAddress2(await this.contract.rewardsContract());
-    })();
-    return await this._rewardsContract;
-  }
-  async stakingTokenAddress() {
-    this._stakingTokenAddress = this._stakingTokenAddress ?? (async () => {
-      return toAddress2(await this.contract.stakingTokenAddress());
-    })();
-    return await this._stakingTokenAddress;
-  }
-  connectContract(address) {
-    return IStakedXyoChain__factory.connect(address, this.provider);
-  }
-};
-__publicField(EvmChainContractViewer, "connectionTypes", ["evm-rpc"]);
-__publicField(EvmChainContractViewer, "defaultMoniker", ChainContractViewerMoniker);
-__publicField(EvmChainContractViewer, "dependencies", [EvmChainViewerMoniker2]);
-__publicField(EvmChainContractViewer, "monikers", [ChainContractViewerMoniker]);
-__publicField(EvmChainContractViewer, "surface", "node");
-EvmChainContractViewer = __decorateClass([
-  creatableProvider()
-], EvmChainContractViewer);
-
-// src/modules/ethereum/providers/EvmStakeRunner.ts
-import { toEthAddress as toEthAddress6 } from "@ariestools/sdk";
-import { IStakedXyoChain__factory as IStakedXyoChain__factory2 } from "@xyo-network/typechain";
-import {
-  creatableProvider as creatableProvider2,
-  StakeRunnerMoniker
-} from "@xyo-network/xl1-sdk";
-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);
-    await result.wait();
-    return true;
-  }
-  async removeStake(slot) {
-    const result = await this.contract.removeStake(slot);
-    await result.wait();
-    return true;
-  }
-  async withdrawStake(slot) {
-    const result = await this.contract.withdrawStake(slot);
-    await result.wait();
-    return true;
-  }
-  connectContract(address) {
-    return IStakedXyoChain__factory2.connect(address, this.params.runner);
-  }
-};
-__publicField(EvmStakeRunner, "connectionTypes", ["evm-rpc"]);
-__publicField(EvmStakeRunner, "defaultMoniker", StakeRunnerMoniker);
-__publicField(EvmStakeRunner, "dependencies", []);
-__publicField(EvmStakeRunner, "monikers", [StakeRunnerMoniker]);
-__publicField(EvmStakeRunner, "surface", "node");
-EvmStakeRunner = __decorateClass([
-  creatableProvider2()
-], 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
+  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 { 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);
-
-// 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";
-
-// 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,
-  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([
+  asEvmStakeAddedEvent,
+  asEvmStakeEvent,
+  asEvmStakeRemovedEvent,
+  asEvmStakeWithdrawnEvent,
+  EthHashRegEx,
+  EthHashZod,
   EvmStakeAddedEventNameZod,
+  EvmStakeAddedEventZod,
+  EvmStakeEventArgsZod,
+  EvmStakeEventNameZod,
+  EvmStakeEventZod,
   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_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;
-  /**
-   * 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.config.chain?.deploymentBlock ?? this.defaultDeploymentBlock;
-  }
-  get eventQueryBlockChunkSize() {
-    return this.fixedEventQueryBlockChunkSize ?? this.adaptiveChunkSize ?? DEFAULT_EVENT_QUERY_START_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;
-  }
-  /**
-   * 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);
-    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 = configuredDeploymentBlock(this.config) ?? await resolveContractDeploymentBlock(provider, this.address, this.logger);
-      }
-      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);
-    });
-  }
-  /**
-   * 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;
-    }
-    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 {
-        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 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 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;
-    }
-    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", [EvmChainViewerMoniker4]);
-__publicField(EvmStakeEventsViewer, "monikers", [StakeEventsViewerMoniker]);
-__publicField(EvmStakeEventsViewer, "surface", "node");
-EvmStakeEventsViewer = __decorateClass([
-  creatableProvider4()
-], EvmStakeEventsViewer);
+  EvmStakeRemovedEventZod,
+  EvmStakeWithdrawnEventNameZod,
+  EvmStakeWithdrawnEventZod,
+  isEvmStakeAddedEvent,
+  isEvmStakeEvent,
+  isEvmStakeRemovedEvent,
+  isEvmStakeWithdrawnEvent,
+  toEvmStakeAddedEvent,
+  toEvmStakeEvent,
+  toEvmStakeRemovedEvent,
+  toEvmStakeWithdrawnEvent
+} from "@xyo-network/xl1-sdk";
 
 // src/modules/ethereum/drivers/EvmStakeViewer.ts
-import {
-  assertEx as assertEx11,
-  toAddress as toAddress4,
-  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";
-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(toEthAddress8(address));
-    });
-  }
-  async activeByStaker(address) {
-    return await this._callMutex.runExclusive(async () => {
-      return await this.contract.activeByStaker(toEthAddress8(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 = this.params.deploymentBlock ?? configuredDeploymentBlock(this.config) ?? await resolveContractDeploymentBlock(this.provider, this.address, this.logger);
-  }
-  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(toEthAddress8(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(toEthAddress8(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(toEthAddress8(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, StakeEventsViewerMoniker2]);
-__publicField(EvmStakeViewer, "monikers", [StakeViewerMoniker]);
-__publicField(EvmStakeViewer, "surface", "node");
-EvmStakeViewer = __decorateClass([
-  creatableProvider5()
-], EvmStakeViewer);
+import { EvmStakeViewer } from "@xyo-network/xl1-sdk";
 
 // src/modules/ethereum/ethereum.ts
 import { parseUnits as parseUnits2 } from "ethers/utils";
@@ -1379,44 +497,44 @@ var getDefaultGasConfig = () => {
 
 // src/modules/ethereum/indexing/EvmEventIndexModel.ts
 import {
-  EthAddressZod as EthAddressZod2,
-  HexRegExMinMaxMixedCaseWithPrefix as HexRegExMinMaxMixedCaseWithPrefix2,
-  zodAsFactory as zodAsFactory2
+  EthAddressZod,
+  HexRegExMinMaxMixedCaseWithPrefix,
+  zodAsFactory
 } 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,
+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: z2.number(),
+  blockNumber: z.number(),
   data: EvmDataZod,
-  index: z2.number(),
-  topics: z2.array(EvmHashZod),
+  index: z.number(),
+  topics: z.array(EvmHashZod),
   transactionHash: EvmHashZod,
-  transactionIndex: z2.number()
+  transactionIndex: z.number()
 });
-var EvmEventIndexFrameZod = z2.object({
-  fromBlock: z2.number(),
-  logs: z2.array(EvmEventIndexLogZod),
-  toBlock: z2.number()
+var EvmEventIndexFrameZod = z.object({
+  fromBlock: z.number(),
+  logs: z.array(EvmEventIndexLogZod),
+  toBlock: z.number()
 });
-var EvmEventIndexManifestZod = z2.object({
-  address: EthAddressZod2,
-  chainId: z2.string(),
-  deploymentBlock: z2.number(),
-  frameSize: z2.number(),
-  layout: z2.literal("evm-contract-events-v1")
+var EvmEventIndexManifestZod = z.object({
+  address: EthAddressZod,
+  chainId: z.string(),
+  deploymentBlock: z.number(),
+  frameSize: z.number(),
+  layout: z.literal("evm-contract-events-v1")
 });
-var EvmEventIndexHeadZod = z2.object({
-  address: EthAddressZod2,
-  block: z2.number(),
-  chainId: z2.string(),
+var EvmEventIndexHeadZod = z.object({
+  address: EthAddressZod,
+  block: z.number(),
+  chainId: z.string(),
   hash: EvmHashZod
 });
-var asEvmEventIndexFrame = zodAsFactory2(EvmEventIndexFrameZod, "asEvmEventIndexFrame");
-var asEvmEventIndexHead = zodAsFactory2(EvmEventIndexHeadZod, "asEvmEventIndexHead");
-var asEvmEventIndexManifest = zodAsFactory2(EvmEventIndexManifestZod, "asEvmEventIndexManifest");
+var asEvmEventIndexFrame = zodAsFactory(EvmEventIndexFrameZod, "asEvmEventIndexFrame");
+var asEvmEventIndexHead = zodAsFactory(EvmEventIndexHeadZod, "asEvmEventIndexHead");
+var asEvmEventIndexManifest = zodAsFactory(EvmEventIndexManifestZod, "asEvmEventIndexManifest");
 
 // src/modules/ethereum/indexing/EvmEventIndexPaths.ts
 function root(address) {
@@ -1440,25 +558,25 @@ var EvmEventIndexPublishRunnerMoniker = "EvmEventIndexPublishRunner";
 
 // src/modules/ethereum/indexing/RestStakeEventsViewer.ts
 import {
-  assertEx as assertEx12,
-  isDefined as isDefined4,
-  toAddress as toAddress5,
-  toEthAddress as toEthAddress9
+  assertEx as assertEx5,
+  isDefined as isDefined3,
+  toAddress as toAddress2,
+  toEthAddress as toEthAddress4
 } from "@ariestools/sdk";
-import { IAddressStakingEvents__factory as IAddressStakingEvents__factory2 } from "@xyo-network/typechain";
+import { IAddressStakingEvents__factory } from "@xyo-network/typechain";
 import {
-  AbstractCreatableProvider as AbstractCreatableProvider2,
-  asAttoXL1 as asAttoXL13,
-  creatableProvider as creatableProvider6,
+  AbstractCreatableProvider,
+  asAttoXL1,
+  creatableProvider,
   resolveRestConnectionEndpoint,
-  StakeEventsViewerMoniker as StakeEventsViewerMoniker3
+  StakeEventsViewerMoniker
 } from "@xyo-network/xl1-sdk";
 import { Interface } from "ethers";
-var STAKE_EVENT_NAMES2 = /* @__PURE__ */ new Set(["StakeAdded", "StakeRemoved", "StakeWithdrawn"]);
-var RestStakeEventsViewer = class extends AbstractCreatableProvider2 {
+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__factory2.abi);
+  contractInterface = new Interface(IAddressStakingEvents__factory.abi);
   currentHead;
   manifestPromise;
   stakeEventCache = [];
@@ -1475,10 +593,10 @@ var RestStakeEventsViewer = class extends AbstractCreatableProvider2 {
   }
   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 address = params.address ?? toEthAddress4(assertEx5(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"),
+    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 {
@@ -1506,13 +624,13 @@ var RestStakeEventsViewer = class extends AbstractCreatableProvider2 {
   }
   async fetchJson(path) {
     const response = await this.fetchFn(`${this.eventIndexBaseUrl}/${path}`);
-    assertEx12(response.ok, () => `EVM event index request failed [${response.status}] for ${path}`);
+    assertEx5(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");
+      assertEx5(manifest.address.toLowerCase() === this.address.toLowerCase(), () => "EVM event index manifest address mismatch");
       return manifest;
     })();
     return await this.manifestPromise;
@@ -1521,23 +639,23 @@ var RestStakeEventsViewer = class extends AbstractCreatableProvider2 {
   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;
+    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;
   }
   stakeEventFromLog(log) {
     const parsed = this.contractInterface.parseLog({ data: log.data, topics: log.topics });
-    if (parsed === null || !STAKE_EVENT_NAMES2.has(parsed.name)) return;
+    if (parsed === null || !STAKE_EVENT_NAMES.has(parsed.name)) return;
     const [staked, staker, id, amount] = parsed.args;
     return {
       name: parsed.name,
       args: {
-        amount: asAttoXL13(amount),
+        amount: asAttoXL1(amount),
         id: Number(id),
-        staked: toAddress5(staked),
-        staker: toAddress5(staker)
+        staked: toAddress2(staked),
+        staker: toAddress2(staker)
       },
       time: log.blockNumber
     };
@@ -1551,8 +669,8 @@ var RestStakeEventsViewer = class extends AbstractCreatableProvider2 {
   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");
+    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();
@@ -1564,28 +682,99 @@ var RestStakeEventsViewer = class extends AbstractCreatableProvider2 {
     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`);
+      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) {
-      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");
+      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(RestStakeEventsViewer, "connectionTypes", ["rest"]);
-__publicField(RestStakeEventsViewer, "defaultMoniker", StakeEventsViewerMoniker3);
+__publicField(RestStakeEventsViewer, "defaultMoniker", StakeEventsViewerMoniker);
 __publicField(RestStakeEventsViewer, "dependencies", []);
-__publicField(RestStakeEventsViewer, "monikers", [StakeEventsViewerMoniker3]);
+__publicField(RestStakeEventsViewer, "monikers", [StakeEventsViewerMoniker]);
 __publicField(RestStakeEventsViewer, "surface", "node");
 RestStakeEventsViewer = __decorateClass([
-  creatableProvider6()
+  creatableProvider()
 ], 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 toEthAddress5 } from "@ariestools/sdk";
+import { IStakedXyoChain__factory } from "@xyo-network/typechain";
+import {
+  creatableProvider as creatableProvider2,
+  StakeRunnerMoniker
+} from "@xyo-network/xl1-sdk";
+import { getAddress } from "ethers/address";
+var EvmStakeRunner = class extends AbstractEvmRunner {
+  moniker = EvmStakeRunner.defaultMoniker;
+  async addStake(staked, amount) {
+    const result = await this.contract.addStake(getAddress(toEthAddress5(staked)), amount);
+    await result.wait();
+    return true;
+  }
+  async removeStake(slot) {
+    const result = await this.contract.removeStake(slot);
+    await result.wait();
+    return true;
+  }
+  async withdrawStake(slot) {
+    const result = await this.contract.withdrawStake(slot);
+    await result.wait();
+    return true;
+  }
+  connectContract(address) {
+    return IStakedXyoChain__factory.connect(address, this.params.runner);
+  }
+};
+__publicField(EvmStakeRunner, "connectionTypes", ["evm-rpc"]);
+__publicField(EvmStakeRunner, "defaultMoniker", StakeRunnerMoniker);
+__publicField(EvmStakeRunner, "dependencies", []);
+__publicField(EvmStakeRunner, "monikers", [StakeRunnerMoniker]);
+__publicField(EvmStakeRunner, "surface", "node");
+EvmStakeRunner = __decorateClass([
+  creatableProvider2()
+], EvmStakeRunner);
+
+// src/modules/ethereum/providers/EvmStakeTotalsViewer.ts
+import { EvmStakeTotalsViewer } from "@xyo-network/xl1-sdk";
+
+// src/modules/ethereum/rpc/isRpcRangeLimitError.ts
+import { isRpcRangeLimitError, rpcRangeLimitFromError } from "@xyo-network/xl1-sdk";
+
+// src/modules/ethereum/rpc/isRpcRateLimitError.ts
+import { isRpcRateLimitError } from "@xyo-network/xl1-sdk";
+
+// src/modules/ethereum/rpc/withRpcRateLimitBackoff.ts
+import { withRpcRateLimitBackoff } from "@xyo-network/xl1-sdk";
 export {
   AbstractEvmProvider,
   AbstractEvmRunner,