@xyo-network/chain-sdk 4.0.4 → 4.0.6

package/dist/neutral/ethereum.mjs

@@ -0,0 +1,1288 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/modules/ethereum/BaseEthProvider.ts
+var BaseEthProvider = class {
+  eth_accounts() {
+    throw new Error("Method not implemented.");
+  }
+  eth_blockNumber() {
+    throw new Error("Method not implemented.");
+  }
+  eth_call(_transaction, _blockNumber) {
+    throw new Error("Method not implemented.");
+  }
+  eth_clearSubscriptions(_keepSyncing) {
+    throw new Error("Method not implemented.");
+  }
+  eth_coinbase() {
+    throw new Error("Method not implemented.");
+  }
+  eth_compileLLL(_code) {
+    throw new Error("Method not implemented.");
+  }
+  eth_compileSerpent(_code) {
+    throw new Error("Method not implemented.");
+  }
+  eth_compileSolidity(_code) {
+    throw new Error("Method not implemented.");
+  }
+  eth_estimateGas(_transaction, _blockNumber) {
+    throw new Error("Method not implemented.");
+  }
+  eth_feeHistory(_blockCount, _newestBlock, _rewardPercentiles) {
+    throw new Error("Method not implemented.");
+  }
+  eth_gasPrice() {
+    throw new Error("Method not implemented.");
+  }
+  eth_getBalance(_address, _blockNumber) {
+    throw new Error("Method not implemented.");
+  }
+  eth_getBlockByHash(_blockHash, _hydrated) {
+    throw new Error("Method not implemented.");
+  }
+  eth_getBlockByNumber(_blockNumber, _hydrated) {
+    throw new Error("Method not implemented.");
+  }
+  eth_getBlockTransactionCountByHash(_blockHash) {
+    throw new Error("Method not implemented.");
+  }
+  eth_getBlockTransactionCountByNumber(_blockNumber) {
+    throw new Error("Method not implemented.");
+  }
+  eth_getCode(_address, _blockNumber) {
+    throw new Error("Method not implemented.");
+  }
+  eth_getCompilers() {
+    throw new Error("Method not implemented.");
+  }
+  eth_getFilterChanges(_filterIdentifier) {
+    throw new Error("Method not implemented.");
+  }
+  eth_getFilterLogs(_filterIdentifier) {
+    throw new Error("Method not implemented.");
+  }
+  eth_getLogs(_filter) {
+    throw new Error("Method not implemented.");
+  }
+  eth_getStorageAt(_address, _storageSlot, _blockNumber) {
+    throw new Error("Method not implemented.");
+  }
+  eth_getTransactionByBlockHashAndIndex(_blockHash, _transactionIndex) {
+    throw new Error("Method not implemented.");
+  }
+  eth_getTransactionByBlockNumberAndIndex(_blockNumber, _transactionIndex) {
+    throw new Error("Method not implemented.");
+  }
+  eth_getTransactionByHash(_transactionHash) {
+    throw new Error("Method not implemented.");
+  }
+  eth_getTransactionCount(_address, _blockNumber) {
+    throw new Error("Method not implemented.");
+  }
+  eth_getTransactionReceipt(_transactionHash) {
+    throw new Error("Method not implemented.");
+  }
+  eth_getUncleByBlockHashAndIndex(_blockHash, _uncleIndex) {
+    throw new Error("Method not implemented.");
+  }
+  eth_getUncleByBlockNumberAndIndex(_blockNumber, _uncleIndex) {
+    throw new Error("Method not implemented.");
+  }
+  eth_getUncleCountByBlockHash(_blockHash) {
+    throw new Error("Method not implemented.");
+  }
+  eth_getUncleCountByBlockNumber(_blockNumber) {
+    throw new Error("Method not implemented.");
+  }
+  eth_getWork() {
+    throw new Error("Method not implemented.");
+  }
+  eth_hashrate() {
+    throw new Error("Method not implemented.");
+  }
+  eth_maxPriorityFeePerGas() {
+    throw new Error("Method not implemented.");
+  }
+  eth_mining() {
+    throw new Error("Method not implemented.");
+  }
+  eth_newBlockFilter() {
+    throw new Error("Method not implemented.");
+  }
+  eth_newFilter(_filter) {
+    throw new Error("Method not implemented.");
+  }
+  eth_newPendingTransactionFilter() {
+    throw new Error("Method not implemented.");
+  }
+  eth_protocolVersion() {
+    throw new Error("Method not implemented.");
+  }
+  eth_sendRawTransaction(_transaction) {
+    throw new Error("Method not implemented.");
+  }
+  eth_sendTransaction(_transaction) {
+    throw new Error("Method not implemented.");
+  }
+  eth_sign(_address, _message) {
+    throw new Error("Method not implemented.");
+  }
+  eth_signTransaction(_transaction) {
+    throw new Error("Method not implemented.");
+  }
+  eth_submitHashrate(_hashRate, _id) {
+    throw new Error("Method not implemented.");
+  }
+  eth_submitWork(_nonce, _hash, _digest) {
+    throw new Error("Method not implemented.");
+  }
+  eth_subscribe(..._params) {
+    throw new Error("Method not implemented.");
+  }
+  eth_syncing() {
+    throw new Error("Method not implemented.");
+  }
+  eth_uninstallFilter(_filterIdentifier) {
+    throw new Error("Method not implemented.");
+  }
+  eth_unsubscribe(_subscriptionId) {
+    throw new Error("Method not implemented.");
+  }
+};
+
+// 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 {
+  asEthBlockRange,
+  rateMultipliers,
+  timeDurations
+} from "@xyo-network/xl1-sdk";
+var ethBlockRate = (startBlock, endBlock, timeUnit) => {
+  const heightDifference = endBlock.number - startBlock.number;
+  const timeDifference = endBlock.timestamp - startBlock.timestamp;
+  const rate = heightDifference / timeDifference;
+  const timeUnitValue = isDefined(timeUnit) ? timeUnit : "millis";
+  const returnedTimeDifference = isDefined(timeUnit) ? timeDurations(timeDifference)[timeUnit] : timeDifference;
+  const timePerBlock = returnedTimeDifference / heightDifference;
+  return {
+    range: asEthBlockRange([startBlock.number, endBlock.number], true),
+    span: heightDifference,
+    rate: isDefined(timeUnit) ? rate * rateMultipliers[timeUnit] : rate,
+    timeUnit: timeUnitValue,
+    timeDifference: returnedTimeDifference,
+    timePerBlock
+  };
+};
+var getEthBlockRateBlocks = async (provider, startBlockHeight, endBlockHeight) => {
+  if (endBlockHeight <= startBlockHeight) {
+    console.error("startBlockHeight", startBlockHeight);
+    console.error("endBlockHeight", endBlockHeight);
+    throw new Error("End block height must be greater than start block height");
+  }
+  const startingBlock = await provider.getBlock(startBlockHeight);
+  const endingBlock = await provider.getBlock(endBlockHeight);
+  if (isFalsy(startingBlock) || isFalsy(endingBlock)) {
+    throw new Error("Could not retrieve blocks for speed calculation");
+  }
+  return { startingBlock, endingBlock };
+};
+var calculateEthBlockRate = async (provider, range, timeUnit) => {
+  const [startBlockHeight, endBlockHeight] = range;
+  const { startingBlock, endingBlock } = await getEthBlockRateBlocks(
+    provider,
+    startBlockHeight,
+    endBlockHeight
+  );
+  return ethBlockRate(startingBlock, endingBlock, timeUnit);
+};
+
+// src/modules/ethereum/block/rate/timeRate.ts
+import {
+  assertEx as assertEx2,
+  isDefined as isDefined2,
+  isDefinedNotNull
+} from "@ariestools/sdk";
+import {
+  asEthBlockNumber,
+  asEthBlockRange as asEthBlockRange2,
+  getTimeConfigInMilliseconds
+} from "@xyo-network/xl1-sdk";
+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");
+  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"));
+  const timeInMilliseconds = getTimeConfigInMilliseconds(timeConfig);
+  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(
+    provider,
+    resolvedStartBlock,
+    timeInMilliseconds,
+    initialBlocksInDuration,
+    toleranceMs,
+    maxAttempts
+  );
+  return await calculateEthBlockRate(
+    provider,
+    asEthBlockRange2([endBlockNumber, resolvedStartBlock.number], true),
+    timeUnit
+  );
+};
+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");
+  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(
+    isDefined2(endBlock) ? endBlock : void 0,
+    () => `Could not retrieve block ${estimatedEndBlockNumber} for time rate calculation`
+  );
+  const endBlockEpoch = resolvedEndBlock.timestamp;
+  const actualTimeDifference = startBlockEpoch - endBlockEpoch;
+  const timeDelta = Math.abs(actualTimeDifference - targetTimeMs);
+  if (timeDelta <= toleranceMs) {
+    return asEthBlockNumber(resolvedEndBlock.number, true);
+  }
+  let adjustedBlocksBack;
+  if (actualTimeDifference < targetTimeMs) {
+    const adjustmentFactor = targetTimeMs / actualTimeDifference;
+    adjustedBlocksBack = Math.floor(estimatedBlocksBack * adjustmentFactor);
+    if (adjustedBlocksBack > startBlock.number) {
+      adjustedBlocksBack = startBlock.number / 2;
+    }
+  } else {
+    const adjustmentFactor = actualTimeDifference / targetTimeMs;
+    adjustedBlocksBack = Math.floor(estimatedBlocksBack / adjustmentFactor);
+  }
+  return await findEndBlockRecursive(
+    provider,
+    startBlock,
+    targetTimeMs,
+    adjustedBlocksBack,
+    toleranceMs,
+    attemptsRemaining - 1
+  );
+};
+
+// src/modules/ethereum/createChain.ts
+import {
+  toAddress,
+  toEthAddress as toEthAddress3
+} from "@ariestools/sdk";
+import { PayloadBuilder } from "@xyo-network/sdk";
+import { XYO_NETWORK_STAKING_ADDRESS as XYO_NETWORK_STAKING_ADDRESS2 } from "@xyo-network/xl1-sdk";
+import { createGenesisBlock } from "#protocol";
+
+// src/modules/ethereum/createChainContract.ts
+import {
+  asAddress,
+  assertEx as assertEx3,
+  ETH_ZERO_ADDRESS,
+  hexToBigInt,
+  toEthAddress
+} from "@ariestools/sdk";
+import { StakedXyoChainV2__factory } from "@xyo-network/typechain";
+import { XYO_NETWORK_STAKING_ADDRESS } from "@xyo-network/xl1-sdk";
+var createChainContract = async (signer, stakingTokenAddress, genesisBlockHash, rewardsContractAddress, minWithdrawalBlocks, maxStakersPerAddress = 10, unlimitedStakingAddress = XYO_NETWORK_STAKING_ADDRESS, minStake = 10000n, gas = {}) => {
+  try {
+    const xyoChainFactory = new StakedXyoChainV2__factory(signer);
+    const deployResponse = await xyoChainFactory.deploy(
+      ETH_ZERO_ADDRESS,
+      // forkFromChainId
+      0n,
+      // forkFromLastBlockNumber
+      hexToBigInt(genesisBlockHash),
+      // forkFromLastHash
+      toEthAddress(rewardsContractAddress),
+      minWithdrawalBlocks,
+      // min withdraw blocks
+      toEthAddress(stakingTokenAddress),
+      maxStakersPerAddress,
+      toEthAddress(unlimitedStakingAddress),
+      minStake,
+      gas
+    );
+    await deployResponse.waitForDeployment();
+    const xyoChainContractAddress = await deployResponse.getAddress();
+    return assertEx3(asAddress(xyoChainContractAddress), () => "Invalid staking contract address");
+  } catch (ex) {
+    console.log(ex);
+    throw ex;
+  }
+};
+
+// src/modules/ethereum/createChainRewardsContract.ts
+import {
+  asAddress as asAddress2,
+  assertEx as assertEx4,
+  toFixedPoint
+} from "@ariestools/sdk";
+import { XyoChainRewards__factory as XyoChainRewardsFactory } from "@xyo-network/typechain";
+import { parseUnits } from "ethers";
+var gasConfig = () => {
+  return {
+    gasLimit: 2e6,
+    // Set the gas limit
+    gasPrice: parseUnits("100", "gwei")
+  };
+};
+var createChainRewardsContract = async (signer, genesisReward = 0n, gas = gasConfig()) => {
+  try {
+    const xyoChainRewardsFactory = new XyoChainRewardsFactory(signer);
+    const deployResponse = await xyoChainRewardsFactory.deploy(
+      toFixedPoint(1000n),
+      1000000n,
+      95n,
+      100n,
+      toFixedPoint(30n),
+      genesisReward,
+      18n,
+      gas
+    );
+    await deployResponse.waitForDeployment();
+    const xyoChainRewardsAddress = await deployResponse.getAddress();
+    return assertEx4(asAddress2(xyoChainRewardsAddress), () => "Invalid rewards contract address");
+  } catch (ex) {
+    console.log(ex);
+    throw ex;
+  }
+};
+
+// src/modules/ethereum/nextContractAddress.ts
+import {
+  asAddress as asAddress3,
+  assertEx as assertEx5,
+  toEthAddress as toEthAddress2
+} from "@ariestools/sdk";
+import { getCreateAddress } from "ethers/address";
+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");
+};
+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");
+  return await nextContractAddressForAddress(address, provider);
+};
+
+// src/modules/ethereum/createChain.ts
+async function createChain(signer, stakingTokenAddress, initialBlockProducer, rewardsContractAddress, genesisBlockRewardAmount, genesisBlockRewardAddress, minWithdrawalBlocks, maxStakersPerAddress = 10, unlimitedStakingAddress = XYO_NETWORK_STAKING_ADDRESS2, minStake = 10000n, gas) {
+  const ethStakingTokenAddress = toEthAddress3(stakingTokenAddress);
+  const rewardContractAddressResolved = rewardsContractAddress ?? await createChainRewardsContract(signer, genesisBlockRewardAmount, gas);
+  const contractAddress = await nextContractAddress(signer);
+  const genesisBlock = await createGenesisBlock(
+    initialBlockProducer,
+    contractAddress,
+    genesisBlockRewardAmount,
+    genesisBlockRewardAddress
+  );
+  const chainId = toAddress(await createChainContract(
+    signer,
+    ethStakingTokenAddress,
+    await PayloadBuilder.hash(genesisBlock[0]),
+    rewardContractAddressResolved,
+    minWithdrawalBlocks,
+    maxStakersPerAddress,
+    unlimitedStakingAddress,
+    minStake,
+    gas
+  ));
+  return [chainId, genesisBlock, rewardContractAddressResolved];
+}
+
+// src/modules/ethereum/drivers/EvmStakeEventsViewer.ts
+import {
+  assertEx as assertEx8,
+  exists,
+  isDefined as isDefined3,
+  toAddress as toAddress3,
+  toEthAddress as toEthAddress8
+} from "@ariestools/sdk";
+import {
+  IAddressStakingEvents__factory
+} from "@xyo-network/typechain";
+import {
+  creatableProvider as creatableProvider4,
+  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 { AbstractCreatableProvider } from "@xyo-network/xl1-sdk";
+var AbstractEvmProvider = class extends AbstractCreatableProvider {
+  _contract;
+  get contract() {
+    return this._contract;
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._contract = this.connectContract(toEthAddress4(this.params.address));
+  }
+};
+
+// src/modules/ethereum/providers/AbstractEvmRunner.ts
+import { assertEx as assertEx6 } from "@ariestools/sdk";
+
+// src/modules/ethereum/providers/AbstractEvmViewer.ts
+var AbstractEvmViewer = class extends AbstractEvmProvider {
+};
+
+// 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 {
+  asHash,
+  assertEx as assertEx7,
+  toAddress as toAddress2,
+  toEthAddress as toEthAddress5,
+  toHex
+} from "@ariestools/sdk";
+import { IStakedXyoChain__factory } from "@xyo-network/typechain";
+import {
+  ChainContractViewerMoniker,
+  creatableProvider,
+  toXL1BlockNumber,
+  withContextCacheResponse
+} from "@xyo-network/xl1-sdk";
+var EvmChainContractViewer = class extends AbstractEvmViewer {
+  moniker = EvmChainContractViewer.defaultMoniker;
+  _forkedAtBlockNumber;
+  _forkedAtHash;
+  _forkedChainContractViewer;
+  _forkedChainId;
+  _minWithdrawalBlocks;
+  _rewardsContract;
+  _stakingTokenAddress;
+  get address() {
+    return this.params.address;
+  }
+  chainId() {
+    return toHex(this.params.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 = assertEx7(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) });
+    })();
+    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.params.provider);
+  }
+};
+__publicField(EvmChainContractViewer, "connectionTypes", ["evm-rpc"]);
+__publicField(EvmChainContractViewer, "defaultMoniker", ChainContractViewerMoniker);
+__publicField(EvmChainContractViewer, "dependencies", []);
+__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,
+  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.params.provider);
+  }
+};
+__publicField(EvmStakeTotalsViewer, "connectionTypes", ["evm-rpc"]);
+__publicField(EvmStakeTotalsViewer, "defaultMoniker", StakeTotalsViewerMoniker);
+__publicField(EvmStakeTotalsViewer, "dependencies", []);
+__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 === -32016;
+}
+function matchesRateLimitText(text) {
+  const normalized = text.toLowerCase();
+  return normalized.includes("too many requests") || normalized.includes("rate limit") || normalized.includes("rate exceeded") || normalized.includes("call rate limit") || normalized.includes("exceeded the quota");
+}
+
+// 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.params.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 = assertEx8(this.contract.runner?.provider, () => new Error("Failed to get provider"));
+      const historyEndBlock = assertEx8(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 = assertEx8(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" ? assertEx8(await this.contract.runner?.provider?.getBlockNumber(), () => new Error("Failed to resolve latest block")) : range[1];
+    if (fromBlock > toBlock) {
+      return [];
+    }
+    const chunkSize = this.eventQueryBlockChunkSize;
+    const chunks = blockRangeChunks(fromBlock, toBlock, chunkSize);
+    const ethEventGroups = [];
+    for (const [chunkFrom, chunkTo] of chunks) {
+      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) => {
+      assertEx8(e.eventName === name, () => `Event name mismatch expected '${name}' but got '${e.eventName}'`);
+      return this.onEventHandler(e.args.staked, e.args.by, e.args.id, e.args.amount, e, true);
+    }).filter(exists);
+  }
+};
+__publicField(EvmStakeEventsViewer, "connectionTypes", ["evm-rpc"]);
+__publicField(EvmStakeEventsViewer, "defaultMoniker", StakeEventsViewerMoniker);
+__publicField(EvmStakeEventsViewer, "dependencies", []);
+__publicField(EvmStakeEventsViewer, "monikers", [StakeEventsViewerMoniker]);
+__publicField(EvmStakeEventsViewer, "surface", "node");
+EvmStakeEventsViewer = __decorateClass([
+  creatableProvider4()
+], EvmStakeEventsViewer);
+
+// src/modules/ethereum/drivers/EvmStakeViewer.ts
+import {
+  assertEx as assertEx9,
+  isDefined as isDefined4,
+  toAddress as toAddress4,
+  toEthAddress as toEthAddress9
+} from "@ariestools/sdk";
+import { IAddressStaking__factory } from "@xyo-network/typechain";
+import {
+  creatableProvider as creatableProvider5,
+  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.params.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.params.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 = assertEx9(this._stakeCache.get(Number(id)));
+      this._stakeCache.set(Number(id), {
+        ...stake,
+        removeBlock: event.blockNumber
+      });
+    });
+    await this.contract.on(this.contract.getEvent("StakeWithdrawn"), (staked, staker, id, amount, event) => {
+      const stake = assertEx9(this._stakeCache.get(Number(id)));
+      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 = assertEx9(this._stakeCache.get(event.args.id));
+      this._stakeCache.set(event.args.id, {
+        ...stake,
+        removeBlock: event.time
+      });
+      return;
+    }
+    if (event.name === "StakeWithdrawn") {
+      const stake = assertEx9(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", []);
+__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")
+  };
+};
+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_EVM_BLOCK_TIME_SEC,
+  EthHashRegEx,
+  EthHashZod,
+  EvmChainContractViewer,
+  EvmStakeAddedEventNameZod,
+  EvmStakeAddedEventZod,
+  EvmStakeEventArgsZod,
+  EvmStakeEventNameZod,
+  EvmStakeEventZod,
+  EvmStakeEventsViewer,
+  EvmStakeRemovedEventNameZod,
+  EvmStakeRemovedEventZod,
+  EvmStakeRunner,
+  EvmStakeTotalsViewer,
+  EvmStakeViewer,
+  EvmStakeWithdrawnEventNameZod,
+  EvmStakeWithdrawnEventZod,
+  asEvmStakeAddedEvent,
+  asEvmStakeEvent,
+  asEvmStakeRemovedEvent,
+  asEvmStakeWithdrawnEvent,
+  blockRangeChunks,
+  calculateEthBlockRate,
+  calculateEthTimeRate,
+  createChain,
+  createChainContract,
+  createChainRewardsContract,
+  estimateBlockNumberAt,
+  estimateBlockNumberFromHead,
+  ethBlockRate,
+  getDefaultGasConfig,
+  getEthBlockRateBlocks,
+  isEvmStakeAddedEvent,
+  isEvmStakeEvent,
+  isEvmStakeRemovedEvent,
+  isEvmStakeWithdrawnEvent,
+  nextContractAddress,
+  nextContractAddressForAddress,
+  toEvmStakeAddedEvent,
+  toEvmStakeEvent,
+  toEvmStakeRemovedEvent,
+  toEvmStakeWithdrawnEvent
+};
+//# sourceMappingURL=ethereum.mjs.map