@xyo-network/xl1-protocol-sdk 1.15.27 → 1.16.0

package/dist/neutral/index.mjs

@@ -112,37 +112,153 @@ var tryHydrateBlock = /* @__PURE__ */ __name(async (archivist, hash, maxDepth =
 import { asHash } from "@xylabs/hex";
 import { toSafeJsonString } from "@xylabs/object";
 import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta2, StepSizes } from "@xyo-network/xl1-protocol";
-async function blockFromBlockNumber(context, blockNumber) {
-  const head = await context.head();
-  const result = await context.store.chainMap.get(head);
-  let currentBlock = asBlockBoundWitnessWithStorageMeta2(result, () => `Head block not found for hash: ${head}`, {
-    required: true
-  });
-  if (currentBlock.block < blockNumber) {
-    throw new Error(`Error: Block number ${blockNumber} is greater than head ${currentBlock.block}.`);
+
+// src/model/ChainContext/ChainContext.ts
+import { isDefined as isDefined2, isUndefined } from "@xylabs/typeof";
+
+// src/driver/cache/LruCacheMap.ts
+import { LRUCache } from "lru-cache";
+var LruCacheMap = class {
+  static {
+    __name(this, "LruCacheMap");
+  }
+  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);
+  }
+};
+
+// src/driver/memory/MemoryMap.ts
+import { isDefined } from "@xylabs/typeof";
+var MemoryMap = class {
+  static {
+    __name(this, "MemoryMap");
+  }
+  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);
   }
-  while (currentBlock.block > blockNumber) {
-    let jumpHash = currentBlock.previous;
-    let jumpBlockNumber = currentBlock.block - 1;
-    for (const [step, stepSize2] of StepSizes.entries()) {
-      const possibleJumpBlockNumber = currentBlock.block - currentBlock.block % stepSize2 - 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}`);
+  getMany(ids) {
+    const results = [];
+    for (const id of ids) {
+      const data = this.map.get(id);
+      if (isDefined(data)) {
+        results.push(data);
       }
     }
-    const newBlock = await context.store.chainMap.get(asHash(jumpHash, () => `Jump hash not found for block number [${blockNumber}]: ${jumpBlockNumber} ${toSafeJsonString(currentBlock, 10)}`));
-    currentBlock = asBlockBoundWitnessWithStorageMeta2(newBlock, () => `Block not found for hash: ${jumpHash}`, {
+    return results;
+  }
+  has(id) {
+    return this.map.has(id);
+  }
+  set(id, data) {
+    this.map.set(id, data);
+  }
+};
+
+// src/model/ChainContext/ChainContext.ts
+function contextCache(context, name, create) {
+  if (!context.caches) {
+    context.caches = {};
+  }
+  if (isUndefined(context.caches[name])) {
+    context.caches[name] = create?.() ?? new MemoryMap();
+  }
+  return context.caches[name];
+}
+__name(contextCache, "contextCache");
+async function withContextCacheResponse(context, name, key, func, options) {
+  const cache = contextCache(context, name, () => new LruCacheMap({
+    max: options?.max ?? 1e4
+  }));
+  const cacheResult = await cache.get(key);
+  if (isDefined2(cacheResult)) {
+    return cacheResult;
+  }
+  const result = await func();
+  await cache.set(key, result);
+  return result;
+}
+__name(withContextCacheResponse, "withContextCacheResponse");
+
+// src/model/StakeEvents.ts
+var StakeEventNames = [
+  "StakeAdded",
+  "StakeRemoved",
+  "StakeWithdrawn"
+];
+
+// src/block/primitives/blockFromBlockNumber.ts
+async function blockFromBlockNumber(context, blockNumber) {
+  const cacheKey = `${blockNumber}`;
+  return await withContextCacheResponse(context, "blockFromBlockNumber", cacheKey, async () => {
+    const [headHash] = await context.head();
+    const result = await context.store.chainMap.get(headHash);
+    let currentBlock = asBlockBoundWitnessWithStorageMeta2(result, () => `Head block not found for hash: ${headHash}`, {
       required: true
     });
-    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}.`);
+      throw new Error(`Error: Block number ${blockNumber} is greater than head ${currentBlock.block}.`);
     }
-  }
-  return currentBlock;
+    while (currentBlock.block > blockNumber) {
+      let jumpHash = currentBlock.previous;
+      let jumpBlockNumber = currentBlock.block - 1;
+      for (const [step, stepSize2] of StepSizes.entries()) {
+        const possibleJumpBlockNumber = currentBlock.block - currentBlock.block % stepSize2 - 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 context.store.chainMap.get(asHash(jumpHash, () => `Jump hash not found for block number [${blockNumber}]: ${jumpBlockNumber} ${toSafeJsonString(currentBlock, 10)}`));
+      currentBlock = asBlockBoundWitnessWithStorageMeta2(newBlock, () => `Block not found for hash: ${jumpHash}`, {
+        required: true
+      });
+      if (currentBlock.block === blockNumber) {
+        break;
+      }
+      if (currentBlock.block < blockNumber) {
+        throw new Error(`Block number ${blockNumber} is not a valid step block number for block ${headHash}.`);
+      }
+    }
+    return currentBlock;
+  });
 }
 __name(blockFromBlockNumber, "blockFromBlockNumber");
 
@@ -228,6 +344,12 @@ function isReadWriteArchivist(value) {
 }
 __name(isReadWriteArchivist, "isReadWriteArchivist");
 
+// src/block/primitives/toStepIdentityString.ts
+function toStepIdentityString({ block, step }) {
+  return `${block}|${step}`;
+}
+__name(toStepIdentityString, "toStepIdentityString");
+
 // src/block/primitives/transfers/transfersStepSummaryFromRange.ts
 import { assertEx as assertEx4 } from "@xylabs/assert";
 import { PayloadBuilder } from "@xyo-network/payload-builder";
@@ -354,11 +476,49 @@ var toPositiveBigInt = /* @__PURE__ */ __name((value) => {
   throw new Error("Invalid value for positive big int");
 }, "toPositiveBigInt");
 
+// src/block/primitives/transfers/transfersSummary.ts
+import { asAddress } from "@xylabs/hex";
+import { spanRootAsync } from "@xylabs/telemetry";
+import { isDefined as isDefined3 } from "@xylabs/typeof";
+import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta3, asXL1BlockNumber as asXL1BlockNumber2 } from "@xyo-network/xl1-protocol";
+async function transfersSummary(transferContext) {
+  return await spanRootAsync("transferSummary", async () => {
+    const [headHash] = await transferContext.head();
+    const headResult = await transferContext.store.chainMap.get(headHash);
+    const headBoundWitness = asBlockBoundWitnessWithStorageMeta3(headResult, () => `Head block not found for hash: ${transferContext.head}`, {
+      required: true
+    });
+    const rangeStart = asXL1BlockNumber2(isDefined3(transferContext.windowSize) ? Math.max(headBoundWitness.block - transferContext.windowSize + 1, 0) : 0);
+    const ranges = deepCalculateFramesFromRange([
+      rangeStart,
+      asXL1BlockNumber2(headBoundWitness.block)
+    ]);
+    const summaries = await Promise.all(ranges.map((range) => transfersStepSummaryFromRange(transferContext, range)));
+    const transfers = {};
+    for (let summary of summaries) {
+      for (const [from, toMap] of Object.entries(summary.transfers)) {
+        const validFrom = asAddress(from, () => `Invalid address: ${from}`);
+        transfers[validFrom] = transfers[validFrom] ?? {};
+        for (const [to, transfer] of Object.entries(toMap)) {
+          const validTo = asAddress(to, () => `Invalid address: ${to}`);
+          transfers[validFrom][validTo] = (transfers[validFrom][validTo] ?? 0n) + parseSignedBigInt(transfer);
+        }
+      }
+    }
+    return transfers;
+  });
+}
+__name(transfersSummary, "transfersSummary");
+function transfersSummaryKey(frameHeadHash, frameSize) {
+  return `${frameHeadHash}|${frameSize}`;
+}
+__name(transfersSummaryKey, "transfersSummaryKey");
+
 // src/block/primitives/transfers/transfersStepSummaryFromRange.ts
 async function transfersStepSummaryFromRange(context, range) {
   const frameHeadHash = await hashFromBlockNumber(context, range[1]);
   const frameSize = range[1] - range[0] + 1;
-  const head = await context.head();
+  const [headHash] = await context.head();
   let result = void 0;
   if (frameSize === 1) {
     const hash = await hashFromBlockNumber(context, range[0]);
@@ -372,14 +532,15 @@ async function transfersStepSummaryFromRange(context, range) {
     }
     result = {
       schema: TransfersStepSummarySchema,
-      hash: head,
+      hash: headHash,
       stepSize: -1,
       transfers
     };
   } else {
     const step = StepSizes3.indexOf(frameSize);
     assertEx4(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes3.join(", ")}`);
-    const summaryResult = await context.summaryMap.get(`${frameHeadHash}|${frameSize}`);
+    const key = transfersSummaryKey(frameHeadHash, frameSize);
+    const summaryResult = await context.summaryMap.get(key);
     if (isAnyPayload(summaryResult)) {
       result = summaryResult;
     } else {
@@ -410,7 +571,7 @@ async function transfersStepSummaryFromRange(context, range) {
           stepSize: frameSize,
           transfers
         };
-        await context.summaryMap.set(`${frameHeadHash}|${frameSize}`, result);
+        await context.summaryMap.set(key, result);
       } finally {
         context.stepSemaphores[step].release();
       }
@@ -421,47 +582,48 @@ async function transfersStepSummaryFromRange(context, range) {
 }
 __name(transfersStepSummaryFromRange, "transfersStepSummaryFromRange");
 
-// src/block/primitives/transfers/transfersSummary.ts
-import { asAddress } from "@xylabs/hex";
-import { spanRootAsync } from "@xylabs/telemetry";
-import { isDefined } from "@xylabs/typeof";
-import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta3, asXL1BlockNumber as asXL1BlockNumber2 } from "@xyo-network/xl1-protocol";
-async function transfersSummary(context) {
-  return await spanRootAsync("transferSummary", async () => {
-    const head = await context.head();
-    const headResult = await context.store.chainMap.get(head);
-    const headBoundWitness = asBlockBoundWitnessWithStorageMeta3(headResult, () => `Head block not found for hash: ${context.head}`, {
-      required: true
-    });
-    const rangeStart = asXL1BlockNumber2(isDefined(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0);
-    const ranges = deepCalculateFramesFromRange([
-      rangeStart,
-      asXL1BlockNumber2(headBoundWitness.block)
-    ]);
-    const summaries = await Promise.all(ranges.map((range) => transfersStepSummaryFromRange(context, range)));
-    const transfers = {};
-    for (let summary of summaries) {
-      for (const [from, toMap] of Object.entries(summary.transfers)) {
-        const validFrom = asAddress(from, () => `Invalid address: ${from}`);
-        transfers[validFrom] = transfers[validFrom] ?? {};
-        for (const [to, transfer] of Object.entries(toMap)) {
-          const validTo = asAddress(to, () => `Invalid address: ${to}`);
-          transfers[validFrom][validTo] = (transfers[validFrom][validTo] ?? 0n) + parseSignedBigInt(transfer);
-        }
-      }
-    }
-    return transfers;
-  });
-}
-__name(transfersSummary, "transfersSummary");
-
 // src/config/Config.ts
-import * as z14 from "zod";
+import * as z15 from "zod";
 
 // src/config/Api.ts
 import { globalRegistry } from "zod";
 import * as z2 from "zod";
 
+// src/validation/block/error.ts
+import { isValidationError, ValidationError } from "@xyo-network/xl1-protocol";
+var BlockValidationError = class extends ValidationError {
+  static {
+    __name(this, "BlockValidationError");
+  }
+};
+var isBlockValidationError = /* @__PURE__ */ __name((error) => {
+  if (!isValidationError(error)) return false;
+  return error.name === BlockValidationError.constructor.name;
+}, "isBlockValidationError");
+var HydratedBlockValidationError = class extends ValidationError {
+  static {
+    __name(this, "HydratedBlockValidationError");
+  }
+};
+var isHydratedBlockValidationError = /* @__PURE__ */ __name((error) => {
+  if (!isValidationError(error)) return false;
+  return error.name === HydratedBlockValidationError.constructor.name;
+}, "isHydratedBlockValidationError");
+var HydratedBlockStateValidationError = class extends ValidationError {
+  static {
+    __name(this, "HydratedBlockStateValidationError");
+  }
+  chainId;
+  constructor(hash, chainId, value, message, cause) {
+    super(hash, value, message, cause);
+    this.chainId = chainId;
+  }
+};
+var isHydratedBlockStateValidationError = /* @__PURE__ */ __name((error) => {
+  if (!isValidationError(error)) return false;
+  return error.name === HydratedBlockStateValidationError.constructor.name;
+}, "isHydratedBlockStateValidationError");
+
 // src/validation/lib/isLocalhost.ts
 var isLocalhost = /* @__PURE__ */ __name((hostname) => {
   return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname.endsWith(".localhost");
@@ -616,57 +778,106 @@ var LogConfigZod = z7.object({
   })
 });
 
-// src/config/Producer.ts
-import { AddressZod, asAddress as asAddress2 } from "@xylabs/hex";
+// src/config/Mempool.ts
 import { globalRegistry as globalRegistry7 } from "zod";
 import * as z8 from "zod";
-var ProducerConfigZod = z8.object({
-  allowlist: z8.preprocess((val) => {
+var MempoolConfigZod = z8.object({
+  enabled: z8.string().default("false").transform((val, ctx) => {
+    const normalized = val.toLowerCase().trim();
+    if ([
+      "true",
+      "1",
+      "yes",
+      "on"
+    ].includes(normalized)) return true;
+    if ([
+      "false",
+      "0",
+      "no",
+      "off"
+    ].includes(normalized)) return false;
+    ctx.addIssue({
+      code: "invalid_type",
+      expected: "boolean",
+      message: `Invalid boolean value: "${val}". Use true/false, 1/0, yes/no.`
+    });
+    return z8.NEVER;
+  }).register(globalRegistry7, {
+    default: "false",
+    description: "Enable the Mempool",
+    title: "mempool.enabled",
+    type: "boolean"
+  }),
+  host: z8.string().default("localhost").register(globalRegistry7, {
+    default: "localhost",
+    description: "Host for the Mempool",
+    title: "mempool.host",
+    type: "string"
+  }),
+  mnemonic: MnemonicStringZod.optional().register(globalRegistry7, {
+    description: "Mnemonic for the Mempool wallet",
+    title: "mempool.mnemonic",
+    type: "string"
+  }),
+  port: z8.coerce.number().default(8083).register(globalRegistry7, {
+    default: 8083,
+    description: "Port for the Mempool",
+    title: "mempool.port",
+    type: "number"
+  })
+});
+
+// src/config/Producer.ts
+import { AddressZod, asAddress as asAddress2 } from "@xylabs/hex";
+import { globalRegistry as globalRegistry8 } from "zod";
+import * as z9 from "zod";
+var ProducerConfigZod = z9.object({
+  allowlist: z9.preprocess((val) => {
     if (typeof val === "string") {
       return val.split(",").map((s) => asAddress2(s.trim()));
     }
     return val;
-  }, z8.array(AddressZod).optional().register(globalRegistry7, {
+  }, z9.array(AddressZod).optional().register(globalRegistry8, {
     description: "List of allowed producer addresses, if undefined anyone can participate",
     title: "allowlist",
     type: "array"
   })),
-  disableIntentRedeclaration: z8.boolean().optional().register(globalRegistry7, {
+  disableIntentRedeclaration: z9.boolean().optional().register(globalRegistry8, {
     description: "Should the producer skip redeclaring their intent to continue producing blocks",
     title: "producer.disableIntentRedeclaration",
     type: "boolean"
   }),
   // TODO: Port schema
-  healthCheckPort: z8.coerce.number().optional().register(globalRegistry7, {
+  healthCheckPort: z9.coerce.number().optional().register(globalRegistry8, {
     description: "Port for the Producer health checks",
     title: "producer.healthCheckPort",
     type: "number"
   }),
-  heartbeatInterval: z8.coerce.number().default(36e5).register(globalRegistry7, {
+  heartbeatInterval: z9.coerce.number().default(36e5).register(globalRegistry8, {
     description: "The number of milliseconds between heartbeats if no blocks are produced",
     title: "producer.heartbeatInterval",
     type: "number"
   }),
   // TODO: BigInt schema
-  minStake: z8.coerce.number().default(1).register(globalRegistry7, {
+  minStake: z9.coerce.number().default(1).register(globalRegistry8, {
     description: "Minimum stake required to be a Producer",
     title: "producer.minStake",
     type: "number"
   }),
-  mnemonic: MnemonicStringZod.optional().register(globalRegistry7, {
+  mnemonic: MnemonicStringZod.optional().register(globalRegistry8, {
     description: "Mnemonic for the Producer wallet",
     title: "producer.mnemonic",
     type: "string"
   }),
   // TODO: Port schema
-  port: z8.coerce.number().default(8081).register(globalRegistry7, {
+  port: z9.coerce.number().default(8081).register(globalRegistry8, {
     default: 8081,
     description: "Port for the Producer",
     title: "producer.port",
     type: "number"
   }),
   // TODO: Address schema
-  rewardAddress: z8.string().optional().register(globalRegistry7, {
+  rewardAddress: z9.string().optional().register(globalRegistry8, {
     description: "Address to receive block rewards",
     title: "producer.rewardAddress",
     type: "string"
@@ -674,27 +885,27 @@ var ProducerConfigZod = z8.object({
 });
 
 // src/config/RewardRedemptionApi.ts
-import { globalRegistry as globalRegistry8 } from "zod";
-import * as z9 from "zod";
-var RewardRedemptionApiConfigZod = z9.object({
-  chainRpcApiUrl: z9.string().default("http://localhost:8080/rpc").register(globalRegistry8, {
+import { globalRegistry as globalRegistry9 } from "zod";
+import * as z10 from "zod";
+var RewardRedemptionApiConfigZod = z10.object({
+  chainRpcApiUrl: z10.string().default("http://localhost:8080/rpc").register(globalRegistry9, {
     default: "http://localhost:8080/rpc",
     description: "URL for the Chain RPC API",
     title: "rewardRedemptionApi.chainRpcApiUrl",
     type: "string"
   }),
-  host: z9.string().default("localhost").register(globalRegistry8, {
+  host: z10.string().default("localhost").register(globalRegistry9, {
     default: "localhost",
     description: "Host for the Redemption API",
     title: "rewardRedemptionApi.host",
     type: "string"
   }),
-  mnemonic: MnemonicStringZod.optional().register(globalRegistry8, {
+  mnemonic: MnemonicStringZod.optional().register(globalRegistry9, {
     description: "Mnemonic for the Redemption API wallet",
     title: "rewardRedemptionApi.mnemonic",
     type: "string"
   }),
-  port: z9.coerce.number().default(8082).register(globalRegistry8, {
+  port: z10.coerce.number().default(8082).register(globalRegistry9, {
     default: 8082,
     description: "Port for the Redemption API",
     title: "rewardRedemptionApi.port",
@@ -703,36 +914,36 @@ var RewardRedemptionApiConfigZod = z9.object({
 });
 
 // src/config/storage/driver/Mongo.ts
-import { isDefined as isDefined2, isUndefined } from "@xylabs/typeof";
-import { globalRegistry as globalRegistry9 } from "zod";
-import * as z10 from "zod";
+import { isDefined as isDefined4, isUndefined as isUndefined2 } from "@xylabs/typeof";
+import { globalRegistry as globalRegistry10 } from "zod";
+import * as z11 from "zod";
 var hasMongoConfig = /* @__PURE__ */ __name((config) => {
-  if (isUndefined(config)) return false;
-  return isDefined2(config.connectionString) && isDefined2(config.database) && isDefined2(config.domain) && isDefined2(config.password) && isDefined2(config.username);
+  if (isUndefined2(config)) return false;
+  return isDefined4(config.connectionString) && isDefined4(config.database) && isDefined4(config.domain) && isDefined4(config.password) && isDefined4(config.username);
 }, "hasMongoConfig");
-var MongoConfigZod = z10.object({
+var MongoConfigZod = z11.object({
   // TODO: Create from other arguments
-  connectionString: z10.string().nonempty().optional().register(globalRegistry9, {
+  connectionString: z11.string().nonempty().optional().register(globalRegistry10, {
     description: "MongoDB connection string",
     title: "storage.mongo.connectionString",
     type: "string"
   }),
-  database: z10.string().nonempty().optional().register(globalRegistry9, {
+  database: z11.string().nonempty().optional().register(globalRegistry10, {
     description: "MongoDB database name",
     title: "storage.mongo.database",
     type: "string"
   }),
-  domain: z10.string().nonempty().optional().register(globalRegistry9, {
+  domain: z11.string().nonempty().optional().register(globalRegistry10, {
     description: "MongoDB domain",
     title: "storage.mongo.domain",
     type: "string"
   }),
-  password: z10.string().nonempty().optional().register(globalRegistry9, {
+  password: z11.string().nonempty().optional().register(globalRegistry10, {
     description: "MongoDB password",
     title: "storage.mongo.password",
     type: "string"
   }),
-  username: z10.string().nonempty().optional().register(globalRegistry9, {
+  username: z11.string().nonempty().optional().register(globalRegistry10, {
     description: "MongoDB username",
     title: "storage.mongo.username",
     type: "string"
@@ -740,11 +951,11 @@ var MongoConfigZod = z10.object({
 });
 
 // src/config/storage/Storage.ts
-import { globalRegistry as globalRegistry10 } from "zod";
-import * as z11 from "zod";
-var StorageConfigZod = z11.object({
+import { globalRegistry as globalRegistry11 } from "zod";
+import * as z12 from "zod";
+var StorageConfigZod = z12.object({
   mongo: MongoConfigZod.optional().describe("Configuration for the MongoD storage driver"),
-  root: z11.string().optional().register(globalRegistry10, {
+  root: z12.string().optional().register(globalRegistry11, {
     description: "Root directory for local storage",
     title: "storage.root",
     type: "string"
@@ -752,42 +963,42 @@ var StorageConfigZod = z11.object({
 }).describe("Storage configuration options");
 
 // src/config/Telemetry.ts
-import { globalRegistry as globalRegistry11 } from "zod";
-import * as z12 from "zod";
-var OpenTelemetryConfigZod = z12.object({
+import { globalRegistry as globalRegistry12 } from "zod";
+import * as z13 from "zod";
+var OpenTelemetryConfigZod = z13.object({
   // OpenTelemetry options
-  otlpEndpoint: z12.url().optional().register(globalRegistry11, {
+  otlpEndpoint: z13.url().optional().register(globalRegistry12, {
     description: "OTLP endpoint for exporting telemetry data",
     title: "telemetry.otel.otlpEndpoint",
     type: "string"
   })
 });
-var TelemetryConfigZod = z12.object({
+var TelemetryConfigZod = z13.object({
   // OpenTelemetry configuration
   otel: OpenTelemetryConfigZod.optional().describe("OpenTelemetry configuration")
 }).describe("Telemetry configuration options");
 
 // src/config/Validation.ts
 import { AddressZod as AddressZod2, asAddress as asAddress3 } from "@xylabs/hex";
-import { globalRegistry as globalRegistry12 } from "zod";
-import * as z13 from "zod";
-var ValidationConfigZod = z13.object({
-  allowedRewardRedeemers: z13.preprocess((val) => {
+import { globalRegistry as globalRegistry13 } from "zod";
+import * as z14 from "zod";
+var ValidationConfigZod = z14.object({
+  allowedRewardRedeemers: z14.preprocess((val) => {
     if (typeof val === "string") {
       return val.split(",").map((s) => asAddress3(s.trim()));
     }
     return val;
-  }, z13.array(AddressZod2).optional().register(globalRegistry12, {
+  }, z14.array(AddressZod2).optional().register(globalRegistry13, {
     description: "List of allowed reward redeemer addresses, if undefined anyone can participate",
     title: "allowedRewardRedeemers",
     type: "array"
   })),
-  allowedRewardEscrowAccountSigners: z13.preprocess((val) => {
+  allowedRewardEscrowAccountSigners: z14.preprocess((val) => {
     if (typeof val === "string") {
       return val.split(",").map((s) => asAddress3(s.trim()));
     }
     return val;
-  }, z13.array(AddressZod2).optional().register(globalRegistry12, {
+  }, z14.array(AddressZod2).optional().register(globalRegistry13, {
     description: "List of allowed reward escrow account signer addresses, if undefined anyone can participate",
     title: "allowedRewardEscrowAccountSigners",
     type: "array"
@@ -795,16 +1006,17 @@ var ValidationConfigZod = z13.object({
 });
 
 // src/config/Config.ts
-var Xl1CommonConfigSchema = z14.object({
+var Xl1CommonConfigSchema = z15.object({
   ...LogConfigZod.shape
 }).describe("XL1 common configuration options");
-var ConfigZod = z14.object({
+var ConfigZod = z15.object({
   ...Xl1CommonConfigSchema.shape,
   api: ApiConfigZod.default(ApiConfigZod.parse({})).describe("Configuration for the API node"),
   app: AppConfigZod.default(AppConfigZod.parse({})).describe("Configuration for the application"),
   bridge: BridgeConfigZod.default(BridgeConfigZod.parse({})).describe("Configuration for the Bridge node"),
   chain: ChainConfigZod.default(ChainConfigZod.parse({})).describe("Configuration for the chain"),
   evm: EvmConfigZod.default(EvmConfigZod.parse({})).describe("Configuration for EVM-backed services"),
+  mempool: MempoolConfigZod.default(MempoolConfigZod.parse({})).describe("Configuration for the mempool"),
   producer: ProducerConfigZod.default(ProducerConfigZod.parse({})).describe("Configuration for the producer"),
   rewardRedemptionApi: RewardRedemptionApiConfigZod.default(RewardRedemptionApiConfigZod.parse({})).describe("Configuration for the rewards redemption API"),
   storage: StorageConfigZod.default(StorageConfigZod.parse({})).describe("Configuration for the storage"),
@@ -814,35 +1026,35 @@ var ConfigZod = z14.object({
 var getDefaultConfig = /* @__PURE__ */ __name(() => ConfigZod.parse({}), "getDefaultConfig");
 
 // src/config/UsageMeta.ts
-import * as z15 from "zod";
-var DescriptionSchema = z15.string();
-var TitleSchema = z15.string();
-var JSONSchemaMetaSchema = z15.object({
-  id: z15.string().optional(),
+import * as z16 from "zod";
+var DescriptionSchema = z16.string();
+var TitleSchema = z16.string();
+var JSONSchemaMetaSchema = z16.object({
+  id: z16.string().optional(),
   title: TitleSchema.optional(),
   description: DescriptionSchema.optional(),
-  deprecated: z15.boolean().optional()
-}).catchall(z15.unknown());
+  deprecated: z16.boolean().optional()
+}).catchall(z16.unknown());
 var GlobalMetaSchema = JSONSchemaMetaSchema.extend({});
-var ChoicesSchema = z15.array(z15.union([
-  z15.string(),
-  z15.number(),
-  z15.literal(true),
-  z15.undefined()
+var ChoicesSchema = z16.array(z16.union([
+  z16.string(),
+  z16.number(),
+  z16.literal(true),
+  z16.undefined()
 ])).readonly();
 var UsageMetaSchema = GlobalMetaSchema.extend({
   choices: ChoicesSchema.optional(),
-  default: z15.unknown().optional(),
+  default: z16.unknown().optional(),
   description: DescriptionSchema,
-  group: z15.string().optional(),
-  hidden: z15.boolean().optional(),
+  group: z16.string().optional(),
+  hidden: z16.boolean().optional(),
   title: TitleSchema,
-  type: z15.union([
-    z15.literal("array"),
-    z15.literal("count"),
-    z15.literal("boolean"),
-    z15.literal("number"),
-    z15.literal("string")
+  type: z16.union([
+    z16.literal("array"),
+    z16.literal("count"),
+    z16.literal("boolean"),
+    z16.literal("number"),
+    z16.literal("string")
   ])
 });
 function isUsageMeta(v) {
@@ -857,39 +1069,38 @@ var XL1_NETWORK_STAKING_GENESIS_PERIOD_END_XL1_BLOCK = 107496;
 // src/eip-712/Payloads/EIP712Data.ts
 import { AsObjectFactory as AsObjectFactory4 } from "@xylabs/object";
 import { isPayloadOfZodType } from "@xyo-network/payload-model";
-import z17 from "zod";
+import z18 from "zod";
 
 // src/eip-712/Types.ts
-import z16 from "zod";
-var TypedDataDomainZod = z16.object({
-  name: z16.string().nullable().optional(),
-  version: z16.string().nullable().optional(),
-  chainId: z16.union([
-    z16.string(),
-    z16.number(),
-    z16.bigint()
+import z17 from "zod";
+var TypedDataDomainZod = z17.object({
+  name: z17.string().nullable().optional(),
+  version: z17.string().nullable().optional(),
+  chainId: z17.union([
+    z17.string(),
+    z17.number(),
+    z17.bigint()
   ]).nullable().optional(),
-  verifyingContract: z16.string().nullable().optional(),
-  salt: z16.union([
-    z16.string(),
-    z16.instanceof(Uint8Array)
+  verifyingContract: z17.string().nullable().optional(),
+  salt: z17.union([
+    z17.string(),
+    z17.instanceof(Uint8Array)
   ]).nullable().optional()
 });
-var TypedDataFieldZod = z16.object({
-  name: z16.string(),
-  type: z16.string()
+var TypedDataFieldZod = z17.object({
+  name: z17.string(),
+  type: z17.string()
 });
-var TypedDataTypesZod = z16.record(z16.string(), z16.array(TypedDataFieldZod));
-var TypedDataValueZod = z16.record(z16.string(), z16.any());
+var TypedDataTypesZod = z17.record(z17.string(), z17.array(TypedDataFieldZod));
+var TypedDataValueZod = z17.record(z17.string(), z17.any());
 
 // src/eip-712/Payloads/EIP712Data.ts
-var EIP712DataPayloadFieldsZod = z17.object({
+var EIP712DataPayloadFieldsZod = z18.object({
   domain: TypedDataDomainZod,
   types: TypedDataTypesZod,
   values: TypedDataValueZod
 });
 var EIP712DataPayloadSchema = "network.xyo.chains.ethereum.eip712.data";
-var EIP712PayloadSchema = EIP712DataPayloadSchema;
 var isEIP712DataPayload = isPayloadOfZodType(EIP712DataPayloadFieldsZod, EIP712DataPayloadSchema);
 var asEIP712DataPayload = AsObjectFactory4.create(isEIP712DataPayload);
 
@@ -897,11 +1108,11 @@ var asEIP712DataPayload = AsObjectFactory4.create(isEIP712DataPayload);
 import { HashZod } from "@xylabs/hex";
 import { AsObjectFactory as AsObjectFactory5 } from "@xylabs/object";
 import { isPayloadOfZodType as isPayloadOfZodType2 } from "@xyo-network/payload-model";
-import z18 from "zod";
-var EIP712SignaturePayloadFieldsZod = z18.object({
-  address: z18.string(),
+import z19 from "zod";
+var EIP712SignaturePayloadFieldsZod = z19.object({
+  address: z19.string(),
   hash: HashZod,
-  signature: z18.string()
+  signature: z19.string()
 });
 var EIP712SignaturePayloadSchema = "network.xyo.chains.ethereum.eip712.signature";
 var isEIP712SignaturePayload = isPayloadOfZodType2(EIP712SignaturePayloadFieldsZod, EIP712SignaturePayloadSchema);
@@ -924,25 +1135,18 @@ var signEIP712Message = /* @__PURE__ */ __name(async (signer, data) => {
 
 // src/eip-712/verify.ts
 import { asHash as asHash2 } from "@xylabs/hex";
-import { isUndefined as isUndefined2 } from "@xylabs/typeof";
+import { isUndefined as isUndefined3 } from "@xylabs/typeof";
 import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
 import { verifyTypedData } from "ethers/hash";
 var verifyEIP712Message = /* @__PURE__ */ __name(async (data, sig) => {
   const { address, signature, hash } = sig;
   const { schema, ...fields } = data;
   const signedHash = asHash2(hash);
-  if (isUndefined2(signedHash) || signedHash !== await PayloadBuilder3.hash(data)) return false;
+  if (isUndefined3(signedHash) || signedHash !== await PayloadBuilder3.hash(data)) return false;
   const recoveredAddress = verifyTypedData(fields.domain, fields.types, fields.values, signature);
   return recoveredAddress.toLowerCase() === address.toLowerCase();
 }, "verifyEIP712Message");
 
-// src/model/StakeEvents.ts
-var StakeEventNames = [
-  "StakeAdded",
-  "StakeRemoved",
-  "StakeWithdrawn"
-];
-
 // src/multipliers.ts
 import { asAttoXL1 } from "@xyo-network/xl1-protocol";
 var XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_EARNED_REWARDS = asAttoXL1(1343884111859145740576652n);
@@ -956,7 +1160,7 @@ var RewardMultipliers = {
 };
 
 // src/primitives/readPayloadMapFromStore.ts
-import { isDefined as isDefined3 } from "@xylabs/typeof";
+import { isDefined as isDefined5 } from "@xylabs/typeof";
 function readPayloadMapFromStore(store) {
   if (isReadArchivist(store)) {
     return {
@@ -969,7 +1173,7 @@ function readPayloadMapFromStore(store) {
         return await store.get(hashes);
       }, "getMany"),
       has: /* @__PURE__ */ __name(async (hash) => {
-        return isDefined3((await store.get([
+        return isDefined5((await store.get([
           hash
         ]))[0]);
       }, "has")
@@ -994,10 +1198,10 @@ __name(completedStepRewardAddress, "completedStepRewardAddress");
 
 // src/primitives/step/derivedReceiveAddress.ts
 import { toAddress as toAddress3 } from "@xylabs/hex";
-import { isDefined as isDefined4 } from "@xylabs/typeof";
+import { isDefined as isDefined6 } from "@xylabs/typeof";
 import { keccak256 as keccak2562 } from "ethers";
 function derivedReceiveAddress(address, scope) {
-  const addressKey = new TextEncoder().encode(isDefined4(scope) ? `${scope}|${address}` : address);
+  const addressKey = new TextEncoder().encode(isDefined6(scope) ? `${scope}|${address}` : address);
   return toAddress3(keccak2562(addressKey).slice(-40), {
     prefix: false
   });
@@ -1047,7 +1251,7 @@ import { StepSizes as StepSizes7 } from "@xyo-network/xl1-protocol";
 async function balancesStepSummaryFromRange(context, range) {
   const frameHeadHash = await hashFromBlockNumber(context, range[1]);
   const frameSize = range[1] - range[0] + 1;
-  const head = await context.head();
+  const [headHash] = await context.head();
   let result = void 0;
   if (frameSize === 1) {
     const hash = await hashFromBlockNumber(context, range[0]);
@@ -1058,7 +1262,7 @@ async function balancesStepSummaryFromRange(context, range) {
     }
     result = {
       schema: BalancesStepSummarySchema,
-      hash: head,
+      hash: headHash,
       stepSize: -1,
       balances
     };
@@ -1104,16 +1308,16 @@ __name(balancesStepSummaryFromRange, "balancesStepSummaryFromRange");
 // src/primitives/summary/balances/balancesSummary.ts
 import { asAddress as asAddress4 } from "@xylabs/hex";
 import { spanRootAsync as spanRootAsync2 } from "@xylabs/telemetry";
-import { isDefined as isDefined5 } from "@xylabs/typeof";
+import { isDefined as isDefined7 } from "@xylabs/typeof";
 import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta4, asXL1BlockNumber as asXL1BlockNumber3 } from "@xyo-network/xl1-protocol";
 async function balancesSummary(context) {
   return await spanRootAsync2("balanceSummary", async () => {
-    const head = await context.head();
-    const headResult = await context.store.chainMap.get(head);
-    const headBoundWitness = asBlockBoundWitnessWithStorageMeta4(headResult, () => `Head block not found for hash: ${context.head}`, {
+    const [headHash] = await context.head();
+    const headResult = await context.store.chainMap.get(headHash);
+    const headBoundWitness = asBlockBoundWitnessWithStorageMeta4(headResult, () => `Head block not found for hash: ${headHash}`, {
       required: true
     });
-    const rangeStart = asXL1BlockNumber3(isDefined5(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0);
+    const rangeStart = asXL1BlockNumber3(isDefined7(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0);
     const ranges = deepCalculateFramesFromRange([
       rangeStart,
       asXL1BlockNumber3(headBoundWitness.block)
@@ -1131,6 +1335,18 @@ async function balancesSummary(context) {
 }
 __name(balancesSummary, "balancesSummary");
 
+// src/primitives/timeBudget.ts
+async function timeBudget(name, logger, func, budget) {
+  const start = Date.now();
+  const result = await func();
+  const duration = Date.now() - start;
+  if (duration > budget) {
+    logger?.warn(`Function [${name}] execution exceeded budget: ${duration}ms > ${budget}ms`);
+  }
+  return result;
+}
+__name(timeBudget, "timeBudget");
+
 // src/primitives/transaction/elevatedPayloads.ts
 import { isAllowedBlockPayload } from "@xyo-network/xl1-protocol";
 var ELEVATE_OPCODE = "elevate";
@@ -1153,6 +1369,25 @@ function elevatedPayloads([tx, payloads]) {
 }
 __name(elevatedPayloads, "elevatedPayloads");
 
+// src/provider/XyoDataLake.ts
+var isDataLakeViewer = /* @__PURE__ */ __name((value) => {
+  return typeof value === "object" && value !== null && "fetch" in value && typeof value.fetch === "function" && "get" in value && typeof value.get === "function" && "trace" in value && typeof value.trace === "function";
+}, "isDataLakeViewer");
+var isDataLakeProvider = /* @__PURE__ */ __name((value) => {
+  return isDataLakeViewer(value) && "add" in value && typeof value.add === "function";
+}, "isDataLakeProvider");
+
+// src/services/StakeIntentService/ChainIndexingServiceStateSchema.ts
+import { AsObjectFactory as AsObjectFactory6 } from "@xylabs/object";
+import { isPayloadOfSchemaType as isPayloadOfSchemaType4, isStorageMeta as isStorageMeta3 } from "@xyo-network/payload-model";
+var ChainIndexingServiceStateSchema = "network.xyo.chain.indexing.service.state";
+var isChainIndexingServiceState = /* @__PURE__ */ __name((payload) => {
+  return isPayloadOfSchemaType4(ChainIndexingServiceStateSchema)(payload);
+}, "isChainIndexingServiceState");
+var asChainIndexingServiceState = AsObjectFactory6.create(isChainIndexingServiceState);
+var isChainIndexingServiceStateWithStorageMeta = /* @__PURE__ */ __name((value) => isChainIndexingServiceState(value) && isStorageMeta3(value), "isChainIndexingServiceStateWithStorageMeta");
+var asChainIndexingServiceStateWithStorageMeta = AsObjectFactory6.create(isChainIndexingServiceStateWithStorageMeta);
+
 // src/time/primitives/xl1BlockNumberToEthBlockNumber.ts
 import { assertEx as assertEx7 } from "@xylabs/assert";
 import { asTimePayload, TimeSchema } from "@xyo-network/xl1-protocol";
@@ -1250,15 +1485,15 @@ async function buildUnsignedTransaction(chain, onChainPayloads, offChainPayloads
     ...offChainPayloads
   ]).build();
   return [
-    await PayloadBuilder6.addStorageMeta(tx),
-    await PayloadBuilder6.addStorageMeta(txPayloads)
+    tx,
+    txPayloads
   ];
 }
 __name(buildUnsignedTransaction, "buildUnsignedTransaction");
 
 // src/transaction/confirmSubmittedTransaction.ts
 import { delay } from "@xylabs/delay";
-import { isDefined as isDefined6 } from "@xylabs/typeof";
+import { isDefined as isDefined8 } from "@xylabs/typeof";
 import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
 var DEFAULT_CONFIRMATION_ATTEMPTS = 20;
 var DEFAULT_DELAY_BETWEEN_ATTEMPTS = 1e3;
@@ -1269,7 +1504,7 @@ var confirmSubmittedTransaction = /* @__PURE__ */ __name(async (viewer, transact
   let attempts = 0;
   while (true) {
     const tx = await viewer.transactionByHash(txBWHash) ?? void 0;
-    if (isDefined6(tx)) {
+    if (isDefined8(tx)) {
       options?.logger?.log("\u2705 Transaction confirmed:", txBWHash, "\n");
       return tx;
     } else {
@@ -1413,7 +1648,7 @@ __name(transactionRequiredGas, "transactionRequiredGas");
 import { filterAs as filterAs2 } from "@xylabs/array";
 import { assertEx as assertEx10 } from "@xylabs/assert";
 import { asHash as asHash4 } from "@xylabs/hex";
-import { isAllowedBlockPayloadWithHashStorageMeta } from "@xyo-network/xl1-protocol";
+import { isAllowedBlockPayloadWithHashMeta } from "@xyo-network/xl1-protocol";
 var tryExtractElevatedHashesFromScript = /* @__PURE__ */ __name((strings) => {
   const hashes = strings.filter((str) => str.startsWith("elevate|")).map((str) => str.split("|")[1]);
   return filterAs2(hashes, (h) => asHash4(h));
@@ -1428,13 +1663,13 @@ var tryExtractElevatedHashes = /* @__PURE__ */ __name((tx) => {
   const [bw, payloads] = tx;
   const { script } = bw;
   const hashes = script ? tryExtractElevatedHashesFromScript(script) : [];
-  return payloads.filter((p) => hashes.includes(p._hash)).filter(isAllowedBlockPayloadWithHashStorageMeta);
+  return payloads.filter((p) => hashes.includes(p._hash)).filter(isAllowedBlockPayloadWithHashMeta);
 }, "tryExtractElevatedHashes");
 var extractElevatedHashes = /* @__PURE__ */ __name((tx) => {
   const [bw, payloads] = tx;
   const { script } = bw;
   const hashes = script ? tryExtractElevatedHashesFromScript(script) : [];
-  const filtered = payloads.filter((p) => hashes.includes(p._hash)).filter(isAllowedBlockPayloadWithHashStorageMeta);
+  const filtered = payloads.filter((p) => hashes.includes(p._hash)).filter(isAllowedBlockPayloadWithHashMeta);
   assertEx10(filtered.length === hashes.length, () => "Invalid elevated hashes");
   return filtered;
 }, "extractElevatedHashes");
@@ -1495,17 +1730,22 @@ export {
   ADDRESS_INDEX,
   AddressPairSchema,
   BalancesStepSummarySchema,
+  BlockValidationError,
   CHANGE_ADDRESS,
   COIN_TYPES,
+  ChainIndexingServiceStateSchema,
   ConfigZod,
   DEFAULT_WALLET_PATH,
   EIP712DataPayloadFieldsZod,
   EIP712DataPayloadSchema,
-  EIP712PayloadSchema,
   EIP712SignaturePayloadFieldsZod,
   EIP712SignaturePayloadSchema,
   GlobalMetaSchema,
+  HydratedBlockStateValidationError,
+  HydratedBlockValidationError,
   JSONSchemaMetaSchema,
+  LruCacheMap,
+  MemoryMap,
   MnemonicStringZod,
   RewardMultipliers,
   StakeEventNames,
@@ -1528,6 +1768,8 @@ export {
   asAddressPairPayload,
   asBalancesStepSummary,
   asBalancesStepSummaryWithStorageMeta,
+  asChainIndexingServiceState,
+  asChainIndexingServiceStateWithStorageMeta,
   asEIP712DataPayload,
   asEIP712SignaturePayload,
   asOptionalAddressPairPayload,
@@ -1542,6 +1784,7 @@ export {
   calculateFramesFromRange,
   completedStepRewardAddress,
   confirmSubmittedTransaction,
+  contextCache,
   crackOperation,
   crackOperations,
   deepCalculateFramesFromRange,
@@ -1564,8 +1807,15 @@ export {
   isAddressPairPayload,
   isBalancesStepSummary,
   isBalancesStepSummaryWithStorageMeta,
+  isBlockValidationError,
+  isChainIndexingServiceState,
+  isChainIndexingServiceStateWithStorageMeta,
+  isDataLakeProvider,
+  isDataLakeViewer,
   isEIP712DataPayload,
   isEIP712SignaturePayload,
+  isHydratedBlockStateValidationError,
+  isHydratedBlockValidationError,
   isLocalhost,
   isNegativeBigInt,
   isPositiveBigInt,
@@ -1583,8 +1833,10 @@ export {
   signTransaction,
   stepBlockRange,
   stepTransferIndex,
+  timeBudget,
   toPositiveBigInt,
   toSignedBigInt,
+  toStepIdentityString,
   transactionBlockByteCount,
   transactionBytesRequiredGas,
   transactionElevatedPayloadHashes,
@@ -1593,12 +1845,14 @@ export {
   transactionsFromHydratedBlock,
   transfersStepSummaryFromRange,
   transfersSummary,
+  transfersSummaryKey,
   tryExtractElevatedHashes,
   tryExtractElevatedHashesFromScript,
   tryHydrateBlock,
   tryHydrateElevatedTransaction,
   tryHydrateTransaction,
   verifyEIP712Message,
+  withContextCacheResponse,
   xl1BlockNumberToEthBlockNumber
 };
 //# sourceMappingURL=index.mjs.map