@xyo-network/chain-sdk 4.0.3 → 4.0.5

package/dist/neutral/ethereum.mjs

@@ -0,0 +1,1104 @@
+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/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,
+  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) => {
+  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;
+  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);
+  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(
+    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}`);
+  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 = assertEx(
+    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 assertEx2,
+  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 assertEx2(asAddress(xyoChainContractAddress), () => "Invalid staking contract address");
+  } catch (ex) {
+    console.log(ex);
+    throw ex;
+  }
+};
+
+// src/modules/ethereum/createChainRewardsContract.ts
+import {
+  asAddress as asAddress2,
+  assertEx as assertEx3,
+  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 assertEx3(asAddress2(xyoChainRewardsAddress), () => "Invalid rewards contract address");
+  } catch (ex) {
+    console.log(ex);
+    throw ex;
+  }
+};
+
+// src/modules/ethereum/nextContractAddress.ts
+import {
+  asAddress as asAddress3,
+  assertEx as assertEx4,
+  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 assertEx4(asAddress3(contractAddress), () => "Unable to convert contract address to address");
+};
+var nextContractAddress = async (signer) => {
+  const provider = assertEx4(signer.provider, () => "Unable to obtain provider from signer");
+  const address = assertEx4(asAddress3(await signer.getAddress()), () => "Unable to obtain address from signer");
+  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 assertEx7,
+  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 assertEx5 } 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 = assertEx5(params?.runner, () => new Error("No runner defined"));
+    const provider = assertEx5(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 assertEx6,
+  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 = assertEx6(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/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 EvmStakeEventsViewer = class extends AbstractEvmViewer {
+  moniker = EvmStakeEventsViewer.defaultMoniker;
+  eventCache = /* @__PURE__ */ new Map();
+  get deploymentBlock() {
+    return this.params.deploymentBlock ?? 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.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;
+    this.logger?.log(`Processing ${eventName} event for stake ID ${id} at block ${blockNumber}`);
+    const cacheKey = `${Number(id)}|${eventName}|${staker}`;
+    const existingStakeEvent = this.eventCache.get(cacheKey);
+    const stakeEvent = {
+      name: eventName,
+      args: {
+        id: Number(id),
+        staked: toAddress3(staked),
+        staker: toAddress3(staker),
+        amount: asAttoXL1(amount)
+      },
+      time: blockNumber
+    };
+    if (isDefined3(existingStakeEvent)) {
+      this.logger?.warn(`Received ${eventName} event for stake ID ${id} that is already cached, updating cache...`);
+      this.logger?.warn("1");
+      this.logger?.warn("Previous event", existingStakeEvent);
+      this.logger?.warn("2");
+      this.logger?.warn("New event", stakeEvent);
+      this.logger?.warn("3");
+    }
+    this.eventCache.set(cacheKey, stakeEvent);
+    return stakeEvent;
+  }
+  async startHandler() {
+    try {
+      const currentEthBlock = assertEx7(await this.contract.runner?.provider?.getBlockNumber(), () => new Error("Failed to egt currentEthBlock"));
+      await this.contract.on(this.contract.getEvent("StakeAdded"), (staked, staker, id, amount, event) => {
+        this.onEventHandler(staked, staker, id, amount, event);
+      });
+      await this.contract.on(this.contract.getEvent("StakeRemoved"), (staked, staker, id, amount, event) => {
+        this.onEventHandler(staked, staker, id, amount, event);
+      });
+      await this.contract.on(this.contract.getEvent("StakeWithdrawn"), (staked, staker, id, amount, event) => {
+        this.onEventHandler(staked, staker, id, amount, event);
+      });
+      await this.loadHistoricalEvents(currentEthBlock);
+    } catch (error) {
+      this.logger?.error("EthereumChainStakeEvents failed to start:", error);
+      throw error;
+    }
+  }
+  async loadHistoricalEvents(currentEthBlock) {
+    const stakeEventGroups = await Promise.all([
+      this.stakeEventsNative([this.deploymentBlock, currentEthBlock], { name: "StakeAdded" }),
+      this.stakeEventsNative([this.deploymentBlock, currentEthBlock], { name: "StakeRemoved" }),
+      this.stakeEventsNative([this.deploymentBlock, currentEthBlock], { name: "StakeWithdrawn" })
+    ]);
+    const allStakeEvents = stakeEventGroups.flat().toSorted((a, b) => a.time - b.time);
+    console.warn(`Caching ${allStakeEvents.length} stake events from chain starting at block ${this.deploymentBlock}`);
+    for (const event of allStakeEvents) {
+      this.eventCache.set(`${Number(event.args.id)}|${event.name}|${event.args.staker}`, event);
+    }
+  }
+  async stakeEventsNative(range = [0, "latest"], filter) {
+    const name = filter?.name;
+    if (isDefined3(name)) {
+      const stakedFilter = filter?.args?.staked;
+      const stakerFilter = filter?.args?.staker;
+      const stakedFilterEth = isDefined3(stakedFilter) ? toEthAddress8(stakedFilter) : void 0;
+      const stakerFilterEth = isDefined3(stakerFilter) ? toEthAddress8(stakerFilter) : void 0;
+      const ethFilter = this.contract.filters[name](stakedFilterEth, stakerFilterEth);
+      const ethEvents = await this.contract.queryFilter(ethFilter, range[0], range[1]);
+      return ethEvents.map((e) => {
+        assertEx7(e.eventName === name, () => `Event name mismatch expected '${name}' but got '${e.eventName}'`);
+        return this.onEventHandler(e.args.staked, e.args.by, e.args.id, e.args.amount, e, true);
+      }).filter(exists);
+    }
+    throw new Error("Only filtered stake events (by name) are supported");
+  }
+};
+__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 assertEx8,
+  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);
+  }
+  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 = assertEx8(this._stakeCache.get(Number(id)));
+      this._stakeCache.set(Number(id), {
+        ...stake,
+        removeBlock: event.blockNumber
+      });
+    });
+    await this.contract.on(this.contract.getEvent("StakeWithdrawn"), (staked, staker, id, amount, event) => {
+      const stake = assertEx8(this._stakeCache.get(Number(id)));
+      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 = assertEx8(this._stakeCache.get(event.args.id));
+      this._stakeCache.set(event.args.id, {
+        ...stake,
+        removeBlock: event.time
+      });
+      return;
+    }
+    if (event.name === "StakeWithdrawn") {
+      const stake = assertEx8(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,
+  EthHashRegEx,
+  EthHashZod,
+  EvmChainContractViewer,
+  EvmStakeAddedEventNameZod,
+  EvmStakeAddedEventZod,
+  EvmStakeEventArgsZod,
+  EvmStakeEventNameZod,
+  EvmStakeEventZod,
+  EvmStakeEventsViewer,
+  EvmStakeRemovedEventNameZod,
+  EvmStakeRemovedEventZod,
+  EvmStakeRunner,
+  EvmStakeTotalsViewer,
+  EvmStakeViewer,
+  EvmStakeWithdrawnEventNameZod,
+  EvmStakeWithdrawnEventZod,
+  asEvmStakeAddedEvent,
+  asEvmStakeEvent,
+  asEvmStakeRemovedEvent,
+  asEvmStakeWithdrawnEvent,
+  calculateEthBlockRate,
+  calculateEthTimeRate,
+  createChain,
+  createChainContract,
+  createChainRewardsContract,
+  ethBlockRate,
+  getDefaultGasConfig,
+  getEthBlockRateBlocks,
+  isEvmStakeAddedEvent,
+  isEvmStakeEvent,
+  isEvmStakeRemovedEvent,
+  isEvmStakeWithdrawnEvent,
+  nextContractAddress,
+  nextContractAddressForAddress,
+  toEvmStakeAddedEvent,
+  toEvmStakeEvent,
+  toEvmStakeRemovedEvent,
+  toEvmStakeWithdrawnEvent
+};
+//# sourceMappingURL=ethereum.mjs.map