@ensnode/ensnode-sdk 0.0.0-next-20260303184716 → 0.0.0-next-20260304002121

package/dist/index.cjs

@@ -531,16 +531,16 @@ var uint256ToHex32 = (num) => (0, import_viem6.toHex)(num, { size: 32 });
 var import_datasources = require("@ensnode/datasources");
 
 // src/ensapi/config/deserialize.ts
-var import_v46 = require("zod/v4");
+var import_v47 = require("zod/v4");
 
 // src/ensindexer/config/deserialize.ts
-var import_v43 = require("zod/v4");
+var import_v44 = require("zod/v4");
 
 // src/ensindexer/config/zod-schemas.ts
-var import_v42 = require("zod/v4");
+var import_v43 = require("zod/v4");
 
-// src/shared/collections.ts
-var uniq = (arr) => [...new Set(arr)];
+// src/ensrainbow/zod-schemas/config.ts
+var import_v42 = require("zod/v4");
 
 // src/shared/zod-schemas.ts
 var import_caip = require("caip");
@@ -823,6 +823,29 @@ var makeReinterpretedNameSchema = (valueLabel = "Reinterpreted Name") => import_
   }
 }).transform(reinterpretName);
 
+// src/ensrainbow/zod-schemas/config.ts
+var makeLabelSetIdSchema = (valueLabel = "Label set ID") => {
+  return import_v42.z.string({ error: `${valueLabel} must be a string` }).min(1, { error: `${valueLabel} must be 1-50 characters long` }).max(50, { error: `${valueLabel} must be 1-50 characters long` }).regex(/^[a-z-]+$/, {
+    error: `${valueLabel} can only contain lowercase letters (a-z) and hyphens (-)`
+  });
+};
+var makeLabelSetVersionSchema = (valueLabel = "Label set version") => {
+  return import_v42.z.coerce.number({ error: `${valueLabel} must be an integer.` }).pipe(makeNonNegativeIntegerSchema(valueLabel));
+};
+var makeEnsRainbowPublicConfigSchema = (valueLabel = "EnsRainbowPublicConfig") => import_v42.z.object({
+  version: import_v42.z.string().nonempty({ error: `${valueLabel}.version must be a non-empty string.` }),
+  labelSet: import_v42.z.object({
+    labelSetId: makeLabelSetIdSchema(`${valueLabel}.labelSet.labelSetId`),
+    highestLabelSetVersion: makeLabelSetVersionSchema(
+      `${valueLabel}.labelSet.highestLabelSetVersion`
+    )
+  }),
+  recordsCount: makeNonNegativeIntegerSchema(`${valueLabel}.recordsCount`)
+});
+
+// src/shared/collections.ts
+var uniq = (arr) => [...new Set(arr)];
+
 // src/ensindexer/config/is-subgraph-compatible.ts
 var import_datasources3 = require("@ensnode/datasources");
 
@@ -848,6 +871,35 @@ function isSubgraphCompatible(config) {
   return onlySubgraphPluginActivated && labelSetIsSubgraphCompatible;
 }
 
+// src/ensindexer/config/labelset-utils.ts
+function buildLabelSetId(maybeLabelSetId) {
+  return makeLabelSetIdSchema("LabelSetId").parse(maybeLabelSetId);
+}
+function buildLabelSetVersion(maybeLabelSetVersion) {
+  return makeLabelSetVersionSchema("LabelSetVersion").parse(maybeLabelSetVersion);
+}
+function buildEnsRainbowClientLabelSet(labelSetId, labelSetVersion) {
+  if (labelSetVersion !== void 0 && labelSetId === void 0) {
+    throw new Error("When a labelSetVersion is defined, labelSetId must also be defined.");
+  }
+  return { labelSetId, labelSetVersion };
+}
+function validateSupportedLabelSetAndVersion(serverSet, clientSet) {
+  if (clientSet.labelSetId === void 0) {
+    return;
+  }
+  if (serverSet.labelSetId !== clientSet.labelSetId) {
+    throw new Error(
+      `Server label set ID "${serverSet.labelSetId}" does not match client's requested label set ID "${clientSet.labelSetId}".`
+    );
+  }
+  if (clientSet.labelSetVersion !== void 0 && serverSet.highestLabelSetVersion < clientSet.labelSetVersion) {
+    throw new Error(
+      `Server highest label set version ${serverSet.highestLabelSetVersion} is less than client's requested version ${clientSet.labelSetVersion} for label set ID "${clientSet.labelSetId}".`
+    );
+  }
+}
+
 // src/ensindexer/config/validations.ts
 function invariant_ensDbVersionIsSameAsEnsIndexerVersion(ctx) {
   const versionInfo = ctx.value;
@@ -861,32 +913,24 @@ function invariant_ensDbVersionIsSameAsEnsIndexerVersion(ctx) {
 }
 
 // src/ensindexer/config/zod-schemas.ts
-var makeIndexedChainIdsSchema = (valueLabel = "Indexed Chain IDs") => import_v42.z.set(makeChainIdSchema(valueLabel), { error: `${valueLabel} must be a set` }).min(1, {
+var makeIndexedChainIdsSchema = (valueLabel = "Indexed Chain IDs") => import_v43.z.set(makeChainIdSchema(valueLabel), { error: `${valueLabel} must be a set` }).min(1, {
   error: `${valueLabel} must be a set with at least one chain ID.`
 });
-var makeSerializedIndexedChainIdsSchema = (valueLabel = "Indexed Chain IDs") => import_v42.z.array(makeChainIdSchema(valueLabel), {
+var makeSerializedIndexedChainIdsSchema = (valueLabel = "Indexed Chain IDs") => import_v43.z.array(makeChainIdSchema(valueLabel), {
   error: `${valueLabel} must be an array.`
 }).min(1, {
   error: `${valueLabel} must be an array with at least one chain ID.`
 });
-var makePluginsListSchema = (valueLabel = "Plugins") => import_v42.z.array(import_v42.z.string(), {
+var makePluginsListSchema = (valueLabel = "Plugins") => import_v43.z.array(import_v43.z.string(), {
   error: `${valueLabel} must be a list of strings.`
 }).min(1, {
   error: `${valueLabel} must be a list of strings with at least one string value`
 }).refine((arr) => arr.length === uniq(arr).length, {
   error: `${valueLabel} cannot contain duplicate values.`
 });
-var makeDatabaseSchemaNameSchema = (valueLabel = "Database schema name") => import_v42.z.string({ error: `${valueLabel} must be a string` }).trim().nonempty({
+var makeDatabaseSchemaNameSchema = (valueLabel = "Database schema name") => import_v43.z.string({ error: `${valueLabel} must be a string` }).trim().nonempty({
   error: `${valueLabel} is required and must be a non-empty string.`
 });
-var makeLabelSetIdSchema = (valueLabel) => {
-  return import_v42.z.string({ error: `${valueLabel} must be a string` }).min(1, { error: `${valueLabel} must be 1-50 characters long` }).max(50, { error: `${valueLabel} must be 1-50 characters long` }).regex(/^[a-z-]+$/, {
-    error: `${valueLabel} can only contain lowercase letters (a-z) and hyphens (-)`
-  });
-};
-var makeLabelSetVersionSchema = (valueLabel) => {
-  return import_v42.z.coerce.number({ error: `${valueLabel} must be an integer.` }).pipe(makeNonNegativeIntegerSchema(valueLabel));
-};
 var makeFullyPinnedLabelSetSchema = (valueLabel = "Label set") => {
   let valueLabelLabelSetId = valueLabel;
   let valueLabelLabelSetVersion = valueLabel;
@@ -897,21 +941,19 @@ var makeFullyPinnedLabelSetSchema = (valueLabel = "Label set") => {
     valueLabelLabelSetId = `${valueLabel}.labelSetId`;
     valueLabelLabelSetVersion = `${valueLabel}.labelSetVersion`;
   }
-  return import_v42.z.object({
+  return import_v43.z.object({
     labelSetId: makeLabelSetIdSchema(valueLabelLabelSetId),
     labelSetVersion: makeLabelSetVersionSchema(valueLabelLabelSetVersion)
   });
 };
-var makeNonEmptyStringSchema = (valueLabel = "Value") => import_v42.z.string().nonempty({ error: `${valueLabel} must be a non-empty string.` });
-var makeEnsIndexerVersionInfoSchema = (valueLabel = "Value") => import_v42.z.strictObject(
+var makeNonEmptyStringSchema = (valueLabel = "Value") => import_v43.z.string().nonempty({ error: `${valueLabel} must be a non-empty string.` });
+var makeEnsIndexerVersionInfoSchema = (valueLabel = "Value") => import_v43.z.object(
   {
     nodejs: makeNonEmptyStringSchema(),
     ponder: makeNonEmptyStringSchema(),
     ensDb: makeNonEmptyStringSchema(),
     ensIndexer: makeNonEmptyStringSchema(),
-    ensNormalize: makeNonEmptyStringSchema(),
-    ensRainbow: makeNonEmptyStringSchema(),
-    ensRainbowSchema: makePositiveIntegerSchema()
+    ensNormalize: makeNonEmptyStringSchema()
   },
   {
     error: `${valueLabel} must be a valid ENSIndexerVersionInfo object.`
@@ -927,26 +969,46 @@ function invariant_isSubgraphCompatibleRequirements(ctx) {
     });
   }
 }
-var makeEnsIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") => import_v42.z.object({
-  labelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.labelSet`),
+function invariant_ensRainbowSupportedLabelSetAndVersion(ctx) {
+  const clientLabelSet = ctx.value.labelSet;
+  const serverLabelSet = ctx.value.ensRainbowPublicConfig.labelSet;
+  try {
+    validateSupportedLabelSetAndVersion(serverLabelSet, clientLabelSet);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `The ENSRainbow label set and version specified in the config are not supported by the ENSRainbow version specified in ensRainbowPublicConfig. Cause: ${errorMessage}`
+    });
+  }
+}
+var makeEnsIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") => import_v43.z.object({
+  databaseSchemaName: makeDatabaseSchemaNameSchema(`${valueLabel}.databaseSchemaName`),
+  ensRainbowPublicConfig: makeEnsRainbowPublicConfigSchema(
+    `${valueLabel}.ensRainbowPublicConfig`
+  ),
   indexedChainIds: makeIndexedChainIdsSchema(`${valueLabel}.indexedChainIds`),
-  isSubgraphCompatible: import_v42.z.boolean({
+  isSubgraphCompatible: import_v43.z.boolean({
     error: `${valueLabel}.isSubgraphCompatible must be a boolean value.`
   }),
+  labelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.labelSet`),
   namespace: makeENSNamespaceIdSchema(`${valueLabel}.namespace`),
   plugins: makePluginsListSchema(`${valueLabel}.plugins`),
-  databaseSchemaName: makeDatabaseSchemaNameSchema(`${valueLabel}.databaseSchemaName`),
   versionInfo: makeEnsIndexerVersionInfoSchema(`${valueLabel}.versionInfo`)
-}).check(invariant_isSubgraphCompatibleRequirements);
-var makeSerializedEnsIndexerPublicConfigSchema = (valueLabel = "Serialized ENSIndexerPublicConfig") => import_v42.z.object({
-  labelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.labelSet`),
+}).check(invariant_isSubgraphCompatibleRequirements).check(invariant_ensRainbowSupportedLabelSetAndVersion);
+var makeSerializedEnsIndexerPublicConfigSchema = (valueLabel = "Serialized ENSIndexerPublicConfig") => import_v43.z.object({
+  databaseSchemaName: makeDatabaseSchemaNameSchema(`${valueLabel}.databaseSchemaName`),
+  ensRainbowPublicConfig: makeEnsRainbowPublicConfigSchema(
+    `${valueLabel}.ensRainbowPublicConfig`
+  ),
   indexedChainIds: makeSerializedIndexedChainIdsSchema(`${valueLabel}.indexedChainIds`),
-  isSubgraphCompatible: import_v42.z.boolean({
+  isSubgraphCompatible: import_v43.z.boolean({
     error: `${valueLabel}.isSubgraphCompatible must be a boolean value.`
   }),
+  labelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.labelSet`),
   namespace: makeENSNamespaceIdSchema(`${valueLabel}.namespace`),
   plugins: makePluginsListSchema(`${valueLabel}.plugins`),
-  databaseSchemaName: makeDatabaseSchemaNameSchema(`${valueLabel}.databaseSchemaName`),
   versionInfo: makeEnsIndexerVersionInfoSchema(`${valueLabel}.versionInfo`)
 });
 
@@ -961,7 +1023,7 @@ function deserializeEnsIndexerPublicConfig(maybePublicConfig, valueLabel) {
   const parsed = makeSerializedEnsIndexerPublicConfigSchema(valueLabel).transform(buildUnvalidatedEnsIndexerPublicConfig).pipe(makeEnsIndexerPublicConfigSchema(valueLabel)).safeParse(maybePublicConfig);
   if (parsed.error) {
     throw new Error(`Cannot deserialize EnsIndexerPublicConfig:
-${(0, import_v43.prettifyError)(parsed.error)}
+${(0, import_v44.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -969,22 +1031,22 @@ ${(0, import_v43.prettifyError)(parsed.error)}
 var deserializeENSIndexerPublicConfig = deserializeEnsIndexerPublicConfig;
 
 // src/ensapi/config/zod-schemas.ts
-var import_v45 = require("zod/v4");
+var import_v46 = require("zod/v4");
 
 // src/shared/config/thegraph.ts
-var import_v44 = require("zod/v4");
-var TheGraphCannotFallbackReasonSchema = import_v44.z.enum({
+var import_v45 = require("zod/v4");
+var TheGraphCannotFallbackReasonSchema = import_v45.z.enum({
   NotSubgraphCompatible: "not-subgraph-compatible",
   NoApiKey: "no-api-key",
   NoSubgraphUrl: "no-subgraph-url"
 });
-var TheGraphFallbackSchema = import_v44.z.discriminatedUnion("canFallback", [
-  import_v44.z.strictObject({
-    canFallback: import_v44.z.literal(true),
-    url: import_v44.z.string()
+var TheGraphFallbackSchema = import_v45.z.discriminatedUnion("canFallback", [
+  import_v45.z.strictObject({
+    canFallback: import_v45.z.literal(true),
+    url: import_v45.z.string()
   }),
-  import_v44.z.strictObject({
-    canFallback: import_v44.z.literal(false),
+  import_v45.z.strictObject({
+    canFallback: import_v45.z.literal(false),
     reason: TheGraphCannotFallbackReasonSchema
   })
 ]);
@@ -992,8 +1054,8 @@ var TheGraphFallbackSchema = import_v44.z.discriminatedUnion("canFallback", [
 // src/ensapi/config/zod-schemas.ts
 function makeEnsApiPublicConfigSchema(valueLabel) {
   const label = valueLabel ?? "ENSApiPublicConfig";
-  return import_v45.z.object({
-    version: import_v45.z.string().min(1, `${label}.version must be a non-empty string`),
+  return import_v46.z.object({
+    version: import_v46.z.string().min(1, `${label}.version must be a non-empty string`),
     theGraphFallback: TheGraphFallbackSchema,
     ensIndexerPublicConfig: makeEnsIndexerPublicConfigSchema(`${label}.ensIndexerPublicConfig`)
   });
@@ -1001,8 +1063,8 @@ function makeEnsApiPublicConfigSchema(valueLabel) {
 var makeENSApiPublicConfigSchema = makeEnsApiPublicConfigSchema;
 function makeSerializedEnsApiPublicConfigSchema(valueLabel) {
   const label = valueLabel ?? "ENSApiPublicConfig";
-  return import_v45.z.object({
-    version: import_v45.z.string().min(1, `${label}.version must be a non-empty string`),
+  return import_v46.z.object({
+    version: import_v46.z.string().min(1, `${label}.version must be a non-empty string`),
     theGraphFallback: TheGraphFallbackSchema,
     ensIndexerPublicConfig: makeSerializedEnsIndexerPublicConfigSchema(
       `${label}.ensIndexerPublicConfig`
@@ -1023,7 +1085,7 @@ function deserializeEnsApiPublicConfig(maybePublicConfig, valueLabel) {
   const parsed = makeSerializedEnsApiPublicConfigSchema(valueLabel).transform(buildUnvalidatedEnsApiPublicConfig).pipe(makeEnsApiPublicConfigSchema(valueLabel)).safeParse(maybePublicConfig);
   if (parsed.error) {
     throw new Error(`Cannot deserialize EnsApiPublicConfig:
-${(0, import_v46.prettifyError)(parsed.error)}
+${(0, import_v47.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -1042,19 +1104,21 @@ function serializeIndexedChainIds(indexedChainIds) {
 }
 function serializeEnsIndexerPublicConfig(config) {
   const {
-    labelSet,
-    indexedChainIds,
     databaseSchemaName,
+    ensRainbowPublicConfig,
+    indexedChainIds,
     isSubgraphCompatible: isSubgraphCompatible2,
+    labelSet,
     namespace,
     plugins,
     versionInfo
   } = config;
   return {
-    labelSet,
-    indexedChainIds: serializeIndexedChainIds(indexedChainIds),
     databaseSchemaName,
+    ensRainbowPublicConfig,
+    indexedChainIds: serializeIndexedChainIds(indexedChainIds),
     isSubgraphCompatible: isSubgraphCompatible2,
+    labelSet,
     namespace,
     plugins,
     versionInfo
@@ -1080,16 +1144,16 @@ function serializeEnsApiConfigResponse(response) {
 var serializeConfigResponse = serializeEnsApiConfigResponse;
 
 // src/ensapi/api/indexing-status/deserialize.ts
-var import_v417 = require("zod/v4");
+var import_v418 = require("zod/v4");
 
 // src/indexing-status/deserialize/realtime-indexing-status-projection.ts
-var import_v415 = require("zod/v4");
+var import_v416 = require("zod/v4");
 
 // src/indexing-status/zod-schema/realtime-indexing-status-projection.ts
-var import_v412 = require("zod/v4");
+var import_v413 = require("zod/v4");
 
 // src/indexing-status/zod-schema/cross-chain-indexing-status-snapshot.ts
-var import_v411 = require("zod/v4");
+var import_v412 = require("zod/v4");
 
 // src/shared/block-ref.ts
 function isBefore(blockA, blockB) {
@@ -1269,13 +1333,13 @@ function sortChainStatusesByStartBlockAsc(chains) {
 }
 
 // src/indexing-status/validate/cross-chain-indexing-status-snapshot.ts
-var import_v47 = require("zod/v4");
+var import_v48 = require("zod/v4");
 function validateCrossChainIndexingStatusSnapshot(unvalidatedSnapshot, valueLabel) {
   const schema = makeCrossChainIndexingStatusSnapshotSchema(valueLabel);
   const parsed = schema.safeParse(unvalidatedSnapshot);
   if (parsed.error) {
     throw new Error(`Invalid CrossChainIndexingStatusSnapshot:
-${(0, import_v47.prettifyError)(parsed.error)}
+${(0, import_v48.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -1319,16 +1383,16 @@ function buildCrossChainIndexingStatusSnapshotOmnichain(omnichainSnapshot, snaps
 }
 
 // src/indexing-status/zod-schema/omnichain-indexing-status-snapshot.ts
-var import_v410 = require("zod/v4");
+var import_v411 = require("zod/v4");
 
 // src/indexing-status/validate/omnichain-indexing-status-snapshot.ts
-var import_v48 = require("zod/v4");
+var import_v49 = require("zod/v4");
 function validateOmnichainIndexingStatusSnapshot(unvalidatedSnapshot, valueLabel) {
   const schema = makeOmnichainIndexingStatusSnapshotSchema(valueLabel);
   const parsed = schema.safeParse(unvalidatedSnapshot);
   if (parsed.error) {
     throw new Error(`Invalid OmnichainIndexingStatusSnapshot:
-${(0, import_v48.prettifyError)(parsed.error)}
+${(0, import_v49.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -1458,7 +1522,7 @@ function buildOmnichainIndexingStatusSnapshot(chainStatusSnapshots) {
 }
 
 // src/indexing-status/zod-schema/chain-indexing-status-snapshot.ts
-var import_v49 = require("zod/v4");
+var import_v410 = require("zod/v4");
 function invariant_chainSnapshotQueuedBlocks(ctx) {
   const { config } = ctx.value;
   if (config.rangeType === RangeTypeIds.LeftBounded) {
@@ -1533,29 +1597,29 @@ function invariant_chainSnapshotFollowingBlocks(ctx) {
     });
   }
 }
-var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => import_v49.z.object({
-  chainStatus: import_v49.z.literal(ChainIndexingStatusIds.Queued),
-  config: import_v49.z.discriminatedUnion("rangeType", [
-    import_v49.z.object({
-      rangeType: import_v49.z.literal(RangeTypeIds.LeftBounded),
+var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => import_v410.z.object({
+  chainStatus: import_v410.z.literal(ChainIndexingStatusIds.Queued),
+  config: import_v410.z.discriminatedUnion("rangeType", [
+    import_v410.z.object({
+      rangeType: import_v410.z.literal(RangeTypeIds.LeftBounded),
       startBlock: makeBlockRefSchema(valueLabel)
     }),
-    import_v49.z.object({
-      rangeType: import_v49.z.literal(RangeTypeIds.Bounded),
+    import_v410.z.object({
+      rangeType: import_v410.z.literal(RangeTypeIds.Bounded),
       startBlock: makeBlockRefSchema(valueLabel),
       endBlock: makeBlockRefSchema(valueLabel)
     })
   ])
 }).check(invariant_chainSnapshotQueuedBlocks);
-var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => import_v49.z.object({
-  chainStatus: import_v49.z.literal(ChainIndexingStatusIds.Backfill),
-  config: import_v49.z.discriminatedUnion("rangeType", [
-    import_v49.z.object({
-      rangeType: import_v49.z.literal(RangeTypeIds.LeftBounded),
+var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => import_v410.z.object({
+  chainStatus: import_v410.z.literal(ChainIndexingStatusIds.Backfill),
+  config: import_v410.z.discriminatedUnion("rangeType", [
+    import_v410.z.object({
+      rangeType: import_v410.z.literal(RangeTypeIds.LeftBounded),
       startBlock: makeBlockRefSchema(valueLabel)
     }),
-    import_v49.z.object({
-      rangeType: import_v49.z.literal(RangeTypeIds.Bounded),
+    import_v410.z.object({
+      rangeType: import_v410.z.literal(RangeTypeIds.Bounded),
       startBlock: makeBlockRefSchema(valueLabel),
       endBlock: makeBlockRefSchema(valueLabel)
     })
@@ -1563,25 +1627,25 @@ var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => im
   latestIndexedBlock: makeBlockRefSchema(valueLabel),
   backfillEndBlock: makeBlockRefSchema(valueLabel)
 }).check(invariant_chainSnapshotBackfillBlocks);
-var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => import_v49.z.object({
-  chainStatus: import_v49.z.literal(ChainIndexingStatusIds.Completed),
-  config: import_v49.z.object({
-    rangeType: import_v49.z.literal(RangeTypeIds.Bounded),
+var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => import_v410.z.object({
+  chainStatus: import_v410.z.literal(ChainIndexingStatusIds.Completed),
+  config: import_v410.z.object({
+    rangeType: import_v410.z.literal(RangeTypeIds.Bounded),
     startBlock: makeBlockRefSchema(valueLabel),
     endBlock: makeBlockRefSchema(valueLabel)
   }),
   latestIndexedBlock: makeBlockRefSchema(valueLabel)
 }).check(invariant_chainSnapshotCompletedBlocks);
-var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => import_v49.z.object({
-  chainStatus: import_v49.z.literal(ChainIndexingStatusIds.Following),
-  config: import_v49.z.object({
-    rangeType: import_v49.z.literal(RangeTypeIds.LeftBounded),
+var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => import_v410.z.object({
+  chainStatus: import_v410.z.literal(ChainIndexingStatusIds.Following),
+  config: import_v410.z.object({
+    rangeType: import_v410.z.literal(RangeTypeIds.LeftBounded),
     startBlock: makeBlockRefSchema(valueLabel)
   }),
   latestIndexedBlock: makeBlockRefSchema(valueLabel),
   latestKnownBlock: makeBlockRefSchema(valueLabel)
 }).check(invariant_chainSnapshotFollowingBlocks);
-var makeChainIndexingStatusSnapshotSchema = (valueLabel = "Value") => import_v49.z.discriminatedUnion("chainStatus", [
+var makeChainIndexingStatusSnapshotSchema = (valueLabel = "Value") => import_v410.z.discriminatedUnion("chainStatus", [
   makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
   makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
   makeChainIndexingStatusSnapshotCompletedSchema(valueLabel),
@@ -1710,11 +1774,11 @@ function invariant_omnichainStatusSnapshotFollowingHasValidChains(ctx) {
     });
   }
 }
-var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_v410.z.object({
-  omnichainStatus: import_v410.z.literal(OmnichainIndexingStatusIds.Unstarted),
-  chains: import_v410.z.map(
+var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_v411.z.object({
+  omnichainStatus: import_v411.z.literal(OmnichainIndexingStatusIds.Unstarted),
+  chains: import_v411.z.map(
     makeChainIdSchema(),
-    import_v410.z.discriminatedUnion("chainStatus", [
+    import_v411.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotQueuedSchema(valueLabel)
     ]),
     {
@@ -1723,11 +1787,11 @@ var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 }).check(invariant_omnichainSnapshotUnstartedHasValidChains);
-var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => import_v410.z.object({
-  omnichainStatus: import_v410.z.literal(OmnichainIndexingStatusIds.Backfill),
-  chains: import_v410.z.map(
+var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => import_v411.z.object({
+  omnichainStatus: import_v411.z.literal(OmnichainIndexingStatusIds.Backfill),
+  chains: import_v411.z.map(
     makeChainIdSchema(),
-    import_v410.z.discriminatedUnion("chainStatus", [
+    import_v411.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
       makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
       makeChainIndexingStatusSnapshotCompletedSchema(valueLabel)
@@ -1738,11 +1802,11 @@ var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => import_v
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 }).check(invariant_omnichainStatusSnapshotBackfillHasValidChains);
-var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => import_v410.z.object({
-  omnichainStatus: import_v410.z.literal(OmnichainIndexingStatusIds.Completed),
-  chains: import_v410.z.map(
+var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => import_v411.z.object({
+  omnichainStatus: import_v411.z.literal(OmnichainIndexingStatusIds.Completed),
+  chains: import_v411.z.map(
     makeChainIdSchema(),
-    import_v410.z.discriminatedUnion("chainStatus", [
+    import_v411.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotCompletedSchema(valueLabel)
     ]),
     {
@@ -1751,11 +1815,11 @@ var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => import_
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 }).check(invariant_omnichainStatusSnapshotCompletedHasValidChains);
-var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => import_v410.z.object({
-  omnichainStatus: import_v410.z.literal(OmnichainIndexingStatusIds.Following),
-  chains: import_v410.z.map(
+var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => import_v411.z.object({
+  omnichainStatus: import_v411.z.literal(OmnichainIndexingStatusIds.Following),
+  chains: import_v411.z.map(
     makeChainIdSchema(),
-    import_v410.z.discriminatedUnion("chainStatus", [
+    import_v411.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
       makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
       makeChainIndexingStatusSnapshotFollowingSchema(valueLabel),
@@ -1767,7 +1831,7 @@ var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => import_
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 }).check(invariant_omnichainStatusSnapshotFollowingHasValidChains);
-var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => import_v410.z.discriminatedUnion("omnichainStatus", [
+var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => import_v411.z.discriminatedUnion("omnichainStatus", [
   makeOmnichainIndexingStatusSnapshotUnstartedSchema(valueLabel),
   makeOmnichainIndexingStatusSnapshotBackfillSchema(valueLabel),
   makeOmnichainIndexingStatusSnapshotCompletedSchema(valueLabel),
@@ -1775,21 +1839,21 @@ var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexin
 ]).check(invariant_omnichainSnapshotStatusIsConsistentWithChainSnapshot).check(invariant_omnichainIndexingCursorLowerThanEarliestStartBlockAcrossQueuedChains).check(
   invariant_omnichainIndexingCursorLowerThanOrEqualToLatestBackfillEndBlockAcrossBackfillChains
 ).check(invariant_omnichainIndexingCursorIsEqualToHighestLatestIndexedBlockAcrossIndexedChain);
-var makeSerializedOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_v410.z.object({
-  omnichainStatus: import_v410.z.literal(OmnichainIndexingStatusIds.Unstarted),
-  chains: import_v410.z.record(
+var makeSerializedOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_v411.z.object({
+  omnichainStatus: import_v411.z.literal(OmnichainIndexingStatusIds.Unstarted),
+  chains: import_v411.z.record(
     makeChainIdStringSchema(),
-    import_v410.z.discriminatedUnion("chainStatus", [
+    import_v411.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotQueuedSchema(valueLabel)
     ])
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeSerializedOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => import_v410.z.object({
-  omnichainStatus: import_v410.z.literal(OmnichainIndexingStatusIds.Backfill),
-  chains: import_v410.z.record(
+var makeSerializedOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => import_v411.z.object({
+  omnichainStatus: import_v411.z.literal(OmnichainIndexingStatusIds.Backfill),
+  chains: import_v411.z.record(
     makeChainIdStringSchema(),
-    import_v410.z.discriminatedUnion("chainStatus", [
+    import_v411.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
       makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
       makeChainIndexingStatusSnapshotCompletedSchema(valueLabel)
@@ -1797,21 +1861,21 @@ var makeSerializedOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) =
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeSerializedOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => import_v410.z.object({
-  omnichainStatus: import_v410.z.literal(OmnichainIndexingStatusIds.Completed),
-  chains: import_v410.z.record(
+var makeSerializedOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => import_v411.z.object({
+  omnichainStatus: import_v411.z.literal(OmnichainIndexingStatusIds.Completed),
+  chains: import_v411.z.record(
     makeChainIdStringSchema(),
-    import_v410.z.discriminatedUnion("chainStatus", [
+    import_v411.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotCompletedSchema(valueLabel)
     ])
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeSerializedOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => import_v410.z.object({
-  omnichainStatus: import_v410.z.literal(OmnichainIndexingStatusIds.Following),
-  chains: import_v410.z.record(
+var makeSerializedOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => import_v411.z.object({
+  omnichainStatus: import_v411.z.literal(OmnichainIndexingStatusIds.Following),
+  chains: import_v411.z.record(
     makeChainIdStringSchema(),
-    import_v410.z.discriminatedUnion("chainStatus", [
+    import_v411.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
       makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
       makeChainIndexingStatusSnapshotFollowingSchema(valueLabel),
@@ -1820,7 +1884,7 @@ var makeSerializedOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel)
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeSerializedOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Value") => import_v410.z.discriminatedUnion("omnichainStatus", [
+var makeSerializedOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Value") => import_v411.z.discriminatedUnion("omnichainStatus", [
   makeSerializedOmnichainIndexingStatusSnapshotUnstartedSchema(valueLabel),
   makeSerializedOmnichainIndexingStatusSnapshotBackfillSchema(valueLabel),
   makeSerializedOmnichainIndexingStatusSnapshotCompletedSchema(valueLabel),
@@ -1860,17 +1924,17 @@ function invariant_snapshotTimeIsTheHighestKnownBlockTimestamp(ctx) {
     });
   }
 }
-var makeCrossChainIndexingStatusSnapshotOmnichainSchema = (valueLabel = "Cross-chain Indexing Status Snapshot Omnichain") => import_v411.z.object({
-  strategy: import_v411.z.literal(CrossChainIndexingStrategyIds.Omnichain),
+var makeCrossChainIndexingStatusSnapshotOmnichainSchema = (valueLabel = "Cross-chain Indexing Status Snapshot Omnichain") => import_v412.z.object({
+  strategy: import_v412.z.literal(CrossChainIndexingStrategyIds.Omnichain),
   slowestChainIndexingCursor: makeUnixTimestampSchema(valueLabel),
   snapshotTime: makeUnixTimestampSchema(valueLabel),
   omnichainSnapshot: makeOmnichainIndexingStatusSnapshotSchema(valueLabel)
 }).check(invariant_slowestChainEqualsToOmnichainSnapshotTime).check(invariant_snapshotTimeIsTheHighestKnownBlockTimestamp);
-var makeCrossChainIndexingStatusSnapshotSchema = (valueLabel = "Cross-chain Indexing Status Snapshot") => import_v411.z.discriminatedUnion("strategy", [
+var makeCrossChainIndexingStatusSnapshotSchema = (valueLabel = "Cross-chain Indexing Status Snapshot") => import_v412.z.discriminatedUnion("strategy", [
   makeCrossChainIndexingStatusSnapshotOmnichainSchema(valueLabel)
 ]);
-var makeSerializedCrossChainIndexingStatusSnapshotSchema = (valueLabel = "Serialized Cross-chain Indexing Status Snapshot") => import_v411.z.object({
-  strategy: import_v411.z.enum(CrossChainIndexingStrategyIds),
+var makeSerializedCrossChainIndexingStatusSnapshotSchema = (valueLabel = "Serialized Cross-chain Indexing Status Snapshot") => import_v412.z.object({
+  strategy: import_v412.z.enum(CrossChainIndexingStrategyIds),
   slowestChainIndexingCursor: makeUnixTimestampSchema(valueLabel),
   snapshotTime: makeUnixTimestampSchema(valueLabel),
   omnichainSnapshot: makeSerializedOmnichainIndexingStatusSnapshotSchema(valueLabel)
@@ -1900,22 +1964,22 @@ function invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect(ct
     });
   }
 }
-var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => import_v412.z.object({
+var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => import_v413.z.object({
   projectedAt: makeUnixTimestampSchema(valueLabel),
   worstCaseDistance: makeDurationSchema(valueLabel),
   snapshot: makeCrossChainIndexingStatusSnapshotSchema(valueLabel)
 }).check(invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime).check(invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect);
-var makeSerializedRealtimeIndexingStatusProjectionSchema = (valueLabel = "Value") => import_v412.z.object({
+var makeSerializedRealtimeIndexingStatusProjectionSchema = (valueLabel = "Value") => import_v413.z.object({
   snapshot: makeSerializedCrossChainIndexingStatusSnapshotSchema(valueLabel),
   projectedAt: makeUnixTimestampSchema(valueLabel),
   worstCaseDistance: makeDurationSchema(valueLabel)
 });
 
 // src/indexing-status/deserialize/cross-chain-indexing-status-snapshot.ts
-var import_v414 = require("zod/v4");
+var import_v415 = require("zod/v4");
 
 // src/indexing-status/deserialize/omnichain-indexing-status-snapshot.ts
-var import_v413 = require("zod/v4");
+var import_v414 = require("zod/v4");
 function buildUnvalidatedOmnichainIndexingStatusSnapshot(serializedSnapshot) {
   const chains = /* @__PURE__ */ new Map();
   for (const [chainIdString, chainIndexingStatusSnapshot] of Object.entries(
@@ -1936,7 +2000,7 @@ function deserializeOmnichainIndexingStatusSnapshot(data, valueLabel) {
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize into OmnichainIndexingStatusSnapshot:
-${(0, import_v413.prettifyError)(parsed.error)}
+${(0, import_v414.prettifyError)(parsed.error)}
 `
     );
   }
@@ -1958,7 +2022,7 @@ function deserializeCrossChainIndexingStatusSnapshot(maybeSnapshot, valueLabel)
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize into CrossChainIndexingStatusSnapshot:
-${(0, import_v414.prettifyError)(parsed.error)}
+${(0, import_v415.prettifyError)(parsed.error)}
 `
     );
   }
@@ -1978,7 +2042,7 @@ function deserializeRealtimeIndexingStatusProjection(maybeProjection, valueLabel
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize into RealtimeIndexingStatusProjection:
-${(0, import_v415.prettifyError)(parsed.error)}
+${(0, import_v416.prettifyError)(parsed.error)}
 `
     );
   }
@@ -1999,23 +2063,23 @@ var EnsApiIndexingStatusResponseCodes = {
 var IndexingStatusResponseCodes = EnsApiIndexingStatusResponseCodes;
 
 // src/ensapi/api/indexing-status/zod-schemas.ts
-var import_v416 = require("zod/v4");
-var makeEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v416.z.strictObject({
-  responseCode: import_v416.z.literal(EnsApiIndexingStatusResponseCodes.Ok),
+var import_v417 = require("zod/v4");
+var makeEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v417.z.strictObject({
+  responseCode: import_v417.z.literal(EnsApiIndexingStatusResponseCodes.Ok),
   realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel)
 });
-var makeEnsApiIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v416.z.strictObject({
-  responseCode: import_v416.z.literal(EnsApiIndexingStatusResponseCodes.Error)
+var makeEnsApiIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v417.z.strictObject({
+  responseCode: import_v417.z.literal(EnsApiIndexingStatusResponseCodes.Error)
 });
-var makeEnsApiIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v416.z.discriminatedUnion("responseCode", [
+var makeEnsApiIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v417.z.discriminatedUnion("responseCode", [
   makeEnsApiIndexingStatusResponseOkSchema(valueLabel),
   makeEnsApiIndexingStatusResponseErrorSchema(valueLabel)
 ]);
-var makeSerializedEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => import_v416.z.strictObject({
-  responseCode: import_v416.z.literal(EnsApiIndexingStatusResponseCodes.Ok),
+var makeSerializedEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => import_v417.z.strictObject({
+  responseCode: import_v417.z.literal(EnsApiIndexingStatusResponseCodes.Ok),
   realtimeProjection: makeSerializedRealtimeIndexingStatusProjectionSchema(valueLabel)
 });
-var makeSerializedEnsApiIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => import_v416.z.discriminatedUnion("responseCode", [
+var makeSerializedEnsApiIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => import_v417.z.discriminatedUnion("responseCode", [
   makeSerializedEnsApiIndexingStatusResponseOkSchema(valueLabel),
   makeEnsApiIndexingStatusResponseErrorSchema(valueLabel)
 ]);
@@ -2037,7 +2101,7 @@ function deserializeEnsApiIndexingStatusResponse(maybeResponse) {
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize EnsApiIndexingStatusResponse:
-${(0, import_v417.prettifyError)(parsed.error)}
+${(0, import_v418.prettifyError)(parsed.error)}
 `
     );
   }
@@ -2174,11 +2238,11 @@ function serializeEnsApiIndexingStatusResponse(response) {
 var serializeIndexingStatusResponse = serializeEnsApiIndexingStatusResponse;
 
 // src/ensapi/api/name-tokens/deserialize.ts
-var import_v422 = require("zod/v4");
+var import_v423 = require("zod/v4");
 
 // src/ensapi/api/name-tokens/zod-schemas.ts
 var import_viem14 = require("viem");
-var import_v421 = require("zod/v4");
+var import_v422 = require("zod/v4");
 
 // src/tokenscope/name-token.ts
 var import_viem13 = require("viem");
@@ -2218,12 +2282,12 @@ var makeContractMatcher = (namespace, b) => (datasourceName, contractName) => {
 
 // src/tokenscope/assets.ts
 var import_viem12 = require("viem");
-var import_v419 = require("zod/v4");
+var import_v420 = require("zod/v4");
 
 // src/tokenscope/zod-schemas.ts
 var import_caip3 = require("caip");
 var import_viem11 = require("viem");
-var import_v418 = require("zod/v4");
+var import_v419 = require("zod/v4");
 
 // src/shared/types.ts
 var AssetNamespaces = {
@@ -2232,10 +2296,10 @@ var AssetNamespaces = {
 };
 
 // src/tokenscope/zod-schemas.ts
-var tokenIdSchemaSerializable = import_v418.z.string();
-var tokenIdSchemaNative = import_v418.z.preprocess(
+var tokenIdSchemaSerializable = import_v419.z.string();
+var tokenIdSchemaNative = import_v419.z.preprocess(
   (v) => typeof v === "string" ? BigInt(v) : v,
-  import_v418.z.bigint().positive()
+  import_v419.z.bigint().positive()
 );
 function makeTokenIdSchema(_valueLabel = "Token ID Schema", serializable = false) {
   if (serializable) {
@@ -2245,13 +2309,13 @@ function makeTokenIdSchema(_valueLabel = "Token ID Schema", serializable = false
   }
 }
 var makeAssetIdSchema = (valueLabel = "Asset ID Schema", serializable) => {
-  return import_v418.z.object({
-    assetNamespace: import_v418.z.enum(AssetNamespaces),
+  return import_v419.z.object({
+    assetNamespace: import_v419.z.enum(AssetNamespaces),
     contract: makeAccountIdSchema(valueLabel),
     tokenId: makeTokenIdSchema(valueLabel, serializable ?? false)
   });
 };
-var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => import_v418.z.preprocess((v) => {
+var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => import_v419.z.preprocess((v) => {
   if (typeof v === "string") {
     const result = new import_caip3.AssetId(v);
     return {
@@ -2275,20 +2339,20 @@ function invariant_nameTokenOwnershipHasNonZeroAddressOwner(ctx) {
     });
   }
 }
-var makeNameTokenOwnershipNameWrapperSchema = (valueLabel = "Name Token Ownership NameWrapper") => import_v418.z.object({
-  ownershipType: import_v418.z.literal(NameTokenOwnershipTypes.NameWrapper),
+var makeNameTokenOwnershipNameWrapperSchema = (valueLabel = "Name Token Ownership NameWrapper") => import_v419.z.object({
+  ownershipType: import_v419.z.literal(NameTokenOwnershipTypes.NameWrapper),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
-var makeNameTokenOwnershipFullyOnchainSchema = (valueLabel = "Name Token Ownership Fully Onchain") => import_v418.z.object({
-  ownershipType: import_v418.z.literal(NameTokenOwnershipTypes.FullyOnchain),
+var makeNameTokenOwnershipFullyOnchainSchema = (valueLabel = "Name Token Ownership Fully Onchain") => import_v419.z.object({
+  ownershipType: import_v419.z.literal(NameTokenOwnershipTypes.FullyOnchain),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
-var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => import_v418.z.object({
-  ownershipType: import_v418.z.literal(NameTokenOwnershipTypes.Burned),
+var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => import_v419.z.object({
+  ownershipType: import_v419.z.literal(NameTokenOwnershipTypes.Burned),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasZeroAddressOwner);
-var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => import_v418.z.object({
-  ownershipType: import_v418.z.literal(NameTokenOwnershipTypes.Unknown),
+var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => import_v419.z.object({
+  ownershipType: import_v419.z.literal(NameTokenOwnershipTypes.Unknown),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
 function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
@@ -2301,16 +2365,16 @@ function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
     });
   }
 }
-var makeNameTokenOwnershipSchema = (valueLabel = "Name Token Ownership") => import_v418.z.discriminatedUnion("ownershipType", [
+var makeNameTokenOwnershipSchema = (valueLabel = "Name Token Ownership") => import_v419.z.discriminatedUnion("ownershipType", [
   makeNameTokenOwnershipNameWrapperSchema(valueLabel),
   makeNameTokenOwnershipFullyOnchainSchema(valueLabel),
   makeNameTokenOwnershipBurnedSchema(valueLabel),
   makeNameTokenOwnershipUnknownSchema(valueLabel)
 ]);
-var makeNameTokenSchema = (valueLabel = "Name Token Schema", serializable) => import_v418.z.object({
+var makeNameTokenSchema = (valueLabel = "Name Token Schema", serializable) => import_v419.z.object({
   token: makeAssetIdSchema(`${valueLabel}.token`, serializable),
   ownership: makeNameTokenOwnershipSchema(`${valueLabel}.ownership`),
-  mintStatus: import_v418.z.enum(NFTMintStatuses)
+  mintStatus: import_v419.z.enum(NFTMintStatuses)
 });
 
 // src/tokenscope/assets.ts
@@ -2326,7 +2390,7 @@ function deserializeAssetId(maybeAssetId, valueLabel) {
   const parsed = schema.safeParse(maybeAssetId);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize AssetId:
-${(0, import_v419.prettifyError)(parsed.error)}
+${(0, import_v420.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2336,7 +2400,7 @@ function parseAssetId(maybeAssetId, valueLabel) {
   const parsed = schema.safeParse(maybeAssetId);
   if (parsed.error) {
     throw new RangeError(`Cannot parse AssetId:
-${(0, import_v419.prettifyError)(parsed.error)}
+${(0, import_v420.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2636,10 +2700,10 @@ function getNameTokenOwnership(namespaceId, name, owner) {
 }
 
 // src/ensapi/api/shared/errors/zod-schemas.ts
-var import_v420 = require("zod/v4");
-var ErrorResponseSchema = import_v420.z.object({
-  message: import_v420.z.string(),
-  details: import_v420.z.optional(import_v420.z.unknown())
+var import_v421 = require("zod/v4");
+var ErrorResponseSchema = import_v421.z.object({
+  message: import_v421.z.string(),
+  details: import_v421.z.optional(import_v421.z.unknown())
 });
 
 // src/ensapi/api/name-tokens/response.ts
@@ -2678,10 +2742,10 @@ var NameTokensResponseErrorCodes = {
 };
 
 // src/ensapi/api/name-tokens/zod-schemas.ts
-var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", serializable) => import_v421.z.object({
+var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", serializable) => import_v422.z.object({
   domainId: makeNodeSchema(`${valueLabel}.domainId`),
   name: makeReinterpretedNameSchema(valueLabel),
-  tokens: import_v421.z.array(makeNameTokenSchema(`${valueLabel}.tokens`, serializable)).nonempty(),
+  tokens: import_v422.z.array(makeNameTokenSchema(`${valueLabel}.tokens`, serializable)).nonempty(),
   expiresAt: makeUnixTimestampSchema(`${valueLabel}.expiresAt`),
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 }).check(function invariant_nameIsAssociatedWithDomainId(ctx) {
@@ -2723,32 +2787,32 @@ var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", seria
     });
   }
 });
-var makeNameTokensResponseOkSchema = (valueLabel = "Name Tokens Response OK", serializable) => import_v421.z.strictObject({
-  responseCode: import_v421.z.literal(NameTokensResponseCodes.Ok),
+var makeNameTokensResponseOkSchema = (valueLabel = "Name Tokens Response OK", serializable) => import_v422.z.strictObject({
+  responseCode: import_v422.z.literal(NameTokensResponseCodes.Ok),
   registeredNameTokens: makeRegisteredNameTokenSchema(`${valueLabel}.nameTokens`, serializable)
 });
-var makeNameTokensResponseErrorNameTokensNotIndexedSchema = (_valueLabel = "Name Tokens Response Error Name Not Indexed") => import_v421.z.strictObject({
-  responseCode: import_v421.z.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v421.z.literal(NameTokensResponseErrorCodes.NameTokensNotIndexed),
+var makeNameTokensResponseErrorNameTokensNotIndexedSchema = (_valueLabel = "Name Tokens Response Error Name Not Indexed") => import_v422.z.strictObject({
+  responseCode: import_v422.z.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v422.z.literal(NameTokensResponseErrorCodes.NameTokensNotIndexed),
   error: ErrorResponseSchema
 });
-var makeNameTokensResponseErrorEnsIndexerConfigUnsupported = (_valueLabel = "Name Tokens Response Error ENSIndexer Config Unsupported") => import_v421.z.strictObject({
-  responseCode: import_v421.z.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v421.z.literal(NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported),
+var makeNameTokensResponseErrorEnsIndexerConfigUnsupported = (_valueLabel = "Name Tokens Response Error ENSIndexer Config Unsupported") => import_v422.z.strictObject({
+  responseCode: import_v422.z.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v422.z.literal(NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported),
   error: ErrorResponseSchema
 });
-var makeNameTokensResponseErrorNameIndexingStatusUnsupported = (_valueLabel = "Name Tokens Response Error Indexing Status Unsupported") => import_v421.z.strictObject({
-  responseCode: import_v421.z.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v421.z.literal(NameTokensResponseErrorCodes.IndexingStatusUnsupported),
+var makeNameTokensResponseErrorNameIndexingStatusUnsupported = (_valueLabel = "Name Tokens Response Error Indexing Status Unsupported") => import_v422.z.strictObject({
+  responseCode: import_v422.z.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v422.z.literal(NameTokensResponseErrorCodes.IndexingStatusUnsupported),
   error: ErrorResponseSchema
 });
-var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => import_v421.z.discriminatedUnion("errorCode", [
+var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => import_v422.z.discriminatedUnion("errorCode", [
   makeNameTokensResponseErrorNameTokensNotIndexedSchema(valueLabel),
   makeNameTokensResponseErrorEnsIndexerConfigUnsupported(valueLabel),
   makeNameTokensResponseErrorNameIndexingStatusUnsupported(valueLabel)
 ]);
 var makeNameTokensResponseSchema = (valueLabel = "Name Tokens Response", serializable) => {
-  return import_v421.z.discriminatedUnion("responseCode", [
+  return import_v422.z.discriminatedUnion("responseCode", [
     makeNameTokensResponseOkSchema(valueLabel, serializable ?? false),
     makeNameTokensResponseErrorSchema(valueLabel)
   ]);
@@ -2761,7 +2825,7 @@ function deserializedNameTokensResponse(maybeResponse) {
   );
   if (parsed.error) {
     throw new Error(`Cannot deserialize NameTokensResponse:
-${(0, import_v422.prettifyError)(parsed.error)}
+${(0, import_v423.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2835,14 +2899,14 @@ function serializeNameTokensResponse(response) {
 }
 
 // src/ensapi/api/registrar-actions/deserialize.ts
-var import_v426 = require("zod/v4");
+var import_v427 = require("zod/v4");
 
 // src/ensapi/api/registrar-actions/zod-schemas.ts
 var import_ens7 = require("viem/ens");
-var import_v425 = require("zod/v4");
+var import_v426 = require("zod/v4");
 
 // src/registrars/zod-schemas.ts
-var import_v423 = require("zod/v4");
+var import_v424 = require("zod/v4");
 
 // src/registrars/encoded-referrer.ts
 var import_viem15 = require("viem");
@@ -2917,11 +2981,11 @@ function serializeRegistrarAction(registrarAction) {
 }
 
 // src/registrars/zod-schemas.ts
-var makeSubregistrySchema = (valueLabel = "Subregistry") => import_v423.z.object({
+var makeSubregistrySchema = (valueLabel = "Subregistry") => import_v424.z.object({
   subregistryId: makeAccountIdSchema(`${valueLabel} Subregistry ID`),
   node: makeNodeSchema(`${valueLabel} Node`)
 });
-var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => import_v423.z.object({
+var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => import_v424.z.object({
   subregistry: makeSubregistrySchema(`${valueLabel} Subregistry`),
   node: makeNodeSchema(`${valueLabel} Node`),
   expiresAt: makeUnixTimestampSchema(`${valueLabel} Expires at`)
@@ -2937,18 +3001,18 @@ function invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium(ctx) {
     });
   }
 }
-var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => import_v423.z.union([
+var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => import_v424.z.union([
   // pricing available
-  import_v423.z.object({
+  import_v424.z.object({
     baseCost: makePriceEthSchema(`${valueLabel} Base Cost`),
     premium: makePriceEthSchema(`${valueLabel} Premium`),
     total: makePriceEthSchema(`${valueLabel} Total`)
   }).check(invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium).transform((v) => v),
   // pricing unknown
-  import_v423.z.object({
-    baseCost: import_v423.z.null(),
-    premium: import_v423.z.null(),
-    total: import_v423.z.null()
+  import_v424.z.object({
+    baseCost: import_v424.z.null(),
+    premium: import_v424.z.null(),
+    total: import_v424.z.null()
   }).transform((v) => v)
 ]);
 function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
@@ -2971,9 +3035,9 @@ function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
     });
   }
 }
-var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => import_v423.z.union([
+var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => import_v424.z.union([
   // referral available
-  import_v423.z.object({
+  import_v424.z.object({
     encodedReferrer: makeHexStringSchema(
       { bytesCount: ENCODED_REFERRER_BYTE_LENGTH },
       `${valueLabel} Encoded Referrer`
@@ -2981,9 +3045,9 @@ var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral
     decodedReferrer: makeLowercaseAddressSchema(`${valueLabel} Decoded Referrer`)
   }).check(invariant_registrarActionDecodedReferrerBasedOnRawReferrer),
   // referral not applicable
-  import_v423.z.object({
-    encodedReferrer: import_v423.z.null(),
-    decodedReferrer: import_v423.z.null()
+  import_v424.z.object({
+    encodedReferrer: import_v424.z.null(),
+    decodedReferrer: import_v424.z.null()
   })
 ]);
 function invariant_eventIdsInitialElementIsTheActionId(ctx) {
@@ -2996,9 +3060,9 @@ function invariant_eventIdsInitialElementIsTheActionId(ctx) {
     });
   }
 }
-var EventIdSchema = import_v423.z.string().nonempty();
-var EventIdsSchema = import_v423.z.array(EventIdSchema).min(1).transform((v) => v);
-var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => import_v423.z.object({
+var EventIdSchema = import_v424.z.string().nonempty();
+var EventIdsSchema = import_v424.z.array(EventIdSchema).min(1).transform((v) => v);
+var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => import_v424.z.object({
   id: EventIdSchema,
   incrementalDuration: makeDurationSchema(`${valueLabel} Incremental Duration`),
   registrant: makeLowercaseAddressSchema(`${valueLabel} Registrant`),
@@ -3012,38 +3076,38 @@ var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => im
   eventIds: EventIdsSchema
 }).check(invariant_eventIdsInitialElementIsTheActionId);
 var makeRegistrarActionRegistrationSchema = (valueLabel = "Registration ") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: import_v423.z.literal(RegistrarActionTypes.Registration)
+  type: import_v424.z.literal(RegistrarActionTypes.Registration)
 });
 var makeRegistrarActionRenewalSchema = (valueLabel = "Renewal") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: import_v423.z.literal(RegistrarActionTypes.Renewal)
+  type: import_v424.z.literal(RegistrarActionTypes.Renewal)
 });
-var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => import_v423.z.discriminatedUnion("type", [
+var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => import_v424.z.discriminatedUnion("type", [
   makeRegistrarActionRegistrationSchema(`${valueLabel} Registration`),
   makeRegistrarActionRenewalSchema(`${valueLabel} Renewal`)
 ]);
 
 // src/ensapi/api/shared/pagination/zod-schemas.ts
-var import_v424 = require("zod/v4");
+var import_v425 = require("zod/v4");
 
 // src/ensapi/api/shared/pagination/request.ts
 var RECORDS_PER_PAGE_DEFAULT = 10;
 var RECORDS_PER_PAGE_MAX = 100;
 
 // src/ensapi/api/shared/pagination/zod-schemas.ts
-var makeRequestPageParamsSchema = (valueLabel = "RequestPageParams") => import_v424.z.object({
+var makeRequestPageParamsSchema = (valueLabel = "RequestPageParams") => import_v425.z.object({
   page: makePositiveIntegerSchema(`${valueLabel}.page`),
   recordsPerPage: makePositiveIntegerSchema(`${valueLabel}.recordsPerPage`).max(
     RECORDS_PER_PAGE_MAX,
     `${valueLabel}.recordsPerPage must not exceed ${RECORDS_PER_PAGE_MAX}`
   )
 });
-var makeResponsePageContextSchemaWithNoRecords = (valueLabel = "ResponsePageContextWithNoRecords") => import_v424.z.object({
-  totalRecords: import_v424.z.literal(0),
-  totalPages: import_v424.z.literal(1),
-  hasNext: import_v424.z.literal(false),
-  hasPrev: import_v424.z.literal(false),
-  startIndex: import_v424.z.undefined(),
-  endIndex: import_v424.z.undefined()
+var makeResponsePageContextSchemaWithNoRecords = (valueLabel = "ResponsePageContextWithNoRecords") => import_v425.z.object({
+  totalRecords: import_v425.z.literal(0),
+  totalPages: import_v425.z.literal(1),
+  hasNext: import_v425.z.literal(false),
+  hasPrev: import_v425.z.literal(false),
+  startIndex: import_v425.z.undefined(),
+  endIndex: import_v425.z.undefined()
 }).extend(makeRequestPageParamsSchema(valueLabel).shape);
 function invariant_responsePageWithRecordsIsCorrect(ctx) {
   const { hasNext, hasPrev, recordsPerPage, page, totalRecords, startIndex, endIndex } = ctx.value;
@@ -3078,15 +3142,15 @@ function invariant_responsePageWithRecordsIsCorrect(ctx) {
     });
   }
 }
-var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => import_v424.z.object({
+var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => import_v425.z.object({
   totalRecords: makePositiveIntegerSchema(`${valueLabel}.totalRecords`),
   totalPages: makePositiveIntegerSchema(`${valueLabel}.totalPages`),
-  hasNext: import_v424.z.boolean(),
-  hasPrev: import_v424.z.boolean(),
+  hasNext: import_v425.z.boolean(),
+  hasPrev: import_v425.z.boolean(),
   startIndex: makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`),
   endIndex: makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`)
 }).extend(makeRequestPageParamsSchema(valueLabel).shape).check(invariant_responsePageWithRecordsIsCorrect);
-var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => import_v424.z.union([
+var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => import_v425.z.union([
   makeResponsePageContextSchemaWithNoRecords(valueLabel),
   makeResponsePageContextSchemaWithRecords(valueLabel)
 ]);
@@ -3116,21 +3180,21 @@ function invariant_registrationLifecycleNodeMatchesName(ctx) {
     });
   }
 }
-var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => import_v425.z.object({
+var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => import_v426.z.object({
   action: makeRegistrarActionSchema(valueLabel),
   name: makeReinterpretedNameSchema(valueLabel)
 }).check(invariant_registrationLifecycleNodeMatchesName);
-var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => import_v425.z.object({
-  responseCode: import_v425.z.literal(RegistrarActionsResponseCodes.Ok),
-  registrarActions: import_v425.z.array(makeNamedRegistrarActionSchema(valueLabel)),
+var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => import_v426.z.object({
+  responseCode: import_v426.z.literal(RegistrarActionsResponseCodes.Ok),
+  registrarActions: import_v426.z.array(makeNamedRegistrarActionSchema(valueLabel)),
   pageContext: makeResponsePageContextSchema(`${valueLabel}.pageContext`),
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`).optional()
 });
-var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => import_v425.z.strictObject({
-  responseCode: import_v425.z.literal(RegistrarActionsResponseCodes.Error),
+var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => import_v426.z.strictObject({
+  responseCode: import_v426.z.literal(RegistrarActionsResponseCodes.Error),
   error: ErrorResponseSchema
 });
-var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => import_v425.z.discriminatedUnion("responseCode", [
+var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => import_v426.z.discriminatedUnion("responseCode", [
   makeRegistrarActionsResponseOkSchema(valueLabel),
   makeRegistrarActionsResponseErrorSchema(valueLabel)
 ]);
@@ -3141,7 +3205,7 @@ function deserializeRegistrarActionsResponse(maybeResponse) {
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize RegistrarActionsResponse:
-${(0, import_v426.prettifyError)(parsed.error)}
+${(0, import_v427.prettifyError)(parsed.error)}
 `
     );
   }
@@ -3270,12 +3334,12 @@ function serializeRegistrarActionsResponse(response) {
 }
 
 // src/ensapi/api/shared/errors/deserialize.ts
-var import_v427 = require("zod/v4");
+var import_v428 = require("zod/v4");
 function deserializeErrorResponse(maybeErrorResponse) {
   const parsed = ErrorResponseSchema.safeParse(maybeErrorResponse);
   if (parsed.error) {
     throw new Error(`Cannot deserialize ErrorResponse:
-${(0, import_v427.prettifyError)(parsed.error)}
+${(0, import_v428.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -3835,7 +3899,7 @@ function serializeEnsIndexerConfigResponse(response) {
 }
 
 // src/ensindexer/api/indexing-status/deserialize.ts
-var import_v429 = require("zod/v4");
+var import_v430 = require("zod/v4");
 
 // src/ensindexer/api/indexing-status/response.ts
 var EnsIndexerIndexingStatusResponseCodes = {
@@ -3850,23 +3914,23 @@ var EnsIndexerIndexingStatusResponseCodes = {
 };
 
 // src/ensindexer/api/indexing-status/zod-schemas.ts
-var import_v428 = require("zod/v4");
-var makeEnsIndexerIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v428.z.strictObject({
-  responseCode: import_v428.z.literal(EnsIndexerIndexingStatusResponseCodes.Ok),
+var import_v429 = require("zod/v4");
+var makeEnsIndexerIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v429.z.strictObject({
+  responseCode: import_v429.z.literal(EnsIndexerIndexingStatusResponseCodes.Ok),
   realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel)
 });
-var makeEnsIndexerIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v428.z.strictObject({
-  responseCode: import_v428.z.literal(EnsIndexerIndexingStatusResponseCodes.Error)
+var makeEnsIndexerIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v429.z.strictObject({
+  responseCode: import_v429.z.literal(EnsIndexerIndexingStatusResponseCodes.Error)
 });
-var makeEnsIndexerIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v428.z.discriminatedUnion("responseCode", [
+var makeEnsIndexerIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v429.z.discriminatedUnion("responseCode", [
   makeEnsIndexerIndexingStatusResponseOkSchema(valueLabel),
   makeEnsIndexerIndexingStatusResponseErrorSchema(valueLabel)
 ]);
-var makeSerializedEnsIndexerIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => import_v428.z.strictObject({
-  responseCode: import_v428.z.literal(EnsIndexerIndexingStatusResponseCodes.Ok),
+var makeSerializedEnsIndexerIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => import_v429.z.strictObject({
+  responseCode: import_v429.z.literal(EnsIndexerIndexingStatusResponseCodes.Ok),
   realtimeProjection: makeSerializedRealtimeIndexingStatusProjectionSchema(valueLabel)
 });
-var makeSerializedEnsIndexerIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => import_v428.z.discriminatedUnion("responseCode", [
+var makeSerializedEnsIndexerIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => import_v429.z.discriminatedUnion("responseCode", [
   makeSerializedEnsIndexerIndexingStatusResponseOkSchema(valueLabel),
   makeEnsIndexerIndexingStatusResponseErrorSchema(valueLabel)
 ]);
@@ -3888,7 +3952,7 @@ function deserializeEnsIndexerIndexingStatusResponse(maybeResponse) {
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize EnsIndexerIndexingStatusResponse:
-${(0, import_v429.prettifyError)(parsed.error)}
+${(0, import_v430.prettifyError)(parsed.error)}
 `
     );
   }
@@ -3909,13 +3973,13 @@ function serializeEnsIndexerIndexingStatusResponse(response) {
 }
 
 // src/ensindexer/api/shared/errors/deserialize.ts
-var import_v431 = require("zod/v4");
+var import_v432 = require("zod/v4");
 
 // src/ensindexer/api/shared/errors/zod-schemas.ts
-var import_v430 = require("zod/v4");
-var ErrorResponseSchema2 = import_v430.z.object({
-  message: import_v430.z.string(),
-  details: import_v430.z.optional(import_v430.z.unknown())
+var import_v431 = require("zod/v4");
+var ErrorResponseSchema2 = import_v431.z.object({
+  message: import_v431.z.string(),
+  details: import_v431.z.optional(import_v431.z.unknown())
 });
 
 // src/ensindexer/api/shared/errors/deserialize.ts
@@ -3923,7 +3987,7 @@ function deserializeErrorResponse2(maybeErrorResponse) {
   const parsed = ErrorResponseSchema2.safeParse(maybeErrorResponse);
   if (parsed.error) {
     throw new Error(`Cannot deserialize ErrorResponse:
-${(0, import_v431.prettifyError)(parsed.error)}
+${(0, import_v432.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4087,35 +4151,6 @@ function labelHashToBytes(labelHash) {
   }
 }
 
-// src/ensindexer/config/labelset-utils.ts
-function buildLabelSetId(maybeLabelSetId) {
-  return makeLabelSetIdSchema("LabelSetId").parse(maybeLabelSetId);
-}
-function buildLabelSetVersion(maybeLabelSetVersion) {
-  return makeLabelSetVersionSchema("LabelSetVersion").parse(maybeLabelSetVersion);
-}
-function buildEnsRainbowClientLabelSet(labelSetId, labelSetVersion) {
-  if (labelSetVersion !== void 0 && labelSetId === void 0) {
-    throw new Error("When a labelSetVersion is defined, labelSetId must also be defined.");
-  }
-  return { labelSetId, labelSetVersion };
-}
-function validateSupportedLabelSetAndVersion(serverSet, clientSet) {
-  if (clientSet.labelSetId === void 0) {
-    return;
-  }
-  if (serverSet.labelSetId !== clientSet.labelSetId) {
-    throw new Error(
-      `Server label set ID "${serverSet.labelSetId}" does not match client's requested label set ID "${clientSet.labelSetId}".`
-    );
-  }
-  if (clientSet.labelSetVersion !== void 0 && serverSet.highestLabelSetVersion < clientSet.labelSetVersion) {
-    throw new Error(
-      `Server highest label set version ${serverSet.highestLabelSetVersion} is less than client's requested version ${clientSet.labelSetVersion} for label set ID "${clientSet.labelSetId}".`
-    );
-  }
-}
-
 // src/ensindexer/config/parsing.ts
 function parseNonNegativeInteger(maybeNumber) {
   const trimmed = maybeNumber.trim();
@@ -4210,14 +4245,14 @@ function isResolvedIdentity(identity) {
 }
 
 // src/indexing-status/deserialize/chain-indexing-status-snapshot.ts
-var import_v432 = require("zod/v4");
+var import_v433 = require("zod/v4");
 function deserializeChainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
   const schema = makeChainIndexingStatusSnapshotSchema(valueLabel);
   const parsed = schema.safeParse(maybeSnapshot);
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize into ChainIndexingStatusSnapshot:
-${(0, import_v432.prettifyError)(parsed.error)}
+${(0, import_v433.prettifyError)(parsed.error)}
 `
     );
   }
@@ -4235,26 +4270,26 @@ function createRealtimeIndexingStatusProjection(snapshot, now) {
 }
 
 // src/indexing-status/validate/chain-indexing-status-snapshot.ts
-var import_v433 = require("zod/v4");
+var import_v434 = require("zod/v4");
 function validateChainIndexingStatusSnapshot(unvalidatedSnapshot, valueLabel) {
   const schema = makeChainIndexingStatusSnapshotSchema(valueLabel);
   const parsed = schema.safeParse(unvalidatedSnapshot);
   if (parsed.error) {
     throw new Error(`Invalid ChainIndexingStatusSnapshot:
-${(0, import_v433.prettifyError)(parsed.error)}
+${(0, import_v434.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
 }
 
 // src/indexing-status/validate/realtime-indexing-status-projection.ts
-var import_v434 = require("zod/v4");
+var import_v435 = require("zod/v4");
 function validateRealtimeIndexingStatusProjection(unvalidatedProjection, valueLabel) {
   const schema = makeRealtimeIndexingStatusProjectionSchema(valueLabel);
   const parsed = schema.safeParse(unvalidatedProjection);
   if (parsed.error) {
     throw new Error(`Invalid RealtimeIndexingStatusProjection:
-${(0, import_v434.prettifyError)(parsed.error)}
+${(0, import_v435.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4432,13 +4467,13 @@ var import_getUnixTime2 = require("date-fns/getUnixTime");
 var import_getUnixTime = require("date-fns/getUnixTime");
 
 // src/shared/deserialize.ts
-var import_v435 = __toESM(require("zod/v4"), 1);
+var import_v436 = __toESM(require("zod/v4"), 1);
 function deserializeChainId(maybeChainId, valueLabel) {
   const schema = makeChainIdStringSchema(valueLabel);
   const parsed = schema.safeParse(maybeChainId);
   if (parsed.error) {
     throw new Error(`Cannot deserialize ChainId:
-${(0, import_v435.prettifyError)(parsed.error)}
+${(0, import_v436.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4448,7 +4483,7 @@ function deserializeDatetime(maybeDatetime, valueLabel) {
   const parsed = schema.safeParse(maybeDatetime);
   if (parsed.error) {
     throw new Error(`Cannot deserialize Datetime:
-${(0, import_v435.prettifyError)(parsed.error)}
+${(0, import_v436.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4458,7 +4493,7 @@ function deserializeUnixTimestamp(maybeTimestamp, valueLabel) {
   const parsed = schema.safeParse(maybeTimestamp);
   if (parsed.error) {
     throw new Error(`Cannot deserialize Unix Timestamp:
-${(0, import_v435.prettifyError)(parsed.error)}
+${(0, import_v436.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4468,7 +4503,7 @@ function deserializeUrl(maybeUrl, valueLabel) {
   const parsed = schema.safeParse(maybeUrl);
   if (parsed.error) {
     throw new Error(`Cannot deserialize URL:
-${(0, import_v435.prettifyError)(parsed.error)}
+${(0, import_v436.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4478,7 +4513,7 @@ function deserializeBlockNumber(maybeBlockNumber, valueLabel) {
   const parsed = schema.safeParse(maybeBlockNumber);
   if (parsed.error) {
     throw new Error(`Cannot deserialize BlockNumber:
-${(0, import_v435.prettifyError)(parsed.error)}
+${(0, import_v436.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4488,17 +4523,17 @@ function deserializeBlockRef(maybeBlockRef, valueLabel) {
   const parsed = schema.safeParse(maybeBlockRef);
   if (parsed.error) {
     throw new Error(`Cannot deserialize BlockRef:
-${(0, import_v435.prettifyError)(parsed.error)}
+${(0, import_v436.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
 }
 function deserializeDuration(maybeDuration, valueLabel) {
-  const schema = import_v435.default.coerce.number().pipe(makeDurationSchema(valueLabel));
+  const schema = import_v436.default.coerce.number().pipe(makeDurationSchema(valueLabel));
   const parsed = schema.safeParse(maybeDuration);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize Duration:
-${(0, import_v435.prettifyError)(parsed.error)}
+${(0, import_v436.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4508,7 +4543,7 @@ function parseAccountId(maybeAccountId, valueLabel) {
   const parsed = schema.safeParse(maybeAccountId);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize AccountId:
-${(0, import_v435.prettifyError)(parsed.error)}
+${(0, import_v436.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4518,7 +4553,7 @@ function deserializePriceEth(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceEth:
-${(0, import_v435.prettifyError)(parsed.error)}
+${(0, import_v436.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4528,7 +4563,7 @@ function deserializePriceUsdc(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceUsdc:
-${(0, import_v435.prettifyError)(parsed.error)}
+${(0, import_v436.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4538,7 +4573,7 @@ function deserializePriceDai(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceDai:
-${(0, import_v435.prettifyError)(parsed.error)}
+${(0, import_v436.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;