@xyo-network/xl1-protocol-sdk 1.26.28 → 1.26.29

package/dist/neutral/test/index.mjs

@@ -0,0 +1,1995 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/test/buildRandomTransaction.ts
+import { Account } from "@xyo-network/sdk-js";
+import { asXL1BlockNumber, isAllowedBlockPayload } from "@xyo-network/xl1-protocol-lib";
+
+// src/createTransferPayload.ts
+import { toHex } from "@xylabs/sdk-js";
+import { PayloadBuilder } from "@xyo-network/sdk-js";
+import { TransferSchema } from "@xyo-network/xl1-protocol-lib";
+function createTransferPayload(from, transfers, context) {
+  return new PayloadBuilder({ schema: TransferSchema }).fields({
+    epoch: Date.now(),
+    from,
+    transfers: Object.fromEntries(Object.entries(transfers).map(([k, v]) => [k, toHex(v)])),
+    context
+  }).build();
+}
+
+// src/transaction/buildTransaction.ts
+import { assertEx, toHex as toHex2 } from "@xylabs/sdk-js";
+import {
+  asAnyPayload,
+  BoundWitnessBuilder,
+  PayloadBuilder as PayloadBuilder2
+} from "@xyo-network/sdk-js";
+import { defaultTransactionFees } from "@xyo-network/xl1-protocol-lib";
+async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer, nbf, exp, from, fees = defaultTransactionFees) {
+  if (from === void 0 && Array.isArray(signer)) {
+    throw new Error("from is required when signer is an array");
+  }
+  const txBoundWitnessFields = {
+    chain,
+    fees: {
+      base: toHex2(fees.base),
+      gasLimit: toHex2(fees.gasLimit),
+      gasPrice: toHex2(fees.gasPrice),
+      priority: toHex2(fees.priority)
+    },
+    nbf,
+    exp
+  };
+  const elevatedHashes = await PayloadBuilder2.hashes(onChainPayloads);
+  const script = [];
+  for (const elevatedHash of elevatedHashes) {
+    script.push(`elevate|${elevatedHash}`);
+  }
+  const fields = {
+    ...txBoundWitnessFields,
+    from: from ?? (Array.isArray(signer) ? assertEx(signer.at(0)?.address) : signer.address)
+  };
+  if (script.length > 0) {
+    fields.script = script;
+  }
+  const [tx, txPayloads] = await new BoundWitnessBuilder().fields(fields).meta({ $signatures: [] }).payloads([...onChainPayloads, ...offChainPayloads]).signers(Array.isArray(signer) ? signer : [signer]).build();
+  return [await PayloadBuilder2.addHashMeta(tx), await PayloadBuilder2.addHashMeta(txPayloads.map((p) => asAnyPayload(p, true)))];
+}
+
+// src/test/buildRandomTransaction.ts
+var buildRandomTransaction = async (chain, payloads, account, nbf = asXL1BlockNumber(0, true), exp = asXL1BlockNumber(nbf + 1e3, true), privatePayloadSchemas = [], receiverAddress) => {
+  const elevatedPayloads = (payloads ?? []).filter(isAllowedBlockPayload);
+  const additionalPayloads = (payloads ?? []).filter((payload) => !isAllowedBlockPayload(payload));
+  const sender = account ?? await Account.random();
+  if (elevatedPayloads.length === 0) {
+    const receiver = receiverAddress ?? (await Account.random()).address;
+    const transferPayload = createTransferPayload(sender.address, { [receiver]: 1n });
+    elevatedPayloads.push(transferPayload);
+  }
+  const hydratedTransaction = await buildTransaction(chain, elevatedPayloads, additionalPayloads, sender, nbf, exp);
+  return [hydratedTransaction[0], hydratedTransaction[1].filter((payload) => !privatePayloadSchemas.includes(payload.schema))];
+};
+
+// src/test/getSimpleBlockViewerLocator.ts
+import { XYO_ZERO_ADDRESS as XYO_ZERO_ADDRESS3 } from "@xyo-network/xl1-protocol-lib";
+
+// src/CreatableProvider/AbstractCreatableProvider.ts
+import {
+  AbstractCreatable,
+  assertEx as assertEx3,
+  IdLogger
+} from "@xylabs/sdk-js";
+
+// src/CreatableProvider/ProviderFactory.ts
+import { assertEx as assertEx2 } from "@xylabs/sdk-js";
+function providerFactoryDescription(factory, labels) {
+  return `${factory.providerName}:${factory.defaultMoniker}:${JSON.stringify(labels ?? factory.labels ?? {})}`;
+}
+var ProviderFactory = class _ProviderFactory {
+  creatableProvider;
+  defaultMoniker;
+  defaultParams;
+  dependencies;
+  labels;
+  monikers;
+  providerName;
+  scope;
+  _uniqueId;
+  constructor(creatableProvider2, dependencies, params, labels = {}, scope = "context") {
+    this.creatableProvider = creatableProvider2;
+    this.defaultParams = params;
+    this.defaultMoniker = creatableProvider2.defaultMoniker;
+    this.dependencies = dependencies;
+    this.monikers = creatableProvider2.monikers;
+    this.scope = scope;
+    assertEx2(this.monikers.includes(this.defaultMoniker), () => "defaultMoniker must be in monikers");
+    this.labels = Object.assign({}, creatableProvider2.labels ?? {}, labels ?? {});
+    this.providerName = creatableProvider2.name;
+    this._uniqueId = Symbol(providerFactoryDescription(this));
+  }
+  get resolvedMoniker() {
+    const labels = this.labels ?? {};
+    const labelString = Object.entries(labels).map(([key, value]) => `${key}=${value}`).join(",");
+    return labelString.length === 0 ? `${this.defaultMoniker}` : `${this.defaultMoniker}|${labelString}`;
+  }
+  get uniqueId() {
+    return this._uniqueId;
+  }
+  static withParams(creatableProvider2, dependencies, params, labels = {}) {
+    return new _ProviderFactory(creatableProvider2, dependencies, params, labels);
+  }
+  factory(dependencies, params, labels = {}) {
+    return new _ProviderFactory(this.creatableProvider, dependencies, params, labels);
+  }
+  async getInstance(params, { start = true }) {
+    let scopeObject;
+    switch (this.scope) {
+      case "global": {
+        globalThis.xyoServiceSingletons ??= {};
+        scopeObject = globalThis.xyoServiceSingletons;
+        break;
+      }
+      case "context": {
+        const context = assertEx2(
+          params?.context,
+          () => "Context is required for context-scoped providers"
+        );
+        context.singletons ??= {};
+        scopeObject = context.singletons;
+        break;
+      }
+      default: {
+        scopeObject = {};
+        break;
+      }
+    }
+    const mergedParams = {
+      ...this.defaultParams,
+      ...params
+    };
+    const resultPromise = scopeObject[this.resolvedMoniker] ?? this.creatableProvider.create(mergedParams);
+    scopeObject[this.resolvedMoniker] = resultPromise;
+    const result = await resultPromise;
+    if (start) {
+      assertEx2(await result.start(), () => `Failed to start provider instance [${this.resolvedMoniker}]`);
+    }
+    return result;
+  }
+  async tryGetInstance(params, options) {
+    try {
+      return await this.getInstance(params, options);
+    } catch {
+      return;
+    }
+  }
+};
+
+// src/CreatableProvider/AbstractCreatableProvider.ts
+var AbstractCreatableProvider = class extends AbstractCreatable {
+  dependencies = {};
+  _contextCache;
+  _logger;
+  get logger() {
+    if (this._logger === void 0) {
+      const providedLogger = this.params.logger ?? this.context.logger;
+      this._logger = providedLogger ? new IdLogger(providedLogger, () => `${this.moniker} [${this.constructor.name}]`) : null;
+    }
+    return this._logger ?? void 0;
+  }
+  get meter() {
+    return this.context.meterProvider?.getMeter(this.name) ?? super.meter;
+  }
+  get tracer() {
+    return this.context.traceProvider?.getTracer(this.name) ?? super.tracer;
+  }
+  get config() {
+    return this.context.config;
+  }
+  get context() {
+    return this.params.context;
+  }
+  get locator() {
+    return this.context.locator;
+  }
+  static factory(dependencies, params) {
+    const factory = ProviderFactory.withParams(this, dependencies, params);
+    return factory;
+  }
+  static async paramsHandler(params = {}) {
+    const context = assertEx3(params.context, () => new Error("Context is required"));
+    const config = assertEx3(context.config, () => new Error("Context config is required"));
+    const locator = assertEx3(context.locator, () => new Error("Context locator is required"));
+    return await super.paramsHandler({
+      ...params,
+      statusReporter: params.statusReporter ?? context.statusReporter,
+      context: {
+        ...context,
+        config,
+        locator
+      },
+      name: params.name ?? this.defaultMoniker,
+      logger: params.logger ?? context.logger
+    });
+  }
+  async createHandler() {
+    await super.createHandler();
+    if (this.tracer === void 0) {
+      this.logger?.warn("No tracer available in context");
+    }
+    if (this.meter === void 0) {
+      this.logger?.warn("No meter available in context");
+    }
+  }
+  async locateAndCreate(moniker) {
+    return await this.locator.getInstance(moniker);
+  }
+  async tryLocateAndCreate(moniker) {
+    return await this.locator.tryGetInstance(moniker);
+  }
+};
+
+// src/CreatableProvider/CreatableProvider.ts
+function creatableProvider() {
+  return (constructor) => {
+    constructor;
+  };
+}
+
+// src/CreatableProvider/CreatableProviderRegistry.ts
+import { isTruthy } from "@xylabs/sdk-js";
+var buildProviderFactory = (provider, defaultParams, labels) => {
+  const factory = {
+    monikers: provider.monikers,
+    uniqueId: Symbol(providerFactoryDescription(provider, labels)),
+    // Merge module & supplied labels
+    labels: { ...provider.labels, ...labels },
+    creatableProvider: provider.creatableProvider,
+    dependencies: provider.dependencies,
+    resolvedMoniker: provider.resolvedMoniker,
+    providerName: provider.providerName,
+    scope: provider.scope,
+    defaultParams,
+    getInstance: provider.getInstance.bind(provider),
+    tryGetInstance: provider.tryGetInstance?.bind(provider),
+    defaultMoniker: provider.defaultMoniker,
+    factory: provider.factory.bind(provider)
+  };
+  return factory;
+};
+var registerCreatableProviderFactory = (registry, factory, labels, primary = false) => {
+  const primaryMonikers = primary !== true && isTruthy(primary) ? Array.isArray(primary) ? primary : [primary] : [];
+  for (const primaryMoniker of primaryMonikers) {
+    if (!factory.monikers.includes(primaryMoniker)) {
+      console.warn(`Primary moniker ${String(primary)} not found in factory monikers`);
+    }
+  }
+  const isPrimaryForMoniker = (moniker) => {
+    switch (typeof primary) {
+      case "boolean": {
+        return primary;
+      }
+      case "string": {
+        return moniker === primary;
+      }
+      case "object": {
+        if (Array.isArray(primary)) {
+          return primary.includes(moniker);
+        }
+      }
+    }
+    throw new Error(`Invalid primary value: ${String(primary)}`);
+  };
+  const factoryClone = buildProviderFactory(factory, factory.defaultParams, labels);
+  registry[factoryClone.defaultMoniker] = [factoryClone, ...registry[factoryClone.defaultMoniker] ?? []];
+  for (const moniker of factoryClone.monikers) {
+    registry[moniker] = isPrimaryForMoniker(moniker) ? [factoryClone, ...registry[moniker] ?? []] : [...registry[moniker] ?? [], factoryClone];
+  }
+};
+
+// src/CreatableProvider/LabeledCreatableProviderFactory.ts
+var hasLabels = (factory) => {
+  return factory.labels !== void 0;
+};
+
+// src/CreatableProvider/ProviderFactoryLocator.ts
+import { hasAllLabels } from "@xylabs/sdk-js";
+import { assertEx as assertEx4 } from "@xylabs/sdk-js";
+var ProviderFactoryLocator = class _ProviderFactoryLocator {
+  _context;
+  _registry;
+  _frozen = false;
+  _parent;
+  _validateDepsOnRegister;
+  constructor(context, registry = {}, validateDepsOnRegister = false) {
+    this._registry = registry;
+    this._context = { ...context, locator: this };
+    this._parent = context.locator;
+    this._validateDepsOnRegister = validateDepsOnRegister;
+  }
+  get context() {
+    return this._context;
+  }
+  get logger() {
+    return this.context.logger;
+  }
+  /**
+   * The current registry for the module factory
+   */
+  get registry() {
+    return this._registry;
+  }
+  get validateDepsOnRegister() {
+    return this._validateDepsOnRegister;
+  }
+  freeze() {
+    this._frozen = true;
+  }
+  async getInstance(moniker, { start = true, labels } = {}) {
+    return assertEx4(
+      await this.tryGetInstance(moniker, { start, labels }),
+      () => `No provider instance for the supplied config moniker [${moniker}]${labels ? ` & labels [${JSON.stringify(labels)}]` : ""} could be created`
+    );
+  }
+  has(moniker) {
+    return !!this._registry[moniker];
+  }
+  /**
+   * Locates a provider factory that matches the supplied moniker and labels
+   * @param moniker The config moniker for the provider
+   * @param labels The labels for the provider factory
+   * @returns A provider factory that matches the supplied moniker and labels or throws if one is not found
+   */
+  locate(moniker, labels) {
+    return assertEx4(
+      this.tryLocate(moniker, labels),
+      () => `No module factory for the supplied config moniker [${moniker}]${labels ? ` & labels [${JSON.stringify(labels)}]` : ""} registered`
+    );
+  }
+  merge(locator) {
+    const registry = { ...this.registry };
+    for (const moniker in locator.registry) {
+      if (registry[moniker]) {
+        registry[moniker].push(...locator.registry[moniker] ?? []);
+      } else {
+        registry[moniker] = locator.registry[moniker];
+      }
+    }
+    return new _ProviderFactoryLocator(this.context, registry);
+  }
+  /**
+   * Registers a single module factory (with optional tags) with the locator
+   * @param factory The factory to register
+   * @param labels The labels for the module factory
+   */
+  register(factory, labels, primary = false) {
+    assertEx4(!this._frozen, () => "Cannot register a module factory after the locator has been frozen");
+    if (this.validateDepsOnRegister) {
+      const missingDeps = factory.dependencies.filter((dep) => !this.registered(dep));
+      assertEx4(missingDeps.length === 0, () => `Cannot register module factory [${factory.uniqueId.description}] due to missing dependencies: ${missingDeps.join(", ")}`);
+    }
+    registerCreatableProviderFactory(this._registry, factory, labels, primary);
+    return this;
+  }
+  /**
+   * Registers multiple module factories with the locator
+   * @param factories The factories to register
+   */
+  registerMany(factories) {
+    for (const factory of factories) {
+      this.register(factory);
+    }
+    return this;
+  }
+  registered(moniker) {
+    return !!this.registry[moniker] || (this._parent?.registered(moniker) ?? false);
+  }
+  async tryGetInstance(moniker, { start = true, labels } = {}) {
+    const resolvedParams = { context: this.context };
+    const factory = this.tryLocate(moniker, labels);
+    if (factory) {
+      if (this.context.singletons[factory.uniqueId]) {
+        return this.context.singletons[factory.uniqueId];
+      }
+      this.logger?.info(`Creating provider instance for moniker [${moniker}]${labels ? ` with labels [${JSON.stringify(labels)}]` : ""} using factory [${factory.uniqueId.description}]`);
+      const result = await factory.getInstance(resolvedParams, { start });
+      this.context.singletons[factory.uniqueId] = result;
+      return result;
+    }
+  }
+  /**
+   * Tries to locate a module factory that matches the supplied moniker and labels
+   * @param moniker The config moniker for the module
+   * @param labels The labels for the module factory
+   * @returns A module factory that matches the supplied moniker and labels or undefined
+   */
+  tryLocate(moniker, labels) {
+    const result = (labels ? this._registry[moniker]?.filter(hasLabels).find((factory) => hasAllLabels(factory?.labels, labels)) ?? this._registry[moniker]?.[0] : this._registry[moniker]?.[0]) ?? this._parent?.tryLocate(moniker, labels);
+    return result;
+  }
+  validateDependencies(recursive = false) {
+    if (recursive) {
+      this._parent?.validateDependencies();
+    }
+    for (const moniker in this.registry) {
+      for (const factory of this.registry[moniker] ?? []) {
+        const missingDeps = factory.dependencies.filter((dep) => !this.registered(dep));
+        assertEx4(missingDeps.length === 0, () => `Module factory [${factory.uniqueId.description}] is missing dependencies: ${missingDeps.join(", ")}`);
+      }
+    }
+  }
+};
+
+// src/_internal/context/getTestProviderContext.ts
+function getTestProviderContext(config) {
+  const singletons = {};
+  const caches = {};
+  const locator = new ProviderFactoryLocator({
+    config,
+    singletons,
+    caches,
+    logger: console
+  });
+  return locator.context;
+}
+
+// src/config/Actor.ts
+import {
+  zodAsFactory as zodAsFactory2,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory as zodToFactory2
+} from "@xylabs/sdk-js";
+import { globalRegistry as globalRegistry12, z as z17 } from "zod";
+
+// src/validation/schema/Mnemonic.ts
+import { z } from "zod";
+var MnemonicStringZod = z.string().transform((s) => s.trim().replaceAll(/\s+/g, " ")).refine(
+  (s) => [12, 15, 18, 21, 24].includes(s.split(" ").length),
+  { message: "Mnemonic must contain 12, 15, 18, 21, or 24 words." }
+).describe("BIP-39 mnemonic string");
+
+// src/config/Base.ts
+import { z as z16 } from "zod";
+
+// src/config/Chain.ts
+import { AddressZod, HexZod } from "@xylabs/sdk-js";
+import { globalRegistry, z as z2 } from "zod";
+var ChainConfigZod = z2.object({
+  id: HexZod.optional().register(globalRegistry, {
+    description: "The unique identifier for the chain. Should be the staking contract address for contract-backed chains.",
+    title: "chain.id",
+    type: "string"
+  }),
+  genesisRewardAddress: AddressZod.optional().register(globalRegistry, {
+    description: "Address to send the initial genesis rewards to, if a new chain is being created.",
+    title: "chain.genesisRewardAddress",
+    type: "Address"
+  })
+});
+
+// src/config/DataLake/DataLake.ts
+import { z as z6 } from "zod";
+
+// src/config/DataLake/RestDataLakeConfig.ts
+import { globalRegistry as globalRegistry3, z as z4 } from "zod";
+
+// src/config/DataLake/DataLakeRemoteConfig.ts
+import { globalRegistry as globalRegistry2, z as z3 } from "zod";
+var DataLakeDriverConfigBaseZod = z3.object({
+  driver: z3.string().register(globalRegistry2, {
+    description: "Driver for the data lake",
+    type: "string"
+  })
+}).describe("Base configuration for a data lake driver");
+
+// src/config/DataLake/RestDataLakeConfig.ts
+var RestDataLakeConfigZod = DataLakeDriverConfigBaseZod.extend({
+  driver: z4.literal("rest").register(globalRegistry3, {
+    description: "Driver for the REST data lake",
+    type: "string"
+  }),
+  url: z4.string().register(globalRegistry3, {
+    description: "URL for the REST data lake",
+    type: "string"
+  })
+}).describe("Configuration for the REST data lake driver");
+
+// src/config/DataLake/RouterDataLakeConfig.ts
+import { globalRegistry as globalRegistry4, z as z5 } from "zod";
+var RouterDataLakeConfigZod = z5.object({
+  driver: z5.literal("router").register(globalRegistry4, {
+    description: "Driver for the router data lake",
+    type: "string"
+  }),
+  children: z5.array(z5.lazy(() => DataLakeConfigZod)).register(globalRegistry4, {
+    description: "Child data lake drivers",
+    type: "array"
+  })
+}).describe("Configuration for the router data lake driver");
+
+// src/config/DataLake/DataLake.ts
+var DataLakeConfigZod = z6.lazy(() => z6.union([RestDataLakeConfigZod, RouterDataLakeConfigZod])).describe("Configuration for a data lake");
+
+// src/config/Evm.ts
+import { globalRegistry as globalRegistry5, z as z7 } from "zod";
+var EvmInfuraConfigZod = z7.object({
+  projectId: z7.string().optional().register(globalRegistry5, {
+    description: "Infura project ID",
+    title: "evm.infura.projectId",
+    type: "string"
+  }),
+  projectSecret: z7.string().optional().register(globalRegistry5, {
+    description: "Infura project secret",
+    title: "evm.infura.projectSecret",
+    type: "string"
+  })
+});
+var EvmJsonRpcConfigZod = z7.object({
+  url: z7.url().optional().register(globalRegistry5, {
+    description: "JSON-RPC URL",
+    title: "evm.jsonRpc.url",
+    type: "string"
+  })
+});
+var EvmConfigZod = z7.object({
+  chainId: z7.string().optional().register(globalRegistry5, {
+    description: "EVM chain ID",
+    title: "evm.chainId",
+    type: "string"
+  }),
+  infura: EvmInfuraConfigZod.optional().describe("Infura Provider configuration"),
+  jsonRpc: EvmJsonRpcConfigZod.optional().describe("JSON-RPC Provider configuration")
+});
+
+// src/config/Log.ts
+import { LogLevel } from "@xylabs/sdk-js";
+import { globalRegistry as globalRegistry6, z as z8 } from "zod";
+var LogLevelNames = Object.keys(LogLevel);
+var LogConfigZod = z8.object({
+  logLevel: z8.enum(LogLevelNames).default("info").register(globalRegistry6, {
+    choices: LogLevelNames,
+    default: "info",
+    description: "Desired process verbosity",
+    title: "logLevel",
+    type: "string"
+  }),
+  silent: z8.boolean().default(false).register(globalRegistry6, {
+    default: false,
+    description: "Whether to run in silent mode",
+    title: "silent",
+    type: "boolean"
+  })
+});
+
+// src/config/Providers.ts
+import z10 from "zod";
+
+// src/config/Provider.ts
+import {
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk-js";
+import { z as z9 } from "zod";
+var ProviderConfigZod = z9.object({
+  moniker: z9.string(),
+  labels: z9.array(z9.string()).optional()
+}).describe("Configuration for a Provider");
+var isProviderConfig = zodIsFactory(ProviderConfigZod);
+var asProviderConfig = zodAsFactory(ProviderConfigZod, "asProviderConfig");
+var toProviderConfig = zodToFactory(ProviderConfigZod, "toProviderConfig");
+
+// src/config/Providers.ts
+var ProvidersConfigZod = z10.array(ProviderConfigZod.loose()).describe("Configuration for providers").default([]);
+
+// src/config/Remote.ts
+import { globalRegistry as globalRegistry7, z as z11 } from "zod";
+var RpcRemoteConfigBaseZod = z11.object({
+  protocol: z11.string("http").register(globalRegistry7, {
+    description: "Protocol for the RPC connection",
+    type: "string"
+  })
+}).describe("Base configuration for the remote RPC");
+var HttpRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
+  protocol: z11.string("http").register(globalRegistry7, {
+    description: "Protocol for the RPC connection",
+    type: "string"
+  }).default("http"),
+  url: z11.string().register(globalRegistry7, {
+    description: "URL for the Chain RPC API",
+    type: "string"
+  })
+}).describe("Configuration for the remote RPC using Http");
+var PostMessageRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
+  protocol: z11.string().register(globalRegistry7, {
+    description: "Protocol for the RPC connection",
+    type: "string"
+  }).default("postMessage"),
+  networkId: z11.string().register(globalRegistry7, {
+    description: "Network ID to use for the postMessage RPC connection",
+    type: "string"
+  }),
+  sessionId: z11.string().register(globalRegistry7, {
+    description: "Session ID to use for the postMessage RPC connection",
+    type: "string"
+  })
+}).describe("Configuration for the remote RPC using postMessage");
+var RpcRemoteConfigZod = z11.union([HttpRpcRemoteConfigZod, PostMessageRpcRemoteConfigZod]).describe("Configuration for a remote RPC connection, either Http or postMessage");
+var RemoteConfigZod = z11.object({ rpc: RpcRemoteConfigZod.optional() }).describe("Configuration for remote connections, including RPC");
+
+// src/config/storage/driver/Mongo.ts
+import { isDefined, isUndefined } from "@xylabs/sdk-js";
+import { globalRegistry as globalRegistry8, z as z12 } from "zod";
+var MongoConfigZod = z12.object({
+  // TODO: Create from other arguments
+  connectionString: z12.string().nonempty().optional().register(globalRegistry8, {
+    description: "MongoDB connection string",
+    title: "storage.mongo.connectionString",
+    type: "string"
+  }),
+  database: z12.string().nonempty().optional().register(globalRegistry8, {
+    description: "MongoDB database name",
+    title: "storage.mongo.database",
+    type: "string"
+  }),
+  domain: z12.string().nonempty().optional().register(globalRegistry8, {
+    description: "MongoDB domain",
+    title: "storage.mongo.domain",
+    type: "string"
+  }),
+  password: z12.string().nonempty().optional().register(globalRegistry8, {
+    description: "MongoDB password",
+    title: "storage.mongo.password",
+    type: "string"
+  }),
+  username: z12.string().nonempty().optional().register(globalRegistry8, {
+    description: "MongoDB username",
+    title: "storage.mongo.username",
+    type: "string"
+  })
+});
+
+// src/config/storage/Storage.ts
+import { globalRegistry as globalRegistry9, z as z13 } from "zod";
+var StorageConfigZod = z13.object({
+  mongo: MongoConfigZod.optional().describe("Configuration for the MongoD storage driver"),
+  root: z13.string().optional().register(globalRegistry9, {
+    description: "Root directory for local storage",
+    title: "storage.root",
+    type: "string"
+  })
+}).describe("Storage configuration options");
+
+// src/config/Telemetry.ts
+import { globalRegistry as globalRegistry10, z as z14 } from "zod";
+var MetricsScrapeConfigZod = z14.object({
+  path: z14.string().default("/metrics").register(globalRegistry10, {
+    default: "/metrics",
+    description: "Path for the metrics scrape endpoint",
+    title: "telemetry.metrics.scrape.path",
+    type: "string"
+  }),
+  port: z14.coerce.number().int().positive().optional().register(globalRegistry10, {
+    description: "Port for the metrics scrape endpoint",
+    title: "telemetry.metrics.scrape.port",
+    type: "number"
+  })
+}).describe("Metrics scrape configuration");
+var MetricsConfigZod = z14.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
+var OpenTelemetryConfigZod = z14.object({
+  // OpenTelemetry options
+  otlpEndpoint: z14.url().optional().register(globalRegistry10, {
+    description: "OTLP endpoint for exporting telemetry data",
+    title: "telemetry.otel.otlpEndpoint",
+    type: "string"
+  })
+});
+var TelemetryConfigZod = z14.object({
+  // Metrics configuration
+  metrics: MetricsConfigZod.optional().describe("Metrics configuration"),
+  // OpenTelemetry configuration
+  otel: OpenTelemetryConfigZod.optional().describe("OpenTelemetry configuration")
+}).describe("Telemetry configuration options");
+
+// src/config/Validation.ts
+import { AddressZod as AddressZod2, asAddress } from "@xylabs/sdk-js";
+import { globalRegistry as globalRegistry11, z as z15 } from "zod";
+
+// src/primitives/block/rate/blockRate.ts
+import { isDefined as isDefined3, isFalsy } from "@xylabs/sdk-js";
+import { asXL1BlockRange } from "@xyo-network/xl1-protocol-lib";
+
+// src/primitives/block/rate/timeHelpers.ts
+import { assertEx as assertEx5, isDefined as isDefined2 } from "@xylabs/sdk-js";
+var rateMultipliers = {
+  millis: 1,
+  seconds: 1e3,
+  minutes: 1e3 * 60,
+  hours: 1e3 * 60 * 60,
+  days: 1e3 * 60 * 60 * 24,
+  weeks: 1e3 * 60 * 60 * 24 * 7
+};
+var timeDurations = (timeInMs) => ({
+  millis: timeInMs,
+  seconds: timeInMs / 1e3,
+  minutes: timeInMs / (1e3 * 60),
+  hours: timeInMs / (1e3 * 60 * 60),
+  days: timeInMs / (1e3 * 60 * 60 * 24),
+  weeks: timeInMs / (1e3 * 60 * 60 * 24 * 7)
+});
+var getTimeConfigInMilliseconds = (timeConfig) => {
+  const assertedTimeConfig = assertEx5(isDefined2(timeConfig) ? timeConfig : void 0, () => "Time configuration must be provided");
+  let totalMilliseconds = 0;
+  if ("years" in assertedTimeConfig) {
+    totalMilliseconds += assertedTimeConfig.years * 31536e6;
+    return totalMilliseconds;
+  }
+  if ("months" in assertedTimeConfig) {
+    totalMilliseconds += assertedTimeConfig.months * 2592e6;
+    return totalMilliseconds;
+  }
+  if ("weeks" in assertedTimeConfig) {
+    totalMilliseconds += assertedTimeConfig.weeks * 6048e5;
+    return totalMilliseconds;
+  }
+  if ("days" in assertedTimeConfig) {
+    totalMilliseconds += assertedTimeConfig.days * 864e5;
+    return totalMilliseconds;
+  }
+  if ("hours" in assertedTimeConfig) {
+    totalMilliseconds += assertedTimeConfig.hours * 36e5;
+    return totalMilliseconds;
+  }
+  if ("minutes" in assertedTimeConfig) {
+    totalMilliseconds += assertedTimeConfig.minutes * 6e4;
+    return totalMilliseconds;
+  }
+  return totalMilliseconds;
+};
+
+// src/primitives/block/rate/blockRate.ts
+var blockRate = (startBlock, endBlock, timeUnit) => {
+  const startingBlock = startBlock[0];
+  const endingBlock = endBlock[0];
+  const heightDifference = endingBlock.block - startingBlock.block;
+  const timeDifference = endingBlock.$epoch - startingBlock.$epoch;
+  if (timeDifference === 0) {
+    throw new Error("Time difference must be greater than 0");
+  }
+  const rate = heightDifference / timeDifference;
+  const timeUnitValue = isDefined3(timeUnit) ? timeUnit : "millis";
+  const returnedTimeDifference = isDefined3(timeUnit) ? timeDurations(timeDifference)[timeUnit] : timeDifference;
+  const timePerBlock = returnedTimeDifference / heightDifference;
+  return {
+    range: asXL1BlockRange([startingBlock.block, endingBlock.block], true),
+    span: heightDifference,
+    rate: isDefined3(timeUnit) ? rate * rateMultipliers[timeUnit] : rate,
+    timeUnit: timeUnitValue,
+    timeDifference: returnedTimeDifference,
+    timePerBlock
+  };
+};
+var getBlockRateBlocks = async (viewer, startBlockHeight, endBlockHeight) => {
+  if (endBlockHeight <= startBlockHeight) {
+    console.error("startBlockHeight", startBlockHeight);
+    console.error("endBlockHeight", endBlockHeight);
+    throw new Error("End block height must be greater than start block height");
+  }
+  const startingBlock = await viewer.blockByNumber(startBlockHeight);
+  const endingBlock = await viewer.blockByNumber(endBlockHeight);
+  if (isFalsy(startingBlock) || isFalsy(endingBlock)) {
+    throw new Error("Could not retrieve blocks for speed calculation");
+  }
+  return { startingBlock, endingBlock };
+};
+var calculateBlockRate = async (viewer, range, timeUnit) => {
+  const [startBlockHeight, endBlockHeight] = range;
+  const { startingBlock, endingBlock } = await getBlockRateBlocks(
+    viewer,
+    startBlockHeight,
+    endBlockHeight
+  );
+  return blockRate(startingBlock, endingBlock, timeUnit);
+};
+
+// src/primitives/block/rate/stepRate.ts
+import { assertEx as assertEx6 } from "@xylabs/sdk-js";
+import {
+  asXL1BlockRange as asXL1BlockRange2,
+  isValidStep,
+  StepSizes
+} from "@xyo-network/xl1-protocol-lib";
+var stepRate = async (viewer, start, step, count = 1, timeUnit) => {
+  const end = start + step * count;
+  const range = asXL1BlockRange2([start, end], true);
+  return await calculateBlockRate(viewer, range, timeUnit);
+};
+var calculateStepSizeRate = async (viewer, start, stepIndex, count = 1, timeUnit) => {
+  assertEx6(isValidStep(stepIndex), () => `Invalid step index: ${stepIndex}`);
+  const step = StepSizes[stepIndex];
+  return await stepRate(viewer, start, step, count, timeUnit);
+};
+
+// src/primitives/block/rate/timeRate.ts
+import {
+  assertEx as assertEx7,
+  isDefined as isDefined4,
+  isDefinedNotNull
+} from "@xylabs/sdk-js";
+import { asXL1BlockNumber as asXL1BlockNumber2, asXL1BlockRange as asXL1BlockRange3 } from "@xyo-network/xl1-protocol-lib";
+var DEFAULT_TOLERANCE_MS = 3e4;
+var DEFAULT_MAX_ATTEMPTS = 10;
+var calculateTimeRate = async (viewer, timeConfig, startBlockNumber, timeUnit, toleranceMs = DEFAULT_TOLERANCE_MS, maxAttempts = DEFAULT_MAX_ATTEMPTS) => {
+  assertEx7(Object.keys(timeConfig ?? {}).length === 1, () => "Only one time unit should be specified in timeConfig");
+  const startBlock = isDefinedNotNull(startBlockNumber) ? await viewer.blockByNumber(startBlockNumber) : null;
+  const resolvedStartBlock = isDefinedNotNull(startBlock) ? startBlock[0] : (await viewer.currentBlock())[0];
+  const timeInMilliseconds = getTimeConfigInMilliseconds(timeConfig);
+  assertEx7(timeInMilliseconds > 0, () => "Time duration must be greater than zero");
+  const blocksPerMillisecondRate = 1 / (12 * 1e3);
+  const initialBlocksInDuration = Math.floor(blocksPerMillisecondRate * timeInMilliseconds);
+  const endBlockNumber = await findEndBlockRecursive(
+    viewer,
+    resolvedStartBlock,
+    timeInMilliseconds,
+    initialBlocksInDuration,
+    toleranceMs,
+    maxAttempts
+  );
+  return await calculateBlockRate(
+    viewer,
+    asXL1BlockRange3([endBlockNumber, resolvedStartBlock.block], true),
+    timeUnit
+  );
+};
+var findEndBlockRecursive = async (viewer, startBlock, targetTimeMs, estimatedBlocksBack, toleranceMs, attemptsRemaining) => {
+  console.log(`Attempts remaining: ${attemptsRemaining}, Estimated blocks back: ${estimatedBlocksBack}`);
+  assertEx7(attemptsRemaining >= 0, () => "Maximum attempts reached while searching for end block");
+  const startBlockEpoch = startBlock.$epoch;
+  const estimatedEndBlockNumber = asXL1BlockNumber2(startBlock.block - estimatedBlocksBack, true);
+  if (estimatedEndBlockNumber < 0) {
+    throw new Error("Estimated end block number is less than zero");
+  }
+  const endBlock = await viewer.blockByNumber(estimatedEndBlockNumber);
+  const resolvedEndBlock = assertEx7(
+    isDefined4(endBlock?.[0]) ? endBlock[0] : void 0,
+    () => `Could not retrieve block ${estimatedEndBlockNumber} for time rate calculation`
+  );
+  const endBlockEpoch = resolvedEndBlock.$epoch;
+  if (!Number.isFinite(startBlockEpoch) || !Number.isFinite(endBlockEpoch)) {
+    throw new TypeError("Block has missing or invalid $epoch");
+  }
+  const actualTimeDifference = startBlockEpoch - endBlockEpoch;
+  if (actualTimeDifference === 0) {
+    throw new Error("Start and end blocks have identical timestamps");
+  }
+  const timeDelta = Math.abs(actualTimeDifference - targetTimeMs);
+  if (timeDelta <= toleranceMs) {
+    return resolvedEndBlock.block;
+  }
+  let adjustedBlocksBack;
+  if (actualTimeDifference < targetTimeMs) {
+    const adjustmentFactor = targetTimeMs / actualTimeDifference;
+    adjustedBlocksBack = Math.floor(estimatedBlocksBack * adjustmentFactor);
+  } else {
+    const adjustmentFactor = actualTimeDifference / targetTimeMs;
+    adjustedBlocksBack = Math.floor(estimatedBlocksBack / adjustmentFactor);
+  }
+  adjustedBlocksBack = Number.isFinite(adjustedBlocksBack) && adjustedBlocksBack >= 1 ? adjustedBlocksBack : 1;
+  return await findEndBlockRecursive(
+    viewer,
+    startBlock,
+    targetTimeMs,
+    adjustedBlocksBack,
+    toleranceMs,
+    attemptsRemaining - 1
+  );
+};
+
+// src/ChainContextHelpers.ts
+import {
+  isDefined as isDefined6,
+  isObject,
+  isUndefined as isUndefined2,
+  timeBudget
+} from "@xylabs/sdk-js";
+
+// src/driver/cache/LruCacheMap.ts
+import { LRUCache } from "lru-cache";
+var LruCacheMap = class {
+  lruCache;
+  constructor(options) {
+    this.lruCache = new LRUCache(options ?? { max: 5e3 });
+  }
+  clear() {
+    this.lruCache.clear();
+  }
+  delete(id) {
+    return this.lruCache.delete(id);
+  }
+  get(id) {
+    return this.lruCache.get(id);
+  }
+  getMany(id) {
+    const results = [];
+    for (const key of id) {
+      const value = this.lruCache.get(key);
+      if (value !== void 0) {
+        results.push(value);
+      }
+    }
+    return results;
+  }
+  has(id) {
+    return this.lruCache.has(id);
+  }
+  set(id, data) {
+    this.lruCache.set(id, data);
+  }
+  setMany(entries) {
+    for (const [key, value] of entries) {
+      this.lruCache.set(key, value);
+    }
+  }
+};
+
+// src/driver/memory/MemoryMap.ts
+import { isDefined as isDefined5 } from "@xylabs/sdk-js";
+var MemoryMap = class {
+  map;
+  constructor() {
+    this.map = /* @__PURE__ */ new Map();
+  }
+  clear() {
+    this.map.clear();
+  }
+  delete(id) {
+    return this.map.delete(id);
+  }
+  get(id) {
+    return this.map.get(id);
+  }
+  getMany(ids) {
+    const results = [];
+    for (const id of ids) {
+      const data = this.map.get(id);
+      if (isDefined5(data)) {
+        results.push(data);
+      }
+    }
+    return results;
+  }
+  has(id) {
+    return this.map.has(id);
+  }
+  set(id, data) {
+    this.map.set(id, data);
+  }
+  setMany(entries) {
+    for (const [key, value] of entries) {
+      this.map.set(key, value);
+    }
+  }
+};
+
+// src/ChainContextHelpers.ts
+function contextCache(context, name, create) {
+  if (!isObject(context.caches)) {
+    throw new Error("Context does not have an appropriate caches property");
+  }
+  if (isUndefined2(context.caches[name])) {
+    context.caches[name] = create?.() ?? new MemoryMap();
+  }
+  return context.caches[name];
+}
+async function withContextCacheResponse(context, name, key, func, { max = 1e4 } = {}) {
+  const cache = contextCache(
+    context,
+    name,
+    () => new LruCacheMap({ max })
+  );
+  const { timeBudgetLimit = 0 } = context;
+  const cacheResult = await cache.get(key);
+  if (isDefined6(cacheResult)) {
+    return cacheResult;
+  }
+  const result = timeBudgetLimit > 0 ? timeBudget(name, context.logger, func, timeBudgetLimit) : func();
+  await cache.set(key, result);
+  return result;
+}
+
+// src/block/hydrate/allHashesPresent.ts
+function allHashesPresent(hashes, payloads) {
+  const payloadHashes = new Set(payloads.map((p) => p._hash));
+  return hashes.every((hash) => payloadHashes.has(hash));
+}
+
+// src/block/hydrate/flattenHydratedBlock.ts
+import { toHydratedBlock } from "@xyo-network/xl1-protocol-lib";
+var flattenHydratedBlock = (hydratedBlock) => {
+  const [blk, blkPayloads] = hydratedBlock;
+  return [...blkPayloads, blk];
+};
+
+// src/block/hydrate/flattenHydratedBlocks.ts
+var flattenHydratedBlocks = (hydratedBlocks) => hydratedBlocks.flatMap((blk) => flattenHydratedBlock(blk));
+
+// src/block/hydrate/hydrateBlock.ts
+import { assertEx as assertEx8 } from "@xylabs/sdk-js";
+import { asAnyPayload as asAnyPayload2 } from "@xyo-network/sdk-js";
+import { asBlockBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol-lib";
+var hydrateBlock = async (context, hash, maxDepth = 1, minDepth = maxDepth) => {
+  assertEx8(maxDepth >= 0, () => "maxDepth must be greater than or equal to 0");
+  assertEx8(minDepth >= 0, () => "minDepth must be greater than or equal to 0");
+  assertEx8(maxDepth >= minDepth, () => "maxDepth must be greater than or equal to minDepth");
+  const { chainMap } = context;
+  const [block] = await chainMap.get([hash]);
+  const bw = assertEx8(asBlockBoundWitnessWithStorageMeta(
+    assertEx8(block, () => `block ${hash} not found`)
+  ), () => `hash ${hash} is not a BlockBoundWitness`);
+  if (maxDepth === 0) return [bw, []];
+  const blkPayloads = (await chainMap.get(bw.payload_hashes)).map((p) => asAnyPayload2(p, true));
+  if (minDepth === 1) assertEx8(allHashesPresent(bw.payload_hashes, blkPayloads), () => `Unable to find all payloads for block ${hash}`);
+  if (maxDepth === 1) return [bw, blkPayloads];
+  const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta);
+  const transactionsPayloadHashes = transactions.flatMap((tx) => tx.payload_hashes);
+  const transactionsPayloads = (await chainMap.get(transactionsPayloadHashes)).map((p) => asAnyPayload2(p, true));
+  assertEx8(allHashesPresent(transactionsPayloadHashes, transactionsPayloads), () => `Unable to find all payloads for transactions in block ${hash}`);
+  const allPayloadsHashes = new Set([...blkPayloads, ...transactionsPayloads].flatMap((p) => p._hash));
+  const allPayloads = (await chainMap.get([...allPayloadsHashes])).map((p) => asAnyPayload2(p, true));
+  const allPayloadsFiltered = allPayloads.filter((p) => allPayloadsHashes.has(p._hash));
+  if (maxDepth === 2) assertEx8(allHashesPresent(
+    [...allPayloadsHashes],
+    allPayloadsFiltered
+  ), () => `Unable to find all payloads for transactions in block ${hash}`);
+  return [bw, allPayloadsFiltered];
+};
+
+// src/block/primitives/blockFromBlockNumber.ts
+import {
+  asHash,
+  isDefined as isDefined7,
+  spanAsync
+} from "@xylabs/sdk-js";
+import { toSafeJsonString } from "@xylabs/sdk-js";
+import {
+  asSignedBlockBoundWitnessWithStorageMeta,
+  SignedBlockBoundWitnessWithHashMetaZod,
+  StepSizes as StepSizes2
+} from "@xyo-network/xl1-protocol-lib";
+async function blockFromBlockNumber(context, blockNumber) {
+  return await spanAsync("blockFromBlockNumber", async () => {
+    const cacheKey = `${blockNumber}`;
+    const { chainMap, head } = context;
+    return await withContextCacheResponse(context, "blockFromBlockNumber", cacheKey, async () => {
+      const [result] = await chainMap.get([head._hash]);
+      if (!isDefined7(result)) {
+        throw new Error(`Head block not found for hash: ${head._hash}`);
+      }
+      let currentBlock = asSignedBlockBoundWitnessWithStorageMeta(
+        result,
+        () => `Found Payload is not a Signed<BlockBoundWitness>: ${JSON.stringify(result, null, 2)}`
+      );
+      if (currentBlock.block < blockNumber) {
+        throw new Error(`Block number ${blockNumber} is greater than head ${currentBlock.block}.`);
+      }
+      while (currentBlock.block > blockNumber) {
+        let jumpHash = currentBlock.previous;
+        let jumpBlockNumber = currentBlock.block - 1;
+        for (const [step, stepSize] of StepSizes2.entries()) {
+          const possibleJumpBlockNumber = currentBlock.block - currentBlock.block % stepSize - 1;
+          if (possibleJumpBlockNumber >= blockNumber && possibleJumpBlockNumber <= jumpBlockNumber) {
+            jumpBlockNumber = possibleJumpBlockNumber;
+            jumpHash = asHash(currentBlock.step_hashes?.at(step), () => `Step hash not found for step ${step} in block ${currentBlock.block}`);
+          }
+        }
+        const [newBlock] = await chainMap.get([
+          asHash(jumpHash, () => `Jump hash not found for block number [${blockNumber}]: ${jumpBlockNumber} ${toSafeJsonString(currentBlock, 10)}`)
+        ]);
+        if (!isDefined7(newBlock)) {
+          throw new Error(`Block not found for jump hash: ${jumpHash}`);
+        }
+        currentBlock = asSignedBlockBoundWitnessWithStorageMeta(
+          newBlock,
+          () => {
+            const result2 = SignedBlockBoundWitnessWithHashMetaZod.safeParse(newBlock);
+            return `Found Payload [jump hash] is not a Signed<BlockBoundWitness>: ${result2.error}`;
+          }
+        );
+        if (currentBlock.block === blockNumber) {
+          break;
+        }
+        if (currentBlock.block < blockNumber) {
+          throw new Error(`Block number ${blockNumber} is not a valid step block number for block ${head._hash}.`);
+        }
+      }
+      return currentBlock;
+    });
+  }, { ...context, timeBudgetLimit: 500 });
+}
+
+// src/block/primitives/validateTransactionOpcodes.ts
+import {
+  assertEx as assertEx9,
+  isHash,
+  toSafeJsonString as toSafeJsonString2
+} from "@xylabs/sdk-js";
+import {
+  PayloadBuilder as PayloadBuilder3
+} from "@xyo-network/sdk-js";
+import { isExecutable } from "@xyo-network/xl1-protocol-lib";
+async function validateTransactionsOpcodes(txs) {
+  const txElevatedPayloads = [];
+  for (const [txBw, txPayloads] of txs) {
+    if (isExecutable(txBw)) {
+      const operations = txBw.script.map((op) => op.split("|"));
+      for (const [opCode, ...args] of operations) {
+        switch (opCode) {
+          case "elevate": {
+            const [hash, ...rest] = args;
+            const txPayloadsWithStorageMeta = await PayloadBuilder3.addStorageMeta(txPayloads);
+            assertEx9(rest.length === 0, () => `Invalid elevate operation ${opCode} ${args.join(", ")} - Too many Arguments`);
+            if (isHash(hash)) {
+              assertEx9(
+                txBw.payload_hashes.includes(hash),
+                () => `Invalid elevate operation ${opCode} ${args.join(", ")} - Hash not in payload hashes => ${toSafeJsonString2(txBw, 20)}`
+              );
+              const txPayload = assertEx9(
+                txPayloadsWithStorageMeta.find((p) => p._hash === hash),
+                () => `Invalid elevate operation ${opCode} ${args.join(", ")} - Payload not found`
+              );
+              txElevatedPayloads.push(txPayload);
+            } else {
+              throw new Error(`Invalid elevate operation ${opCode} ${args.join(", ")} - Invalid hash`);
+            }
+            break;
+          }
+          default: {
+            throw new Error(`Invalid opCode ${opCode}`);
+          }
+        }
+      }
+    }
+  }
+  return txElevatedPayloads;
+}
+
+// src/primitives/datalake/addDataLakePayloadsToPayloads.ts
+import { isUndefined as isUndefined3 } from "@xylabs/sdk-js";
+import { isAnyPayload, PayloadBuilder as PayloadBuilder4 } from "@xyo-network/sdk-js";
+async function addDataLakePayloadsToPayloads(hashes, payloads, dataLakeViewer) {
+  if (isUndefined3(dataLakeViewer)) return [payloads, []];
+  const missingPayloadHashes = hashes.filter((hash) => !payloads.some((p) => p._hash === hash));
+  const payloadsFromDataLake = await PayloadBuilder4.addHashMeta(
+    await PayloadBuilder4.addHashMeta((await dataLakeViewer.get(missingPayloadHashes)).filter(isAnyPayload))
+  );
+  return [[...payloads, ...payloadsFromDataLake], payloadsFromDataLake.map((p) => p._hash)];
+}
+
+// src/primitives/datalake/addDataLakePayloads.ts
+async function addDataLakePayloads([boundWitness, payloads], dataLakeViewer) {
+  const [updatedPayloads, foundHashes] = await addDataLakePayloadsToPayloads(boundWitness.payload_hashes, payloads, dataLakeViewer);
+  return [
+    [
+      boundWitness,
+      updatedPayloads
+    ],
+    foundHashes
+  ];
+}
+
+// src/primitives/state/findMostRecentBlock.ts
+import { isSignedBlockBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol-lib";
+var DEFAULT_NEXT_OPTIONS = { limit: 50 };
+var findMostRecentBlock = async (chainArchivist, nextOptions = DEFAULT_NEXT_OPTIONS, maxIterations = Number.POSITIVE_INFINITY) => {
+  let mostRecentBlock;
+  let cursor;
+  let batch;
+  let iterations = 0;
+  do {
+    batch = await chainArchivist.next({
+      ...nextOptions,
+      order: "desc",
+      cursor
+    });
+    const blocks = batch.filter(isSignedBlockBoundWitnessWithStorageMeta);
+    const last = blocks?.at(0);
+    if (last) {
+      mostRecentBlock = last;
+      break;
+    } else {
+      cursor = batch.at(-1)?._sequence;
+    }
+    iterations = iterations + 1;
+  } while (batch.length > 0 && iterations < maxIterations);
+  return mostRecentBlock;
+};
+
+// src/primitives/state/hydratedBlockByNumber.ts
+import { assertEx as assertEx10, spanAsync as spanAsync2 } from "@xylabs/sdk-js";
+async function hydratedBlockByNumber(context, blockNumber) {
+  return await spanAsync2("hydratedBlockByNumber", async () => {
+    if (blockNumber < 0) throw new Error(`Block number ${blockNumber} is less than 0`);
+    if (blockNumber > Number.MAX_SAFE_INTEGER) throw new Error(`Block number ${blockNumber} is greater than the maximum safe integer`);
+    if (blockNumber % 1 !== 0) throw new Error(`Block number ${blockNumber} is not an integer`);
+    const cacheKey = `${blockNumber}`;
+    return await withContextCacheResponse(context, "hydratedBlockByNumber", cacheKey, async () => {
+      const block = assertEx10(
+        await blockFromBlockNumber(context, blockNumber),
+        () => `Could not find block for block number ${blockNumber}`
+      );
+      return await hydrateBlock(context, block._hash);
+    }, { max: 2e4 });
+  }, { ...context, timeBudgetLimit: 500 });
+}
+
+// src/primitives/uncle/findBestUncle.ts
+var DEFAULT_MIN_CANDIDATES = 2;
+var DEFAULT_BACKOFF_MS = 12e4;
+
+// src/config/Validation.ts
+var ValidationConfigZod = z15.object({
+  allowedRewardRedeemers: z15.preprocess((val) => {
+    if (typeof val === "string") {
+      return val.split(",").map((s) => asAddress(s.trim()));
+    }
+    return val;
+  }, z15.array(AddressZod2).optional().register(globalRegistry11, {
+    description: "List of allowed reward redeemer addresses, if undefined anyone can participate",
+    title: "allowedRewardRedeemers",
+    type: "array"
+  })),
+  allowedRewardEscrowAccountSigners: z15.preprocess((val) => {
+    if (typeof val === "string") {
+      return val.split(",").map((s) => asAddress(s.trim()));
+    }
+    return val;
+  }, z15.array(AddressZod2).optional().register(globalRegistry11, {
+    description: "List of allowed reward escrow account signer addresses, if undefined anyone can participate",
+    title: "allowedRewardEscrowAccountSigners",
+    type: "array"
+  })),
+  minCandidates: z15.coerce.number().default(DEFAULT_MIN_CANDIDATES).register(globalRegistry11, {
+    default: DEFAULT_MIN_CANDIDATES,
+    description: "Minimum number of uncle candidates before selecting the best uncle",
+    title: "validation.minCandidates",
+    type: "number"
+  }),
+  backoffMs: z15.coerce.number().default(DEFAULT_BACKOFF_MS).register(globalRegistry11, {
+    default: DEFAULT_BACKOFF_MS,
+    description: "Back-off timeout in ms. If head age exceeds this, minCandidates is ignored",
+    title: "validation.backoffMs",
+    type: "number"
+  })
+});
+
+// src/config/Base.ts
+var BaseConfigZod = z16.object({
+  chain: ChainConfigZod.default(ChainConfigZod.parse({})).describe("Configuration for the chain"),
+  dataLake: DataLakeConfigZod.optional().describe("Configuration for data lakes"),
+  evm: EvmConfigZod.default(EvmConfigZod.parse({})).describe("Configuration for EVM-backed services"),
+  log: LogConfigZod.default(LogConfigZod.parse({})).describe("Configuration for logging"),
+  providers: ProvidersConfigZod.default(ProvidersConfigZod.parse([])).describe("Configuration for providers"),
+  remote: RemoteConfigZod.default(RemoteConfigZod.parse({})).describe("Configuration for remote services"),
+  storage: StorageConfigZod.default(StorageConfigZod.parse({})).describe("Configuration for the storage"),
+  telemetry: TelemetryConfigZod.default(TelemetryConfigZod.parse({})).describe("Configuration for telemetry"),
+  validation: ValidationConfigZod.default(ValidationConfigZod.parse({})).describe("Configuration for validation")
+});
+
+// src/config/Actor.ts
+var ActorConfigZod = BaseConfigZod.extend({
+  name: z17.string(),
+  mnemonic: MnemonicStringZod.optional().register(globalRegistry12, {
+    description: "Mnemonic for the Actor wallet",
+    title: "mnemonic",
+    type: "string"
+  }),
+  healthCheckPort: z17.coerce.number().optional().register(globalRegistry12, {
+    description: "Port for the Producer health checks",
+    title: "producer.healthCheckPort",
+    type: "number"
+  })
+});
+var isActorConfig = zodIsFactory2(ActorConfigZod);
+var asActorConfig = zodAsFactory2(ActorConfigZod, "asActorConfig");
+var toActorConfig = zodToFactory2(ActorConfigZod, "toActorConfig");
+
+// src/config/Actors.ts
+import z18 from "zod";
+var ActorsConfigZod = z18.array(ActorConfigZod.loose()).describe("Actor-specific configurations that override the base configuration when the actor is running").default([]);
+
+// src/config/Config.ts
+var ConfigZod = BaseConfigZod.extend({ actors: ActorsConfigZod }).describe("The complete configuration for the protocol, including global settings and actor-specific overrides");
+
+// src/simple/block/SimpleBlockViewer.ts
+import {
+  assertEx as assertEx11,
+  exists,
+  isUndefined as isUndefined4
+} from "@xylabs/sdk-js";
+import {
+  asSignedHydratedBlockWithHashMeta,
+  asSignedHydratedBlockWithStorageMeta,
+  asXL1BlockNumber as asXL1BlockNumber3,
+  BlockViewerMoniker,
+  DataLakeViewerMoniker,
+  FinalizationViewerMoniker
+} from "@xyo-network/xl1-protocol-lib";
+
+// src/utils/HydratedCache.ts
+import { LRUCache as LRUCache2 } from "lru-cache";
+var HydratedCache = class {
+  cache;
+  context;
+  hydrateFunction;
+  constructor(context, hydrateFunction, maxCount = 2e3, ttl = Number.MAX_SAFE_INTEGER) {
+    this.context = context;
+    this.hydrateFunction = hydrateFunction;
+    this.cache = new LRUCache2({ max: maxCount, ttl });
+  }
+  async get(hash) {
+    const existing = this.cache.get(hash);
+    if (existing !== void 0) return existing;
+    const block = await this.hydrateFunction(this.context, hash) ?? null;
+    if (block !== null) this.cache.set(hash, block);
+    return block;
+  }
+  has(hash) {
+    return this.cache.has(hash);
+  }
+};
+
+// src/simple/block/SimpleBlockViewer.ts
+var SimpleBlockViewer = class extends AbstractCreatableProvider {
+  moniker = SimpleBlockViewer.defaultMoniker;
+  _store;
+  dataLakeViewer;
+  finalizationViewer;
+  payloadCache = new LruCacheMap({ max: 1e4 });
+  signedHydratedBlockWithDataLakePayloadsCache = new LruCacheMap({ max: 2e3, ttl: 1e3 * 60 * 60 });
+  _signedHydratedBlockCache;
+  get finalizedArchivist() {
+    return this.params.finalizedArchivist;
+  }
+  get hydratedBlockCache() {
+    if (this._signedHydratedBlockCache) return this._signedHydratedBlockCache;
+    const context = this.getBlockContextRead();
+    this._signedHydratedBlockCache = new HydratedCache(context, async (context2, hash, maxDepth, minDepth) => {
+      const result = await hydrateBlock(context2, hash, maxDepth, minDepth);
+      return asSignedHydratedBlockWithStorageMeta(result, true);
+    }, 2e4);
+    return this._signedHydratedBlockCache;
+  }
+  get store() {
+    return this._store;
+  }
+  static async paramsHandler(params) {
+    return {
+      ...await super.paramsHandler(params),
+      finalizedArchivist: assertEx11(params.finalizedArchivist, () => "finalizedArchivist is required")
+    };
+  }
+  async blockByHash(hash) {
+    return await this.spanAsync("blockByHash", async () => {
+      const cachedBlock = this.signedHydratedBlockWithDataLakePayloadsCache.get(hash);
+      if (cachedBlock) {
+        return cachedBlock;
+      }
+      const cache = this.hydratedBlockCache;
+      const block = await cache.get(hash);
+      const [result] = block ? await addDataLakePayloads(block, this.dataLakeViewer) : [null, []];
+      if (result) {
+        this.signedHydratedBlockWithDataLakePayloadsCache.set(hash, result);
+      }
+      return result;
+    }, { ...this.context, timeBudgetLimit: 100 });
+  }
+  async blockByNumber(blockNumber) {
+    return await this.spanAsync("blockByNumber", async () => {
+      const chainContext = await this.getChainContextRead();
+      if (isUndefined4(chainContext.head)) {
+        return null;
+      }
+      return await this.blockByNumberWithContext(chainContext, blockNumber);
+    }, { ...this.context, timeBudgetLimit: 100 });
+  }
+  async blocksByHash(hash, limit = 50) {
+    return await this.spanAsync("blocksByHash", async () => {
+      assertEx11(limit > 0, () => "limit must be greater than 0");
+      assertEx11(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.map((b) => asSignedHydratedBlockWithHashMeta(b, true));
+    }, { ...this.context, timeBudgetLimit: 300 });
+  }
+  async blocksByNumber(blockNumber, limit = 50) {
+    return await this.spanAsync("blocksByNumber", async () => {
+      assertEx11(limit > 0, () => "limit must be greater than 0");
+      assertEx11(limit <= 100, () => "limit must be less than 100");
+      const chainContext = await this.getChainContextRead();
+      if (isUndefined4(chainContext.head)) {
+        return [];
+      }
+      const blocks = [];
+      let current = await this.blockByNumberWithContext(chainContext, blockNumber);
+      while (current && blocks.length < limit) {
+        blocks.push(current);
+        if (current[0].block === 0) break;
+        const previousNumber = asXL1BlockNumber3(current[0].block - 1, true);
+        current = await this.blockByNumberWithContext(chainContext, previousNumber);
+      }
+      return blocks.map((b) => asSignedHydratedBlockWithHashMeta(b, true));
+    }, this.context);
+  }
+  async chainId(blockNumber = "latest") {
+    return await this.spanAsync("chainId", async () => {
+      return blockNumber === "latest" ? (await this.finalizationViewer.headBlock()).chain : assertEx11(await this.blockByNumber(blockNumber), () => `Block not found [${blockNumber}]`)[0].chain;
+    }, this.context);
+  }
+  async createHandler() {
+    await super.createHandler();
+    this.dataLakeViewer = await this.locator.tryGetInstance(DataLakeViewerMoniker);
+    this.finalizationViewer = await this.locator.getInstance(FinalizationViewerMoniker);
+    this._store = { chainMap: this.params.finalizedArchivist };
+  }
+  async currentBlock() {
+    const [result] = await addDataLakePayloads(await this.finalizationViewer.head(), this.dataLakeViewer);
+    return result;
+  }
+  async currentBlockHash() {
+    return await this.finalizationViewer.headHash();
+  }
+  async currentBlockNumber() {
+    return await this.finalizationViewer.headNumber();
+  }
+  async payloadByHash(hash) {
+    const [payload] = await this.payloadsByHash([hash]);
+    return payload ?? null;
+  }
+  async payloadsByHash(hashes) {
+    let remainingHashes = [...hashes];
+    const cachedPayloads = this.payloadCache.getMany(remainingHashes);
+    const cachedHashes = new Set(cachedPayloads.map((p) => p._hash));
+    remainingHashes = remainingHashes.filter((h) => !cachedHashes.has(h));
+    const finalizedPayloads = remainingHashes.length > 0 ? await this.finalizedArchivist.get(remainingHashes) : [];
+    const [resultPayloads] = await addDataLakePayloadsToPayloads(hashes, [...cachedPayloads, ...finalizedPayloads.filter(exists)], this.dataLakeViewer);
+    resultPayloads.map((payload) => {
+      this.payloadCache.set(payload._hash, payload);
+    });
+    return resultPayloads;
+  }
+  async rate(range, timeUnit) {
+    return await calculateBlockRate(this, range, timeUnit);
+  }
+  async stepSizeRate(start, stepIndex, count = 1, timeUnit) {
+    return await calculateStepSizeRate(this, start, stepIndex, count, timeUnit);
+  }
+  async timeDurationRate(timeConfig, startBlockNumber, timeUnit, toleranceMs, maxAttempts) {
+    return await calculateTimeRate(this, timeConfig, startBlockNumber, timeUnit, toleranceMs, maxAttempts);
+  }
+  getBlockContextRead() {
+    return {
+      ...this.context,
+      chainMap: this.store.chainMap
+    };
+  }
+  async getChainContextRead() {
+    return {
+      ...this.getBlockContextRead(),
+      head: (await this.finalizationViewer.head())[0]
+    };
+  }
+  async blockByNumberWithContext(chainContext, blockNumber) {
+    const block = asSignedHydratedBlockWithHashMeta(await hydratedBlockByNumber(chainContext, blockNumber)) ?? null;
+    const [result] = block ? await addDataLakePayloads(block, this.dataLakeViewer) : [null, []];
+    return result;
+  }
+};
+__publicField(SimpleBlockViewer, "defaultMoniker", BlockViewerMoniker);
+__publicField(SimpleBlockViewer, "dependencies", [FinalizationViewerMoniker]);
+__publicField(SimpleBlockViewer, "monikers", [BlockViewerMoniker]);
+SimpleBlockViewer = __decorateClass([
+  creatableProvider()
+], SimpleBlockViewer);
+
+// src/simple/chainContractViewer/SimpleChainContractViewer.ts
+import {
+  assertEx as assertEx12
+} from "@xylabs/sdk-js";
+import {
+  ChainContractViewerMoniker,
+  FinalizationViewerMoniker as FinalizationViewerMoniker2
+} from "@xyo-network/xl1-protocol-lib";
+var SimpleChainContractViewer = class extends AbstractCreatableProvider {
+  moniker = SimpleChainContractViewer.defaultMoniker;
+  _finalizationViewer;
+  get finalizationViewer() {
+    return this._finalizationViewer;
+  }
+  chainId() {
+    return this.finalizationViewer.chainId();
+  }
+  async chainIdAtBlockNumber(blockNumber) {
+    return await withContextCacheResponse(this.context, "chainIdAtBlockNumber", `${blockNumber}`, async () => {
+      let chainId = this.chainId();
+      let contractViewer = this;
+      let forkedAtBlockNumber = await contractViewer.forkedAtBlockNumber();
+      while (forkedAtBlockNumber !== null && blockNumber <= forkedAtBlockNumber) {
+        contractViewer = assertEx12(await contractViewer.forkedChainContractViewer());
+        forkedAtBlockNumber = await contractViewer.forkedAtBlockNumber();
+        chainId = await contractViewer.chainId();
+      }
+      return chainId;
+    });
+  }
+  async createHandler() {
+    this._finalizationViewer = await this.locator.getInstance(FinalizationViewerMoniker2);
+    return await super.createHandler();
+  }
+  forkedAtBlockNumber() {
+    return this.params.forkedAtBlockNumber ?? null;
+  }
+  forkedAtHash() {
+    return this.params.forkedAtHash ?? null;
+  }
+  forkedChainContractViewer() {
+    return this.params.forkedChainContractViewer ?? null;
+  }
+  forkedChainId() {
+    return this.params.forkedChainId ?? null;
+  }
+  minWithdrawalBlocks() {
+    return this.params.minWithdrawalBlocks;
+  }
+  rewardsContract() {
+    return this.params.rewardsContract;
+  }
+  stakingTokenAddress() {
+    return this.params.stakingTokenAddress;
+  }
+};
+__publicField(SimpleChainContractViewer, "defaultMoniker", ChainContractViewerMoniker);
+__publicField(SimpleChainContractViewer, "dependencies", [FinalizationViewerMoniker2]);
+__publicField(SimpleChainContractViewer, "monikers", [ChainContractViewerMoniker]);
+SimpleChainContractViewer = __decorateClass([
+  creatableProvider()
+], SimpleChainContractViewer);
+
+// src/simple/finalization/SimpleFinalizationViewer.ts
+import {
+  assertEx as assertEx13
+} from "@xylabs/sdk-js";
+import {
+  asSignedHydratedBlockWithStorageMeta as asSignedHydratedBlockWithStorageMeta2,
+  ChainContractViewerMoniker as ChainContractViewerMoniker2,
+  FinalizationViewerMoniker as FinalizationViewerMoniker3
+} from "@xyo-network/xl1-protocol-lib";
+var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
+  moniker = SimpleFinalizationViewer.defaultMoniker;
+  _chainId;
+  _store;
+  _signedHydratedBlockCache;
+  get finalizedArchivist() {
+    return this.params.finalizedArchivist;
+  }
+  get hydratedBlockCache() {
+    if (this._signedHydratedBlockCache) return this._signedHydratedBlockCache;
+    const context = this.getBlockContextRead();
+    this._signedHydratedBlockCache = new HydratedCache(context, async (store, hash, maxDepth, minDepth) => {
+      const result = await hydrateBlock(context, hash, maxDepth, minDepth);
+      return asSignedHydratedBlockWithStorageMeta2(result, true);
+    }, 200);
+    return this._signedHydratedBlockCache;
+  }
+  get store() {
+    return this._store;
+  }
+  static async paramsHandler(params) {
+    return {
+      ...await super.paramsHandler(params),
+      finalizedArchivist: assertEx13(params.finalizedArchivist, () => "finalizedArchivist is required")
+    };
+  }
+  chainId() {
+    return this._chainId;
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._chainId = assertEx13(this.config.chain.id ?? (await findMostRecentBlock(this.params.finalizedArchivist))?.chain, () => "chain.id is required if empty archivist");
+    this._store = { chainMap: this.params.finalizedArchivist };
+  }
+  async head() {
+    return await this.spanAsync("head", async () => {
+      const currentHead = assertEx13(await this.getCurrentHead(), () => "Could not find most recent block [currentBlock]");
+      const cache = this.hydratedBlockCache;
+      const block = await cache.get(currentHead._hash);
+      if (!block) {
+        console.log(`Could not find current block with hash ${currentHead._hash}`);
+      }
+      return assertEx13(block, () => "Could not find current block");
+    }, this.context);
+  }
+  async headBlock() {
+    return (await this.head())[0];
+  }
+  async headHash() {
+    return (await this.headBlock())._hash;
+  }
+  async headNumber() {
+    return (await this.headBlock()).block;
+  }
+  getBlockContextRead() {
+    return {
+      ...this.context,
+      chainMap: this.store.chainMap
+    };
+  }
+  async getChainContextRead() {
+    return {
+      ...this.getBlockContextRead(),
+      head: (await this.head())[0]
+    };
+  }
+  async getCurrentHead() {
+    const chainArchivist = this.finalizedArchivist;
+    const result = assertEx13(await findMostRecentBlock(chainArchivist), () => "Could not find most recent block [getCurrentHead]");
+    assertEx13(result?.chain === this._chainId, () => "Chain ID does not match head block chain ID");
+    return result;
+  }
+};
+__publicField(SimpleFinalizationViewer, "defaultMoniker", FinalizationViewerMoniker3);
+__publicField(SimpleFinalizationViewer, "dependencies", [ChainContractViewerMoniker2]);
+__publicField(SimpleFinalizationViewer, "monikers", [FinalizationViewerMoniker3]);
+SimpleFinalizationViewer = __decorateClass([
+  creatableProvider()
+], SimpleFinalizationViewer);
+
+// src/test/buildRandomChain.ts
+import { asAddress as asAddress3, assertEx as assertEx16 } from "@xylabs/sdk-js";
+import {
+  Account as Account3,
+  asSchema as asSchema2,
+  IdSchema as IdSchema2,
+  MemoryArchivist,
+  PayloadBuilder as PayloadBuilder9
+} from "@xyo-network/sdk-js";
+import {
+  asXL1BlockNumber as asXL1BlockNumber7
+} from "@xyo-network/xl1-protocol-lib";
+
+// src/test/buildNextBlock.ts
+import {
+  AttoXL1 as AttoXL12,
+  XYO_STEP_REWARD_ADDRESS as XYO_STEP_REWARD_ADDRESS2
+} from "@xyo-network/xl1-protocol-lib";
+
+// src/test/buildBlock.ts
+import { assertEx as assertEx14, isDefined as isDefined8 } from "@xylabs/sdk-js";
+import {
+  asAnyPayload as asAnyPayload3,
+  BoundWitnessBuilder as BoundWitnessBuilder2,
+  PayloadBuilder as PayloadBuilder5
+} from "@xyo-network/sdk-js";
+import {
+  asXL1BlockNumber as asXL1BlockNumber4,
+  AttoXL1,
+  completedStepRewardAddress,
+  isBlockBoundWitness,
+  StepRewardFractions,
+  StepSizes as StepSizes3,
+  XL1_PROTOCOL_VERSION,
+  XYO_STEP_REWARD_ADDRESS,
+  XYO_ZERO_ADDRESS
+} from "@xyo-network/xl1-protocol-lib";
+
+// src/test/BuildBlockOptions.ts
+import {
+  isAddress,
+  isArray,
+  isHash as isHash2,
+  isNumber,
+  isObject as isObject2
+} from "@xylabs/sdk-js";
+var isBaseBuildBlockOptions = (value) => {
+  if (!isObject2(value)) {
+    return false;
+  }
+  const typedValue = value;
+  if (!isArray(typedValue.blockPayloads) || !isAddress(typedValue.chainId) || !isArray(typedValue.signers) || !isArray(typedValue.txs)) {
+    return false;
+  }
+  return true;
+};
+var isBuildGenesisBlockOptions = (value) => {
+  if (!isBaseBuildBlockOptions(value)) {
+    return false;
+  }
+  const typedValue = value;
+  if (typedValue.previousBlockHash !== null) {
+    return false;
+  }
+  if (typedValue.previousBlockNumber !== void 0) {
+    return false;
+  }
+  return true;
+};
+var isBuildNextBlockOptions = (value) => {
+  if (!isBaseBuildBlockOptions(value)) {
+    return false;
+  }
+  const typedValue = value;
+  if (!isHash2(typedValue.previousBlockHash)) {
+    return false;
+  }
+  if (!isNumber(typedValue.previousBlockNumber)) {
+    return false;
+  }
+  if (!isArray(typedValue.previousStepHashes)) {
+    return false;
+  }
+  return true;
+};
+
+// src/test/buildBlock.ts
+function calculateCompletedStepReward(step, balance) {
+  return AttoXL1(StepRewardFractions[step][0] * balance / StepRewardFractions[step][1]);
+}
+async function buildBlock(options) {
+  const previousBlockNumber = isBuildGenesisBlockOptions(options) ? -1 : options.previousBlockNumber;
+  const blockNumber = asXL1BlockNumber4(previousBlockNumber + 1, true);
+  const inStepHashes = isBuildNextBlockOptions(options) ? options.previousStepHashes : [];
+  const previousBlockHash = isBuildNextBlockOptions(options) ? options.previousBlockHash : void 0;
+  const stepRewardPoolBalance = isBuildNextBlockOptions(options) ? options.stepRewardPoolBalance : AttoXL1(0n);
+  const {
+    chainId,
+    txs,
+    chainStepRewardAddress = XYO_STEP_REWARD_ADDRESS,
+    blockPayloads,
+    protocol = XL1_PROTOCOL_VERSION,
+    signers
+  } = options;
+  const step_hashes = [];
+  for (const [tx] of txs) {
+    if (tx.nbf > blockNumber) {
+      throw new Error(`Transaction ${await PayloadBuilder5.hash(tx)} not valid for block ${blockNumber} - NBF is ${tx.nbf}`);
+    }
+    if (tx.exp < blockNumber) {
+      throw new Error(`Transaction ${await PayloadBuilder5.hash(tx)} not valid for block ${blockNumber} - EXP is ${tx.exp}`);
+    }
+  }
+  const completedStepRewardTransfers = [];
+  for (const [i, step] of StepSizes3.entries()) {
+    if (blockNumber < step) {
+      break;
+    }
+    if (blockNumber % step === 0) {
+      if (StepRewardFractions[i][0] > 0 && chainStepRewardAddress !== XYO_ZERO_ADDRESS) {
+        const completedStepRewardHolderAddress = completedStepRewardAddress({ block: blockNumber, step });
+        const completedStepReward = calculateCompletedStepReward(i, stepRewardPoolBalance);
+        completedStepRewardTransfers.push(createTransferPayload(chainStepRewardAddress, { [completedStepRewardHolderAddress]: completedStepReward }));
+      }
+      step_hashes.push(assertEx14(previousBlockHash, () => `Previous block hash is required for step ${step} at block ${blockNumber}`));
+    } else {
+      if (isDefined8(inStepHashes.at(i))) {
+        step_hashes.push(inStepHashes[i]);
+      }
+    }
+  }
+  const previous = previousBlockHash ?? null;
+  const block = blockNumber;
+  const txElevatedPayloads = await validateTransactionsOpcodes(txs);
+  const payloads = [
+    ...txs.map(([tx]) => tx),
+    ...blockPayloads,
+    ...txElevatedPayloads,
+    ...completedStepRewardTransfers
+  ];
+  const [bw, txPayloads] = await new BoundWitnessBuilder2().fields({
+    block,
+    chain: chainId,
+    previous,
+    step_hashes,
+    protocol
+  }).meta({ $epoch: Date.now(), $signatures: [] }).signers(signers).payloads(await PayloadBuilder5.addStorageMeta(payloads)).build();
+  assertEx14(isBlockBoundWitness(bw), () => "Build of BlockBoundWitness failed");
+  return [await PayloadBuilder5.addStorageMeta(bw), txPayloads.map((p) => asAnyPayload3(p, true))];
+}
+
+// src/test/buildNextBlock.ts
+async function buildNextBlock(previousBlock, txs, blockPayloads, signers, chainStepRewardAddress = XYO_STEP_REWARD_ADDRESS2, stepRewardPoolBalance = AttoXL12(0n), protocol, chainId) {
+  return await buildBlock({
+    chainId: chainId ?? previousBlock.chain,
+    previousBlockNumber: previousBlock.block,
+    previousStepHashes: previousBlock.step_hashes ?? [],
+    previousBlockHash: previousBlock._hash,
+    txs,
+    blockPayloads,
+    signers,
+    protocol,
+    chainStepRewardAddress,
+    stepRewardPoolBalance
+  });
+}
+
+// src/test/buildRandomGenesisBlock.ts
+import { asAddress as asAddress2, assertEx as assertEx15 } from "@xylabs/sdk-js";
+import {
+  Account as Account2,
+  asAnyPayload as asAnyPayload4,
+  asSchema,
+  IdSchema,
+  PayloadBuilder as PayloadBuilder6
+} from "@xyo-network/sdk-js";
+import {
+  asXL1BlockNumber as asXL1BlockNumber5
+} from "@xyo-network/xl1-protocol-lib";
+
+// src/test/buildGenesisBlock.ts
+import { XYO_ZERO_ADDRESS as XYO_ZERO_ADDRESS2 } from "@xyo-network/xl1-protocol-lib";
+async function buildGenesisBlock(chainId, txs, blockPayloads, signers, chainStepRewardAddress = XYO_ZERO_ADDRESS2, protocol) {
+  return await buildBlock({
+    previousBlockHash: null,
+    chainId,
+    txs,
+    blockPayloads,
+    signers,
+    chainStepRewardAddress,
+    protocol
+  });
+}
+
+// src/test/buildRandomGenesisBlock.ts
+var TestChainId = assertEx15(asAddress2("c5fe2e6F6841Cbab12d8C0618Be2DF8C6156cC44"));
+
+// src/test/createGenesisBlock.ts
+import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/sdk-js";
+import {
+  BlockBoundWitnessSchemaPayload,
+  BlockBoundWitnessWithStorageMetaSchemaPayload,
+  ChainStakeIntentPayloadJsonSchemaPayload,
+  HashPayloadJsonSchemaPayload,
+  TransactionBoundWitnessSchemaPayload,
+  TransactionBoundWitnessWithStorageMetaSchemaPayload,
+  TransferPayloadJsonSchemaPayload
+} from "@xyo-network/xl1-schema";
+
+// src/test/createProducerChainStakeIntentTransaction.ts
+import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/sdk-js";
+import {
+  asXL1BlockNumber as asXL1BlockNumber6,
+  ChainStakeIntentSchema,
+  defaultTransactionFees as defaultTransactionFees2
+} from "@xyo-network/xl1-protocol-lib";
+async function createProducerChainStakeIntent(from, exp, nbf = 0) {
+  return await PayloadBuilder7.addHashMeta(new PayloadBuilder7({ schema: ChainStakeIntentSchema }).fields({
+    from,
+    exp,
+    nbf,
+    intent: "producer"
+  }).build());
+}
+
+// src/test/createGenesisBlock.ts
+var createGenesisBlock = async (initialBlockProducer, nextContractAddress, genesisBlockRewardAmount, genesisBlockRewardAddress) => {
+  const blockPayloads = await PayloadBuilder8.addHashMeta([
+    TransferPayloadJsonSchemaPayload,
+    BlockBoundWitnessSchemaPayload,
+    BlockBoundWitnessWithStorageMetaSchemaPayload,
+    TransactionBoundWitnessSchemaPayload,
+    TransactionBoundWitnessWithStorageMetaSchemaPayload,
+    ChainStakeIntentPayloadJsonSchemaPayload,
+    HashPayloadJsonSchemaPayload
+  ]);
+  const intentPayload = await createProducerChainStakeIntent(initialBlockProducer.address, 1, 0);
+  blockPayloads.push(intentPayload);
+  if (genesisBlockRewardAmount > 0n) {
+    blockPayloads.push(await PayloadBuilder8.addHashMeta(createTransferPayload(
+      nextContractAddress,
+      { [genesisBlockRewardAddress]: genesisBlockRewardAmount }
+    )));
+  }
+  return await buildGenesisBlock(nextContractAddress, [], blockPayloads, [initialBlockProducer]);
+};
+
+// src/test/buildRandomChain.ts
+var TestGenesisBlockRewardAddress = assertEx16(asAddress3("fa7f0bb865a4bfff3d5e2c726d3e063297014da9"));
+var buildRandomChain = async (blockProducer, count = 10, previousBlock, chainId, transactionAccount, receiverAddresses) => {
+  const chainIdToUse = chainId ?? TestChainId;
+  const blocks = [];
+  let remaining = count;
+  let lastBlock = previousBlock;
+  const transactionAccountToUse = transactionAccount ?? await Account3.random();
+  if (!lastBlock) {
+    const block = await createGenesisBlock(
+      blockProducer,
+      chainIdToUse,
+      1000000000n * 10n ** 18n,
+      transactionAccountToUse.address
+    );
+    blocks.push(block);
+    remaining = remaining - 1;
+    lastBlock = block;
+  }
+  const resolvedReceiverAddresses = receiverAddresses ?? [(await Account3.random()).address];
+  let saltCounter = 0;
+  while (remaining > 0) {
+    saltCounter += 1;
+    const payloads = [new PayloadBuilder9({ schema: IdSchema2 }).fields({ salt: `${Date.now()}-${saltCounter}` }).build()];
+    saltCounter += 1;
+    const additionalPrivatePayloads = remaining % 2 === 0 ? [new PayloadBuilder9({ schema: asSchema2("network.xyo.private", true) }).fields({ salt: `${Date.now()}-${saltCounter}` }).build()] : [];
+    const txs = [];
+    for (const receiverAddress of resolvedReceiverAddresses) {
+      txs.push(await buildRandomTransaction(
+        chainIdToUse,
+        [...payloads, ...additionalPrivatePayloads],
+        transactionAccountToUse,
+        asXL1BlockNumber7(Math.max(count - remaining - 1e3, 0), true),
+        asXL1BlockNumber7(count - remaining + 1e3, true),
+        [asSchema2("network.xyo.private", true)],
+        receiverAddress
+      ));
+    }
+    const previousBlock2 = assertEx16(lastBlock?.[0], () => new Error("No last block"));
+    const block = await buildNextBlock(previousBlock2, txs, [], [blockProducer], transactionAccountToUse.address);
+    blocks.push(block);
+    remaining = remaining - 1;
+    lastBlock = block;
+  }
+  return blocks;
+};
+async function buildRandomChainArchivist(count = 20) {
+  const producerAccount = await Account3.random();
+  const blocks = await buildRandomChain(producerAccount, count);
+  const archivist = await MemoryArchivist.create();
+  const payloads = flattenHydratedBlocks(blocks);
+  await archivist.insert(payloads);
+  return archivist;
+}
+
+// src/test/getSimpleBlockViewerLocator.ts
+async function getTestSimpleBlockViewerLocator({
+  minWithdrawalBlocks = 10,
+  config = ConfigZod.parse({}),
+  finalizedArchivist: finalizedArchivistIn,
+  rewardsContract = XYO_ZERO_ADDRESS3,
+  stakingTokenAddress = XYO_ZERO_ADDRESS3
+}) {
+  const finalizedArchivist = finalizedArchivistIn ?? await buildRandomChainArchivist();
+  const context = getTestProviderContext(config);
+  context.locator.registerMany([
+    SimpleChainContractViewer.factory(SimpleChainContractViewer.dependencies, {
+      minWithdrawalBlocks,
+      rewardsContract,
+      stakingTokenAddress
+    }),
+    SimpleFinalizationViewer.factory(SimpleFinalizationViewer.dependencies, { finalizedArchivist }),
+    SimpleBlockViewer.factory(SimpleBlockViewer.dependencies, { finalizedArchivist })
+  ]);
+  return context.locator;
+}
+
+// src/test/getTestProviderContext.ts
+function getTestProviderContext2(config) {
+  return getTestProviderContext(config);
+}
+export {
+  buildRandomTransaction,
+  getTestProviderContext2 as getTestProviderContext,
+  getTestSimpleBlockViewerLocator
+};
+//# sourceMappingURL=index.mjs.map