@xyo-network/xl1-cli 1.16.20 → 1.16.21

package/dist/cli-min.mjs

@@ -23,6 +23,9 @@ import { ConsoleSpanExporter, BatchSpanProcessor, AlwaysOnSampler, BasicTracerPr
 import process$1 from 'node:process';
 import os from 'node:os';
 import tty from 'node:tty';
+import require$$0$h from 'net';
+import require$$2$6 from 'tls';
+import require$$0$f from 'buffer';
 import { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks';
 import { CompositePropagator, W3CTraceContextPropagator, W3CBaggagePropagator } from '@opentelemetry/core';
 import { PrometheusExporter } from '@opentelemetry/exporter-prometheus';
@@ -35,10 +38,8 @@ import { MeterProvider } from '@opentelemetry/sdk-metrics';
 import { ATTR_SERVICE_VERSION, ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
 import { createRequire } from 'node:module';
 import require$$2$7, { readdirSync as readdirSync$1, readFileSync as readFileSync$1 } from 'node:fs';
-import require$$0$f from 'buffer';
 import require$$1$4 from 'string_decoder';
 import require$$4$5 from 'node:zlib';
-import require$$0$h from 'net';
 import require$$1$6 from 'node:events';
 import require$$7$2 from 'node:path';
 import require$$2$8 from 'node:http';
@@ -49,7 +50,6 @@ import { ExpressInstrumentation } from '@opentelemetry/instrumentation-express';
 import { HttpInstrumentation } from '@opentelemetry/instrumentation-http';
 import require$$0$i from 'timers';
 import require$$0$j from 'dns';
-import require$$2$6 from 'tls';
 import require$$1$8 from 'child_process';
 import require$$0$l from 'timers/promises';
 import require$$1$9 from 'module';
@@ -20724,46 +20724,46 @@ function createInstance(defaultConfig) {
 }
 
 // Create the default instance to be exported
-const axios$1 = createInstance(defaults$3);
+const axios = createInstance(defaults$3);
 
 // Expose Axios class to allow class inheritance
-axios$1.Axios = Axios$1;
+axios.Axios = Axios$1;
 
 // Expose Cancel & CancelToken
-axios$1.CanceledError = CanceledError$1;
-axios$1.CancelToken = CancelToken$1;
-axios$1.isCancel = isCancel$1;
-axios$1.VERSION = VERSION$1;
-axios$1.toFormData = toFormData$1;
+axios.CanceledError = CanceledError$1;
+axios.CancelToken = CancelToken$1;
+axios.isCancel = isCancel$1;
+axios.VERSION = VERSION$1;
+axios.toFormData = toFormData$1;
 
 // Expose AxiosError class
-axios$1.AxiosError = AxiosError$1;
+axios.AxiosError = AxiosError$1;
 
 // alias for CanceledError for backward compatibility
-axios$1.Cancel = axios$1.CanceledError;
+axios.Cancel = axios.CanceledError;
 
 // Expose all/spread
-axios$1.all = function all(promises) {
+axios.all = function all(promises) {
   return Promise.all(promises);
 };
 
-axios$1.spread = spread$1;
+axios.spread = spread$1;
 
 // Expose isAxiosError
-axios$1.isAxiosError = isAxiosError$1;
+axios.isAxiosError = isAxiosError$1;
 
 // Expose mergeConfig
-axios$1.mergeConfig = mergeConfig$1;
+axios.mergeConfig = mergeConfig$1;
 
-axios$1.AxiosHeaders = AxiosHeaders$1;
+axios.AxiosHeaders = AxiosHeaders$1;
 
-axios$1.formToJSON = thing => formDataToJSON(utils$b.isHTMLForm(thing) ? new FormData(thing) : thing);
+axios.formToJSON = thing => formDataToJSON(utils$b.isHTMLForm(thing) ? new FormData(thing) : thing);
 
-axios$1.getAdapter = adapters$1.getAdapter;
+axios.getAdapter = adapters$1.getAdapter;
 
-axios$1.HttpStatusCode = HttpStatusCode$1;
+axios.HttpStatusCode = HttpStatusCode$1;
 
-axios$1.default = axios$1;
+axios.default = axios;
 
 // This module is intended to unwrap Axios default export as named.
 // Keep top-level export same with static properties
@@ -20785,7 +20785,7 @@ const {
   formToJSON,
   getAdapter,
   mergeConfig
-} = axios$1;
+} = axios;
 
 // src/index.ts
 var exists$1 = (x) => {
@@ -38125,23 +38125,7 @@ function axiosJsonConfig({
     ...config
   };
 }
-function deprecated(from, to, logger = console) {
-  logger.warn(`${from} is deprecated. Please use ${to} instead.`);
-}
-var AxiosJson = class _AxiosJson extends Axios {
-  constructor(config) {
-    deprecated("AxiosJson", "axiosJsonConfig");
-    super(_AxiosJson.axiosConfig(config));
-  }
-  static axiosConfig(config = {}) {
-    return axiosJsonConfig(config);
-  }
-  static create(config) {
-    return new Axios(this.axiosConfig(config));
-  }
-};
 var axiosJson = new Axios(axiosJsonConfig());
-var axios = axiosJson;
 
 // src/Base.ts
 var DEFAULT_HISTORY_INTERVAL = 1e3 * 5;
@@ -72776,7 +72760,7 @@ var DnsRecordType = {
 var DnsReturnCode = {
   NoError: 0};
 var googleDnsOverHttps = async (name, type = DnsRecordType.A) => {
-  return (await axios.get(`https://dns.google/resolve?name=${name}&type=${type}`)).data;
+  return (await axiosJson.get(`https://dns.google/resolve?name=${name}&type=${type}`)).data;
 };
 
 // src/domainResolve.ts
@@ -75799,7 +75783,7 @@ var ResolveHelper = class _ResolveHelper extends ResolveHelperStatic {
         ...up ? await upResolver.resolve("*", upLocalOptions) : []
       ].filter(duplicateModules);
       if (modules.length > 0) {
-        log?.log("modules [count]", modules.length);
+        log?.debug("modules [count]", modules.length);
         log?.debug("modules", toSafeJsonString(modules, 4));
       }
       if (maxDepth === 0) {
@@ -77573,7 +77557,7 @@ var AbstractArchivist = class _AbstractArchivist extends AbstractModuleInstance
   get storeParentReads() {
     return !!this.config?.storeParentReads;
   }
-  /** deprecated use next or snapshot instead */
+  /** @deprecated use next or snapshot instead */
   async all() {
     this._noOverride("all");
     this.isSupportedQuery(ArchivistAllQuerySchema, "all");
@@ -83018,7 +83002,7 @@ var StatusNetworks = {
   }
   async makeRequest(url3) {
     try {
-      const response = await axios$1.get(url3);
+      const response = await axios.get(url3);
       if (isNetworkStatus(response.data)) {
         return response.data;
       } else {
@@ -117789,116 +117773,6 @@ BaseTimeSyncService = _ts_decorate14([
   creatable()
 ], BaseTimeSyncService);
 
-var __defProp$i = Object.defineProperty;
-var __name$a = (target, value) => __defProp$i(target, "name", { value, configurable: true });
-var initContextManager = /* @__PURE__ */ __name$a(() => {
-  const contextManager = new AsyncLocalStorageContextManager();
-  context.setGlobalContextManager(contextManager.enable());
-}, "initContextManager");
-var initPropagation = /* @__PURE__ */ __name$a(() => {
-  propagation.setGlobalPropagator(new CompositePropagator({
-    propagators: [
-      new W3CTraceContextPropagator(),
-      new W3CBaggagePropagator()
-    ]
-  }));
-}, "initPropagation");
-var initResource = /* @__PURE__ */ __name$a((attributes) => {
-  const detectedResource = detectResources({
-    detectors: [
-      // hostDetector,
-      // osDetector,
-      // processDetector,
-      serviceInstanceIdDetector
-    ]
-  });
-  const staticResource = resourceFromAttributes({
-    [ATTR_SERVICE_NAME]: attributes.serviceName,
-    [ATTR_SERVICE_VERSION]: attributes.serviceName
-  });
-  const resource = detectedResource.merge(staticResource);
-  return resource;
-}, "initResource");
-var initHostMetrics = /* @__PURE__ */ __name$a((meterProvider) => {
-  const hostMetrics = new HostMetrics({
-    meterProvider,
-    name: "host-metrics"
-  });
-  hostMetrics.start();
-}, "initHostMetrics");
-var initNodeMetrics = /* @__PURE__ */ __name$a((meterProvider) => {
-  const instrumentation = new RuntimeNodeInstrumentation({
-    monitoringPrecision: 5e3
-  });
-  instrumentation.setMeterProvider(meterProvider);
-  instrumentation.enable();
-}, "initNodeMetrics");
-var initMetricsExporter = /* @__PURE__ */ __name$a((metricsConfig) => {
-  const { port, endpoint } = metricsConfig;
-  const exporter = new PrometheusExporter({
-    port,
-    endpoint
-  }, (err) => {
-    if (err) console.error("Error initializing Prometheus exporter", err);
-  });
-  return exporter;
-}, "initMetricsExporter");
-var initMeterProvider = /* @__PURE__ */ __name$a((resource, readers) => {
-  const meterProvider = new MeterProvider({
-    readers,
-    resource,
-    views: [
-      {
-        aggregation: void 0,
-        instrumentName: "*",
-        instrumentType: void 0,
-        meterName: "*"
-      }
-    ]
-  });
-  metrics$3.setGlobalMeterProvider(meterProvider);
-  return meterProvider;
-}, "initMeterProvider");
-var initTraceProvider = /* @__PURE__ */ __name$a((otlpEndpoint, resource) => {
-  const spanProcessors = [];
-  if (isDefined(otlpEndpoint)) {
-    const isHttp = otlpEndpoint.includes("/v1/traces") || otlpEndpoint.includes(":4318") || otlpEndpoint.startsWith("http");
-    const exporter = isHttp ? new OTLPTraceExporter({
-      url: otlpEndpoint
-    }) : new OTLPTraceExporter$1({
-      url: otlpEndpoint
-    });
-    const batchSpanProcessorConfig = {};
-    const spanProcessor = new BatchSpanProcessor(exporter, batchSpanProcessorConfig);
-    spanProcessors.push(spanProcessor);
-  }
-  const config = {
-    resource,
-    sampler: new AlwaysOnSampler(),
-    spanProcessors
-  };
-  const traceProvider = new BasicTracerProvider(config);
-  trace.setGlobalTracerProvider(traceProvider);
-  return traceProvider;
-}, "initTraceProvider");
-var initTelemetry = /* @__PURE__ */ __name$a((params) => {
-  const { attributes, metricsConfig, otlpEndpoint } = params;
-  initContextManager();
-  initPropagation();
-  const resource = initResource(attributes);
-  const exporter = initMetricsExporter(metricsConfig);
-  const meterProvider = initMeterProvider(resource, [
-    exporter
-  ]);
-  initHostMetrics(meterProvider);
-  initNodeMetrics(meterProvider);
-  const traceProvider = initTraceProvider(otlpEndpoint, resource);
-  return {
-    meterProvider,
-    traceProvider
-  };
-}, "initTelemetry");
-
 // src/AbstractNode.ts
 var AbstractNode = class _AbstractNode extends AbstractModuleInstance {
   static configSchemas = [...super.configSchemas, NodeConfigSchema];
@@ -118834,9 +118708,9 @@ factory.create(requiredAttachableBridgeInstanceFunctions, [
 // src/Config.ts
 var BridgeConfigSchema = "network.xyo.bridge.config";
 
-var __defProp$h = Object.defineProperty;
+var __defProp$i = Object.defineProperty;
 var __getOwnPropDesc$7 = Object.getOwnPropertyDescriptor;
-var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$h(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$i(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __decorateClass$7 = (decorators, target, key, kind) => {
   var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$7(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
@@ -119750,11 +119624,11 @@ var AbstractModuleProxy = class extends AbstractModuleInstance {
   }
 };
 
-var __defProp$g = Object.defineProperty;
+var __defProp$h = Object.defineProperty;
 var __getOwnPropDesc$6 = Object.getOwnPropertyDescriptor;
 var __getProtoOf$4 = Object.getPrototypeOf;
 var __reflectGet$4 = Reflect.get;
-var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$g(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$h(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __decorateClass$6 = (decorators, target, key, kind) => {
   var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$6(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
@@ -120044,7 +119918,7 @@ var HttpBridge = class extends AbstractBridge {
     return [];
   }
 };
-__publicField$6(HttpBridge, "axios", new AxiosJson());
+__publicField$6(HttpBridge, "axios", new Axios(axiosJsonConfig()));
 __publicField$6(HttpBridge, "configSchemas", [...__superGet$4(HttpBridge, HttpBridge, "configSchemas"), HttpBridgeConfigSchema]);
 __publicField$6(HttpBridge, "defaultConfigSchema", HttpBridgeConfigSchema);
 __publicField$6(HttpBridge, "defaultFailureRetryTime", 1e3 * 60);
@@ -120055,9 +119929,1627 @@ HttpBridge = __decorateClass$6([
   creatableModule()
 ], HttpBridge);
 
+var __defProp$g = Object.defineProperty;
+var __name$a = (target, value) => __defProp$g(target, "name", { value, configurable: true });
+
+// src/BaseEthProvider.ts
+(class {
+  static {
+    __name$a(this, "BaseEthProvider");
+  }
+  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.");
+  }
+});
+var createChainContract = /* @__PURE__ */ __name$a(async (signer, stakingTokenAddress, genesisBlockHash, rewardsContractAddress, minWithdrawalBlocks, gas = {}) => {
+  try {
+    const xyoChainFactory = new StakedXyoChain__factory(signer);
+    const contractTransactionResponse = await (await xyoChainFactory.deploy(ETH_ZERO_ADDRESS, 0n, hexToBigInt(genesisBlockHash), toEthAddress(rewardsContractAddress), minWithdrawalBlocks, toEthAddress(stakingTokenAddress), gas)).waitForDeployment();
+    const xyoChainContractAddress = await contractTransactionResponse.getAddress();
+    return assertEx(asAddress(xyoChainContractAddress), () => "Invalid staking contract address");
+  } catch (ex) {
+    console.log(ex);
+    throw ex;
+  }
+}, "createChainContract");
+var gasConfig = /* @__PURE__ */ __name$a(() => {
+  return {
+    gasLimit: 2e6,
+    gasPrice: parseUnits$1("100", "gwei")
+  };
+}, "gasConfig");
+var createChainRewardsContract = /* @__PURE__ */ __name$a(async (signer, genesisReward = 0n, gas = gasConfig()) => {
+  try {
+    const xyoChainRewardsFactory = new XyoChainRewards__factory(signer);
+    const xyoChainRewardsFactoryResponse = await (await xyoChainRewardsFactory.deploy(toFixedPoint(1000n), 1000000n, 95n, 100n, toFixedPoint(30n), genesisReward, 18n, gas)).waitForDeployment();
+    const xyoChainRewardsAddress = await xyoChainRewardsFactoryResponse.getAddress();
+    return assertEx(asAddress(xyoChainRewardsAddress), () => "Invalid rewards contract address");
+  } catch (ex) {
+    console.log(ex);
+    throw ex;
+  }
+}, "createChainRewardsContract");
+var nextContractAddressForAddress = /* @__PURE__ */ __name$a(async (address, provider) => {
+  const deployerAddress = toEthAddress(address);
+  const nonce = await provider.getTransactionCount(deployerAddress);
+  const contractAddress = getCreateAddress({
+    from: deployerAddress,
+    nonce
+  });
+  return assertEx(asAddress(contractAddress), () => "Unable to convert contract address to address");
+}, "nextContractAddressForAddress");
+var nextContractAddress = /* @__PURE__ */ __name$a(async (signer) => {
+  const provider = assertEx(signer.provider, () => "Unable to obtain provider from signer");
+  const address = assertEx(asAddress(await signer.getAddress()), () => "Unable to obtain address from signer");
+  return await nextContractAddressForAddress(address, provider);
+}, "nextContractAddress");
+
+// src/createChain.ts
+async function createChain(signer, stakingTokenAddress, initialBlockProducer, rewardsContractAddress, genesisBlockRewardAmount, genesisBlockRewardAddress, minWithdrawalBlocks, gas) {
+  const ethStakingTokenAddress = toEthAddress(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, gas));
+  return [
+    chainId,
+    genesisBlock,
+    rewardContractAddressResolved
+  ];
+}
+__name$a(createChain, "createChain");
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name$a(_ts_decorate, "_ts_decorate");
+var ethStakeToStake = /* @__PURE__ */ __name$a((ethStake) => {
+  const stake = {
+    id: Number(ethStake.id),
+    staked: toAddress(ethStake.staked),
+    staker: toAddress(ethStake.staker),
+    amount: asAttoXL1(ethStake.amount),
+    addBlock: Number(ethStake.addBlock),
+    removeBlock: Number(ethStake.removeBlock),
+    withdrawBlock: Number(ethStake.withdrawBlock)
+  };
+  return stake;
+}, "ethStakeToStake");
+var EthereumChainStakeViewer = class extends AbstractCreatable {
+  static {
+    __name$a(this, "EthereumChainStakeViewer");
+  }
+  _callMutex = new Mutex$1();
+  _chainId;
+  _deploymentBlock = 0;
+  _stakeCache = /* @__PURE__ */ new Map();
+  get chainId() {
+    return assertEx(this._chainId, () => "Chain ID not set");
+  }
+  get contract() {
+    return assertEx(this.params.contract, () => new Error("Contract not defined"));
+  }
+  get minWithdrawalBlocks() {
+    return 0;
+  }
+  get rewardsContract() {
+    return toAddress("0x000000000000000000000000000000");
+  }
+  get stakeEvents() {
+    return this.params.stakeEventsViewer;
+  }
+  get stakingTokenAddress() {
+    return toAddress("0x000000000000000000000000000011");
+  }
+  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(toEthAddress(address));
+    });
+  }
+  async activeByStaker(address) {
+    return await this._callMutex.runExclusive(async () => {
+      return await this.contract.activeByStaker(toEthAddress(address));
+    });
+  }
+  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(toEthAddress(staker));
+    });
+  }
+  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(toEthAddress(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 (toAddress(event.args.staked) === toAddress(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 (toAddress(event.args.staker) === toAddress(staker)) {
+        result.push(await this.stakeById(event.args.id));
+      }
+    }
+    return result;
+  }
+  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(toEthAddress(staker));
+    });
+  }
+  async startHandler() {
+    this._chainId = toAddress(await this.contract.chainId());
+    await this.contract.on(this.contract.getEvent("StakeAdded"), (staked, staker, id, amount, event) => {
+      this._stakeCache.set(Number(id), {
+        id: Number(id),
+        staked: toAddress(staked),
+        staker: toAddress(staker),
+        amount: asAttoXL1(amount),
+        addBlock: event.blockNumber,
+        removeBlock: 0,
+        withdrawBlock: 0
+      });
+    });
+    await this.contract.on(this.contract.getEvent("StakeRemoved"), (staked, staker, id, amount, event) => {
+      const stake = assertEx(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 = assertEx(this._stakeCache.get(Number(id)));
+      this._stakeCache.set(Number(id), {
+        ...stake,
+        withdrawBlock: event.blockNumber
+      });
+    });
+    const allStakeEvents = (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"
+      })
+    ])).flat().toSorted((a, b) => a.time - b.time);
+    for (const event of allStakeEvents) {
+      switch (event.name) {
+        case "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
+          });
+          break;
+        }
+        case "StakeRemoved": {
+          const stake = assertEx(this._stakeCache.get(event.args.id));
+          this._stakeCache.set(event.args.id, {
+            ...stake,
+            removeBlock: event.time
+          });
+          break;
+        }
+        case "StakeWithdrawn": {
+          const stake = assertEx(this._stakeCache.get(event.args.id));
+          this._stakeCache.set(event.args.id, {
+            ...stake,
+            withdrawBlock: event.time
+          });
+          break;
+        }
+      }
+    }
+    for (const event of allStakeEvents) {
+      await this.stakeById(event.args.id);
+    }
+  }
+};
+EthereumChainStakeViewer = _ts_decorate([
+  creatable()
+], EthereumChainStakeViewer);
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name$a(_ts_decorate2, "_ts_decorate");
+var isStakeLogEventName = /* @__PURE__ */ __name$a((name) => {
+  return isString$1(name) && [
+    "StakeAdded",
+    "StakeRemoved",
+    "StakeWithdrawn"
+  ].includes(name);
+}, "isStakeLogEventName");
+var EthereumChainStakeEvents = class extends AbstractCreatable {
+  static {
+    __name$a(this, "EthereumChainStakeEvents");
+  }
+  eventCache = /* @__PURE__ */ new Map();
+  get contract() {
+    return assertEx(this.params.contract, () => new Error("Contract not defined"));
+  }
+  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()
+    ];
+    const result = allEvents.filter((e) => {
+      if (range[1] !== "latest" && e.time > range[1]) {
+        return false;
+      }
+      if (e.time < range[0]) {
+        return false;
+      }
+      if (isDefined(filter?.name) && e.name !== filter.name) {
+        return false;
+      }
+      if (isDefined(filter?.args?.id) && e.args.id !== filter.args.id) {
+        return false;
+      }
+      if (isDefined(filter?.args?.staked) && e.args.staked !== filter.args.staked) {
+        return false;
+      }
+      if (isDefined(filter?.args?.staker) && e.args.staker !== filter.args.staker) {
+        return false;
+      }
+      return true;
+    });
+    return result;
+  }
+  onEventHandler(staked, staker, id, amount, { eventName, blockNumber }) {
+    if (blockNumber === void 0) {
+      this.logger?.warn(`Received ${eventName} event with ${blockNumber} blockNumber, ignoring...`);
+      return;
+    }
+    if (!isStakeLogEventName(eventName)) {
+      this.logger?.warn(`Received event with unsupported name '${eventName}'`);
+      return;
+    }
+    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: toAddress(staked),
+        staker: toAddress(staker),
+        amount: asAttoXL1(amount)
+      },
+      time: blockNumber
+    };
+    if (isDefined(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 = assertEx(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);
+      });
+      const allStakeEvents = (await Promise.all([
+        this.stakeEventsNative([
+          this.deploymentBlock,
+          currentEthBlock
+        ], {
+          name: "StakeAdded"
+        }),
+        this.stakeEventsNative([
+          this.deploymentBlock,
+          currentEthBlock
+        ], {
+          name: "StakeRemoved"
+        }),
+        this.stakeEventsNative([
+          this.deploymentBlock,
+          currentEthBlock
+        ], {
+          name: "StakeWithdrawn"
+        })
+      ])).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);
+      }
+    } catch (error) {
+      this.logger?.error("EthereumChainStakeEvents failed to start:", error);
+      throw error;
+    }
+  }
+  async stakeEventsNative(range = [
+    0,
+    "latest"
+  ], filter) {
+    const name = filter?.name;
+    if (isDefined(name)) {
+      const stakedFilter = filter?.args?.staked;
+      const stakerFilter = filter?.args?.staker;
+      const stakedFilterEth = isDefined(stakedFilter) ? toEthAddress(stakedFilter) : void 0;
+      const stakerFilterEth = isDefined(stakerFilter) ? toEthAddress(stakerFilter) : void 0;
+      let ethEvents = [];
+      const ethFilter = this.contract.filters[name](stakedFilterEth, stakerFilterEth);
+      ethEvents = await this.contract.queryFilter(ethFilter, range[0], range[1]);
+      return ethEvents.map((e) => {
+        assertEx(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);
+      }).filter(exists$1);
+    } else {
+      throw new Error("Only filtered stake events (by name) are supported");
+    }
+  }
+};
+EthereumChainStakeEvents = _ts_decorate2([
+  creatable()
+], EthereumChainStakeEvents);
+
 var __defProp$f = Object.defineProperty;
 var __name$9 = (target, value) => __defProp$f(target, "name", { value, configurable: true });
-var initArchivistSync = /* @__PURE__ */ __name$9(async (name, inArchivist, outArchivist, frequency = 1e3, max = 1e3, traceProvider) => {
+var NodeXyoViewer = class extends AbstractCreatable {
+  static {
+    __name$9(this, "NodeXyoViewer");
+  }
+  // TODO: Make configurable with defaults
+  _tracer;
+  addressBalanceDivinerPath = "XYOChain:Chain:AddressBalanceDiviner";
+  finalizedArchivistPath = "XYOChain:Chain:Finalized";
+  headValidationDivinerPath = "XYOChain:Chain:HeadValidationDiviner";
+  transferBalanceDivinerPath = "XYOChain:Chain:AddressTransferDiviner";
+  _addressBalanceDiviner;
+  _chainId;
+  _finalizedArchivist;
+  _rewardMultipliers;
+  _signedHydratedBlockCache;
+  _signedHydratedTransactionCache;
+  _transferBalanceDiviner;
+  get context() {
+    return assertEx(this.params.context, () => "NodeXyoViewer requires a context");
+  }
+  get initRewardsCache() {
+    return this.params.initRewardsCache ?? true;
+  }
+  get node() {
+    return this.params.node;
+  }
+  get rewardMultipliers() {
+    this._rewardMultipliers = this._rewardMultipliers ?? this.params.rewardMultipliers ?? {};
+    return this._rewardMultipliers;
+  }
+  get stake() {
+    return this.context.stake;
+  }
+  get transfersSummaryContext() {
+    return this.params.transfersSummaryContext ?? {
+      ...this.context
+    };
+  }
+  async accountBalance(address) {
+    return await spanRootAsync("accountBalance", async () => {
+      const diviner = await this.getAddressBalanceDiviner();
+      const query = new PayloadBuilder({
+        schema: AddressSchema
+      }).fields({
+        address
+      }).build();
+      const result = await diviner.divine([
+        query
+      ]);
+      const chainSummary = assertEx(result.find(isChainSummaryBalances), () => "Failed to divine chain summary balances");
+      const balances = chainSummary.balances;
+      const signedBalance = balances[address] === void 0 ? 0n : parseSignedBigInt(balances[address]);
+      return asAttoXL1(signedBalance > 0n ? signedBalance : 0n);
+    }, this.tracer);
+  }
+  async accountBalanceHistory(address, rangeOrHash) {
+    return await spanRootAsync("accountHistory", async () => {
+      const range = asRange(rangeOrHash);
+      const startingRange = asXL1BlockRange(range ?? [
+        0,
+        await this.currentBlockNumber()
+      ], {
+        name: "accountBalanceHistory"
+      });
+      const blockNumbers = await this.distillTransferHistory(address, startingRange);
+      const blocks = (await Promise.all(blockNumbers.map(async (bn) => await this.blockByNumber(bn)))).filter(exists$1);
+      const result = [];
+      for (const block of blocks) {
+        const transferIndexes = block[0].payload_schemas.map((schema, index) => schema === TransferSchema ? index : void 0).filter(exists$1);
+        const transfers = transferIndexes.map((index) => {
+          const hash = block[0].payload_hashes[index];
+          return assertEx(block[1].find((p) => p._hash === hash), () => `Could not find Transfer with hash ${hash} in block ${block[0]._hash}`);
+        }).filter(exists$1).filter((t) => t.from === address || isDefined(t.transfers[address]));
+        if (transfers.length === 0) {
+          continue;
+        }
+        const pairs = transfers.map((transfer) => {
+          return [
+            block[0],
+            transfer
+          ];
+        });
+        result.push(...pairs.map(([block2, transfer]) => [
+          block2,
+          null,
+          transfer
+        ]));
+      }
+      return result;
+    }, this.tracer);
+  }
+  async blockByHash(hash) {
+    return await spanRootAsync("blockByHash", async () => {
+      const cache = await this.getHydratedBlockCache();
+      return await cache.get(hash);
+    }, this.tracer);
+  }
+  async blockByNumber(blockNumber) {
+    return await spanRootAsync("blockByNumber", async () => {
+      return await hydratedBlockByNumber(this.context, blockNumber);
+    }, this.tracer);
+  }
+  async blocksByHash(hash, limit = 10) {
+    return await spanRootAsync("blocksByHash", async () => {
+      assertEx(limit > 0, () => "limit must be greater than 0");
+      assertEx(limit <= 100, () => "limit must be less than 100");
+      const blocks = [];
+      let current = await this.blockByHash(hash);
+      while (current && blocks.length < limit) {
+        blocks.push(current);
+        const previousHash = current[0].previous;
+        if (previousHash === null) break;
+        current = await this.blockByHash(previousHash);
+      }
+      return blocks;
+    }, this.tracer);
+  }
+  async chainId() {
+    return await spanRootAsync("chainId", async () => {
+      if (this._chainId !== void 0) return this._chainId;
+      const block = await this.currentBlock();
+      this._chainId = block[0].chain;
+      return this._chainId;
+    }, this.tracer);
+  }
+  async chainIdAtBlock(blockNumber) {
+    return await spanRootAsync("chainIdAtBlock", async () => {
+      if (this._chainId !== void 0) return this._chainId;
+      const block = await this.blockByNumber(blockNumber);
+      this._chainId = block?.[0].chain;
+      return this._chainId;
+    }, this.tracer);
+  }
+  async currentBlock() {
+    return await spanRootAsync("currentBlock", async () => {
+      const currentHead = assertEx(await this.getCurrentHead(), () => "Could not find most recent block");
+      const cache = await this.getHydratedBlockCache();
+      const block = await cache.get(currentHead._hash);
+      if (!block) {
+        console.log(`Could not find current block with hash ${currentHead._hash}`);
+      }
+      return assertEx(block, () => "Could not find current block");
+    }, this.tracer);
+  }
+  async currentBlockHash() {
+    return await spanRootAsync("currentBlockHash", async () => {
+      const currentHead = assertEx(await this.getCurrentHead(), () => "Could not find most recent block");
+      return currentHead._hash;
+    }, this.tracer);
+  }
+  async currentBlockNumber() {
+    return await spanRootAsync("currentBlockNumber", async () => {
+      const currentHead = assertEx(await this.getCurrentHead(), () => "Could not find most recent block");
+      return asXL1BlockNumber(currentHead.block, {
+        name: "currentBlockNumber"
+      });
+    }, this.tracer);
+  }
+  forkHistory() {
+    throw new Error("Method not implemented.");
+  }
+  networkStakeStepRewardAddressHistory(_address) {
+    throw new Error("Method not implemented.");
+  }
+  networkStakeStepRewardAddressReward(_context, _address) {
+    throw new Error("Method not implemented.");
+  }
+  networkStakeStepRewardAddressShare(_context, _address) {
+    throw new Error("Method not implemented.");
+  }
+  networkStakeStepRewardClaimedByAddress(_address) {
+    throw new Error("Method not implemented.");
+  }
+  async networkStakeStepRewardForPosition(position, range) {
+    return await timeBudget("networkStakeStepRewardForPosition", this.logger, async () => {
+      const externalRange = await externalBlockRangeFromXL1BlockRange(this.context, range);
+      const positionCount = await this.context.stake.stakeEvents.positionCount(externalRange);
+      if (positionCount === 0) {
+        return [
+          0n,
+          0n
+        ];
+      }
+      const steps = blockRangeSteps(range, [
+        3,
+        4,
+        5,
+        6,
+        7
+      ]);
+      const rewards = await Promise.all(steps.map((step) => this.networkStakeStepRewardForStepForPosition(step, position)));
+      const positionReward = rewards.reduce((a, b) => a + b[0], 0n);
+      const totalReward = rewards.reduce((a, b) => a + b[1], 0n);
+      return [
+        positionReward,
+        totalReward
+      ];
+    }, 100);
+  }
+  async networkStakeStepRewardForStep(stepContext) {
+    return await stepRewardTotal(this.context, stepContext, this.rewardMultipliers);
+  }
+  async networkStakeStepRewardForStepForPosition(stepIdentity, position) {
+    const stepIdentityString = toStepIdentityString(stepIdentity);
+    const cacheKey = `${stepIdentityString}|${position}`;
+    return await withContextCacheResponse(this.context, "NodeXyoViewer-networkStakeStepRewardForStepForPosition", cacheKey, async () => {
+      const range = await externalBlockRangeFromStep(this.context, stepIdentity);
+      const stake = await this.stakeById(position);
+      const numerator = stake.staked === XYO_NETWORK_STAKING_ADDRESS ? await weightedStakeForRangeByPosition(this.context, range, position) : 0n;
+      const denominator = await this.stepWeightedDenominator(stepIdentity);
+      const totalReward = await this.networkStakeStepRewardForStep(stepIdentity);
+      const positionReward = denominator > 0n ? totalReward * numerator / denominator : 0n;
+      const result = [
+        positionReward,
+        totalReward
+      ];
+      return result;
+    });
+  }
+  async networkStakeStepRewardPoolRewards(step) {
+    const stakes = await this.context.stake.stakesByStaked(XYO_NETWORK_STAKING_ADDRESS);
+    const rewards = [];
+    for (const stake of stakes) {
+      rewards.push([
+        stake.staker,
+        await this.networkStakeStepRewardForStepForPosition(step, stake.id)
+      ]);
+    }
+    const result = {};
+    for (const [staker, reward] of rewards) {
+      result[staker] = (result[staker] ?? 0n) + reward[0];
+    }
+    const filtered = Object.fromEntries(Object.entries(result).filter(([_, v]) => v > 0n));
+    return filtered;
+  }
+  networkStakeStepRewardPoolShares(_context) {
+    throw new Error("Method not implemented.");
+  }
+  async networkStakeStepRewardPositionWeight(stepContext, position) {
+    return await networkStakeStepRewardPositionWeight(this.context, stepContext, position);
+  }
+  networkStakeStepRewardPotentialPositionLoss(_context, _position) {
+    throw new Error("Method not implemented.");
+  }
+  networkStakeStepRewardRandomizer(_context) {
+    throw new Error("Method not implemented.");
+  }
+  async networkStakeStepRewardStakerCount(stepContext) {
+    return Object.keys(await allStakersForStep(this.context, stepContext, XYO_NETWORK_STAKING_ADDRESS)).length;
+  }
+  networkStakeStepRewardUnclaimedByAddress(_address) {
+    throw new Error("Method not implemented.");
+  }
+  networkStakeStepRewardWeightForAddress(_context, _address) {
+    throw new Error("Method not implemented.");
+  }
+  async networkStakeStepRewardsForPosition(position, range) {
+    const steps = blockRangeSteps(range, [
+      3,
+      4,
+      5,
+      6,
+      7,
+      8
+    ]);
+    const rewards = await Promise.all(steps.map(async (step) => {
+      return [
+        toStepIdentityString(step),
+        await this.networkStakeStepRewardForStepForPosition(step, position)
+      ];
+    }));
+    const result = {};
+    for (const [step, reward] of rewards) {
+      result[step] = reward;
+    }
+    const filtered = Object.fromEntries(Object.entries(result).filter(([_, v]) => v[0] > 0n));
+    return filtered;
+  }
+  async networkStakeStepRewardsForRange(range) {
+    return await timeBudget("networkStakeStepRewardsForRange", this.logger, async () => {
+      const steps = blockRangeSteps(range, [
+        3,
+        4,
+        5,
+        6,
+        7,
+        8
+      ]);
+      const rewards = await Promise.all(steps.map(async (step) => {
+        return await this.networkStakeStepRewardForStep(step);
+      }));
+      return rewards.reduce((a, b) => a + b, 0n);
+    }, 100);
+  }
+  async networkStakeStepRewardsForStepLevel(stepLevel, range) {
+    const steps = blockRangeSteps(range, [
+      stepLevel
+    ]);
+    const rewards = await Promise.all(steps.map(async (step) => {
+      return await this.networkStakeStepRewardForStep(step);
+    }));
+    return rewards.reduce((a, b) => a + b, 0n);
+  }
+  async stakeById(id) {
+    return await this.stake.stakeById(id);
+  }
+  async stakeByStaker(staker, slot) {
+    return await this.stake.stakeByStaker(staker, slot);
+  }
+  async stakedByStaker(staker) {
+    const result = /* @__PURE__ */ new Set();
+    let slot = 0;
+    while (true) {
+      try {
+        const ethStake = await this.stake.stakeByStaker(staker, slot);
+        result.add(toAddress(ethStake.staked));
+        slot++;
+      } catch {
+        break;
+      }
+    }
+    return [
+      ...result
+    ];
+  }
+  async stakesByStaked(staked) {
+    return await this.stake.stakesByStaked(staked);
+  }
+  async stakesByStaker(staker) {
+    return await this.stake.stakesByStaker(staker);
+  }
+  async transactionByBlockHashAndIndex(blockHash, transactionIndex = 0) {
+    return await spanRootAsync("transactionByBlockHashAndIndex", async () => {
+      assertEx(transactionIndex >= 0, () => "transactionIndex must be greater than or equal to 0");
+      try {
+        const block = await this.blockByHash(blockHash);
+        if (!block) return null;
+        const blockBoundWitnessIndexes = block[0].payload_schemas.map((schema, index) => schema === BoundWitnessSchema ? index : void 0).filter(exists$1);
+        const blockBoundWitnessHashes = new Set(blockBoundWitnessIndexes.map((index) => block[0].payload_hashes[index]));
+        const blockBoundWitnesses = block[1].filter((payload) => blockBoundWitnessHashes.has(payload._hash) || blockBoundWitnessHashes.has(payload._dataHash));
+        const blockTransactionBoundWitnesses = blockBoundWitnesses.filter(isTransactionBoundWitnessWithStorageMeta);
+        const transaction = blockTransactionBoundWitnesses.at(transactionIndex);
+        if (!transaction) return null;
+        return await this.transactionByHash(transaction._hash);
+      } catch {
+        return null;
+      }
+    }, this.tracer);
+  }
+  async transactionByBlockNumberAndIndex(blockNumber, transactionIndex = 0) {
+    return await spanRootAsync("transactionByBlockNumberAndIndex", async () => {
+      try {
+        const block = await this.blockByNumber(blockNumber);
+        if (!block) return null;
+        return await this.transactionByBlockHashAndIndex(block[0]._hash, transactionIndex);
+      } catch {
+        return null;
+      }
+    }, this.tracer);
+  }
+  async transactionByHash(transactionHash) {
+    return await spanRootAsync("transactionByHash", async () => {
+      try {
+        const cache = await this.getHydratedTransactionCache();
+        const hydratedTransaction = await cache.get(transactionHash);
+        return hydratedTransaction ?? null;
+      } catch {
+        return null;
+      }
+    }, this.tracer);
+  }
+  async transferBalance(address) {
+    return await spanRootAsync("transferBalance", async () => {
+      const diviner = await this.getTransferBalanceDiviner();
+      const query = new PayloadBuilder({
+        schema: AddressSchema
+      }).fields({
+        address
+      }).build();
+      const result = await diviner.divine([
+        query
+      ]);
+      const chainSummary = result.find(isChainSummaryTransfers);
+      const transfers = chainSummary?.transfers ?? {};
+      let transferBalance = 0n;
+      for (const [from, transfer] of Object.entries(transfers)) {
+        if (from === address) {
+          for (const [, amount] of Object.entries(transfer)) {
+            transferBalance += parseSignedBigInt(amount);
+          }
+        }
+      }
+      return asAttoXL1(transferBalance > 0n ? transferBalance : 0n);
+    }, this.tracer);
+  }
+  transferBalanceHistory(_address) {
+    throw new Error("Method not implemented.");
+  }
+  async transferPairBalance(pair) {
+    return await spanRootAsync("transferPairBalance", async () => {
+      const diviner = await this.getTransferBalanceDiviner();
+      const query = new PayloadBuilder({
+        schema: AddressPairSchema
+      }).fields({
+        addresses: [
+          pair[0],
+          pair[1]
+        ]
+      }).build();
+      const result = await diviner.divine([
+        query
+      ]);
+      const chainSummary = assertEx(result.find(isChainSummaryTransfers), () => "Failed to divine chain summary transfers");
+      const transfers = chainSummary.transfers;
+      const balance = transfers[pair[0]]?.[pair[1]];
+      return isDefined(balance) ? asAttoXL1(parseSignedBigInt(balance) * -1n) : asAttoXL1(0n);
+    }, this.tracer);
+  }
+  transferPairBalanceHistory(_pair) {
+    throw new Error("Method not implemented.");
+  }
+  getAddressBalanceDiviner = /* @__PURE__ */ __name$9(async () => {
+    if (this._addressBalanceDiviner) return this._addressBalanceDiviner;
+    const resolved = await this.getDiviner(this.addressBalanceDivinerPath);
+    this._addressBalanceDiviner = resolved;
+    return assertEx(this._addressBalanceDiviner, () => `Could not resolve ${this.addressBalanceDivinerPath} to a diviner instance`);
+  }, "getAddressBalanceDiviner");
+  getArchivist = /* @__PURE__ */ __name$9(async (identifier) => {
+    const archivist = await this.node.resolve(identifier);
+    return assertEx(asAttachableArchivistInstance(archivist), () => `Could not resolve ${identifier} to an archivist instance`);
+  }, "getArchivist");
+  async getCurrentHead() {
+    const chainArchivist = await this.getFinalizedArchivist();
+    return await findMostRecentBlock(chainArchivist);
+  }
+  getDiviner = /* @__PURE__ */ __name$9(async (identifier) => {
+    const diviner = await this.node.resolve(identifier);
+    return assertEx(asDivinerInstance(diviner), () => `Could not resolve ${identifier} to a diviner instance`);
+  }, "getDiviner");
+  getFinalizedArchivist = /* @__PURE__ */ __name$9(async () => {
+    if (this._finalizedArchivist) return this._finalizedArchivist;
+    const resolved = await this.getArchivist(this.finalizedArchivistPath);
+    this._finalizedArchivist = resolved;
+    return assertEx(this._finalizedArchivist, () => `Could not resolve finalized archivist at ${this.finalizedArchivistPath}`);
+  }, "getFinalizedArchivist");
+  getFinalizedPayloadMap = /* @__PURE__ */ __name$9(async () => {
+    const archivist = this.getFinalizedArchivist();
+    return readPayloadMapFromStore(await archivist);
+  }, "getFinalizedPayloadMap");
+  async getHydratedBlockCache() {
+    if (this._signedHydratedBlockCache) return this._signedHydratedBlockCache;
+    const chainMap = await this.getFinalizedPayloadMap();
+    this._signedHydratedBlockCache = new HydratedCache(chainMap, hydrateBlock, 200);
+    return this._signedHydratedBlockCache;
+  }
+  async getHydratedTransactionCache() {
+    if (this._signedHydratedTransactionCache) return this._signedHydratedTransactionCache;
+    const chainMap = await this.getFinalizedPayloadMap();
+    this._signedHydratedTransactionCache = new HydratedCache(chainMap, tryHydrateTransaction, 200);
+    return this._signedHydratedTransactionCache;
+  }
+  getTransferBalanceDiviner = /* @__PURE__ */ __name$9(async () => {
+    if (this._transferBalanceDiviner) return this._transferBalanceDiviner;
+    const resolved = await this.getDiviner(this.transferBalanceDivinerPath);
+    this._transferBalanceDiviner = resolved;
+    return assertEx(this._transferBalanceDiviner, () => `Could not resolve ${this.transferBalanceDivinerPath} to a diviner instance`);
+  }, "getTransferBalanceDiviner");
+  async startHandler() {
+    try {
+      const currentBlockNumber = await this.currentBlockNumber();
+      await this.transferBalance(XYO_ZERO_ADDRESS);
+      await this.accountBalance(XYO_ZERO_ADDRESS);
+      if (this.initRewardsCache) {
+        const externalRange = await externalBlockRangeFromXL1BlockRange(this.context, asXL1BlockRange([
+          0,
+          currentBlockNumber
+        ], {
+          name: "startHandler"
+        }));
+        const positionCount = await this.context.stake.stakeEvents.positionCount(externalRange);
+        this.logger?.log(`NodeXyoViewer: Precomputing networkStakeStepRewardForPosition up to position ${positionCount - 1}`);
+        for (let position = 0; position < positionCount; position++) {
+          await this.networkStakeStepRewardForPosition(position, asXL1BlockRange([
+            0,
+            currentBlockNumber
+          ], {
+            name: "startHandler"
+          }));
+        }
+        this.logger?.log(`NodeXyoViewer: Precomputed networkStakeStepRewardForPosition up to position ${positionCount - 1}`);
+      }
+    } catch (ex) {
+      this.logger?.error(`NodeXyoViewer: Error during startHandler initialization: ${ex.message}`);
+      this.logger?.error(ex.stack ?? "<No Stack>");
+      throw ex;
+    }
+  }
+  async stepWeightedDenominator(stepIdentity) {
+    const cacheKey = toStepIdentityString(stepIdentity);
+    return await withContextCacheResponse(this.context, "NodeXyoViewer-networkStakeStepRewardForStepForPosition-denominator", cacheKey, async () => {
+      const range = await externalBlockRangeFromStep(this.context, stepIdentity);
+      return await weightedStakeForRangeByPosition(this.context, range);
+    });
+  }
+  async distillTransferHistory(address, range, max = 50) {
+    if (range[1] - range[0] <= StepSizes[0] || max <= 1) {
+      return Array.from({
+        length: range[1] - range[0] + 1
+      }, (_, i) => range[1] - i).slice(0, max).map((n) => asXL1BlockNumber(n, {
+        name: "distillTransferHistory"
+      }));
+    }
+    const frames = deepCalculateFramesFromRange(asXL1BlockRange(range, {
+      name: "distillTransferHistory"
+    }));
+    const transferSummaryPairs = await Promise.all(frames.map(async (frame) => {
+      return [
+        frame,
+        await transfersStepSummaryFromRange(this.transfersSummaryContext, frame)
+      ];
+    }));
+    const filteredTransferSummaryPairs = transferSummaryPairs.filter(([_, summary]) => Object.keys(summary.transfers).includes(address));
+    const sortedTransferSummaryPairs = filteredTransferSummaryPairs.toSorted((a, b) => {
+      return b[0][1] - a[0][1];
+    });
+    const resultBlockNumbers = /* @__PURE__ */ new Set();
+    for (const [frame] of sortedTransferSummaryPairs) {
+      if (frame[1] - frame[0] + 1 > StepSizes[0]) {
+        const values = await this.distillTransferHistory(address, asXL1BlockRange([
+          frame[0],
+          frame[1] - 1
+        ], {
+          name: "distillTransferHistory"
+        }), max - resultBlockNumbers.size);
+        for (const value of values) {
+          resultBlockNumbers.add(value);
+        }
+        resultBlockNumbers.add(frame[1]);
+      } else {
+        for (let i = frame[0]; i <= frame[1]; i++) {
+          resultBlockNumbers.add(i);
+        }
+      }
+      if (resultBlockNumbers.size >= max) {
+        break;
+      }
+    }
+    return [
+      ...resultBlockNumbers
+    ].toSorted((a, b) => b - a).slice(0, max);
+  }
+};
+
+var __defProp$e = Object.defineProperty;
+var __name$8 = (target, value) => __defProp$e(target, "name", { value, configurable: true });
+var initContextManager = /* @__PURE__ */ __name$8(() => {
+  const contextManager = new AsyncLocalStorageContextManager();
+  context.setGlobalContextManager(contextManager.enable());
+}, "initContextManager");
+var initPropagation = /* @__PURE__ */ __name$8(() => {
+  propagation.setGlobalPropagator(new CompositePropagator({
+    propagators: [
+      new W3CTraceContextPropagator(),
+      new W3CBaggagePropagator()
+    ]
+  }));
+}, "initPropagation");
+var initResource = /* @__PURE__ */ __name$8((attributes) => {
+  const detectedResource = detectResources({
+    detectors: [
+      // hostDetector,
+      // osDetector,
+      // processDetector,
+      serviceInstanceIdDetector
+    ]
+  });
+  const staticResource = resourceFromAttributes({
+    [ATTR_SERVICE_NAME]: attributes.serviceName,
+    [ATTR_SERVICE_VERSION]: attributes.serviceName
+  });
+  const resource = detectedResource.merge(staticResource);
+  return resource;
+}, "initResource");
+var initHostMetrics = /* @__PURE__ */ __name$8((meterProvider) => {
+  const hostMetrics = new HostMetrics({
+    meterProvider,
+    name: "host-metrics"
+  });
+  hostMetrics.start();
+}, "initHostMetrics");
+var initNodeMetrics = /* @__PURE__ */ __name$8((meterProvider) => {
+  const instrumentation = new RuntimeNodeInstrumentation({
+    monitoringPrecision: 5e3
+  });
+  instrumentation.setMeterProvider(meterProvider);
+  instrumentation.enable();
+}, "initNodeMetrics");
+var initMetricsExporter = /* @__PURE__ */ __name$8((metricsConfig) => {
+  const { port, endpoint } = metricsConfig;
+  const exporter = new PrometheusExporter({
+    port,
+    endpoint
+  }, (err) => {
+    if (err) console.error("Error initializing Prometheus exporter", err);
+  });
+  return exporter;
+}, "initMetricsExporter");
+var initMeterProvider = /* @__PURE__ */ __name$8((resource, readers) => {
+  const meterProvider = new MeterProvider({
+    readers,
+    resource,
+    views: [
+      {
+        aggregation: void 0,
+        instrumentName: "*",
+        instrumentType: void 0,
+        meterName: "*"
+      }
+    ]
+  });
+  metrics$3.setGlobalMeterProvider(meterProvider);
+  return meterProvider;
+}, "initMeterProvider");
+var initTraceProvider = /* @__PURE__ */ __name$8((otlpEndpoint, resource) => {
+  const spanProcessors = [];
+  if (isDefined(otlpEndpoint)) {
+    const isHttp = otlpEndpoint.includes("/v1/traces") || otlpEndpoint.includes(":4318") || otlpEndpoint.startsWith("http");
+    const exporter = isHttp ? new OTLPTraceExporter({
+      url: otlpEndpoint
+    }) : new OTLPTraceExporter$1({
+      url: otlpEndpoint
+    });
+    const batchSpanProcessorConfig = {};
+    const spanProcessor = new BatchSpanProcessor(exporter, batchSpanProcessorConfig);
+    spanProcessors.push(spanProcessor);
+  }
+  const config = {
+    resource,
+    sampler: new AlwaysOnSampler(),
+    spanProcessors
+  };
+  const traceProvider = new BasicTracerProvider(config);
+  trace.setGlobalTracerProvider(traceProvider);
+  return traceProvider;
+}, "initTraceProvider");
+var initTelemetry = /* @__PURE__ */ __name$8((params) => {
+  const { attributes, metricsConfig, otlpEndpoint } = params;
+  initContextManager();
+  initPropagation();
+  const resource = initResource(attributes);
+  const exporter = initMetricsExporter(metricsConfig);
+  const meterProvider = initMeterProvider(resource, [
+    exporter
+  ]);
+  initHostMetrics(meterProvider);
+  initNodeMetrics(meterProvider);
+  const traceProvider = initTraceProvider(otlpEndpoint, resource);
+  return {
+    meterProvider,
+    traceProvider
+  };
+}, "initTelemetry");
+
+var __defProp$d = Object.defineProperty;
+var __name$7 = (target, value) => __defProp$d(target, "name", { value, configurable: true });
+async function networkStakeStepRewardEarnedForPosition(context, stepIdentity, position, rewardMultipliers = {}) {
+  const cacheKey = `${stepIdentity.block}|${stepIdentity.step}|${position.id}`;
+  return await withContextCacheResponse(context, "networkStakeStepRewardEarnedForPosition", cacheKey, async () => {
+    const range = await externalBlockRangeFromStep(context, stepIdentity);
+    const numerator = position.staked === XYO_NETWORK_STAKING_ADDRESS ? await weightedStakeForRangeByPosition(context, range, position.id) : 0n;
+    const denominator = await weightedStakeForRangeByPosition(context, range);
+    const totalReward = await stepRewardTotal(context, stepIdentity, rewardMultipliers);
+    const positionReward = denominator > 0n ? totalReward * numerator / denominator : 0n;
+    const result = [
+      positionReward,
+      totalReward
+    ];
+    return result;
+  });
+}
+__name$7(networkStakeStepRewardEarnedForPosition, "networkStakeStepRewardEarnedForPosition");
+
+// src/primitives/networkStakeStepRewardEarned.ts
+async function networkStakeStepRewardEarned(context, stepIdentity, rewardMultipliers = {}) {
+  const cacheKey = `${stepIdentity.block}|${stepIdentity.step}`;
+  return await withContextCacheResponse(context, "networkStakeStepRewardEarned", cacheKey, async () => {
+    const positions = await context.stake.stakesByStaked(XYO_NETWORK_STAKING_ADDRESS);
+    const results = await Promise.all(positions.map((pos) => {
+      return networkStakeStepRewardEarnedForPosition(context, stepIdentity, pos, rewardMultipliers);
+    }));
+    const numerator = results.reduce((acc, [positionReward]) => acc + positionReward, 0n);
+    const result = results.length > 0 ? [
+      numerator,
+      results[0][1]
+    ] : [
+      0n,
+      0n
+    ];
+    return result;
+  });
+}
+__name$7(networkStakeStepRewardEarned, "networkStakeStepRewardEarned");
+async function networkStakeStepRewardEarnedForStaker(context, stepIdentity, staker, rewardMultipliers = {}) {
+  const stepId = toStepIdentityString(stepIdentity);
+  return await withContextCacheResponse(context, "networkStakeStepRewardEarnedForStaker", `${stepId}-${staker}`, async () => {
+    const positions = (await context.stake.stakesByStaker(staker)).filter((pos) => pos.staked === XYO_NETWORK_STAKING_ADDRESS);
+    const results = await Promise.all(positions.map((pos) => {
+      return networkStakeStepRewardEarnedForPosition(context, stepIdentity, pos, rewardMultipliers);
+    }));
+    const numerator = results.reduce((acc, [positionReward]) => acc + positionReward, 0n);
+    const result = results.length > 0 ? [
+      numerator,
+      results[0][1]
+    ] : [
+      0n,
+      0n
+    ];
+    return result;
+  });
+}
+__name$7(networkStakeStepRewardEarnedForStaker, "networkStakeStepRewardEarnedForStaker");
+var SimpleStepRewardsByPositionViewer = class extends AbstractCreatable {
+  static {
+    __name$7(this, "SimpleStepRewardsByPositionViewer");
+  }
+  get context() {
+    return this.params.context;
+  }
+  get rewardMultipliers() {
+    return this.params.rewardMultipliers ?? {};
+  }
+  async bonus({ range, positions } = {}) {
+    const total = await this.total({
+      range,
+      positions
+    });
+    const earned = await this.earned({
+      range,
+      positions
+    });
+    const result = {};
+    for (const pos of Object.keys(total).map(Number)) {
+      result[pos] = asAttoXL1(total[pos] - (earned[pos] ?? 0n));
+    }
+    return result;
+  }
+  claimed(_options) {
+    throw new Error("Method not implemented.");
+  }
+  async earned({ range, positions } = {}) {
+    return await this.calculateRewards({
+      range,
+      positions
+    });
+  }
+  async total({ range, positions } = {}) {
+    return await this.calculateRewards({
+      range,
+      positions
+    }, this.rewardMultipliers);
+  }
+  unclaimed(_options = {}) {
+    throw new Error("Method not implemented.");
+  }
+  async calculateRewards({ range, positions } = {}, rewardMultipliers) {
+    const result = {};
+    const steps = blockRangeSteps(asXL1BlockRange(range ?? [
+      0,
+      (await this.context.head())[1]
+    ], {
+      name: "NodeStepRewardsByPositionViewer"
+    }), [
+      3,
+      4,
+      5,
+      6,
+      7
+    ]);
+    for (const step of steps) {
+      if (isArray$1(positions)) {
+        for (const positionId of positions) {
+          const position = await this.context.stake.stakeById(positionId);
+          result[positionId] = asAttoXL1((result[positionId] ?? 0n) + (await networkStakeStepRewardEarnedForPosition(this.context, step, position, rewardMultipliers))[0]);
+        }
+      }
+    }
+    return result;
+  }
+};
+var SimpleStepRewardsByStakerViewer = class extends AbstractCreatable {
+  static {
+    __name$7(this, "SimpleStepRewardsByStakerViewer");
+  }
+  get context() {
+    return this.params.context;
+  }
+  get rewardMultipliers() {
+    return this.params.rewardMultipliers ?? {};
+  }
+  get stakedChainContext() {
+    return this.params.context;
+  }
+  async bonus({ range, stakers } = {}) {
+    const total = await this.total({
+      range,
+      stakers
+    });
+    const earned = await this.earned({
+      range,
+      stakers
+    });
+    const result = {};
+    for (const staker of Object.keys(total)) {
+      result[staker] = asAttoXL1(total[staker] - (earned[staker] ?? 0n));
+    }
+    return result;
+  }
+  claimed(_options) {
+    throw new Error("Method not implemented.");
+  }
+  async earned(options = {}) {
+    return await this.calculateRewards(options);
+  }
+  async total(options = {}) {
+    return await this.calculateRewards(options, this.rewardMultipliers);
+  }
+  unclaimed(_options = {}) {
+    throw new Error("Method not implemented.");
+  }
+  async calculateRewards({ range, stakers } = {}, rewardMultipliers) {
+    const result = {};
+    const steps = blockRangeSteps(asXL1BlockRange(range ?? [
+      0,
+      (await this.context.head())[1]
+    ], {
+      name: "NodeStepRewardsByStakerViewer"
+    }), [
+      3,
+      4,
+      5,
+      6,
+      7
+    ]);
+    for (const step of steps) {
+      if (isArray$1(stakers)) {
+        for (const staker of stakers) {
+          result[staker] = asAttoXL1((result[staker] ?? 0n) + (await networkStakeStepRewardEarnedForStaker(this.context, step, staker, rewardMultipliers))[0]);
+        }
+      }
+    }
+    return result;
+  }
+};
+var SimpleStepRewardsByStepViewer = class extends AbstractCreatable {
+  static {
+    __name$7(this, "SimpleStepRewardsByStepViewer");
+  }
+  get context() {
+    return this.params.context;
+  }
+  get rewardMultipliers() {
+    return this.params.rewardMultipliers ?? {};
+  }
+  async bonus({ range, steps } = {}) {
+    const total = await this.total({
+      range,
+      steps
+    });
+    const earned = await this.earned({
+      range,
+      steps
+    });
+    const result = {};
+    for (const stepString of Object.keys(total)) {
+      result[stepString] = asAttoXL1(total[stepString] - (earned[stepString] ?? 0n));
+    }
+    return result;
+  }
+  claimed(_options) {
+    throw new Error("Method not implemented.");
+  }
+  async earned({ range, steps } = {}) {
+    const result = {};
+    const resolvedSteps = steps ?? blockRangeSteps(asXL1BlockRange(range ?? [
+      0,
+      (await this.context.head())[1]
+    ], {
+      name: "NodeStepRewardsByStepViewer"
+    }), [
+      3,
+      4,
+      5,
+      6,
+      7
+    ]);
+    for (const step of resolvedSteps) {
+      const stepIdentityString = toStepIdentityString(step);
+      result[stepIdentityString] = asAttoXL1((result[stepIdentityString] ?? 0n) + (await networkStakeStepRewardEarned(this.context, step))[0]);
+    }
+    return result;
+  }
+  async total({ range, steps } = {}) {
+    const result = {};
+    const resolvedSteps = steps ?? blockRangeSteps(asXL1BlockRange(range ?? [
+      0,
+      (await this.context.head())[1]
+    ], {
+      name: "NodeStepRewardsByStepViewer"
+    }), [
+      3,
+      4,
+      5,
+      6,
+      7
+    ]);
+    for (const step of resolvedSteps) {
+      const stepIdentityString = toStepIdentityString(step);
+      result[stepIdentityString] = asAttoXL1((result[stepIdentityString] ?? 0n) + (await networkStakeStepRewardEarned(this.context, step, this.rewardMultipliers))[0]);
+    }
+    return result;
+  }
+  unclaimed(_options = {}) {
+    throw new Error("Method not implemented.");
+  }
+};
+var SimpleStepRewardsViewer = class extends AbstractCreatable {
+  static {
+    __name$7(this, "SimpleStepRewardsViewer");
+  }
+  _position;
+  _staker;
+  _step;
+  get position() {
+    return assertEx(this._position, () => "Position viewer not initialized");
+  }
+  get staker() {
+    return assertEx(this._staker, () => "Position viewer not initialized");
+  }
+  get step() {
+    return assertEx(this._step, () => "Step viewer not initialized");
+  }
+  get total() {
+    throw new Error("Method not implemented.");
+  }
+  get context() {
+    return this.params.context;
+  }
+  get rewardMultipliers() {
+    return this.params.rewardMultipliers;
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._position = await SimpleStepRewardsByPositionViewer.create({
+      context: this.context,
+      rewardMultipliers: this.rewardMultipliers
+    });
+    this._staker = await SimpleStepRewardsByStakerViewer.create({
+      context: this.context,
+      rewardMultipliers: this.rewardMultipliers
+    });
+    this._step = await SimpleStepRewardsByStepViewer.create({
+      context: this.context,
+      rewardMultipliers: this.rewardMultipliers
+    });
+  }
+  async startHandler() {
+    await super.startHandler();
+    await assertEx(this._position, () => "Position viewer not created").start();
+    await assertEx(this._staker, () => "Staker viewer not created").start();
+    await assertEx(this._step, () => "Step viewer not created").start();
+  }
+};
+var SimpleNetworkStakeViewer = class extends AbstractCreatable {
+  static {
+    __name$7(this, "SimpleNetworkStakeViewer");
+  }
+  _stepRewardsViewer;
+  get context() {
+    return this.params.context;
+  }
+  get rewardMultipliers() {
+    return this.params.rewardMultipliers;
+  }
+  get stepRewards() {
+    return assertEx(this._stepRewardsViewer, () => "Step rewards viewer not initialized");
+  }
+  async active(blockNumber) {
+    const resolvedBlockNumber = blockNumber ?? (await this.context.head())[1];
+    return [
+      await this.context.stake.active(resolvedBlockNumber),
+      resolvedBlockNumber
+    ];
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._stepRewardsViewer = await SimpleStepRewardsViewer.create({
+      context: this.context,
+      rewardMultipliers: this.rewardMultipliers
+    });
+  }
+  async startHandler() {
+    await super.startHandler();
+    const stepRewardsByPositionViewer = await SimpleStepRewardsByPositionViewer.create({
+      context: this.context,
+      rewardMultipliers: this.rewardMultipliers
+    });
+    console.log("Initializing NodeStepRewardsByPositionViewer...");
+    await stepRewardsByPositionViewer.start();
+    console.log("Initialized NodeStepRewardsByPositionViewer.");
+  }
+};
+
+var __defProp$c = Object.defineProperty;
+var __name$6 = (target, value) => __defProp$c(target, "name", { value, configurable: true });
+var initArchivistSync = /* @__PURE__ */ __name$6(async (name, inArchivist, outArchivist, frequency = 1e3, max = 1e3, traceProvider) => {
   const node = await MemoryNode.create({
     account: "random"
   });
@@ -120104,7 +121596,7 @@ var initArchivistSync = /* @__PURE__ */ __name$9(async (name, inArchivist, outAr
 }, "initArchivistSync");
 var initMutex = new Mutex$1();
 var bridgeSingletonMap = /* @__PURE__ */ new Map();
-var initBridge = /* @__PURE__ */ __name$9(async (nodeUrl) => {
+var initBridge = /* @__PURE__ */ __name$6(async (nodeUrl) => {
   return await initMutex.runExclusive(async () => {
     const existing = bridgeSingletonMap.get(nodeUrl);
     if (existing) return existing;
@@ -120127,9 +121619,18 @@ var initBridge = /* @__PURE__ */ __name$9(async (nodeUrl) => {
     return bridge;
   });
 }, "initBridge");
+async function createProducerChainStakeIntentBlock(prevBlock, producerAccount, range) {
+  const producerDeclarationPayload = createDeclarationIntent(producerAccount.address, "producer", range[0], range[1]);
+  return await buildNextBlock(prevBlock, [], [
+    producerDeclarationPayload
+  ], [
+    producerAccount
+  ]);
+}
+__name$6(createProducerChainStakeIntentBlock, "createProducerChainStakeIntentBlock");
 var initMutex2 = new Mutex$1();
 var bridgedModuleDictionary = {};
-var initBridgedModule = /* @__PURE__ */ __name$9(async ({ bridge, moduleName }) => {
+var initBridgedModule = /* @__PURE__ */ __name$6(async ({ bridge, moduleName }) => {
   return await initMutex2.runExclusive(async () => {
     const existing = bridgedModuleDictionary?.[bridge.address]?.[moduleName];
     if (existing) return existing;
@@ -120144,18 +121645,146 @@ var initBridgedModule = /* @__PURE__ */ __name$9(async ({ bridge, moduleName })
     return moduleInstance;
   });
 }, "initBridgedModule");
-var initBridgedArchivistModule = /* @__PURE__ */ __name$9(async ({ bridge, moduleName }) => {
+var initBridgedArchivistModule = /* @__PURE__ */ __name$6(async ({ bridge, moduleName }) => {
   return assertEx(asAttachableArchivistInstance(await initBridgedModule({
     bridge,
     moduleName
   })), () => `Could not convert ${moduleName} to attachable archivist instance`);
 }, "initBridgedArchivistModule");
+var canUseChainId$1 = /* @__PURE__ */ __name$6((config) => {
+  return isDefined(config.evm.chainId);
+}, "canUseChainId");
+var getChainId$1 = /* @__PURE__ */ __name$6((config) => {
+  const chainId = assertEx(config.evm.chainId, () => "Missing config.evm.chainId");
+  if (isHex(chainId, {
+    prefix: true
+  })) {
+    const hex = hexFrom(chainId);
+    const parsed = Number.parseInt(hex, 16);
+    return parsed;
+  } else {
+    const parsed = Number.parseInt(chainId, 10);
+    return parsed;
+  }
+}, "getChainId");
 
-var __defProp$e = Object.defineProperty;
+// src/evm/initInfuraProvider.ts
+var instance$1;
+var initInfuraProvider$1 = /* @__PURE__ */ __name$6((config) => {
+  if (instance$1) return instance$1;
+  const providerConfig = getInfuraProviderConfig$1(config);
+  instance$1 = Promise.resolve(new InfuraProvider(...providerConfig));
+  return instance$1;
+}, "initInfuraProvider");
+var canUseInfuraProvider$1 = /* @__PURE__ */ __name$6((config) => {
+  return canUseChainId$1(config) && isDefined(config.evm?.infura?.projectId) && isDefined(config.evm?.infura?.projectSecret);
+}, "canUseInfuraProvider");
+var getInfuraProviderConfig$1 = /* @__PURE__ */ __name$6((config) => {
+  const projectId = assertEx(config.evm?.infura?.projectId, () => "Missing config.evm.infura.projectId");
+  const projectSecret = assertEx(config.evm?.infura?.projectSecret, () => "Missing config.evm.infura.projectSecret");
+  return [
+    getChainId$1(config),
+    projectId,
+    projectSecret
+  ];
+}, "getInfuraProviderConfig");
+var initJsonRpcProvider$1 = /* @__PURE__ */ __name$6((config) => {
+  const providerConfig = getJsonRpcProviderConfig$1(config);
+  return Promise.resolve(new JsonRpcProvider(...providerConfig));
+}, "initJsonRpcProvider");
+var canUseJsonRpcProvider$1 = /* @__PURE__ */ __name$6((config) => {
+  return canUseChainId$1(config) && isDefined(config.evm.jsonRpc?.url);
+}, "canUseJsonRpcProvider");
+var getJsonRpcProviderConfig$1 = /* @__PURE__ */ __name$6((config) => {
+  const jsonRpcUrl = assertEx(config.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
+  return [
+    jsonRpcUrl,
+    getChainId$1(config)
+  ];
+}, "getJsonRpcProviderConfig");
+
+// src/evm/initEvmProvider.ts
+var provider$1;
+var initEvmProvider$1 = /* @__PURE__ */ __name$6(async ({ config }) => {
+  if (provider$1) return provider$1;
+  if (canUseInfuraProvider$1(config)) {
+    provider$1 = initInfuraProvider$1(config);
+  } else if (canUseJsonRpcProvider$1(config)) {
+    provider$1 = initJsonRpcProvider$1(config);
+  }
+  return assertEx(await provider$1, () => "No provider available");
+}, "initEvmProvider");
+var canUseEvmProvider$1 = /* @__PURE__ */ __name$6(({ config }) => {
+  return canUseInfuraProvider$1(config) || canUseJsonRpcProvider$1(config);
+}, "canUseEvmProvider");
+
+// src/initChainStakeViewer.ts
+async function initEvmChainStakeViewer(config, logger) {
+  const provider2 = await initEvmProvider$1({
+    config,
+    logger
+  });
+  const contractAddress = assertEx(config.chain.id, () => "Missing config.evm.chainId");
+  const contract = StakedXyoChainV2__factory.connect(toEthAddress(contractAddress), provider2);
+  const stakeEventsViewer = await EthereumChainStakeEvents.create({
+    contract,
+    logger
+  });
+  assertEx(await stakeEventsViewer.start(), () => "Failed to start EthereumChainStakeEvents reader");
+  const stakeChainViewer = await EthereumChainStakeViewer.create({
+    contract,
+    stakeEventsViewer,
+    logger
+  });
+  assertEx(await stakeChainViewer.start(), () => "Failed to start EthereumChainStake viewer");
+  return stakeChainViewer;
+}
+__name$6(initEvmChainStakeViewer, "initEvmChainStakeViewer");
+async function initSimpleStakeViewer(config, logger) {
+  const stakeChainViewer = await SimpleChainStakeViewer.create({
+    logger,
+    positions: []
+  });
+  assertEx(await stakeChainViewer.start(), () => "Failed to start SimpleChainStake viewer");
+  return stakeChainViewer;
+}
+__name$6(initSimpleStakeViewer, "initSimpleStakeViewer");
+async function initChainStakeViewer(config, logger) {
+  if (canUseEvmProvider$1({
+    config
+  })) {
+    return await initEvmChainStakeViewer(config, logger);
+  } else {
+    console.warn("[API] Infura configuration not found. Using SimpleChainStakeViewer with no positions. This means no staking data will be available.");
+    return await initSimpleStakeViewer(config, logger);
+  }
+}
+__name$6(initChainStakeViewer, "initChainStakeViewer");
+var accountServiceSingleton;
+var initProducerAccount = /* @__PURE__ */ __name$6(async ({ config, logger }) => {
+  if (accountServiceSingleton) return accountServiceSingleton;
+  let walletPhrase = config.producer.mnemonic;
+  if (isUndefined$1(walletPhrase)) {
+    logger?.warn("[Producer] No wallet mnemonic specified!");
+    const randomMnemonic = HDWallet.generateMnemonic();
+    logger?.warn(`[Producer] Using randomly generated mnemonic:
+    
+${randomMnemonic}
+      
+    `);
+    walletPhrase = randomMnemonic;
+  }
+  const wallet = await generateXyoBaseWalletFromPhrase(walletPhrase);
+  const account = await wallet.derivePath(ADDRESS_INDEX.XYO);
+  accountServiceSingleton = account;
+  return accountServiceSingleton;
+}, "initProducerAccount");
+
+var __defProp$b = Object.defineProperty;
 var __getOwnPropDesc$5 = Object.getOwnPropertyDescriptor;
 var __getProtoOf$3 = Object.getPrototypeOf;
 var __reflectGet$3 = Reflect.get;
-var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __decorateClass$5 = (decorators, target, key, kind) => {
   var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$5(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
@@ -211535,910 +213164,6 @@ function requireExpress () {
 var expressExports = requireExpress();
 var express2 = /*@__PURE__*/getDefaultExportFromCjs(expressExports);
 
-var __defProp$d = Object.defineProperty;
-var __name$8 = (target, value) => __defProp$d(target, "name", { value, configurable: true });
-var NodeXyoViewer = class extends AbstractCreatable {
-  static {
-    __name$8(this, "NodeXyoViewer");
-  }
-  // TODO: Make configurable with defaults
-  _tracer;
-  addressBalanceDivinerPath = "XYOChain:Chain:AddressBalanceDiviner";
-  finalizedArchivistPath = "XYOChain:Chain:Finalized";
-  headValidationDivinerPath = "XYOChain:Chain:HeadValidationDiviner";
-  transferBalanceDivinerPath = "XYOChain:Chain:AddressTransferDiviner";
-  _addressBalanceDiviner;
-  _chainId;
-  _finalizedArchivist;
-  _rewardMultipliers;
-  _signedHydratedBlockCache;
-  _signedHydratedTransactionCache;
-  _transferBalanceDiviner;
-  get context() {
-    return assertEx(this.params.context, () => "NodeXyoViewer requires a context");
-  }
-  get initRewardsCache() {
-    return this.params.initRewardsCache ?? true;
-  }
-  get node() {
-    return this.params.node;
-  }
-  get rewardMultipliers() {
-    this._rewardMultipliers = this._rewardMultipliers ?? this.params.rewardMultipliers ?? {};
-    return this._rewardMultipliers;
-  }
-  get stake() {
-    return this.context.stake;
-  }
-  get transfersSummaryContext() {
-    return this.params.transfersSummaryContext ?? {
-      ...this.context
-    };
-  }
-  async accountBalance(address) {
-    return await spanRootAsync("accountBalance", async () => {
-      const diviner = await this.getAddressBalanceDiviner();
-      const query = new PayloadBuilder({
-        schema: AddressSchema
-      }).fields({
-        address
-      }).build();
-      const result = await diviner.divine([
-        query
-      ]);
-      const chainSummary = assertEx(result.find(isChainSummaryBalances), () => "Failed to divine chain summary balances");
-      const balances = chainSummary.balances;
-      const signedBalance = balances[address] === void 0 ? 0n : parseSignedBigInt(balances[address]);
-      return asAttoXL1(signedBalance > 0n ? signedBalance : 0n);
-    }, this.tracer);
-  }
-  async accountBalanceHistory(address, rangeOrHash) {
-    return await spanRootAsync("accountHistory", async () => {
-      const range = asRange(rangeOrHash);
-      const startingRange = asXL1BlockRange(range ?? [
-        0,
-        await this.currentBlockNumber()
-      ], {
-        name: "accountBalanceHistory"
-      });
-      const blockNumbers = await this.distillTransferHistory(address, startingRange);
-      const blocks = (await Promise.all(blockNumbers.map(async (bn) => await this.blockByNumber(bn)))).filter(exists$1);
-      const result = [];
-      for (const block of blocks) {
-        const transferIndexes = block[0].payload_schemas.map((schema, index) => schema === TransferSchema ? index : void 0).filter(exists$1);
-        const transfers = transferIndexes.map((index) => {
-          const hash = block[0].payload_hashes[index];
-          return assertEx(block[1].find((p) => p._hash === hash), () => `Could not find Transfer with hash ${hash} in block ${block[0]._hash}`);
-        }).filter(exists$1).filter((t) => t.from === address || isDefined(t.transfers[address]));
-        if (transfers.length === 0) {
-          continue;
-        }
-        const pairs = transfers.map((transfer) => {
-          return [
-            block[0],
-            transfer
-          ];
-        });
-        result.push(...pairs.map(([block2, transfer]) => [
-          block2,
-          null,
-          transfer
-        ]));
-      }
-      return result;
-    }, this.tracer);
-  }
-  async blockByHash(hash) {
-    return await spanRootAsync("blockByHash", async () => {
-      const cache = await this.getHydratedBlockCache();
-      return await cache.get(hash);
-    }, this.tracer);
-  }
-  async blockByNumber(blockNumber) {
-    return await spanRootAsync("blockByNumber", async () => {
-      return await hydratedBlockByNumber(this.context, blockNumber);
-    }, this.tracer);
-  }
-  async blocksByHash(hash, limit = 10) {
-    return await spanRootAsync("blocksByHash", async () => {
-      assertEx(limit > 0, () => "limit must be greater than 0");
-      assertEx(limit <= 100, () => "limit must be less than 100");
-      const blocks = [];
-      let current = await this.blockByHash(hash);
-      while (current && blocks.length < limit) {
-        blocks.push(current);
-        const previousHash = current[0].previous;
-        if (previousHash === null) break;
-        current = await this.blockByHash(previousHash);
-      }
-      return blocks;
-    }, this.tracer);
-  }
-  async chainId() {
-    return await spanRootAsync("chainId", async () => {
-      if (this._chainId !== void 0) return this._chainId;
-      const block = await this.currentBlock();
-      this._chainId = block[0].chain;
-      return this._chainId;
-    }, this.tracer);
-  }
-  async chainIdAtBlock(blockNumber) {
-    return await spanRootAsync("chainIdAtBlock", async () => {
-      if (this._chainId !== void 0) return this._chainId;
-      const block = await this.blockByNumber(blockNumber);
-      this._chainId = block?.[0].chain;
-      return this._chainId;
-    }, this.tracer);
-  }
-  async currentBlock() {
-    return await spanRootAsync("currentBlock", async () => {
-      const currentHead = assertEx(await this.getCurrentHead(), () => "Could not find most recent block");
-      const cache = await this.getHydratedBlockCache();
-      const block = await cache.get(currentHead._hash);
-      if (!block) {
-        console.log(`Could not find current block with hash ${currentHead._hash}`);
-      }
-      return assertEx(block, () => "Could not find current block");
-    }, this.tracer);
-  }
-  async currentBlockHash() {
-    return await spanRootAsync("currentBlockHash", async () => {
-      const currentHead = assertEx(await this.getCurrentHead(), () => "Could not find most recent block");
-      return currentHead._hash;
-    }, this.tracer);
-  }
-  async currentBlockNumber() {
-    return await spanRootAsync("currentBlockNumber", async () => {
-      const currentHead = assertEx(await this.getCurrentHead(), () => "Could not find most recent block");
-      return asXL1BlockNumber(currentHead.block, {
-        name: "currentBlockNumber"
-      });
-    }, this.tracer);
-  }
-  forkHistory() {
-    throw new Error("Method not implemented.");
-  }
-  networkStakeStepRewardAddressHistory(_address) {
-    throw new Error("Method not implemented.");
-  }
-  networkStakeStepRewardAddressReward(_context, _address) {
-    throw new Error("Method not implemented.");
-  }
-  networkStakeStepRewardAddressShare(_context, _address) {
-    throw new Error("Method not implemented.");
-  }
-  networkStakeStepRewardClaimedByAddress(_address) {
-    throw new Error("Method not implemented.");
-  }
-  async networkStakeStepRewardForPosition(position, range) {
-    return await timeBudget("networkStakeStepRewardForPosition", this.logger, async () => {
-      const externalRange = await externalBlockRangeFromXL1BlockRange(this.context, range);
-      const positionCount = await this.context.stake.stakeEvents.positionCount(externalRange);
-      if (positionCount === 0) {
-        return [
-          0n,
-          0n
-        ];
-      }
-      const steps = blockRangeSteps(range, [
-        3,
-        4,
-        5,
-        6,
-        7
-      ]);
-      const rewards = await Promise.all(steps.map((step) => this.networkStakeStepRewardForStepForPosition(step, position)));
-      const positionReward = rewards.reduce((a, b) => a + b[0], 0n);
-      const totalReward = rewards.reduce((a, b) => a + b[1], 0n);
-      return [
-        positionReward,
-        totalReward
-      ];
-    }, 100);
-  }
-  async networkStakeStepRewardForStep(stepContext) {
-    return await stepRewardTotal(this.context, stepContext, this.rewardMultipliers);
-  }
-  async networkStakeStepRewardForStepForPosition(stepIdentity, position) {
-    const stepIdentityString = toStepIdentityString(stepIdentity);
-    const cacheKey = `${stepIdentityString}|${position}`;
-    return await withContextCacheResponse(this.context, "NodeXyoViewer-networkStakeStepRewardForStepForPosition", cacheKey, async () => {
-      const range = await externalBlockRangeFromStep(this.context, stepIdentity);
-      const stake = await this.stakeById(position);
-      const numerator = stake.staked === XYO_NETWORK_STAKING_ADDRESS ? await weightedStakeForRangeByPosition(this.context, range, position) : 0n;
-      const denominator = await this.stepWeightedDenominator(stepIdentity);
-      const totalReward = await this.networkStakeStepRewardForStep(stepIdentity);
-      const positionReward = denominator > 0n ? totalReward * numerator / denominator : 0n;
-      const result = [
-        positionReward,
-        totalReward
-      ];
-      return result;
-    });
-  }
-  async networkStakeStepRewardPoolRewards(step) {
-    const stakes = await this.context.stake.stakesByStaked(XYO_NETWORK_STAKING_ADDRESS);
-    const rewards = [];
-    for (const stake of stakes) {
-      rewards.push([
-        stake.staker,
-        await this.networkStakeStepRewardForStepForPosition(step, stake.id)
-      ]);
-    }
-    const result = {};
-    for (const [staker, reward] of rewards) {
-      result[staker] = (result[staker] ?? 0n) + reward[0];
-    }
-    const filtered = Object.fromEntries(Object.entries(result).filter(([_, v]) => v > 0n));
-    return filtered;
-  }
-  networkStakeStepRewardPoolShares(_context) {
-    throw new Error("Method not implemented.");
-  }
-  async networkStakeStepRewardPositionWeight(stepContext, position) {
-    return await networkStakeStepRewardPositionWeight(this.context, stepContext, position);
-  }
-  networkStakeStepRewardPotentialPositionLoss(_context, _position) {
-    throw new Error("Method not implemented.");
-  }
-  networkStakeStepRewardRandomizer(_context) {
-    throw new Error("Method not implemented.");
-  }
-  async networkStakeStepRewardStakerCount(stepContext) {
-    return Object.keys(await allStakersForStep(this.context, stepContext, XYO_NETWORK_STAKING_ADDRESS)).length;
-  }
-  networkStakeStepRewardUnclaimedByAddress(_address) {
-    throw new Error("Method not implemented.");
-  }
-  networkStakeStepRewardWeightForAddress(_context, _address) {
-    throw new Error("Method not implemented.");
-  }
-  async networkStakeStepRewardsForPosition(position, range) {
-    const steps = blockRangeSteps(range, [
-      3,
-      4,
-      5,
-      6,
-      7,
-      8
-    ]);
-    const rewards = await Promise.all(steps.map(async (step) => {
-      return [
-        toStepIdentityString(step),
-        await this.networkStakeStepRewardForStepForPosition(step, position)
-      ];
-    }));
-    const result = {};
-    for (const [step, reward] of rewards) {
-      result[step] = reward;
-    }
-    const filtered = Object.fromEntries(Object.entries(result).filter(([_, v]) => v[0] > 0n));
-    return filtered;
-  }
-  async networkStakeStepRewardsForRange(range) {
-    return await timeBudget("networkStakeStepRewardsForRange", this.logger, async () => {
-      const steps = blockRangeSteps(range, [
-        3,
-        4,
-        5,
-        6,
-        7,
-        8
-      ]);
-      const rewards = await Promise.all(steps.map(async (step) => {
-        return await this.networkStakeStepRewardForStep(step);
-      }));
-      return rewards.reduce((a, b) => a + b, 0n);
-    }, 100);
-  }
-  async networkStakeStepRewardsForStepLevel(stepLevel, range) {
-    const steps = blockRangeSteps(range, [
-      stepLevel
-    ]);
-    const rewards = await Promise.all(steps.map(async (step) => {
-      return await this.networkStakeStepRewardForStep(step);
-    }));
-    return rewards.reduce((a, b) => a + b, 0n);
-  }
-  async stakeById(id) {
-    return await this.stake.stakeById(id);
-  }
-  async stakeByStaker(staker, slot) {
-    return await this.stake.stakeByStaker(staker, slot);
-  }
-  async stakedByStaker(staker) {
-    const result = /* @__PURE__ */ new Set();
-    let slot = 0;
-    while (true) {
-      try {
-        const ethStake = await this.stake.stakeByStaker(staker, slot);
-        result.add(toAddress(ethStake.staked));
-        slot++;
-      } catch {
-        break;
-      }
-    }
-    return [
-      ...result
-    ];
-  }
-  async stakesByStaked(staked) {
-    return await this.stake.stakesByStaked(staked);
-  }
-  async stakesByStaker(staker) {
-    return await this.stake.stakesByStaker(staker);
-  }
-  async transactionByBlockHashAndIndex(blockHash, transactionIndex = 0) {
-    return await spanRootAsync("transactionByBlockHashAndIndex", async () => {
-      assertEx(transactionIndex >= 0, () => "transactionIndex must be greater than or equal to 0");
-      try {
-        const block = await this.blockByHash(blockHash);
-        if (!block) return null;
-        const blockBoundWitnessIndexes = block[0].payload_schemas.map((schema, index) => schema === BoundWitnessSchema ? index : void 0).filter(exists$1);
-        const blockBoundWitnessHashes = new Set(blockBoundWitnessIndexes.map((index) => block[0].payload_hashes[index]));
-        const blockBoundWitnesses = block[1].filter((payload) => blockBoundWitnessHashes.has(payload._hash) || blockBoundWitnessHashes.has(payload._dataHash));
-        const blockTransactionBoundWitnesses = blockBoundWitnesses.filter(isTransactionBoundWitnessWithStorageMeta);
-        const transaction = blockTransactionBoundWitnesses.at(transactionIndex);
-        if (!transaction) return null;
-        return await this.transactionByHash(transaction._hash);
-      } catch {
-        return null;
-      }
-    }, this.tracer);
-  }
-  async transactionByBlockNumberAndIndex(blockNumber, transactionIndex = 0) {
-    return await spanRootAsync("transactionByBlockNumberAndIndex", async () => {
-      try {
-        const block = await this.blockByNumber(blockNumber);
-        if (!block) return null;
-        return await this.transactionByBlockHashAndIndex(block[0]._hash, transactionIndex);
-      } catch {
-        return null;
-      }
-    }, this.tracer);
-  }
-  async transactionByHash(transactionHash) {
-    return await spanRootAsync("transactionByHash", async () => {
-      try {
-        const cache = await this.getHydratedTransactionCache();
-        const hydratedTransaction = await cache.get(transactionHash);
-        return hydratedTransaction ?? null;
-      } catch {
-        return null;
-      }
-    }, this.tracer);
-  }
-  async transferBalance(address) {
-    return await spanRootAsync("transferBalance", async () => {
-      const diviner = await this.getTransferBalanceDiviner();
-      const query = new PayloadBuilder({
-        schema: AddressSchema
-      }).fields({
-        address
-      }).build();
-      const result = await diviner.divine([
-        query
-      ]);
-      const chainSummary = result.find(isChainSummaryTransfers);
-      const transfers = chainSummary?.transfers ?? {};
-      let transferBalance = 0n;
-      for (const [from, transfer] of Object.entries(transfers)) {
-        if (from === address) {
-          for (const [, amount] of Object.entries(transfer)) {
-            transferBalance += parseSignedBigInt(amount);
-          }
-        }
-      }
-      return asAttoXL1(transferBalance > 0n ? transferBalance : 0n);
-    }, this.tracer);
-  }
-  transferBalanceHistory(_address) {
-    throw new Error("Method not implemented.");
-  }
-  async transferPairBalance(pair) {
-    return await spanRootAsync("transferPairBalance", async () => {
-      const diviner = await this.getTransferBalanceDiviner();
-      const query = new PayloadBuilder({
-        schema: AddressPairSchema
-      }).fields({
-        addresses: [
-          pair[0],
-          pair[1]
-        ]
-      }).build();
-      const result = await diviner.divine([
-        query
-      ]);
-      const chainSummary = assertEx(result.find(isChainSummaryTransfers), () => "Failed to divine chain summary transfers");
-      const transfers = chainSummary.transfers;
-      const balance = transfers[pair[0]]?.[pair[1]];
-      return isDefined(balance) ? asAttoXL1(parseSignedBigInt(balance) * -1n) : asAttoXL1(0n);
-    }, this.tracer);
-  }
-  transferPairBalanceHistory(_pair) {
-    throw new Error("Method not implemented.");
-  }
-  getAddressBalanceDiviner = /* @__PURE__ */ __name$8(async () => {
-    if (this._addressBalanceDiviner) return this._addressBalanceDiviner;
-    const resolved = await this.getDiviner(this.addressBalanceDivinerPath);
-    this._addressBalanceDiviner = resolved;
-    return assertEx(this._addressBalanceDiviner, () => `Could not resolve ${this.addressBalanceDivinerPath} to a diviner instance`);
-  }, "getAddressBalanceDiviner");
-  getArchivist = /* @__PURE__ */ __name$8(async (identifier) => {
-    const archivist = await this.node.resolve(identifier);
-    return assertEx(asAttachableArchivistInstance(archivist), () => `Could not resolve ${identifier} to an archivist instance`);
-  }, "getArchivist");
-  async getCurrentHead() {
-    const chainArchivist = await this.getFinalizedArchivist();
-    return await findMostRecentBlock(chainArchivist);
-  }
-  getDiviner = /* @__PURE__ */ __name$8(async (identifier) => {
-    const diviner = await this.node.resolve(identifier);
-    return assertEx(asDivinerInstance(diviner), () => `Could not resolve ${identifier} to a diviner instance`);
-  }, "getDiviner");
-  getFinalizedArchivist = /* @__PURE__ */ __name$8(async () => {
-    if (this._finalizedArchivist) return this._finalizedArchivist;
-    const resolved = await this.getArchivist(this.finalizedArchivistPath);
-    this._finalizedArchivist = resolved;
-    return assertEx(this._finalizedArchivist, () => `Could not resolve finalized archivist at ${this.finalizedArchivistPath}`);
-  }, "getFinalizedArchivist");
-  getFinalizedPayloadMap = /* @__PURE__ */ __name$8(async () => {
-    const archivist = this.getFinalizedArchivist();
-    return readPayloadMapFromStore(await archivist);
-  }, "getFinalizedPayloadMap");
-  async getHydratedBlockCache() {
-    if (this._signedHydratedBlockCache) return this._signedHydratedBlockCache;
-    const chainMap = await this.getFinalizedPayloadMap();
-    this._signedHydratedBlockCache = new HydratedCache(chainMap, hydrateBlock, 200);
-    return this._signedHydratedBlockCache;
-  }
-  async getHydratedTransactionCache() {
-    if (this._signedHydratedTransactionCache) return this._signedHydratedTransactionCache;
-    const chainMap = await this.getFinalizedPayloadMap();
-    this._signedHydratedTransactionCache = new HydratedCache(chainMap, tryHydrateTransaction, 200);
-    return this._signedHydratedTransactionCache;
-  }
-  getTransferBalanceDiviner = /* @__PURE__ */ __name$8(async () => {
-    if (this._transferBalanceDiviner) return this._transferBalanceDiviner;
-    const resolved = await this.getDiviner(this.transferBalanceDivinerPath);
-    this._transferBalanceDiviner = resolved;
-    return assertEx(this._transferBalanceDiviner, () => `Could not resolve ${this.transferBalanceDivinerPath} to a diviner instance`);
-  }, "getTransferBalanceDiviner");
-  async startHandler() {
-    try {
-      const currentBlockNumber = await this.currentBlockNumber();
-      await this.transferBalance(XYO_ZERO_ADDRESS);
-      await this.accountBalance(XYO_ZERO_ADDRESS);
-      if (this.initRewardsCache) {
-        const externalRange = await externalBlockRangeFromXL1BlockRange(this.context, asXL1BlockRange([
-          0,
-          currentBlockNumber
-        ], {
-          name: "startHandler"
-        }));
-        const positionCount = await this.context.stake.stakeEvents.positionCount(externalRange);
-        this.logger?.log(`NodeXyoViewer: Precomputing networkStakeStepRewardForPosition up to position ${positionCount - 1}`);
-        for (let position = 0; position < positionCount; position++) {
-          await this.networkStakeStepRewardForPosition(position, asXL1BlockRange([
-            0,
-            currentBlockNumber
-          ], {
-            name: "startHandler"
-          }));
-        }
-        this.logger?.log(`NodeXyoViewer: Precomputed networkStakeStepRewardForPosition up to position ${positionCount - 1}`);
-      }
-    } catch (ex) {
-      this.logger?.error(`NodeXyoViewer: Error during startHandler initialization: ${ex.message}`);
-      this.logger?.error(ex.stack ?? "<No Stack>");
-      throw ex;
-    }
-  }
-  async stepWeightedDenominator(stepIdentity) {
-    const cacheKey = toStepIdentityString(stepIdentity);
-    return await withContextCacheResponse(this.context, "NodeXyoViewer-networkStakeStepRewardForStepForPosition-denominator", cacheKey, async () => {
-      const range = await externalBlockRangeFromStep(this.context, stepIdentity);
-      return await weightedStakeForRangeByPosition(this.context, range);
-    });
-  }
-  async distillTransferHistory(address, range, max = 50) {
-    if (range[1] - range[0] <= StepSizes[0] || max <= 1) {
-      return Array.from({
-        length: range[1] - range[0] + 1
-      }, (_, i) => range[1] - i).slice(0, max).map((n) => asXL1BlockNumber(n, {
-        name: "distillTransferHistory"
-      }));
-    }
-    const frames = deepCalculateFramesFromRange(asXL1BlockRange(range, {
-      name: "distillTransferHistory"
-    }));
-    const transferSummaryPairs = await Promise.all(frames.map(async (frame) => {
-      return [
-        frame,
-        await transfersStepSummaryFromRange(this.transfersSummaryContext, frame)
-      ];
-    }));
-    const filteredTransferSummaryPairs = transferSummaryPairs.filter(([_, summary]) => Object.keys(summary.transfers).includes(address));
-    const sortedTransferSummaryPairs = filteredTransferSummaryPairs.toSorted((a, b) => {
-      return b[0][1] - a[0][1];
-    });
-    const resultBlockNumbers = /* @__PURE__ */ new Set();
-    for (const [frame] of sortedTransferSummaryPairs) {
-      if (frame[1] - frame[0] + 1 > StepSizes[0]) {
-        const values = await this.distillTransferHistory(address, asXL1BlockRange([
-          frame[0],
-          frame[1] - 1
-        ], {
-          name: "distillTransferHistory"
-        }), max - resultBlockNumbers.size);
-        for (const value of values) {
-          resultBlockNumbers.add(value);
-        }
-        resultBlockNumbers.add(frame[1]);
-      } else {
-        for (let i = frame[0]; i <= frame[1]; i++) {
-          resultBlockNumbers.add(i);
-        }
-      }
-      if (resultBlockNumbers.size >= max) {
-        break;
-      }
-    }
-    return [
-      ...resultBlockNumbers
-    ].toSorted((a, b) => b - a).slice(0, max);
-  }
-};
-
-var __defProp$c = Object.defineProperty;
-var __name$7 = (target, value) => __defProp$c(target, "name", { value, configurable: true });
-async function networkStakeStepRewardEarnedForPosition(context, stepIdentity, position, rewardMultipliers = {}) {
-  const cacheKey = `${stepIdentity.block}|${stepIdentity.step}|${position.id}`;
-  return await withContextCacheResponse(context, "networkStakeStepRewardEarnedForPosition", cacheKey, async () => {
-    const range = await externalBlockRangeFromStep(context, stepIdentity);
-    const numerator = position.staked === XYO_NETWORK_STAKING_ADDRESS ? await weightedStakeForRangeByPosition(context, range, position.id) : 0n;
-    const denominator = await weightedStakeForRangeByPosition(context, range);
-    const totalReward = await stepRewardTotal(context, stepIdentity, rewardMultipliers);
-    const positionReward = denominator > 0n ? totalReward * numerator / denominator : 0n;
-    const result = [
-      positionReward,
-      totalReward
-    ];
-    return result;
-  });
-}
-__name$7(networkStakeStepRewardEarnedForPosition, "networkStakeStepRewardEarnedForPosition");
-
-// src/primitives/networkStakeStepRewardEarned.ts
-async function networkStakeStepRewardEarned(context, stepIdentity, rewardMultipliers = {}) {
-  const cacheKey = `${stepIdentity.block}|${stepIdentity.step}`;
-  return await withContextCacheResponse(context, "networkStakeStepRewardEarned", cacheKey, async () => {
-    const positions = await context.stake.stakesByStaked(XYO_NETWORK_STAKING_ADDRESS);
-    const results = await Promise.all(positions.map((pos) => {
-      return networkStakeStepRewardEarnedForPosition(context, stepIdentity, pos, rewardMultipliers);
-    }));
-    const numerator = results.reduce((acc, [positionReward]) => acc + positionReward, 0n);
-    const result = results.length > 0 ? [
-      numerator,
-      results[0][1]
-    ] : [
-      0n,
-      0n
-    ];
-    return result;
-  });
-}
-__name$7(networkStakeStepRewardEarned, "networkStakeStepRewardEarned");
-async function networkStakeStepRewardEarnedForStaker(context, stepIdentity, staker, rewardMultipliers = {}) {
-  const stepId = toStepIdentityString(stepIdentity);
-  return await withContextCacheResponse(context, "networkStakeStepRewardEarnedForStaker", `${stepId}-${staker}`, async () => {
-    const positions = (await context.stake.stakesByStaker(staker)).filter((pos) => pos.staked === XYO_NETWORK_STAKING_ADDRESS);
-    const results = await Promise.all(positions.map((pos) => {
-      return networkStakeStepRewardEarnedForPosition(context, stepIdentity, pos, rewardMultipliers);
-    }));
-    const numerator = results.reduce((acc, [positionReward]) => acc + positionReward, 0n);
-    const result = results.length > 0 ? [
-      numerator,
-      results[0][1]
-    ] : [
-      0n,
-      0n
-    ];
-    return result;
-  });
-}
-__name$7(networkStakeStepRewardEarnedForStaker, "networkStakeStepRewardEarnedForStaker");
-var SimpleStepRewardsByPositionViewer = class extends AbstractCreatable {
-  static {
-    __name$7(this, "SimpleStepRewardsByPositionViewer");
-  }
-  get context() {
-    return this.params.context;
-  }
-  get rewardMultipliers() {
-    return this.params.rewardMultipliers ?? {};
-  }
-  async bonus({ range, positions } = {}) {
-    const total = await this.total({
-      range,
-      positions
-    });
-    const earned = await this.earned({
-      range,
-      positions
-    });
-    const result = {};
-    for (const pos of Object.keys(total).map(Number)) {
-      result[pos] = asAttoXL1(total[pos] - (earned[pos] ?? 0n));
-    }
-    return result;
-  }
-  claimed(_options) {
-    throw new Error("Method not implemented.");
-  }
-  async earned({ range, positions } = {}) {
-    return await this.calculateRewards({
-      range,
-      positions
-    });
-  }
-  async total({ range, positions } = {}) {
-    return await this.calculateRewards({
-      range,
-      positions
-    }, this.rewardMultipliers);
-  }
-  unclaimed(_options = {}) {
-    throw new Error("Method not implemented.");
-  }
-  async calculateRewards({ range, positions } = {}, rewardMultipliers) {
-    const result = {};
-    const steps = blockRangeSteps(asXL1BlockRange(range ?? [
-      0,
-      (await this.context.head())[1]
-    ], {
-      name: "NodeStepRewardsByPositionViewer"
-    }), [
-      3,
-      4,
-      5,
-      6,
-      7
-    ]);
-    for (const step of steps) {
-      if (isArray$1(positions)) {
-        for (const positionId of positions) {
-          const position = await this.context.stake.stakeById(positionId);
-          result[positionId] = asAttoXL1((result[positionId] ?? 0n) + (await networkStakeStepRewardEarnedForPosition(this.context, step, position, rewardMultipliers))[0]);
-        }
-      }
-    }
-    return result;
-  }
-};
-var SimpleStepRewardsByStakerViewer = class extends AbstractCreatable {
-  static {
-    __name$7(this, "SimpleStepRewardsByStakerViewer");
-  }
-  get context() {
-    return this.params.context;
-  }
-  get rewardMultipliers() {
-    return this.params.rewardMultipliers ?? {};
-  }
-  get stakedChainContext() {
-    return this.params.context;
-  }
-  async bonus({ range, stakers } = {}) {
-    const total = await this.total({
-      range,
-      stakers
-    });
-    const earned = await this.earned({
-      range,
-      stakers
-    });
-    const result = {};
-    for (const staker of Object.keys(total)) {
-      result[staker] = asAttoXL1(total[staker] - (earned[staker] ?? 0n));
-    }
-    return result;
-  }
-  claimed(_options) {
-    throw new Error("Method not implemented.");
-  }
-  async earned(options = {}) {
-    return await this.calculateRewards(options);
-  }
-  async total(options = {}) {
-    return await this.calculateRewards(options, this.rewardMultipliers);
-  }
-  unclaimed(_options = {}) {
-    throw new Error("Method not implemented.");
-  }
-  async calculateRewards({ range, stakers } = {}, rewardMultipliers) {
-    const result = {};
-    const steps = blockRangeSteps(asXL1BlockRange(range ?? [
-      0,
-      (await this.context.head())[1]
-    ], {
-      name: "NodeStepRewardsByStakerViewer"
-    }), [
-      3,
-      4,
-      5,
-      6,
-      7
-    ]);
-    for (const step of steps) {
-      if (isArray$1(stakers)) {
-        for (const staker of stakers) {
-          result[staker] = asAttoXL1((result[staker] ?? 0n) + (await networkStakeStepRewardEarnedForStaker(this.context, step, staker, rewardMultipliers))[0]);
-        }
-      }
-    }
-    return result;
-  }
-};
-var SimpleStepRewardsByStepViewer = class extends AbstractCreatable {
-  static {
-    __name$7(this, "SimpleStepRewardsByStepViewer");
-  }
-  get context() {
-    return this.params.context;
-  }
-  get rewardMultipliers() {
-    return this.params.rewardMultipliers ?? {};
-  }
-  async bonus({ range, steps } = {}) {
-    const total = await this.total({
-      range,
-      steps
-    });
-    const earned = await this.earned({
-      range,
-      steps
-    });
-    const result = {};
-    for (const stepString of Object.keys(total)) {
-      result[stepString] = asAttoXL1(total[stepString] - (earned[stepString] ?? 0n));
-    }
-    return result;
-  }
-  claimed(_options) {
-    throw new Error("Method not implemented.");
-  }
-  async earned({ range, steps } = {}) {
-    const result = {};
-    const resolvedSteps = steps ?? blockRangeSteps(asXL1BlockRange(range ?? [
-      0,
-      (await this.context.head())[1]
-    ], {
-      name: "NodeStepRewardsByStepViewer"
-    }), [
-      3,
-      4,
-      5,
-      6,
-      7
-    ]);
-    for (const step of resolvedSteps) {
-      const stepIdentityString = toStepIdentityString(step);
-      result[stepIdentityString] = asAttoXL1((result[stepIdentityString] ?? 0n) + (await networkStakeStepRewardEarned(this.context, step))[0]);
-    }
-    return result;
-  }
-  async total({ range, steps } = {}) {
-    const result = {};
-    const resolvedSteps = steps ?? blockRangeSteps(asXL1BlockRange(range ?? [
-      0,
-      (await this.context.head())[1]
-    ], {
-      name: "NodeStepRewardsByStepViewer"
-    }), [
-      3,
-      4,
-      5,
-      6,
-      7
-    ]);
-    for (const step of resolvedSteps) {
-      const stepIdentityString = toStepIdentityString(step);
-      result[stepIdentityString] = asAttoXL1((result[stepIdentityString] ?? 0n) + (await networkStakeStepRewardEarned(this.context, step, this.rewardMultipliers))[0]);
-    }
-    return result;
-  }
-  unclaimed(_options = {}) {
-    throw new Error("Method not implemented.");
-  }
-};
-var SimpleStepRewardsViewer = class extends AbstractCreatable {
-  static {
-    __name$7(this, "SimpleStepRewardsViewer");
-  }
-  _position;
-  _staker;
-  _step;
-  get position() {
-    return assertEx(this._position, () => "Position viewer not initialized");
-  }
-  get staker() {
-    return assertEx(this._staker, () => "Position viewer not initialized");
-  }
-  get step() {
-    return assertEx(this._step, () => "Step viewer not initialized");
-  }
-  get total() {
-    throw new Error("Method not implemented.");
-  }
-  get context() {
-    return this.params.context;
-  }
-  get rewardMultipliers() {
-    return this.params.rewardMultipliers;
-  }
-  async createHandler() {
-    await super.createHandler();
-    this._position = await SimpleStepRewardsByPositionViewer.create({
-      context: this.context,
-      rewardMultipliers: this.rewardMultipliers
-    });
-    this._staker = await SimpleStepRewardsByStakerViewer.create({
-      context: this.context,
-      rewardMultipliers: this.rewardMultipliers
-    });
-    this._step = await SimpleStepRewardsByStepViewer.create({
-      context: this.context,
-      rewardMultipliers: this.rewardMultipliers
-    });
-  }
-  async startHandler() {
-    await super.startHandler();
-    await assertEx(this._position, () => "Position viewer not created").start();
-    await assertEx(this._staker, () => "Staker viewer not created").start();
-    await assertEx(this._step, () => "Step viewer not created").start();
-  }
-};
-var SimpleNetworkStakeViewer = class extends AbstractCreatable {
-  static {
-    __name$7(this, "SimpleNetworkStakeViewer");
-  }
-  _stepRewardsViewer;
-  get context() {
-    return this.params.context;
-  }
-  get rewardMultipliers() {
-    return this.params.rewardMultipliers;
-  }
-  get stepRewards() {
-    return assertEx(this._stepRewardsViewer, () => "Step rewards viewer not initialized");
-  }
-  async active(blockNumber) {
-    const resolvedBlockNumber = blockNumber ?? (await this.context.head())[1];
-    return [
-      await this.context.stake.active(resolvedBlockNumber),
-      resolvedBlockNumber
-    ];
-  }
-  async createHandler() {
-    await super.createHandler();
-    this._stepRewardsViewer = await SimpleStepRewardsViewer.create({
-      context: this.context,
-      rewardMultipliers: this.rewardMultipliers
-    });
-  }
-  async startHandler() {
-    await super.startHandler();
-    const stepRewardsByPositionViewer = await SimpleStepRewardsByPositionViewer.create({
-      context: this.context,
-      rewardMultipliers: this.rewardMultipliers
-    });
-    console.log("Initializing NodeStepRewardsByPositionViewer...");
-    await stepRewardsByPositionViewer.start();
-    console.log("Initialized NodeStepRewardsByPositionViewer.");
-  }
-};
-
 /**
  * JsonRpcEngine only accepts callback-based middleware directly.
  * createAsyncMiddleware exists to enable consumers to pass in async middleware
@@ -214550,78 +215275,78 @@ function v4(options, buf, offset) {
     return _v4(options);
 }
 
-var __defProp$b = Object.defineProperty;
-var __name$6 = (target, value) => __defProp$b(target, "name", { value, configurable: true });
+var __defProp$a = Object.defineProperty;
+var __name$5 = (target, value) => __defProp$a(target, "name", { value, configurable: true });
 
 // src/engine/requestSchemas.ts
 var requestSchemas = {};
 
 // src/engine/rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer.ts
-var rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer = /* @__PURE__ */ __name$6((viewer) => {
+var rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer = /* @__PURE__ */ __name$5((viewer) => {
   return {
-    networkStakingStepRewardsByPositionViewer_bonus: /* @__PURE__ */ __name$6((params) => viewer.bonus(...params ?? []), "networkStakingStepRewardsByPositionViewer_bonus"),
-    networkStakingStepRewardsByPositionViewer_claimed: /* @__PURE__ */ __name$6((params) => viewer.claimed(...params ?? []), "networkStakingStepRewardsByPositionViewer_claimed"),
-    networkStakingStepRewardsByPositionViewer_earned: /* @__PURE__ */ __name$6((params) => viewer.earned(...params ?? []), "networkStakingStepRewardsByPositionViewer_earned"),
-    networkStakingStepRewardsByPositionViewer_total: /* @__PURE__ */ __name$6((params) => viewer.total(...params ?? []), "networkStakingStepRewardsByPositionViewer_total"),
-    networkStakingStepRewardsByPositionViewer_unclaimed: /* @__PURE__ */ __name$6((params) => viewer.unclaimed(...params ?? []), "networkStakingStepRewardsByPositionViewer_unclaimed")
+    networkStakingStepRewardsByPositionViewer_bonus: /* @__PURE__ */ __name$5((params) => viewer.bonus(...params ?? []), "networkStakingStepRewardsByPositionViewer_bonus"),
+    networkStakingStepRewardsByPositionViewer_claimed: /* @__PURE__ */ __name$5((params) => viewer.claimed(...params ?? []), "networkStakingStepRewardsByPositionViewer_claimed"),
+    networkStakingStepRewardsByPositionViewer_earned: /* @__PURE__ */ __name$5((params) => viewer.earned(...params ?? []), "networkStakingStepRewardsByPositionViewer_earned"),
+    networkStakingStepRewardsByPositionViewer_total: /* @__PURE__ */ __name$5((params) => viewer.total(...params ?? []), "networkStakingStepRewardsByPositionViewer_total"),
+    networkStakingStepRewardsByPositionViewer_unclaimed: /* @__PURE__ */ __name$5((params) => viewer.unclaimed(...params ?? []), "networkStakingStepRewardsByPositionViewer_unclaimed")
   };
 }, "rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer");
 
 // src/engine/rpcMethodHandlersFromRunner.ts
-var rpcMethodHandlersFromRunner = /* @__PURE__ */ __name$6((runner) => {
+var rpcMethodHandlersFromRunner = /* @__PURE__ */ __name$5((runner) => {
   return {
-    xyoRunner_broadcastTransaction: /* @__PURE__ */ __name$6((params) => runner.broadcastTransaction(...params ?? []), "xyoRunner_broadcastTransaction")
+    xyoRunner_broadcastTransaction: /* @__PURE__ */ __name$5((params) => runner.broadcastTransaction(...params ?? []), "xyoRunner_broadcastTransaction")
   };
 }, "rpcMethodHandlersFromRunner");
 
 // src/engine/rpcMethodHandlersFromViewer.ts
-var rpcMethodHandlersFromViewer = /* @__PURE__ */ __name$6((viewer) => {
+var rpcMethodHandlersFromViewer = /* @__PURE__ */ __name$5((viewer) => {
   return {
-    xyoViewer_networkStakeStepRewardClaimedByAddress: /* @__PURE__ */ __name$6((params) => viewer.networkStakeStepRewardClaimedByAddress(...params ?? []), "xyoViewer_networkStakeStepRewardClaimedByAddress"),
-    xyoViewer_networkStakeStepRewardAddressReward: /* @__PURE__ */ __name$6((params) => viewer.networkStakeStepRewardAddressReward(...params ?? []), "xyoViewer_networkStakeStepRewardAddressReward"),
-    xyoViewer_networkStakeStepRewardAddressHistory: /* @__PURE__ */ __name$6((params) => viewer.networkStakeStepRewardAddressHistory(...params ?? []), "xyoViewer_networkStakeStepRewardAddressHistory"),
-    xyoViewer_networkStakeStepRewardAddressShare: /* @__PURE__ */ __name$6((params) => viewer.networkStakeStepRewardAddressShare(...params ?? []), "xyoViewer_networkStakeStepRewardAddressShare"),
-    xyoViewer_networkStakeStepRewardWeightForAddress: /* @__PURE__ */ __name$6((params) => viewer.networkStakeStepRewardWeightForAddress?.(...params ?? []), "xyoViewer_networkStakeStepRewardWeightForAddress"),
-    xyoViewer_networkStakeStepRewardUnclaimedByAddress: /* @__PURE__ */ __name$6((params) => viewer.networkStakeStepRewardUnclaimedByAddress(...params ?? []), "xyoViewer_networkStakeStepRewardUnclaimedByAddress"),
-    xyoViewer_networkStakeStepRewardPoolShares: /* @__PURE__ */ __name$6((params) => viewer.networkStakeStepRewardPoolShares(...params ?? []), "xyoViewer_networkStakeStepRewardPoolShares"),
-    xyoViewer_networkStakeStepRewardPoolRewards: /* @__PURE__ */ __name$6((params) => viewer.networkStakeStepRewardPoolRewards(...params ?? []), "xyoViewer_networkStakeStepRewardPoolRewards"),
-    xyoViewer_networkStakeStepRewardPositionWeight: /* @__PURE__ */ __name$6((params) => viewer.networkStakeStepRewardPositionWeight?.(...params ?? []), "xyoViewer_networkStakeStepRewardPositionWeight"),
-    xyoViewer_networkStakeStepRewardPotentialPositionLoss: /* @__PURE__ */ __name$6((params) => viewer.networkStakeStepRewardPotentialPositionLoss?.(...params ?? []), "xyoViewer_networkStakeStepRewardPotentialPositionLoss"),
-    xyoViewer_networkStakeStepRewardForStep: /* @__PURE__ */ __name$6((params) => viewer.networkStakeStepRewardForStep?.(...params ?? []), "xyoViewer_networkStakeStepRewardForStep"),
-    xyoViewer_networkStakeStepRewardRandomizer: /* @__PURE__ */ __name$6((params) => viewer.networkStakeStepRewardRandomizer?.(...params ?? []), "xyoViewer_networkStakeStepRewardRandomizer"),
-    xyoViewer_networkStakeStepRewardStakerCount: /* @__PURE__ */ __name$6((params) => viewer.networkStakeStepRewardStakerCount?.(...params ?? []), "xyoViewer_networkStakeStepRewardStakerCount"),
-    xyoViewer_networkStakeStepRewardForStepForPosition: /* @__PURE__ */ __name$6((params) => viewer.networkStakeStepRewardForStepForPosition?.(...params ?? []), "xyoViewer_networkStakeStepRewardForStepForPosition"),
-    xyoViewer_networkStakeStepRewardForPosition: /* @__PURE__ */ __name$6((params) => viewer.networkStakeStepRewardForPosition?.(...params ?? []), "xyoViewer_networkStakeStepRewardForPosition"),
-    xyoViewer_networkStakeStepRewardsForPosition: /* @__PURE__ */ __name$6((params) => viewer.networkStakeStepRewardsForPosition?.(...params ?? []), "xyoViewer_networkStakeStepRewardsForPosition"),
-    xyoViewer_networkStakeStepRewardsForRange: /* @__PURE__ */ __name$6((params) => viewer.networkStakeStepRewardsForRange?.(...params ?? []), "xyoViewer_networkStakeStepRewardsForRange"),
-    xyoViewer_networkStakeStepRewardsForStepLevel: /* @__PURE__ */ __name$6((params) => viewer.networkStakeStepRewardsForStepLevel?.(...params ?? []), "xyoViewer_networkStakeStepRewardsForStepLevel"),
-    xyoViewer_accountBalance: /* @__PURE__ */ __name$6((params) => viewer.accountBalance(...params ?? []), "xyoViewer_accountBalance"),
-    xyoViewer_accountBalanceHistory: /* @__PURE__ */ __name$6((params) => viewer.accountBalanceHistory(...params ?? []), "xyoViewer_accountBalanceHistory"),
-    xyoViewer_blockByHash: /* @__PURE__ */ __name$6((params) => viewer.blockByHash(...params ?? []), "xyoViewer_blockByHash"),
-    xyoViewer_blockByNumber: /* @__PURE__ */ __name$6((params) => viewer.blockByNumber(...params ?? []), "xyoViewer_blockByNumber"),
-    xyoViewer_blocksByHash: /* @__PURE__ */ __name$6((params) => viewer.blocksByHash(...params ?? []), "xyoViewer_blocksByHash"),
-    xyoViewer_chainId: /* @__PURE__ */ __name$6((params) => viewer.chainId(...params ?? []), "xyoViewer_chainId"),
-    xyoViewer_chainIdAtBlock: /* @__PURE__ */ __name$6((params) => viewer.chainIdAtBlock(...params ?? []), "xyoViewer_chainIdAtBlock"),
-    xyoViewer_currentBlock: /* @__PURE__ */ __name$6((params) => viewer.currentBlock(...params ?? []), "xyoViewer_currentBlock"),
-    xyoViewer_currentBlockHash: /* @__PURE__ */ __name$6((params) => viewer.currentBlockHash(...params ?? []), "xyoViewer_currentBlockHash"),
-    xyoViewer_currentBlockNumber: /* @__PURE__ */ __name$6((params) => viewer.currentBlockNumber(...params ?? []), "xyoViewer_currentBlockNumber"),
-    xyoViewer_forkHistory: /* @__PURE__ */ __name$6((params) => viewer.forkHistory(...params ?? []), "xyoViewer_forkHistory"),
-    xyoViewer_stakeById: /* @__PURE__ */ __name$6((params) => viewer.stakeById(...params ?? []), "xyoViewer_stakeById"),
-    xyoViewer_stakeByStaker: /* @__PURE__ */ __name$6((params) => viewer.stakeByStaker(...params ?? []), "xyoViewer_stakeByStaker"),
-    xyoViewer_stakesByStaked: /* @__PURE__ */ __name$6((params) => viewer.stakesByStaked(...params ?? []), "xyoViewer_stakesByStaked"),
-    xyoViewer_stakesByStaker: /* @__PURE__ */ __name$6((params) => viewer.stakesByStaker(...params ?? []), "xyoViewer_stakesByStaker"),
-    xyoViewer_transactionByBlockHashAndIndex: /* @__PURE__ */ __name$6((params) => viewer.transactionByBlockHashAndIndex(...params ?? []), "xyoViewer_transactionByBlockHashAndIndex"),
-    xyoViewer_transactionByBlockNumberAndIndex: /* @__PURE__ */ __name$6((params) => viewer.transactionByBlockNumberAndIndex(...params ?? []), "xyoViewer_transactionByBlockNumberAndIndex"),
-    xyoViewer_transactionByHash: /* @__PURE__ */ __name$6((params) => viewer.transactionByHash(...params ?? []), "xyoViewer_transactionByHash"),
-    xyoViewer_transferBalance: /* @__PURE__ */ __name$6((params) => viewer.transferBalance(...params ?? []), "xyoViewer_transferBalance"),
-    xyoViewer_transferBalanceHistory: /* @__PURE__ */ __name$6((params) => viewer.transferBalanceHistory(...params ?? []), "xyoViewer_transferBalanceHistory"),
-    xyoViewer_transferPairBalance: /* @__PURE__ */ __name$6((params) => viewer.transferPairBalance(...params ?? []), "xyoViewer_transferPairBalance"),
-    xyoViewer_transferPairBalanceHistory: /* @__PURE__ */ __name$6((params) => viewer.transferPairBalanceHistory(...params ?? []), "xyoViewer_transferPairBalanceHistory")
+    xyoViewer_networkStakeStepRewardClaimedByAddress: /* @__PURE__ */ __name$5((params) => viewer.networkStakeStepRewardClaimedByAddress(...params ?? []), "xyoViewer_networkStakeStepRewardClaimedByAddress"),
+    xyoViewer_networkStakeStepRewardAddressReward: /* @__PURE__ */ __name$5((params) => viewer.networkStakeStepRewardAddressReward(...params ?? []), "xyoViewer_networkStakeStepRewardAddressReward"),
+    xyoViewer_networkStakeStepRewardAddressHistory: /* @__PURE__ */ __name$5((params) => viewer.networkStakeStepRewardAddressHistory(...params ?? []), "xyoViewer_networkStakeStepRewardAddressHistory"),
+    xyoViewer_networkStakeStepRewardAddressShare: /* @__PURE__ */ __name$5((params) => viewer.networkStakeStepRewardAddressShare(...params ?? []), "xyoViewer_networkStakeStepRewardAddressShare"),
+    xyoViewer_networkStakeStepRewardWeightForAddress: /* @__PURE__ */ __name$5((params) => viewer.networkStakeStepRewardWeightForAddress?.(...params ?? []), "xyoViewer_networkStakeStepRewardWeightForAddress"),
+    xyoViewer_networkStakeStepRewardUnclaimedByAddress: /* @__PURE__ */ __name$5((params) => viewer.networkStakeStepRewardUnclaimedByAddress(...params ?? []), "xyoViewer_networkStakeStepRewardUnclaimedByAddress"),
+    xyoViewer_networkStakeStepRewardPoolShares: /* @__PURE__ */ __name$5((params) => viewer.networkStakeStepRewardPoolShares(...params ?? []), "xyoViewer_networkStakeStepRewardPoolShares"),
+    xyoViewer_networkStakeStepRewardPoolRewards: /* @__PURE__ */ __name$5((params) => viewer.networkStakeStepRewardPoolRewards(...params ?? []), "xyoViewer_networkStakeStepRewardPoolRewards"),
+    xyoViewer_networkStakeStepRewardPositionWeight: /* @__PURE__ */ __name$5((params) => viewer.networkStakeStepRewardPositionWeight?.(...params ?? []), "xyoViewer_networkStakeStepRewardPositionWeight"),
+    xyoViewer_networkStakeStepRewardPotentialPositionLoss: /* @__PURE__ */ __name$5((params) => viewer.networkStakeStepRewardPotentialPositionLoss?.(...params ?? []), "xyoViewer_networkStakeStepRewardPotentialPositionLoss"),
+    xyoViewer_networkStakeStepRewardForStep: /* @__PURE__ */ __name$5((params) => viewer.networkStakeStepRewardForStep?.(...params ?? []), "xyoViewer_networkStakeStepRewardForStep"),
+    xyoViewer_networkStakeStepRewardRandomizer: /* @__PURE__ */ __name$5((params) => viewer.networkStakeStepRewardRandomizer?.(...params ?? []), "xyoViewer_networkStakeStepRewardRandomizer"),
+    xyoViewer_networkStakeStepRewardStakerCount: /* @__PURE__ */ __name$5((params) => viewer.networkStakeStepRewardStakerCount?.(...params ?? []), "xyoViewer_networkStakeStepRewardStakerCount"),
+    xyoViewer_networkStakeStepRewardForStepForPosition: /* @__PURE__ */ __name$5((params) => viewer.networkStakeStepRewardForStepForPosition?.(...params ?? []), "xyoViewer_networkStakeStepRewardForStepForPosition"),
+    xyoViewer_networkStakeStepRewardForPosition: /* @__PURE__ */ __name$5((params) => viewer.networkStakeStepRewardForPosition?.(...params ?? []), "xyoViewer_networkStakeStepRewardForPosition"),
+    xyoViewer_networkStakeStepRewardsForPosition: /* @__PURE__ */ __name$5((params) => viewer.networkStakeStepRewardsForPosition?.(...params ?? []), "xyoViewer_networkStakeStepRewardsForPosition"),
+    xyoViewer_networkStakeStepRewardsForRange: /* @__PURE__ */ __name$5((params) => viewer.networkStakeStepRewardsForRange?.(...params ?? []), "xyoViewer_networkStakeStepRewardsForRange"),
+    xyoViewer_networkStakeStepRewardsForStepLevel: /* @__PURE__ */ __name$5((params) => viewer.networkStakeStepRewardsForStepLevel?.(...params ?? []), "xyoViewer_networkStakeStepRewardsForStepLevel"),
+    xyoViewer_accountBalance: /* @__PURE__ */ __name$5((params) => viewer.accountBalance(...params ?? []), "xyoViewer_accountBalance"),
+    xyoViewer_accountBalanceHistory: /* @__PURE__ */ __name$5((params) => viewer.accountBalanceHistory(...params ?? []), "xyoViewer_accountBalanceHistory"),
+    xyoViewer_blockByHash: /* @__PURE__ */ __name$5((params) => viewer.blockByHash(...params ?? []), "xyoViewer_blockByHash"),
+    xyoViewer_blockByNumber: /* @__PURE__ */ __name$5((params) => viewer.blockByNumber(...params ?? []), "xyoViewer_blockByNumber"),
+    xyoViewer_blocksByHash: /* @__PURE__ */ __name$5((params) => viewer.blocksByHash(...params ?? []), "xyoViewer_blocksByHash"),
+    xyoViewer_chainId: /* @__PURE__ */ __name$5((params) => viewer.chainId(...params ?? []), "xyoViewer_chainId"),
+    xyoViewer_chainIdAtBlock: /* @__PURE__ */ __name$5((params) => viewer.chainIdAtBlock(...params ?? []), "xyoViewer_chainIdAtBlock"),
+    xyoViewer_currentBlock: /* @__PURE__ */ __name$5((params) => viewer.currentBlock(...params ?? []), "xyoViewer_currentBlock"),
+    xyoViewer_currentBlockHash: /* @__PURE__ */ __name$5((params) => viewer.currentBlockHash(...params ?? []), "xyoViewer_currentBlockHash"),
+    xyoViewer_currentBlockNumber: /* @__PURE__ */ __name$5((params) => viewer.currentBlockNumber(...params ?? []), "xyoViewer_currentBlockNumber"),
+    xyoViewer_forkHistory: /* @__PURE__ */ __name$5((params) => viewer.forkHistory(...params ?? []), "xyoViewer_forkHistory"),
+    xyoViewer_stakeById: /* @__PURE__ */ __name$5((params) => viewer.stakeById(...params ?? []), "xyoViewer_stakeById"),
+    xyoViewer_stakeByStaker: /* @__PURE__ */ __name$5((params) => viewer.stakeByStaker(...params ?? []), "xyoViewer_stakeByStaker"),
+    xyoViewer_stakesByStaked: /* @__PURE__ */ __name$5((params) => viewer.stakesByStaked(...params ?? []), "xyoViewer_stakesByStaked"),
+    xyoViewer_stakesByStaker: /* @__PURE__ */ __name$5((params) => viewer.stakesByStaker(...params ?? []), "xyoViewer_stakesByStaker"),
+    xyoViewer_transactionByBlockHashAndIndex: /* @__PURE__ */ __name$5((params) => viewer.transactionByBlockHashAndIndex(...params ?? []), "xyoViewer_transactionByBlockHashAndIndex"),
+    xyoViewer_transactionByBlockNumberAndIndex: /* @__PURE__ */ __name$5((params) => viewer.transactionByBlockNumberAndIndex(...params ?? []), "xyoViewer_transactionByBlockNumberAndIndex"),
+    xyoViewer_transactionByHash: /* @__PURE__ */ __name$5((params) => viewer.transactionByHash(...params ?? []), "xyoViewer_transactionByHash"),
+    xyoViewer_transferBalance: /* @__PURE__ */ __name$5((params) => viewer.transferBalance(...params ?? []), "xyoViewer_transferBalance"),
+    xyoViewer_transferBalanceHistory: /* @__PURE__ */ __name$5((params) => viewer.transferBalanceHistory(...params ?? []), "xyoViewer_transferBalanceHistory"),
+    xyoViewer_transferPairBalance: /* @__PURE__ */ __name$5((params) => viewer.transferPairBalance(...params ?? []), "xyoViewer_transferPairBalance"),
+    xyoViewer_transferPairBalanceHistory: /* @__PURE__ */ __name$5((params) => viewer.transferPairBalanceHistory(...params ?? []), "xyoViewer_transferPairBalanceHistory")
   };
 }, "rpcMethodHandlersFromViewer");
 
 // src/engine/rpcMethodHandlersFromConnection.ts
-var rpcMethodHandlersFromConnection = /* @__PURE__ */ __name$6((connection, networkStakeViewer) => {
+var rpcMethodHandlersFromConnection = /* @__PURE__ */ __name$5((connection, networkStakeViewer) => {
   const { runner, viewer } = connection;
   let result = {};
   if (runner) result = {
@@ -214700,7 +215425,7 @@ function base64Encode(u8) {
   }
   return btoa(binary);
 }
-__name$6(base64Encode, "base64Encode");
+__name$5(base64Encode, "base64Encode");
 function base64Decode(b64) {
   if (typeof Buffer !== "undefined" && typeof Buffer.from === "function") {
     return new Uint8Array(Buffer.from(b64, "base64"));
@@ -214710,7 +215435,7 @@ function base64Decode(b64) {
   for (let i = 0; i < binary.length; i++) u8[i] = binary.charCodeAt(i);
   return u8;
 }
-__name$6(base64Decode, "base64Decode");
+__name$5(base64Decode, "base64Decode");
 var ArrayBufferToJsonZod = _instanceof(ArrayBuffer).transform((x) => {
   const u8 = new Uint8Array(x);
   return base64Encode(u8);
@@ -215709,7 +216434,7 @@ var AllRpcSchemas = {
   ...XyoPermissionsRpcSchemas,
   ...NetworkStakeViewerRpcSchemas
 };
-var createRequestSchema = /* @__PURE__ */ __name$6((methodName, paramsSchema = _undefined()) => object$3({
+var createRequestSchema = /* @__PURE__ */ __name$5((methodName, paramsSchema = _undefined()) => object$3({
   id: union$1([
     string$2(),
     number$3()
@@ -215718,7 +216443,7 @@ var createRequestSchema = /* @__PURE__ */ __name$6((methodName, paramsSchema = _
   method: literal$2(methodName),
   params: paramsSchema
 }), "createRequestSchema");
-var createResponseSchema = /* @__PURE__ */ __name$6((resultSchema = _undefined()) => object$3({
+var createResponseSchema = /* @__PURE__ */ __name$5((resultSchema = _undefined()) => object$3({
   id: union$1([
     string$2(),
     number$3()
@@ -216127,7 +216852,7 @@ var createResponseSchema = /* @__PURE__ */ __name$6((resultSchema = _undefined()
 });
 
 // src/engine-node/rpcEngineFromConnection.ts
-var rpcEngineFromConnection = /* @__PURE__ */ __name$6((connection, networkStakeViewer) => {
+var rpcEngineFromConnection = /* @__PURE__ */ __name$5((connection, networkStakeViewer) => {
   const engine = new JsonRpcEngine();
   const handlers = rpcMethodHandlersFromConnection(connection, networkStakeViewer);
   engine.push(createAsyncMiddleware(async (req, res) => {
@@ -216167,7 +216892,7 @@ var rpcEngineFromConnection = /* @__PURE__ */ __name$6((connection, networkStake
 }, "rpcEngineFromConnection");
 var HttpRpcTransport = class {
   static {
-    __name$6(this, "HttpRpcTransport");
+    __name$5(this, "HttpRpcTransport");
   }
   _rpcUrl;
   _schemas;
@@ -216206,7 +216931,7 @@ var HttpRpcTransport = class {
 };
 (class {
   static {
-    __name$6(this, "MemoryRpcTransport");
+    __name$5(this, "MemoryRpcTransport");
   }
   _rpcEngine;
   _schemas;
@@ -216244,7 +216969,7 @@ var HttpRpcTransport = class {
 // src/provider/runner/JsonRpcXyoRunner.ts
 var JsonRpcXyoRunner = class {
   static {
-    __name$6(this, "JsonRpcXyoRunner");
+    __name$5(this, "JsonRpcXyoRunner");
   }
   transport;
   constructor(transport) {
@@ -216258,7 +216983,7 @@ var JsonRpcXyoRunner = class {
 };
 var NodeXyoRunner = class {
   static {
-    __name$6(this, "NodeXyoRunner");
+    __name$5(this, "NodeXyoRunner");
   }
   // TODO: Make configurable with defaults
   node;
@@ -216281,11 +217006,11 @@ var NodeXyoRunner = class {
     ]);
     return txHash;
   }
-  getArchivist = /* @__PURE__ */ __name$6(async (identifier) => {
+  getArchivist = /* @__PURE__ */ __name$5(async (identifier) => {
     const archivist = await this.node.resolve(identifier);
     return assertEx(asArchivistInstance(archivist), () => `Could not resolve ${identifier} to an archivist instance`);
   }, "getArchivist");
-  getPendingArchivist = /* @__PURE__ */ __name$6(async () => {
+  getPendingArchivist = /* @__PURE__ */ __name$5(async () => {
     if (this._pendingArchivist) return this._pendingArchivist;
     this._pendingArchivist = await this.getArchivist(this.pendingArchivistPath);
     return assertEx(this._pendingArchivist, () => `Could not resolve pending archivist at ${this.pendingArchivistPath}`);
@@ -216295,7 +217020,7 @@ var NodeXyoRunner = class {
 // src/provider/viewer/JsonRpcViewer.ts
 var JsonRpcViewer = class {
   static {
-    __name$6(this, "JsonRpcViewer");
+    __name$5(this, "JsonRpcViewer");
   }
   transport;
   constructor(transport) {
@@ -216306,14 +217031,14 @@ var JsonRpcViewer = class {
 // src/provider/viewer/JsonRpcNetworkStakingStepRewardsViewer/JsonRpcNetworkStakingStepRewardsViewerMethods.ts
 var JsonRpcNetworkStakingStepRewardsViewerMethods = class extends JsonRpcViewer {
   static {
-    __name$6(this, "JsonRpcNetworkStakingStepRewardsViewerMethods");
+    __name$5(this, "JsonRpcNetworkStakingStepRewardsViewerMethods");
   }
 };
 
 // src/provider/viewer/JsonRpcNetworkStakingStepRewardsViewer/JsonRpcNetworkStakingStepRewardsViewer.ts
 var JsonRpcNetworkStakingStepRewardsViewer = class extends JsonRpcNetworkStakingStepRewardsViewerMethods {
   static {
-    __name$6(this, "JsonRpcNetworkStakingStepRewardsViewer");
+    __name$5(this, "JsonRpcNetworkStakingStepRewardsViewer");
   }
   providers;
   constructor(transport, providers) {
@@ -216337,7 +217062,7 @@ var JsonRpcNetworkStakingStepRewardsViewer = class extends JsonRpcNetworkStaking
 // src/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewerMethods.ts
 var JsonRpcNetworkStakeViewerMethods = class extends JsonRpcViewer {
   static {
-    __name$6(this, "JsonRpcNetworkStakeViewerMethods");
+    __name$5(this, "JsonRpcNetworkStakeViewerMethods");
   }
   async active(blockNumber) {
     return await this.transport.sendRequest("networkStakeViewer_active", [
@@ -216349,7 +217074,7 @@ var JsonRpcNetworkStakeViewerMethods = class extends JsonRpcViewer {
 // src/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewer.ts
 var JsonRpcNetworkStakeViewer = class extends JsonRpcNetworkStakeViewerMethods {
   static {
-    __name$6(this, "JsonRpcNetworkStakeViewer");
+    __name$5(this, "JsonRpcNetworkStakeViewer");
   }
   _stepRewards;
   constructor(transport) {
@@ -216364,7 +217089,7 @@ var JsonRpcNetworkStakeViewer = class extends JsonRpcNetworkStakeViewerMethods {
 // src/provider/viewer/JsonRpcTimeSyncViewer/JsonRpcTimeSyncViewerMethods.ts
 var JsonRpcTimeSyncViewerMethods = class {
   static {
-    __name$6(this, "JsonRpcTimeSyncViewerMethods");
+    __name$5(this, "JsonRpcTimeSyncViewerMethods");
   }
   transport;
   constructor(transport) {
@@ -216395,7 +217120,7 @@ var JsonRpcTimeSyncViewerMethods = class {
 // src/provider/viewer/JsonRpcTimeSyncViewer/JsonRpcTimeSyncViewer.ts
 (class extends JsonRpcTimeSyncViewerMethods {
   static {
-    __name$6(this, "JsonRpcTimeSyncViewer");
+    __name$5(this, "JsonRpcTimeSyncViewer");
   }
   constructor(transport) {
     super(transport);
@@ -216403,7 +217128,7 @@ var JsonRpcTimeSyncViewerMethods = class {
 });
 var JsonRpcXyoViewer = class {
   static {
-    __name$6(this, "JsonRpcXyoViewer");
+    __name$5(this, "JsonRpcXyoViewer");
   }
   providers;
   transport;
@@ -216634,7 +217359,7 @@ var JsonRpcXyoViewer = class {
 // src/provider/connection/XyoBaseConnection.ts
 var XyoBaseConnection = class {
   static {
-    __name$6(this, "XyoBaseConnection");
+    __name$5(this, "XyoBaseConnection");
   }
   _network;
   _runner;
@@ -216663,7 +217388,7 @@ var XyoBaseConnection = class {
 // src/provider/connection/HttpRpcXyoConnection.ts
 var HttpRpcXyoConnection = class extends XyoBaseConnection {
   static {
-    __name$6(this, "HttpRpcXyoConnection");
+    __name$5(this, "HttpRpcXyoConnection");
   }
   constructor(params) {
     const { endpoint, storage: storageParam } = params;
@@ -216689,7 +217414,7 @@ var HttpRpcXyoConnection = class extends XyoBaseConnection {
 // src/provider/datalake/JsonRpcDataLakeViewerMethods.ts
 var JsonRpcDataLakeViewerMethods = class extends JsonRpcViewer {
   static {
-    __name$6(this, "JsonRpcDataLakeViewerMethods");
+    __name$5(this, "JsonRpcDataLakeViewerMethods");
   }
   get(_id) {
     throw new Error("Method not implemented.");
@@ -216705,7 +217430,7 @@ var JsonRpcDataLakeViewerMethods = class extends JsonRpcViewer {
 // src/provider/datalake/JsonRpcDataLakeViewer.ts
 (class extends JsonRpcDataLakeViewerMethods {
   static {
-    __name$6(this, "JsonRpcDataLakeViewer");
+    __name$5(this, "JsonRpcDataLakeViewer");
   }
   constructor(transport) {
     super(transport);
@@ -216715,7 +217440,7 @@ var JsonRpcDataLakeViewerMethods = class extends JsonRpcViewer {
 // src/provider/permissions/RpcXyoPermissions.ts
 (class {
   static {
-    __name$6(this, "RpcXyoPermissions");
+    __name$5(this, "RpcXyoPermissions");
   }
   transport;
   constructor(transport) {
@@ -216738,7 +217463,7 @@ var JsonRpcDataLakeViewerMethods = class extends JsonRpcViewer {
 // src/provider/signer/JsonRpcXyoSigner.ts
 (class {
   static {
-    __name$6(this, "RpcXyoSigner");
+    __name$5(this, "RpcXyoSigner");
   }
   transport;
   constructor(transport) {
@@ -217149,610 +217874,6 @@ var getBiosExternalInterface = async () => {
 // src/external/boot.ts
 var boot = () => genericBoot(getBiosExternalInterface);
 
-var __defProp$a = Object.defineProperty;
-var __name$5 = (target, value) => __defProp$a(target, "name", { value, configurable: true });
-
-// src/BaseEthProvider.ts
-(class {
-  static {
-    __name$5(this, "BaseEthProvider");
-  }
-  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.");
-  }
-});
-var createChainContract = /* @__PURE__ */ __name$5(async (signer, stakingTokenAddress, genesisBlockHash, rewardsContractAddress, minWithdrawalBlocks, gas = {}) => {
-  try {
-    const xyoChainFactory = new StakedXyoChain__factory(signer);
-    const contractTransactionResponse = await (await xyoChainFactory.deploy(ETH_ZERO_ADDRESS, 0n, hexToBigInt(genesisBlockHash), toEthAddress(rewardsContractAddress), minWithdrawalBlocks, toEthAddress(stakingTokenAddress), gas)).waitForDeployment();
-    const xyoChainContractAddress = await contractTransactionResponse.getAddress();
-    return assertEx(asAddress(xyoChainContractAddress), () => "Invalid staking contract address");
-  } catch (ex) {
-    console.log(ex);
-    throw ex;
-  }
-}, "createChainContract");
-var gasConfig = /* @__PURE__ */ __name$5(() => {
-  return {
-    gasLimit: 2e6,
-    gasPrice: parseUnits$1("100", "gwei")
-  };
-}, "gasConfig");
-var createChainRewardsContract = /* @__PURE__ */ __name$5(async (signer, genesisReward = 0n, gas = gasConfig()) => {
-  try {
-    const xyoChainRewardsFactory = new XyoChainRewards__factory(signer);
-    const xyoChainRewardsFactoryResponse = await (await xyoChainRewardsFactory.deploy(toFixedPoint(1000n), 1000000n, 95n, 100n, toFixedPoint(30n), genesisReward, 18n, gas)).waitForDeployment();
-    const xyoChainRewardsAddress = await xyoChainRewardsFactoryResponse.getAddress();
-    return assertEx(asAddress(xyoChainRewardsAddress), () => "Invalid rewards contract address");
-  } catch (ex) {
-    console.log(ex);
-    throw ex;
-  }
-}, "createChainRewardsContract");
-var nextContractAddressForAddress = /* @__PURE__ */ __name$5(async (address, provider) => {
-  const deployerAddress = toEthAddress(address);
-  const nonce = await provider.getTransactionCount(deployerAddress);
-  const contractAddress = getCreateAddress({
-    from: deployerAddress,
-    nonce
-  });
-  return assertEx(asAddress(contractAddress), () => "Unable to convert contract address to address");
-}, "nextContractAddressForAddress");
-var nextContractAddress = /* @__PURE__ */ __name$5(async (signer) => {
-  const provider = assertEx(signer.provider, () => "Unable to obtain provider from signer");
-  const address = assertEx(asAddress(await signer.getAddress()), () => "Unable to obtain address from signer");
-  return await nextContractAddressForAddress(address, provider);
-}, "nextContractAddress");
-
-// src/createChain.ts
-async function createChain(signer, stakingTokenAddress, initialBlockProducer, rewardsContractAddress, genesisBlockRewardAmount, genesisBlockRewardAddress, minWithdrawalBlocks, gas) {
-  const ethStakingTokenAddress = toEthAddress(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, gas));
-  return [
-    chainId,
-    genesisBlock,
-    rewardContractAddressResolved
-  ];
-}
-__name$5(createChain, "createChain");
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name$5(_ts_decorate, "_ts_decorate");
-var ethStakeToStake = /* @__PURE__ */ __name$5((ethStake) => {
-  const stake = {
-    id: Number(ethStake.id),
-    staked: toAddress(ethStake.staked),
-    staker: toAddress(ethStake.staker),
-    amount: asAttoXL1(ethStake.amount),
-    addBlock: Number(ethStake.addBlock),
-    removeBlock: Number(ethStake.removeBlock),
-    withdrawBlock: Number(ethStake.withdrawBlock)
-  };
-  return stake;
-}, "ethStakeToStake");
-var EthereumChainStakeViewer = class extends AbstractCreatable {
-  static {
-    __name$5(this, "EthereumChainStakeViewer");
-  }
-  _callMutex = new Mutex$1();
-  _chainId;
-  _deploymentBlock = 0;
-  _stakeCache = /* @__PURE__ */ new Map();
-  get chainId() {
-    return assertEx(this._chainId, () => "Chain ID not set");
-  }
-  get contract() {
-    return assertEx(this.params.contract, () => new Error("Contract not defined"));
-  }
-  get minWithdrawalBlocks() {
-    return 0;
-  }
-  get rewardsContract() {
-    return toAddress("0x000000000000000000000000000000");
-  }
-  get stakeEvents() {
-    return this.params.stakeEventsViewer;
-  }
-  get stakingTokenAddress() {
-    return toAddress("0x000000000000000000000000000011");
-  }
-  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(toEthAddress(address));
-    });
-  }
-  async activeByStaker(address) {
-    return await this._callMutex.runExclusive(async () => {
-      return await this.contract.activeByStaker(toEthAddress(address));
-    });
-  }
-  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(toEthAddress(staker));
-    });
-  }
-  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(toEthAddress(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 (toAddress(event.args.staked) === toAddress(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 (toAddress(event.args.staker) === toAddress(staker)) {
-        result.push(await this.stakeById(event.args.id));
-      }
-    }
-    return result;
-  }
-  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(toEthAddress(staker));
-    });
-  }
-  async startHandler() {
-    this._chainId = toAddress(await this.contract.chainId());
-    await this.contract.on(this.contract.getEvent("StakeAdded"), (staked, staker, id, amount, event) => {
-      this._stakeCache.set(Number(id), {
-        id: Number(id),
-        staked: toAddress(staked),
-        staker: toAddress(staker),
-        amount: asAttoXL1(amount),
-        addBlock: event.blockNumber,
-        removeBlock: 0,
-        withdrawBlock: 0
-      });
-    });
-    await this.contract.on(this.contract.getEvent("StakeRemoved"), (staked, staker, id, amount, event) => {
-      const stake = assertEx(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 = assertEx(this._stakeCache.get(Number(id)));
-      this._stakeCache.set(Number(id), {
-        ...stake,
-        withdrawBlock: event.blockNumber
-      });
-    });
-    const allStakeEvents = (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"
-      })
-    ])).flat().toSorted((a, b) => a.time - b.time);
-    for (const event of allStakeEvents) {
-      switch (event.name) {
-        case "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
-          });
-          break;
-        }
-        case "StakeRemoved": {
-          const stake = assertEx(this._stakeCache.get(event.args.id));
-          this._stakeCache.set(event.args.id, {
-            ...stake,
-            removeBlock: event.time
-          });
-          break;
-        }
-        case "StakeWithdrawn": {
-          const stake = assertEx(this._stakeCache.get(event.args.id));
-          this._stakeCache.set(event.args.id, {
-            ...stake,
-            withdrawBlock: event.time
-          });
-          break;
-        }
-      }
-    }
-    for (const event of allStakeEvents) {
-      await this.stakeById(event.args.id);
-    }
-  }
-};
-EthereumChainStakeViewer = _ts_decorate([
-  creatable()
-], EthereumChainStakeViewer);
-function _ts_decorate2(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name$5(_ts_decorate2, "_ts_decorate");
-var isStakeLogEventName = /* @__PURE__ */ __name$5((name) => {
-  return isString$1(name) && [
-    "StakeAdded",
-    "StakeRemoved",
-    "StakeWithdrawn"
-  ].includes(name);
-}, "isStakeLogEventName");
-var EthereumChainStakeEvents = class extends AbstractCreatable {
-  static {
-    __name$5(this, "EthereumChainStakeEvents");
-  }
-  eventCache = /* @__PURE__ */ new Map();
-  get contract() {
-    return assertEx(this.params.contract, () => new Error("Contract not defined"));
-  }
-  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()
-    ];
-    const result = allEvents.filter((e) => {
-      if (range[1] !== "latest" && e.time > range[1]) {
-        return false;
-      }
-      if (e.time < range[0]) {
-        return false;
-      }
-      if (isDefined(filter?.name) && e.name !== filter.name) {
-        return false;
-      }
-      if (isDefined(filter?.args?.id) && e.args.id !== filter.args.id) {
-        return false;
-      }
-      if (isDefined(filter?.args?.staked) && e.args.staked !== filter.args.staked) {
-        return false;
-      }
-      if (isDefined(filter?.args?.staker) && e.args.staker !== filter.args.staker) {
-        return false;
-      }
-      return true;
-    });
-    return result;
-  }
-  onEventHandler(staked, staker, id, amount, { eventName, blockNumber }) {
-    if (blockNumber === void 0) {
-      this.logger?.warn(`Received ${eventName} event with ${blockNumber} blockNumber, ignoring...`);
-      return;
-    }
-    if (!isStakeLogEventName(eventName)) {
-      this.logger?.warn(`Received event with unsupported name '${eventName}'`);
-      return;
-    }
-    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: toAddress(staked),
-        staker: toAddress(staker),
-        amount: asAttoXL1(amount)
-      },
-      time: blockNumber
-    };
-    if (isDefined(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 = assertEx(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);
-      });
-      const allStakeEvents = (await Promise.all([
-        this.stakeEventsNative([
-          this.deploymentBlock,
-          currentEthBlock
-        ], {
-          name: "StakeAdded"
-        }),
-        this.stakeEventsNative([
-          this.deploymentBlock,
-          currentEthBlock
-        ], {
-          name: "StakeRemoved"
-        }),
-        this.stakeEventsNative([
-          this.deploymentBlock,
-          currentEthBlock
-        ], {
-          name: "StakeWithdrawn"
-        })
-      ])).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);
-      }
-    } catch (error) {
-      this.logger?.error("EthereumChainStakeEvents failed to start:", error);
-      throw error;
-    }
-  }
-  async stakeEventsNative(range = [
-    0,
-    "latest"
-  ], filter) {
-    const name = filter?.name;
-    if (isDefined(name)) {
-      const stakedFilter = filter?.args?.staked;
-      const stakerFilter = filter?.args?.staker;
-      const stakedFilterEth = isDefined(stakedFilter) ? toEthAddress(stakedFilter) : void 0;
-      const stakerFilterEth = isDefined(stakerFilter) ? toEthAddress(stakerFilter) : void 0;
-      let ethEvents = [];
-      const ethFilter = this.contract.filters[name](stakedFilterEth, stakerFilterEth);
-      ethEvents = await this.contract.queryFilter(ethFilter, range[0], range[1]);
-      return ethEvents.map((e) => {
-        assertEx(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);
-      }).filter(exists$1);
-    } else {
-      throw new Error("Only filtered stake events (by name) are supported");
-    }
-  }
-};
-EthereumChainStakeEvents = _ts_decorate2([
-  creatable()
-], EthereumChainStakeEvents);
-
 var lib$6 = {};
 
 var admin$2 = {};
@@ -363782,6 +363903,7 @@ var ViewArchivist = class extends AbstractArchivist {
     this._originArchivistInstance = this._originArchivistInstance ?? assertEx(await this.resolve(this.originArchivist, { identity: isArchivistInstance, required: true }));
     return this._originArchivistInstance;
   }
+  /** @deprecated use next instead */
   async allHandler() {
     return await (await this.originArchivistInstance()).all?.() ?? [];
   }
@@ -363856,7 +363978,7 @@ var MemoryBoundWitnessDiviner = class extends BoundWitnessDiviner {
     const filter = assertEx(payloads?.filter(isBoundWitnessDivinerQueryPayload)?.pop(), () => "Missing query payload");
     if (!filter) return [];
     const archivist = assertEx(await this.archivistInstance(), () => "Unable to resolve archivist");
-    let bws = (await archivist?.all?.() ?? []).filter(isBoundWitnessWithStorageMeta);
+    let bws = (await archivist?.next({ limit: 1e4 }) ?? []).filter(isBoundWitnessWithStorageMeta);
     return applyBoundWitnessDivinerQueryPayload(filter, bws);
   }
 };
@@ -364651,41 +364773,6 @@ var getApp$3 = /* @__PURE__ */ __name$4(async (node, transferSummaryMap, stakedC
   app.use(standardErrors);
   return app;
 }, "getApp");
-var canUseChainId$1 = /* @__PURE__ */ __name$4((config) => {
-  return isDefined(config.evm.chainId);
-}, "canUseChainId");
-var getChainId$1 = /* @__PURE__ */ __name$4((config) => {
-  const chainId = assertEx(config.evm.chainId, () => "Missing config.evm.chainId");
-  if (isHex(chainId, {
-    prefix: true
-  })) {
-    const hex = hexFrom(chainId);
-    const parsed = Number.parseInt(hex, 16);
-    return parsed;
-  } else {
-    const parsed = Number.parseInt(chainId, 10);
-    return parsed;
-  }
-}, "getChainId");
-var instance$1;
-var initInfuraProvider$1 = /* @__PURE__ */ __name$4((config) => {
-  if (instance$1) return instance$1;
-  const providerConfig = getInfuraProviderConfig$1(config);
-  instance$1 = Promise.resolve(new InfuraWebSocketProvider(providerConfig[0], providerConfig[1]));
-  return instance$1;
-}, "initInfuraProvider");
-var canUseInfuraProvider$1 = /* @__PURE__ */ __name$4((config) => {
-  return canUseChainId$1(config) && isDefined(config.evm?.infura?.projectId) && isDefined(config.evm?.infura?.projectSecret);
-}, "canUseInfuraProvider");
-var getInfuraProviderConfig$1 = /* @__PURE__ */ __name$4((config) => {
-  const projectId = assertEx(config.evm?.infura?.projectId, () => "Missing config.evm.infura.projectId");
-  const projectSecret = assertEx(config.evm?.infura?.projectSecret, () => "Missing config.evm.infura.projectSecret");
-  return [
-    getChainId$1(config),
-    projectId,
-    projectSecret
-  ];
-}, "getInfuraProviderConfig");
 async function getTransferSummaryMap(config) {
   const mongoConfig = config.storage?.mongo;
   if (hasMongoConfig(mongoConfig)) {
@@ -365225,41 +365312,13 @@ var getSeedPhrase$2 = /* @__PURE__ */ __name$4(async (bios, config, logger) => {
   }
   return assertEx(await bios.seedPhraseStore.get("os"), () => "Unable to acquire mnemonic from bios");
 }, "getSeedPhrase");
-async function getStakeChainViewer(config, logger) {
-  if (canUseInfuraProvider$1(config)) {
-    const provider = await initInfuraProvider$1(config);
-    const contractAddress = assertEx(config.chain.id, () => "Missing config.evm.chainId");
-    const contract = StakedXyoChainV2__factory.connect(toEthAddress(contractAddress), provider);
-    const stakeEventsViewer = await EthereumChainStakeEvents.create({
-      contract,
-      logger
-    });
-    assertEx(await stakeEventsViewer.start(), () => "Failed to start EthereumChainStakeEvents reader");
-    const stakeChainViewer = await EthereumChainStakeViewer.create({
-      contract,
-      stakeEventsViewer,
-      logger
-    });
-    assertEx(await stakeChainViewer.start(), () => "Failed to start EthereumChainStake viewer");
-    return stakeChainViewer;
-  } else {
-    console.warn("[API] Infura configuration not found. Using SimpleChainStakeViewer with no positions. This means no staking data will be available.");
-    const stakeChainViewer = await SimpleChainStakeViewer.create({
-      logger,
-      positions: []
-    });
-    assertEx(await stakeChainViewer.start(), () => "Failed to start SimpleChainStake viewer");
-    return stakeChainViewer;
-  }
-}
-__name$4(getStakeChainViewer, "getStakeChainViewer");
 var getServer$3 = /* @__PURE__ */ __name$4(async (context) => {
   const { config, logger, node } = context;
   const { mnemonic, port } = context.config.api;
   const bios = await boot();
   const seedPhrase = isDefined(mnemonic) ? mnemonic : await getSeedPhrase$2(bios, config, logger);
   const wallet = await HDWallet.fromPhrase(seedPhrase);
-  const stakeChainViewer = await getStakeChainViewer(config, logger);
+  const stakeChainViewer = await initChainStakeViewer(config, logger);
   const nodeContext = {
     wallet,
     logger,
@@ -365273,14 +365332,26 @@ var getServer$3 = /* @__PURE__ */ __name$4(async (context) => {
   const payloads = await chainArchivist.next();
   if (payloads.length === 0) {
     logger?.warn("[API] No blocks found in chain archivist, creating genesis block");
-    const initialProducer = await Account.random();
+    const producerAccount = await initProducerAccount({
+      config,
+      logger
+    });
     const chainId = stakeChainViewer.chainId;
-    const block = await createGenesisBlock(initialProducer, chainId, 1000000n, initialProducer.address);
+    const block0 = await createGenesisBlock(producerAccount, chainId, 1000000n, producerAccount.address);
     await chainArchivist.insert([
-      ...block[1].flat(),
-      block[0]
+      ...block0[1].flat(),
+      block0[0]
     ]);
     console.log("[API] Genesis block created and inserted into chain archivist");
+    const block1 = await createProducerChainStakeIntentBlock(block0[0], producerAccount, asXL1BlockRange([
+      0,
+      1e4
+    ], true));
+    await chainArchivist.insert([
+      ...block1[1].flat(),
+      block1[0]
+    ]);
+    console.log(`[API] Producer declared: ${producerAccount.address}`);
   }
   const stakedChainContext = {
     chainId: stakeChainViewer.chainId,
@@ -374491,25 +374562,6 @@ async function initTransferSummaryMap(params) {
   });
 }
 __name(initTransferSummaryMap, "initTransferSummaryMap");
-var accountServiceSingleton;
-var initAccount = /* @__PURE__ */ __name(async ({ config: config2, logger }) => {
-  if (accountServiceSingleton) return accountServiceSingleton;
-  let walletPhrase = config2.producer.mnemonic;
-  if (isUndefined$1(walletPhrase)) {
-    logger?.warn("[Producer] No wallet mnemonic specified!");
-    const randomMnemonic = HDWallet.generateMnemonic();
-    logger?.warn(`[Producer] Using randomly generated mnemonic:
-    
-${randomMnemonic}
-      
-    `);
-    walletPhrase = randomMnemonic;
-  }
-  const wallet = await generateXyoBaseWalletFromPhrase(walletPhrase);
-  const account = await wallet.derivePath(ADDRESS_INDEX.XYO);
-  accountServiceSingleton = account;
-  return accountServiceSingleton;
-}, "initAccount");
 var balanceServiceSingleton;
 var initBalanceService = /* @__PURE__ */ __name(async (params) => {
   if (balanceServiceSingleton) return balanceServiceSingleton;
@@ -375034,7 +375086,7 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
   };
   const [{ traceProvider, meterProvider }, account] = await Promise.all([
     startupSpanAsync("initTelemetry", () => initTelemetry(telemetryConfig)),
-    startupSpanAsync("initAccount", () => initAccount(context))
+    startupSpanAsync("initProducerAccount", () => initProducerAccount(context))
   ]);
   const allowedRewardRedeemers = config2.validation?.allowedRewardRedeemers ?? [];
   const allowedRewardEscrowAccountSigners = config2.validation?.allowedRewardEscrowAccountSigners ?? [];
@@ -375351,7 +375403,7 @@ var waitForHostPort = /* @__PURE__ */ __name((host, port) => {
 
 // src/runCLI.ts
 var configuration;
-var version = isDefined("1.16.19") ? "1.16.19" : "unknown";
+var version = isDefined("1.16.20") ? "1.16.20" : "unknown";
 var getContextFromConfig = /* @__PURE__ */ __name((configuration2) => {
   const logger = initLogger(configuration2);
   const orchestrator = new Orchestrator(logger);