@ensnode/ensnode-sdk 0.0.0-next-20260707183518 → 0.0.0-next-20260708171350

package/dist/index.cjs

@@ -287,22 +287,86 @@ var PARENT_CANNOT_CONTROL = 65536;
 var isPccFuseSet = (fuses) => (fuses & PARENT_CANNOT_CONTROL) === PARENT_CANNOT_CONTROL;
 
 // src/ensapi/config/deserialize.ts
-var import_v47 = require("zod/v4");
+var import_v43 = require("zod/v4");
+
+// src/ensapi/config/zod-schemas.ts
+var import_v42 = require("zod/v4");
+
+// src/shared/config/thegraph.ts
+var import_v4 = require("zod/v4");
+var TheGraphCannotFallbackReasonSchema = import_v4.z.enum({
+  NotSubgraphCompatible: "not-subgraph-compatible",
+  NoApiKey: "no-api-key",
+  NoSubgraphUrl: "no-subgraph-url"
+});
+var TheGraphFallbackSchema = import_v4.z.discriminatedUnion("canFallback", [
+  import_v4.z.strictObject({
+    canFallback: import_v4.z.literal(true),
+    url: import_v4.z.string()
+  }),
+  import_v4.z.strictObject({
+    canFallback: import_v4.z.literal(false),
+    reason: TheGraphCannotFallbackReasonSchema
+  })
+]);
+
+// src/ensapi/config/zod-schemas.ts
+var makeEnsApiVersionInfoSchema = (valueLabel = "ENS API version info") => import_v42.z.object({
+  commit: import_v42.z.optional(import_v42.z.string().nonempty(`${valueLabel}.commit must be a non-empty string`)),
+  ensApi: import_v42.z.string().nonempty(`${valueLabel}.ensApi must be a non-empty string`),
+  ensNormalize: import_v42.z.string().nonempty(`${valueLabel}.ensNormalize must be a non-empty string`)
+});
+function makeEnsApiPublicConfigSchema(valueLabel) {
+  const label = valueLabel ?? "ENSApiPublicConfig";
+  return import_v42.z.object({
+    theGraphFallback: TheGraphFallbackSchema,
+    versionInfo: makeEnsApiVersionInfoSchema(`${label}.versionInfo`)
+  });
+}
+var makeENSApiPublicConfigSchema = makeEnsApiPublicConfigSchema;
+function makeSerializedEnsApiPublicConfigSchema(valueLabel) {
+  const label = valueLabel ?? "ENSApiPublicConfig";
+  return import_v42.z.object({
+    theGraphFallback: TheGraphFallbackSchema,
+    versionInfo: makeEnsApiVersionInfoSchema(`${label}.versionInfo`)
+  });
+}
+
+// src/ensapi/config/deserialize.ts
+function buildUnvalidatedEnsApiPublicConfig(serializedPublicConfig) {
+  return serializedPublicConfig;
+}
+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_v43.prettifyError)(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+var deserializeENSApiPublicConfig = deserializeEnsApiPublicConfig;
+
+// src/ensapi/config/serialize.ts
+function serializeEnsApiPublicConfig(config) {
+  return config;
+}
+var serializeENSApiPublicConfig = serializeEnsApiPublicConfig;
 
 // src/ensindexer/config/deserialize.ts
-var import_v44 = require("zod/v4");
+var import_v47 = require("zod/v4");
 
 // src/ensindexer/config/zod-schemas.ts
-var import_v43 = require("zod/v4");
+var import_v46 = require("zod/v4");
 
 // src/ensrainbow/zod-schemas/config.ts
-var import_v42 = require("zod/v4");
+var import_v45 = require("zod/v4");
 
 // src/shared/zod-schemas.ts
 var import_caip = require("caip");
 var import_enssdk = require("enssdk");
 var import_viem2 = require("viem");
-var import_v4 = require("zod/v4");
+var import_v44 = require("zod/v4");
 
 // src/shared/currencies.ts
 var import_viem = require("viem");
@@ -501,7 +565,7 @@ function parseEnsTokens(value) {
 }
 
 // src/shared/zod-schemas.ts
-var makeIntegerSchema = (valueLabel = "Value") => import_v4.z.int({
+var makeIntegerSchema = (valueLabel = "Value") => import_v44.z.int({
   error: `${valueLabel} must be an integer.`
 });
 var makePositiveIntegerSchema = (valueLabel = "Value") => makeIntegerSchema(valueLabel).positive({
@@ -510,12 +574,12 @@ var makePositiveIntegerSchema = (valueLabel = "Value") => makeIntegerSchema(valu
 var makeNonNegativeIntegerSchema = (valueLabel = "Value") => makeIntegerSchema(valueLabel).nonnegative({
   error: `${valueLabel} must be a non-negative integer (>=0).`
 });
-var makeDurationSchema = (valueLabel = "Value") => import_v4.z.number({
+var makeDurationSchema = (valueLabel = "Value") => import_v44.z.number({
   error: `${valueLabel} must be a number.`
 }).pipe(makeNonNegativeIntegerSchema(valueLabel));
 var makeChainIdSchema = (valueLabel = "Chain ID") => makePositiveIntegerSchema(valueLabel).transform((val) => val);
-var makeChainIdStringSchema = (valueLabel = "Chain ID String") => import_v4.z.string({ error: `${valueLabel} must be a string representing a chain ID.` }).pipe(import_v4.z.coerce.number({ error: `${valueLabel} must represent a positive integer (>0).` })).pipe(makeChainIdSchema(`The numeric value represented by ${valueLabel}`));
-var makeNormalizedAddressSchema = (valueLabel = "EVM address") => import_v4.z.string().check((ctx) => {
+var makeChainIdStringSchema = (valueLabel = "Chain ID String") => import_v44.z.string({ error: `${valueLabel} must be a string representing a chain ID.` }).pipe(import_v44.z.coerce.number({ error: `${valueLabel} must represent a positive integer (>0).` })).pipe(makeChainIdSchema(`The numeric value represented by ${valueLabel}`));
+var makeNormalizedAddressSchema = (valueLabel = "EVM address") => import_v44.z.string().check((ctx) => {
   if (!(0, import_viem2.isAddress)(ctx.value, { strict: false })) {
     ctx.issues.push({
       code: "custom",
@@ -524,14 +588,14 @@ var makeNormalizedAddressSchema = (valueLabel = "EVM address") => import_v4.z.st
     });
   }
 }).transform((val) => (0, import_enssdk.toNormalizedAddress)(val));
-var makeDatetimeSchema = (valueLabel = "Datetime string") => import_v4.z.iso.datetime({ error: `${valueLabel} must be a string in ISO 8601 format.` }).transform((v) => new Date(v));
+var makeDatetimeSchema = (valueLabel = "Datetime string") => import_v44.z.iso.datetime({ error: `${valueLabel} must be a string in ISO 8601 format.` }).transform((v) => new Date(v));
 var makeUnixTimestampSchema = (valueLabel = "Timestamp") => makeIntegerSchema(valueLabel);
-var makeUrlSchema = (valueLabel = "Value") => import_v4.z.url({
+var makeUrlSchema = (valueLabel = "Value") => import_v44.z.url({
   error: `${valueLabel} must be a valid URL string (e.g., http://localhost:8080 or https://example.com).`,
   abort: true
 }).transform((v) => new URL(v));
 var makeBlockNumberSchema = (valueLabel = "Block number") => makeNonNegativeIntegerSchema(valueLabel);
-var makeBlockRefSchema = (valueLabel = "Value") => import_v4.z.strictObject(
+var makeBlockRefSchema = (valueLabel = "Value") => import_v44.z.strictObject(
   {
     timestamp: makeUnixTimestampSchema(`${valueLabel}.timestamp`),
     number: makeBlockNumberSchema(`${valueLabel}.number`)
@@ -540,19 +604,19 @@ var makeBlockRefSchema = (valueLabel = "Value") => import_v4.z.strictObject(
     error: `${valueLabel} must be a valid BlockRef object.`
   }
 );
-var makeENSNamespaceIdSchema = (valueLabel = "ENSNamespaceId") => import_v4.z.enum(import_datasources.ENSNamespaceIds, {
+var makeENSNamespaceIdSchema = (valueLabel = "ENSNamespaceId") => import_v44.z.enum(import_datasources.ENSNamespaceIds, {
   error() {
     return `Invalid ${valueLabel}. Supported ENS namespace IDs are: ${Object.keys(import_datasources.ENSNamespaceIds).join(", ")}`;
   }
 });
-var makePriceAmountSchema = (valueLabel = "Amount") => import_v4.z.coerce.bigint({
+var makePriceAmountSchema = (valueLabel = "Amount") => import_v44.z.coerce.bigint({
   error: `${valueLabel} must represent a bigint.`
 }).nonnegative({
   error: `${valueLabel} must not be negative.`
 });
-var makePriceCurrencySchema = (currency, valueLabel = "Price Currency") => import_v4.z.strictObject({
+var makePriceCurrencySchema = (currency, valueLabel = "Price Currency") => import_v44.z.strictObject({
   amount: makePriceAmountSchema(`${valueLabel} amount`),
-  currency: import_v4.z.literal(currency, {
+  currency: import_v44.z.literal(currency, {
     error: `${valueLabel} currency must be set to '${currency}'.`
   })
 });
@@ -560,18 +624,18 @@ var makePriceEthSchema = (valueLabel = "Price ETH") => makePriceCurrencySchema(C
 var makePriceUsdcSchema = (valueLabel = "Price USDC") => makePriceCurrencySchema(CurrencyIds.USDC, valueLabel).transform((v) => v);
 var makePriceDaiSchema = (valueLabel = "Price DAI") => makePriceCurrencySchema(CurrencyIds.DAI, valueLabel).transform((v) => v);
 var makePriceEnsTokensSchema = (valueLabel = "Price ENSTokens") => makePriceCurrencySchema(CurrencyIds.ENSTokens, valueLabel).transform((v) => v);
-var makeAccountIdSchema = (valueLabel = "AccountId") => import_v4.z.strictObject({
+var makeAccountIdSchema = (valueLabel = "AccountId") => import_v44.z.strictObject({
   chainId: makeChainIdSchema(`${valueLabel} chain ID`),
   address: makeNormalizedAddressSchema(`${valueLabel} address`)
 });
-var makeAccountIdStringSchema = (valueLabel = "Account ID String") => import_v4.z.coerce.string().transform((v) => {
+var makeAccountIdStringSchema = (valueLabel = "Account ID String") => import_v44.z.coerce.string().transform((v) => {
   const result = new import_caip.AccountId(v);
   return {
     chainId: Number(result.chainId.reference),
     address: result.address
   };
 }).pipe(makeAccountIdSchema(valueLabel));
-var makeHexStringSchema = (options, valueLabel = "String representation of bytes array") => import_v4.z.string().check(function invariant_isHexEncoded(ctx) {
+var makeHexStringSchema = (options, valueLabel = "String representation of bytes array") => import_v44.z.string().check(function invariant_isHexEncoded(ctx) {
   if (!(0, import_viem2.isHex)(ctx.value)) {
     ctx.issues.push({
       code: "custom",
@@ -592,7 +656,7 @@ var makeHexStringSchema = (options, valueLabel = "String representation of bytes
 });
 var makeNodeSchema = (valueLabel = "Node") => makeHexStringSchema({ bytesCount: 32 }, valueLabel);
 var makeTransactionHashSchema = (valueLabel = "Transaction hash") => makeHexStringSchema({ bytesCount: 32 }, valueLabel);
-var makeReinterpretedNameSchema = (valueLabel = "Reinterpreted Name") => import_v4.z.string().transform((v) => v).check((ctx) => {
+var makeReinterpretedNameSchema = (valueLabel = "Reinterpreted Name") => import_v44.z.string().transform((v) => v).check((ctx) => {
   try {
     (0, import_enssdk.reinterpretName)(ctx.value);
   } catch (error) {
@@ -607,24 +671,24 @@ var makeReinterpretedNameSchema = (valueLabel = "Reinterpreted Name") => import_
 
 // 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-]+$/, {
+  return import_v45.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") => makeNonNegativeIntegerSchema(valueLabel);
-var makeLabelSetVersionStringSchema = (valueLabel = "Label set version") => import_v42.z.coerce.number({ error: `${valueLabel} must be a non-negative integer` }).pipe(makeLabelSetVersionSchema(valueLabel));
-var makeEnsRainbowPublicConfigSchema = (valueLabel = "EnsRainbowPublicConfig") => import_v42.z.object({
-  serverLabelSet: import_v42.z.object({
+var makeLabelSetVersionStringSchema = (valueLabel = "Label set version") => import_v45.z.coerce.number({ error: `${valueLabel} must be a non-negative integer` }).pipe(makeLabelSetVersionSchema(valueLabel));
+var makeEnsRainbowPublicConfigSchema = (valueLabel = "EnsRainbowPublicConfig") => import_v45.z.object({
+  serverLabelSet: import_v45.z.object({
     labelSetId: makeLabelSetIdSchema(`${valueLabel}.serverLabelSet.labelSetId`),
     highestLabelSetVersion: makeLabelSetVersionSchema(
       `${valueLabel}.serverLabelSet.highestLabelSetVersion`
     )
   }),
-  versionInfo: import_v42.z.object({
-    commit: import_v42.z.optional(
-      import_v42.z.string().nonempty(`${valueLabel}.versionInfo.commit must be a non-empty string.`)
+  versionInfo: import_v45.z.object({
+    commit: import_v45.z.optional(
+      import_v45.z.string().nonempty(`${valueLabel}.versionInfo.commit must be a non-empty string.`)
     ),
-    ensRainbow: import_v42.z.string().nonempty(`${valueLabel}.versionInfo.ensRainbow must be a non-empty string.`)
+    ensRainbow: import_v45.z.string().nonempty(`${valueLabel}.versionInfo.ensRainbow must be a non-empty string.`)
   })
 });
 
@@ -657,35 +721,6 @@ function isSubgraphCompatible(config) {
   return onlySubgraphPluginActivated && labelSetIsSubgraphCompatible;
 }
 
-// src/ensindexer/config/labelset-utils.ts
-function buildLabelSetId(maybeLabelSetId) {
-  return makeLabelSetIdSchema("LabelSetId").parse(maybeLabelSetId);
-}
-function buildLabelSetVersion(maybeLabelSetVersion) {
-  return makeLabelSetVersionStringSchema("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;
@@ -699,22 +734,22 @@ function invariant_ensDbVersionIsSameAsEnsIndexerVersion(ctx) {
 }
 
 // src/ensindexer/config/zod-schemas.ts
-var makeIndexedChainIdsSchema = (valueLabel = "Indexed Chain IDs") => import_v43.z.set(makeChainIdSchema(valueLabel), { error: `${valueLabel} must be a set` }).min(1, {
+var makeIndexedChainIdsSchema = (valueLabel = "Indexed Chain IDs") => import_v46.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_v43.z.array(makeChainIdSchema(valueLabel), {
+var makeSerializedIndexedChainIdsSchema = (valueLabel = "Indexed Chain IDs") => import_v46.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_v43.z.array(import_v43.z.string(), {
+var makePluginsListSchema = (valueLabel = "Plugins") => import_v46.z.array(import_v46.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 makeEnsIndexerSchemaNameSchema = (valueLabel = "ENS Indexer Schema Name") => import_v43.z.string({ error: `${valueLabel} must be a string` }).trim().nonempty({
+var makeEnsIndexerSchemaNameSchema = (valueLabel = "ENS Indexer Schema Name") => import_v46.z.string({ error: `${valueLabel} must be a string` }).trim().nonempty({
   error: `${valueLabel} is required and must be a non-empty string.`
 });
 var makeFullyPinnedLabelSetSchema = (valueLabel = "Label set") => {
@@ -727,16 +762,16 @@ var makeFullyPinnedLabelSetSchema = (valueLabel = "Label set") => {
     valueLabelLabelSetId = `${valueLabel}.labelSetId`;
     valueLabelLabelSetVersion = `${valueLabel}.labelSetVersion`;
   }
-  return import_v43.z.object({
+  return import_v46.z.object({
     labelSetId: makeLabelSetIdSchema(valueLabelLabelSetId),
     labelSetVersion: makeLabelSetVersionStringSchema(valueLabelLabelSetVersion)
   });
 };
-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(
+var makeNonEmptyStringSchema = (valueLabel = "Value") => import_v46.z.string().nonempty({ error: `${valueLabel} must be a non-empty string.` });
+var makeEnsIndexerVersionInfoSchema = (valueLabel = "Value") => import_v46.z.object(
   {
     ponder: makeNonEmptyStringSchema(),
-    commit: import_v43.z.optional(makeNonEmptyStringSchema()),
+    commit: import_v46.z.optional(makeNonEmptyStringSchema()),
     ensDb: makeNonEmptyStringSchema(),
     ensIndexer: makeNonEmptyStringSchema(),
     ensNormalize: makeNonEmptyStringSchema()
@@ -755,41 +790,21 @@ function invariant_isSubgraphCompatibleRequirements(ctx) {
     });
   }
 }
-function invariant_ensRainbowSupportedLabelSetAndVersion(ctx) {
-  const { clientLabelSet } = ctx.value;
-  const { serverLabelSet } = ctx.value.ensRainbowPublicConfig;
-  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({
+var makeEnsIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") => import_v46.z.object({
   ensIndexerSchemaName: makeEnsIndexerSchemaNameSchema(`${valueLabel}.ensIndexerSchemaName`),
-  ensRainbowPublicConfig: makeEnsRainbowPublicConfigSchema(
-    `${valueLabel}.ensRainbowPublicConfig`
-  ),
   indexedChainIds: makeIndexedChainIdsSchema(`${valueLabel}.indexedChainIds`),
-  isSubgraphCompatible: import_v43.z.boolean({
+  isSubgraphCompatible: import_v46.z.boolean({
     error: `${valueLabel}.isSubgraphCompatible must be a boolean value.`
   }),
   clientLabelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.clientLabelSet`),
   namespace: makeENSNamespaceIdSchema(`${valueLabel}.namespace`),
   plugins: makePluginsListSchema(`${valueLabel}.plugins`),
   versionInfo: makeEnsIndexerVersionInfoSchema(`${valueLabel}.versionInfo`)
-}).check(invariant_isSubgraphCompatibleRequirements).check(invariant_ensRainbowSupportedLabelSetAndVersion);
-var makeSerializedEnsIndexerPublicConfigSchema = (valueLabel = "Serialized ENSIndexerPublicConfig") => import_v43.z.object({
+}).check(invariant_isSubgraphCompatibleRequirements);
+var makeSerializedEnsIndexerPublicConfigSchema = (valueLabel = "Serialized ENSIndexerPublicConfig") => import_v46.z.object({
   ensIndexerSchemaName: makeEnsIndexerSchemaNameSchema(`${valueLabel}.ensIndexerSchemaName`),
-  ensRainbowPublicConfig: makeEnsRainbowPublicConfigSchema(
-    `${valueLabel}.ensRainbowPublicConfig`
-  ),
   indexedChainIds: makeSerializedIndexedChainIdsSchema(`${valueLabel}.indexedChainIds`),
-  isSubgraphCompatible: import_v43.z.boolean({
+  isSubgraphCompatible: import_v46.z.boolean({
     error: `${valueLabel}.isSubgraphCompatible must be a boolean value.`
   }),
   clientLabelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.clientLabelSet`),
@@ -809,79 +824,17 @@ 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_v44.prettifyError)(parsed.error)}
+${(0, import_v47.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
 }
 var deserializeENSIndexerPublicConfig = deserializeEnsIndexerPublicConfig;
 
-// src/ensapi/config/zod-schemas.ts
-var import_v46 = require("zod/v4");
-
-// src/shared/config/thegraph.ts
-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_v45.z.discriminatedUnion("canFallback", [
-  import_v45.z.strictObject({
-    canFallback: import_v45.z.literal(true),
-    url: import_v45.z.string()
-  }),
-  import_v45.z.strictObject({
-    canFallback: import_v45.z.literal(false),
-    reason: TheGraphCannotFallbackReasonSchema
-  })
-]);
-
-// src/ensapi/config/zod-schemas.ts
-var makeEnsApiVersionInfoSchema = (valueLabel = "ENS API version info") => import_v46.z.object({
-  commit: import_v46.z.optional(import_v46.z.string().nonempty(`${valueLabel}.commit must be a non-empty string`)),
-  ensApi: import_v46.z.string().nonempty(`${valueLabel}.ensApi must be a non-empty string`),
-  ensNormalize: import_v46.z.string().nonempty(`${valueLabel}.ensNormalize must be a non-empty string`)
-});
-function makeEnsApiPublicConfigSchema(valueLabel) {
-  const label = valueLabel ?? "ENSApiPublicConfig";
-  return import_v46.z.object({
-    theGraphFallback: TheGraphFallbackSchema,
-    ensIndexerPublicConfig: makeEnsIndexerPublicConfigSchema(`${label}.ensIndexerPublicConfig`),
-    versionInfo: makeEnsApiVersionInfoSchema(`${label}.versionInfo`)
-  });
-}
-var makeENSApiPublicConfigSchema = makeEnsApiPublicConfigSchema;
-function makeSerializedEnsApiPublicConfigSchema(valueLabel) {
-  const label = valueLabel ?? "ENSApiPublicConfig";
-  return import_v46.z.object({
-    ensIndexerPublicConfig: makeSerializedEnsIndexerPublicConfigSchema(
-      `${label}.ensIndexerPublicConfig`
-    ),
-    theGraphFallback: TheGraphFallbackSchema,
-    versionInfo: makeEnsApiVersionInfoSchema(`${label}.versionInfo`)
-  });
-}
-
-// src/ensapi/config/deserialize.ts
-function buildUnvalidatedEnsApiPublicConfig(serializedPublicConfig) {
-  return {
-    ...serializedPublicConfig,
-    ensIndexerPublicConfig: buildUnvalidatedEnsIndexerPublicConfig(
-      serializedPublicConfig.ensIndexerPublicConfig
-    )
-  };
-}
-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_v47.prettifyError)(parsed.error)}
-`);
-  }
-  return parsed.data;
+// src/ensindexer/api/config/deserialize.ts
+function deserializeEnsIndexerConfigResponse(maybeResponse) {
+  return deserializeEnsIndexerPublicConfig(maybeResponse, "EnsIndexerConfigResponse");
 }
-var deserializeENSApiPublicConfig = deserializeEnsApiPublicConfig;
 
 // src/ensindexer/config/serialize.ts
 function serializeIndexedChainIds(indexedChainIds) {
@@ -890,7 +843,6 @@ function serializeIndexedChainIds(indexedChainIds) {
 function serializeEnsIndexerPublicConfig(config) {
   const {
     ensIndexerSchemaName,
-    ensRainbowPublicConfig,
     indexedChainIds,
     isSubgraphCompatible: isSubgraphCompatible2,
     clientLabelSet,
@@ -900,7 +852,6 @@ function serializeEnsIndexerPublicConfig(config) {
   } = config;
   return {
     ensIndexerSchemaName,
-    ensRainbowPublicConfig,
     indexedChainIds: serializeIndexedChainIds(indexedChainIds),
     isSubgraphCompatible: isSubgraphCompatible2,
     clientLabelSet,
@@ -911,22 +862,6 @@ function serializeEnsIndexerPublicConfig(config) {
 }
 var serializeENSIndexerPublicConfig = serializeEnsIndexerPublicConfig;
 
-// src/ensapi/config/serialize.ts
-function serializeEnsApiPublicConfig(config) {
-  const { ensIndexerPublicConfig, theGraphFallback, versionInfo } = config;
-  return {
-    ensIndexerPublicConfig: serializeEnsIndexerPublicConfig(ensIndexerPublicConfig),
-    theGraphFallback,
-    versionInfo
-  };
-}
-var serializeENSApiPublicConfig = serializeEnsApiPublicConfig;
-
-// src/ensindexer/api/config/deserialize.ts
-function deserializeEnsIndexerConfigResponse(maybeResponse) {
-  return deserializeEnsIndexerPublicConfig(maybeResponse, "EnsIndexerConfigResponse");
-}
-
 // src/ensindexer/api/config/serialize.ts
 function serializeEnsIndexerConfigResponse(response) {
   return serializeEnsIndexerPublicConfig(response);
@@ -2221,6 +2156,35 @@ function labelHashToBytes(labelHash) {
   }
 }
 
+// src/ensindexer/config/labelset-utils.ts
+function buildLabelSetId(maybeLabelSetId) {
+  return makeLabelSetIdSchema("LabelSetId").parse(maybeLabelSetId);
+}
+function buildLabelSetVersion(maybeLabelSetVersion) {
+  return makeLabelSetVersionStringSchema("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();