@xyo-network/xl1-protocol-sdk 1.15.28 → 1.16.1

package/dist/neutral/index.mjs

@@ -476,6 +476,44 @@ 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]);
@@ -501,7 +539,8 @@ async function transfersStepSummaryFromRange(context, range) {
   } 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 {
@@ -532,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();
       }
@@ -543,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 as isDefined3 } 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 [headHash] = await context.head();
-    const headResult = await context.store.chainMap.get(headHash);
-    const headBoundWitness = asBlockBoundWitnessWithStorageMeta3(headResult, () => `Head block not found for hash: ${context.head}`, {
-      required: true
-    });
-    const rangeStart = asXL1BlockNumber2(isDefined3(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");
@@ -738,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"
@@ -796,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",
@@ -826,35 +915,35 @@ var RewardRedemptionApiConfigZod = z9.object({
 
 // src/config/storage/driver/Mongo.ts
 import { isDefined as isDefined4, isUndefined as isUndefined2 } from "@xylabs/typeof";
-import { globalRegistry as globalRegistry9 } from "zod";
-import * as z10 from "zod";
+import { globalRegistry as globalRegistry10 } from "zod";
+import * as z11 from "zod";
 var hasMongoConfig = /* @__PURE__ */ __name((config) => {
   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"
@@ -862,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"
@@ -874,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"
@@ -917,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"),
@@ -936,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) {
@@ -979,33 +1069,33 @@ 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
@@ -1018,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);
@@ -1279,6 +1369,17 @@ function elevatedPayloads([tx, payloads]) {
 }
 __name(elevatedPayloads, "elevatedPayloads");
 
+// 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";
@@ -1621,8 +1722,10 @@ export {
   ADDRESS_INDEX,
   AddressPairSchema,
   BalancesStepSummarySchema,
+  BlockValidationError,
   CHANGE_ADDRESS,
   COIN_TYPES,
+  ChainIndexingServiceStateSchema,
   ConfigZod,
   DEFAULT_WALLET_PATH,
   EIP712DataPayloadFieldsZod,
@@ -1630,6 +1733,8 @@ export {
   EIP712SignaturePayloadFieldsZod,
   EIP712SignaturePayloadSchema,
   GlobalMetaSchema,
+  HydratedBlockStateValidationError,
+  HydratedBlockValidationError,
   JSONSchemaMetaSchema,
   LruCacheMap,
   MemoryMap,
@@ -1655,6 +1760,8 @@ export {
   asAddressPairPayload,
   asBalancesStepSummary,
   asBalancesStepSummaryWithStorageMeta,
+  asChainIndexingServiceState,
+  asChainIndexingServiceStateWithStorageMeta,
   asEIP712DataPayload,
   asEIP712SignaturePayload,
   asOptionalAddressPairPayload,
@@ -1692,8 +1799,13 @@ export {
   isAddressPairPayload,
   isBalancesStepSummary,
   isBalancesStepSummaryWithStorageMeta,
+  isBlockValidationError,
+  isChainIndexingServiceState,
+  isChainIndexingServiceStateWithStorageMeta,
   isEIP712DataPayload,
   isEIP712SignaturePayload,
+  isHydratedBlockStateValidationError,
+  isHydratedBlockValidationError,
   isLocalhost,
   isNegativeBigInt,
   isPositiveBigInt,
@@ -1723,6 +1835,7 @@ export {
   transactionsFromHydratedBlock,
   transfersStepSummaryFromRange,
   transfersSummary,
+  transfersSummaryKey,
   tryExtractElevatedHashes,
   tryExtractElevatedHashesFromScript,
   tryHydrateBlock,