@ensnode/ensnode-sdk 1.13.0 → 1.14.0

package/dist/internal.js

@@ -0,0 +1,3290 @@
+// src/ensapi/config/zod-schemas.ts
+import { z as z5 } from "zod/v4";
+
+// src/ensindexer/config/zod-schemas.ts
+import { z as z3 } from "zod/v4";
+
+// src/ensrainbow/zod-schemas/config.ts
+import { z as z2 } from "zod/v4";
+
+// src/shared/zod-schemas.ts
+import { AccountId as CaipAccountId } from "caip";
+import { reinterpretName, toNormalizedAddress } from "enssdk";
+import { isAddress, isHex, size } from "viem";
+import { z } from "zod/v4";
+
+// src/ens/index.ts
+import { ENSNamespaceIds, getENSRootChainId } from "@ensnode/datasources";
+
+// src/shared/currencies.ts
+import { parseUnits } from "viem";
+var CurrencyIds = {
+  ETH: "ETH",
+  USDC: "USDC",
+  DAI: "DAI",
+  ENSTokens: "ENSTokens"
+};
+var currencyInfo = {
+  [CurrencyIds.ETH]: {
+    id: CurrencyIds.ETH,
+    name: "ETH",
+    decimals: 18
+  },
+  [CurrencyIds.USDC]: {
+    id: CurrencyIds.USDC,
+    name: "USDC",
+    decimals: 6
+  },
+  [CurrencyIds.DAI]: {
+    id: CurrencyIds.DAI,
+    name: "Dai Stablecoin",
+    decimals: 18
+  },
+  [CurrencyIds.ENSTokens]: {
+    id: CurrencyIds.ENSTokens,
+    name: "$ENS Tokens",
+    decimals: 18
+  }
+};
+function isPriceCurrencyEqual(priceA, priceB) {
+  return priceA.currency === priceB.currency;
+}
+function isPriceEqual(priceA, priceB) {
+  return isPriceCurrencyEqual(priceA, priceB) && priceA.amount === priceB.amount;
+}
+function addPrices(...prices) {
+  const firstPrice = prices[0];
+  const allPricesInSameCurrency = prices.every((price) => isPriceCurrencyEqual(firstPrice, price));
+  if (allPricesInSameCurrency === false) {
+    throw new Error("All prices must have the same currency to be added together.");
+  }
+  const { currency } = firstPrice;
+  return prices.reduce(
+    (acc, price) => ({
+      amount: acc.amount + price.amount,
+      currency
+    }),
+    {
+      amount: 0n,
+      currency: firstPrice.currency
+    }
+  );
+}
+
+// src/shared/zod-schemas.ts
+var makeBooleanStringSchema = (valueLabel = "Value") => z.string().pipe(
+  z.enum(["true", "false"], {
+    error: `${valueLabel} must be 'true' or 'false'.`
+  })
+).transform((val) => val === "true");
+var makeFiniteNonNegativeNumberSchema = (valueLabel = "Value") => z.number({
+  // NOTE: Zod's implementation of `number` automatically rejects NaN and Infinity values.
+  // and therefore the finite check is implicit.
+  error: `${valueLabel} must be a finite number.`
+}).nonnegative({
+  error: `${valueLabel} must be a non-negative number (>=0).`
+});
+var makeIntegerSchema = (valueLabel = "Value") => z.int({
+  error: `${valueLabel} must be an integer.`
+});
+var makePositiveIntegerSchema = (valueLabel = "Value") => makeIntegerSchema(valueLabel).positive({
+  error: `${valueLabel} must be a positive integer (>0).`
+});
+var makeNonNegativeIntegerSchema = (valueLabel = "Value") => makeIntegerSchema(valueLabel).nonnegative({
+  error: `${valueLabel} must be a non-negative integer (>=0).`
+});
+var makeDurationSchema = (valueLabel = "Value") => 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") => z.string({ error: `${valueLabel} must be a string representing a chain ID.` }).pipe(z.coerce.number({ error: `${valueLabel} must represent a positive integer (>0).` })).pipe(makeChainIdSchema(`The numeric value represented by ${valueLabel}`));
+var makeDefaultableChainIdSchema = (valueLabel = "Defaultable Chain ID") => makeNonNegativeIntegerSchema(valueLabel).transform((val) => val);
+var makeDefaultableChainIdStringSchema = (valueLabel = "Defaultable Chain ID String") => z.string({ error: `${valueLabel} must be a string representing a chain ID.` }).pipe(z.coerce.number({ error: `${valueLabel} must represent a non-negative integer (>=0).` })).pipe(makeDefaultableChainIdSchema(`The numeric value represented by ${valueLabel}`));
+var makeCoinTypeSchema = (valueLabel = "Coin Type") => z.number({ error: `${valueLabel} must be a number.` }).int({ error: `${valueLabel} must be an integer.` }).nonnegative({ error: `${valueLabel} must be a non-negative integer (>=0).` }).transform((val) => val);
+var makeCoinTypeStringSchema = (valueLabel = "Coin Type String") => z.string({ error: `${valueLabel} must be a string representing a coin type.` }).pipe(z.coerce.number({ error: `${valueLabel} must represent a non-negative integer (>=0).` })).pipe(makeCoinTypeSchema(`The numeric value represented by ${valueLabel}`));
+var makeNormalizedAddressSchema = (valueLabel = "EVM address") => z.string().check((ctx) => {
+  if (!isAddress(ctx.value, { strict: false })) {
+    ctx.issues.push({
+      code: "custom",
+      message: `${valueLabel} must be a valid EVM address`,
+      input: ctx.value
+    });
+  }
+}).transform((val) => toNormalizedAddress(val));
+var makeDatetimeSchema = (valueLabel = "Datetime string") => 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") => 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 makeCommaSeparatedList = (valueLabel = "Value") => z.string({ error: `${valueLabel} must be a comma separated list.` }).transform((val) => val.split(",").filter(Boolean)).refine((val) => val.length > 0, {
+  error: `${valueLabel} must be a comma separated list with at least one value.`
+});
+var makeBlockNumberSchema = (valueLabel = "Block number") => makeNonNegativeIntegerSchema(valueLabel);
+var makeBlockRefSchema = (valueLabel = "Value") => z.strictObject(
+  {
+    timestamp: makeUnixTimestampSchema(`${valueLabel}.timestamp`),
+    number: makeBlockNumberSchema(`${valueLabel}.number`)
+  },
+  {
+    error: `${valueLabel} must be a valid BlockRef object.`
+  }
+);
+var makeENSNamespaceIdSchema = (valueLabel = "ENSNamespaceId") => z.enum(ENSNamespaceIds, {
+  error() {
+    return `Invalid ${valueLabel}. Supported ENS namespace IDs are: ${Object.keys(ENSNamespaceIds).join(", ")}`;
+  }
+});
+var makePriceAmountSchema = (valueLabel = "Amount") => z.coerce.bigint({
+  error: `${valueLabel} must represent a bigint.`
+}).nonnegative({
+  error: `${valueLabel} must not be negative.`
+});
+var makeSerializedCurrencyAmountSchema = (valueLabel = "Serialized Currency Amount") => z.string({ error: `${valueLabel} must be a string.` }).regex(/^\d+$/, {
+  error: `${valueLabel} can only contain digits (0-9) and must represent a non-negative integer.`
+});
+var makePriceCurrencySchema = (currency, valueLabel = "Price Currency") => z.strictObject({
+  amount: makePriceAmountSchema(`${valueLabel} amount`),
+  currency: z.literal(currency, {
+    error: `${valueLabel} currency must be set to '${currency}'.`
+  })
+});
+var makeSerializedPriceCurrencySchema = (currency, valueLabel = "Price Currency") => z.strictObject({
+  amount: makeSerializedCurrencyAmountSchema(`${valueLabel} amount`),
+  currency: z.literal(currency, {
+    error: `${valueLabel} currency must be set to '${currency}'.`
+  })
+});
+var makePriceSchema = (valueLabel = "Price") => z.discriminatedUnion(
+  "currency",
+  [
+    makePriceCurrencySchema(CurrencyIds.ETH, valueLabel),
+    makePriceCurrencySchema(CurrencyIds.USDC, valueLabel),
+    makePriceCurrencySchema(CurrencyIds.DAI, valueLabel),
+    makePriceCurrencySchema(CurrencyIds.ENSTokens, valueLabel)
+  ],
+  { error: `${valueLabel} currency must be one of ${Object.values(CurrencyIds).join(", ")}` }
+);
+var makePriceEthSchema = (valueLabel = "Price ETH") => makePriceCurrencySchema(CurrencyIds.ETH, valueLabel).transform((v) => v);
+var makeSerializedPriceEthSchema = (valueLabel = "Serialized Price ETH") => makeSerializedPriceCurrencySchema(CurrencyIds.ETH, valueLabel).transform(
+  (v) => v
+);
+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") => z.strictObject({
+  chainId: makeChainIdSchema(`${valueLabel} chain ID`),
+  address: makeNormalizedAddressSchema(`${valueLabel} address`)
+});
+var makeAccountIdStringSchema = (valueLabel = "Account ID String") => z.coerce.string().transform((v) => {
+  const result = new CaipAccountId(v);
+  return {
+    chainId: Number(result.chainId.reference),
+    address: result.address
+  };
+}).pipe(makeAccountIdSchema(valueLabel));
+var makeHexStringSchema = (options, valueLabel = "String representation of bytes array") => z.string().check(function invariant_isHexEncoded(ctx) {
+  if (!isHex(ctx.value)) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `${valueLabel} must be a hexadecimal value which starts with '0x'.`
+    });
+  }
+}).transform((v) => v).check(function invariant_encodesRequiredBytesCount(ctx) {
+  const expectedBytesCount = options.bytesCount;
+  const actualBytesCount = size(ctx.value);
+  if (actualBytesCount !== expectedBytesCount) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `${valueLabel} must represent exactly ${expectedBytesCount} bytes. Currently represented bytes count: ${actualBytesCount}.`
+    });
+  }
+});
+var makeNodeSchema = (valueLabel = "Node") => makeHexStringSchema({ bytesCount: 32 }, valueLabel);
+var makeTransactionHashSchema = (valueLabel = "Transaction hash") => makeHexStringSchema({ bytesCount: 32 }, valueLabel);
+var makeReinterpretedNameSchema = (valueLabel = "Reinterpreted Name") => z.string().transform((v) => v).check((ctx) => {
+  try {
+    reinterpretName(ctx.value);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `${valueLabel} cannot be reinterpreted: ${errorMessage}`
+    });
+  }
+}).transform(reinterpretName);
+
+// src/ensrainbow/zod-schemas/config.ts
+var makeLabelSetIdSchema = (valueLabel = "Label set ID") => {
+  return z2.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") => z2.coerce.number({ error: `${valueLabel} must be a non-negative integer` }).pipe(makeLabelSetVersionSchema(valueLabel));
+var makeEnsRainbowPublicConfigSchema = (valueLabel = "EnsRainbowPublicConfig") => z2.object({
+  serverLabelSet: z2.object({
+    labelSetId: makeLabelSetIdSchema(`${valueLabel}.serverLabelSet.labelSetId`),
+    highestLabelSetVersion: makeLabelSetVersionSchema(
+      `${valueLabel}.serverLabelSet.highestLabelSetVersion`
+    )
+  }),
+  versionInfo: z2.object({
+    ensRainbow: z2.string().nonempty({ error: `${valueLabel}.versionInfo.ensRainbow must be a non-empty string.` })
+  })
+});
+
+// src/shared/collections.ts
+var uniq = (arr) => [...new Set(arr)];
+
+// src/ensindexer/config/is-subgraph-compatible.ts
+import { ENSNamespaceIds as ENSNamespaceIds2 } from "@ensnode/datasources";
+function isSubgraphCompatible(config) {
+  const onlySubgraphPluginActivated = config.plugins.length === 1 && config.plugins[0] === "subgraph" /* Subgraph */;
+  const isSubgraphLabelSet = config.clientLabelSet.labelSetId === "subgraph" && config.clientLabelSet.labelSetVersion === 0;
+  const isEnsTestEnvLabelSet = config.clientLabelSet.labelSetId === "ens-test-env" && config.clientLabelSet.labelSetVersion === 0;
+  const labelSetIsSubgraphCompatible = isSubgraphLabelSet || config.namespace === ENSNamespaceIds2.EnsTestEnv && isEnsTestEnvLabelSet;
+  return onlySubgraphPluginActivated && labelSetIsSubgraphCompatible;
+}
+
+// src/ensindexer/config/labelset-utils.ts
+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;
+  if (versionInfo.ensDb !== versionInfo.ensIndexer) {
+    ctx.issues.push({
+      code: "custom",
+      input: versionInfo,
+      message: "`ensDb` version must be same as `ensIndexer` version"
+    });
+  }
+}
+
+// src/ensindexer/config/zod-schemas.ts
+var makeIndexedChainIdsSchema = (valueLabel = "Indexed Chain IDs") => z3.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") => z3.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") => z3.array(z3.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") => z3.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") => {
+  let valueLabelLabelSetId = valueLabel;
+  let valueLabelLabelSetVersion = valueLabel;
+  if (valueLabel === "LABEL_SET") {
+    valueLabelLabelSetId = "LABEL_SET_ID";
+    valueLabelLabelSetVersion = "LABEL_SET_VERSION";
+  } else {
+    valueLabelLabelSetId = `${valueLabel}.labelSetId`;
+    valueLabelLabelSetVersion = `${valueLabel}.labelSetVersion`;
+  }
+  return z3.object({
+    labelSetId: makeLabelSetIdSchema(valueLabelLabelSetId),
+    labelSetVersion: makeLabelSetVersionStringSchema(valueLabelLabelSetVersion)
+  });
+};
+var makeNonEmptyStringSchema = (valueLabel = "Value") => z3.string().nonempty({ error: `${valueLabel} must be a non-empty string.` });
+var makeEnsIndexerVersionInfoSchema = (valueLabel = "Value") => z3.object(
+  {
+    ponder: makeNonEmptyStringSchema(),
+    ensDb: makeNonEmptyStringSchema(),
+    ensIndexer: makeNonEmptyStringSchema(),
+    ensNormalize: makeNonEmptyStringSchema()
+  },
+  {
+    error: `${valueLabel} must be a valid ENSIndexerVersionInfo object.`
+  }
+).check(invariant_ensDbVersionIsSameAsEnsIndexerVersion);
+var makeENSIndexerVersionInfoSchema = makeEnsIndexerVersionInfoSchema;
+function invariant_isSubgraphCompatibleRequirements(ctx) {
+  const { value: config } = ctx;
+  if (config.isSubgraphCompatible && !isSubgraphCompatible(config)) {
+    ctx.issues.push({
+      code: "custom",
+      input: config,
+      message: `'isSubgraphCompatible' requires only the '${"subgraph" /* Subgraph */}' plugin to be active and 'clientLabelSet' must be {labelSetId: "subgraph", labelSetVersion: 0}`
+    });
+  }
+}
+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") => z3.object({
+  ensIndexerSchemaName: makeEnsIndexerSchemaNameSchema(`${valueLabel}.ensIndexerSchemaName`),
+  ensRainbowPublicConfig: makeEnsRainbowPublicConfigSchema(
+    `${valueLabel}.ensRainbowPublicConfig`
+  ),
+  indexedChainIds: makeIndexedChainIdsSchema(`${valueLabel}.indexedChainIds`),
+  isSubgraphCompatible: z3.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 makeENSIndexerPublicConfigSchema = makeEnsIndexerPublicConfigSchema;
+var makeSerializedEnsIndexerPublicConfigSchema = (valueLabel = "Serialized ENSIndexerPublicConfig") => z3.object({
+  ensIndexerSchemaName: makeEnsIndexerSchemaNameSchema(`${valueLabel}.ensIndexerSchemaName`),
+  ensRainbowPublicConfig: makeEnsRainbowPublicConfigSchema(
+    `${valueLabel}.ensRainbowPublicConfig`
+  ),
+  indexedChainIds: makeSerializedIndexedChainIdsSchema(`${valueLabel}.indexedChainIds`),
+  isSubgraphCompatible: z3.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`)
+});
+
+// src/shared/config/thegraph.ts
+import { z as z4 } from "zod/v4";
+var TheGraphCannotFallbackReasonSchema = z4.enum({
+  NotSubgraphCompatible: "not-subgraph-compatible",
+  NoApiKey: "no-api-key",
+  NoSubgraphUrl: "no-subgraph-url"
+});
+var TheGraphFallbackSchema = z4.discriminatedUnion("canFallback", [
+  z4.strictObject({
+    canFallback: z4.literal(true),
+    url: z4.string()
+  }),
+  z4.strictObject({
+    canFallback: z4.literal(false),
+    reason: TheGraphCannotFallbackReasonSchema
+  })
+]);
+
+// src/ensapi/config/zod-schemas.ts
+var makeEnsApiVersionInfoSchema = (valueLabel = "ENS API version info") => z5.object({
+  ensApi: z5.string().nonempty(`${valueLabel}.ensApi must be a non-empty string`),
+  ensNormalize: z5.string().nonempty(`${valueLabel}.ensNormalize must be a non-empty string`)
+});
+function makeEnsApiPublicConfigSchema(valueLabel) {
+  const label = valueLabel ?? "ENSApiPublicConfig";
+  return z5.object({
+    theGraphFallback: TheGraphFallbackSchema,
+    ensIndexerPublicConfig: makeEnsIndexerPublicConfigSchema(`${label}.ensIndexerPublicConfig`),
+    versionInfo: makeEnsApiVersionInfoSchema(`${label}.versionInfo`)
+  });
+}
+var makeENSApiPublicConfigSchema = makeEnsApiPublicConfigSchema;
+function makeSerializedEnsApiPublicConfigSchema(valueLabel) {
+  const label = valueLabel ?? "ENSApiPublicConfig";
+  return z5.object({
+    ensIndexerPublicConfig: makeSerializedEnsIndexerPublicConfigSchema(
+      `${label}.ensIndexerPublicConfig`
+    ),
+    theGraphFallback: TheGraphFallbackSchema,
+    versionInfo: makeEnsApiVersionInfoSchema(`${label}.versionInfo`)
+  });
+}
+
+// src/ensnode/api/indexing-status/zod-schemas.ts
+import { z as z12 } from "zod/v4";
+
+// src/indexing-status/zod-schema/realtime-indexing-status-projection.ts
+import { z as z9 } from "zod/v4";
+
+// src/indexing-status/zod-schema/cross-chain-indexing-status-snapshot.ts
+import { z as z8 } from "zod/v4";
+
+// src/shared/block-ref.ts
+function isBefore(blockA, blockB) {
+  return blockA.number < blockB.number;
+}
+function isEqualTo(blockA, blockB) {
+  return blockA.number === blockB.number && blockA.timestamp === blockB.timestamp;
+}
+function isBeforeOrEqualTo(blockA, blockB) {
+  return isBefore(blockA, blockB) || isEqualTo(blockA, blockB);
+}
+
+// src/shared/blockrange.ts
+var RangeTypeIds = {
+  Unbounded: "unbounded",
+  LeftBounded: "left-bounded",
+  RightBounded: "right-bounded",
+  Bounded: "bounded"
+};
+
+// src/indexing-status/chain-indexing-status-snapshot.ts
+var ChainIndexingStatusIds = {
+  /**
+   * Represents that indexing of the chain is not ready to begin yet because:
+   * - ENSIndexer is in its initialization phase and the data to build a
+   *   "true" {@link ChainIndexingStatusSnapshot} for the chain is still being loaded; or
+   * - ENSIndexer is using an omnichain indexing strategy and the
+   *   `omnichainIndexingCursor` is <= `config.startBlock.timestamp` for the chain's
+   *   {@link ChainIndexingStatusSnapshot}.
+   */
+  Queued: "chain-queued",
+  /**
+   * Represents that indexing of the chain is in progress and under a special
+   * "backfill" phase that optimizes for accelerated indexing until reaching the
+   * "fixed target" `backfillEndBlock`.
+   */
+  Backfill: "chain-backfill",
+  /**
+   * Represents that the "backfill" phase of indexing the chain is completed
+   * and that the chain is configured to be indexed for an indefinite range.
+   * Therefore, indexing of the chain remains indefinitely in progress where
+   * ENSIndexer will continuously work to discover and index new blocks as they
+   * are added to the chain across time.
+   */
+  Following: "chain-following",
+  /**
+   * Represents that indexing of the chain is completed as the chain is configured
+   * to be indexed for a definite range and the indexing of all blocks through
+   * that definite range is completed.
+   */
+  Completed: "chain-completed"
+};
+
+// src/indexing-status/cross-chain-indexing-status-snapshot.ts
+var CrossChainIndexingStrategyIds = {
+  /**
+   * Represents that the indexing of events across all indexed chains will
+   * proceed in a deterministic "omnichain" ordering by block timestamp, chain ID,
+   * and block number.
+   *
+   * This strategy is "deterministic" in that the order of processing cross-chain indexed
+   * events and each resulting indexed data state transition recorded in ENSDb is always
+   * the same for each ENSIndexer instance operating with an equivalent
+   * `ENSIndexerConfig` and ENSIndexer version. However it also has the drawbacks of:
+   * - increased indexing latency that must wait for the slowest indexed chain to
+   *   add new blocks or to discover new blocks through the configured RPCs.
+   * - if any indexed chain gets "stuck" due to chain or RPC failures, all indexed chains
+   *   will be affected.
+   */
+  Omnichain: "omnichain"
+};
+function getHighestKnownBlockTimestamp(chains) {
+  if (chains.length === 0) {
+    throw new Error(
+      "Invariant violation: at least one chain is required to determine the highest known block timestamp"
+    );
+  }
+  const startBlockTimestamps = chains.map((chain) => chain.config.startBlock.timestamp);
+  const endBlockTimestamps = chains.map((chain) => chain.config).filter((chainConfig) => chainConfig.rangeType === RangeTypeIds.Bounded).map((chainConfig) => chainConfig.endBlock.timestamp);
+  const backfillEndBlockTimestamps = chains.filter((chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill).map((chain) => chain.backfillEndBlock.timestamp);
+  const latestKnownBlockTimestamps = chains.filter((chain) => chain.chainStatus === ChainIndexingStatusIds.Following).map((chain) => chain.latestKnownBlock.timestamp);
+  return Math.max(
+    ...startBlockTimestamps,
+    ...endBlockTimestamps,
+    ...backfillEndBlockTimestamps,
+    ...latestKnownBlockTimestamps
+  );
+}
+
+// src/indexing-status/zod-schema/omnichain-indexing-status-snapshot.ts
+import { z as z7 } from "zod/v4";
+
+// src/indexing-status/omnichain-indexing-status-snapshot.ts
+var OmnichainIndexingStatusIds = {
+  /**
+   * Represents that omnichain indexing is not ready to begin yet because
+   * ENSIndexer is in its initialization phase and the data to build a "true"
+   * {@link OmnichainIndexingStatusSnapshot} is still being loaded.
+   */
+  Unstarted: "omnichain-unstarted",
+  /**
+   * Represents that omnichain indexing is in an overall "backfill" status because
+   * - At least one indexed chain has a `chainStatus` of
+   *   {@link ChainIndexingStatusIds.Backfill}; and
+   * - No indexed chain has a `chainStatus` of {@link ChainIndexingStatusIds.Following}.
+   */
+  Backfill: "omnichain-backfill",
+  /**
+   * Represents that omnichain indexing is in an overall "following" status because
+   * at least one indexed chain has a `chainStatus` of
+   * {@link ChainIndexingStatusIds.Following}.
+   */
+  Following: "omnichain-following",
+  /**
+   * Represents that omnichain indexing has completed because all indexed chains have
+   * a `chainStatus` of {@link ChainIndexingStatusIds.Completed}.
+   */
+  Completed: "omnichain-completed"
+};
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(chains) {
+  return chains.every((chain) => chain.chainStatus === ChainIndexingStatusIds.Queued);
+}
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(chains) {
+  const atLeastOneChainInTargetStatus = chains.some(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill
+  );
+  const otherChainsHaveValidStatuses = chains.every(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Queued || chain.chainStatus === ChainIndexingStatusIds.Backfill || chain.chainStatus === ChainIndexingStatusIds.Completed
+  );
+  return atLeastOneChainInTargetStatus && otherChainsHaveValidStatuses;
+}
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(chains) {
+  const allChainsHaveValidStatuses = chains.every(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Completed
+  );
+  return allChainsHaveValidStatuses;
+}
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains) {
+  const allChainsHaveValidStatuses = chains.some(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Following
+  );
+  return allChainsHaveValidStatuses;
+}
+function getOmnichainIndexingStatus(chains) {
+  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains)) {
+    return OmnichainIndexingStatusIds.Following;
+  }
+  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(chains)) {
+    return OmnichainIndexingStatusIds.Backfill;
+  }
+  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(chains)) {
+    return OmnichainIndexingStatusIds.Unstarted;
+  }
+  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(chains)) {
+    return OmnichainIndexingStatusIds.Completed;
+  }
+  throw new Error(`Unable to determine omnichain indexing status for provided chains.`);
+}
+
+// src/indexing-status/zod-schema/chain-indexing-status-snapshot.ts
+import { z as z6 } from "zod/v4";
+function invariant_chainSnapshotQueuedBlocks(ctx) {
+  const { config } = ctx.value;
+  if (config.rangeType === RangeTypeIds.LeftBounded) {
+    return;
+  }
+  if (isBeforeOrEqualTo(config.startBlock, config.endBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`config.startBlock` must be before or same as `config.endBlock`."
+    });
+  }
+}
+function invariant_chainSnapshotBackfillBlocks(ctx) {
+  const { config, latestIndexedBlock, backfillEndBlock } = ctx.value;
+  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
+    });
+  }
+  if (isBeforeOrEqualTo(latestIndexedBlock, backfillEndBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`latestIndexedBlock` must be before or same as `backfillEndBlock`."
+    });
+  }
+  if (config.rangeType === RangeTypeIds.LeftBounded) {
+    return;
+  }
+  if (isEqualTo(backfillEndBlock, config.endBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`backfillEndBlock` must be the same as `config.endBlock`."
+    });
+  }
+}
+function invariant_chainSnapshotCompletedBlocks(ctx) {
+  const { config, latestIndexedBlock } = ctx.value;
+  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
+    });
+  }
+  if (isBeforeOrEqualTo(latestIndexedBlock, config.endBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`latestIndexedBlock` must be before or same as `config.endBlock`."
+    });
+  }
+}
+function invariant_chainSnapshotFollowingBlocks(ctx) {
+  const { config, latestIndexedBlock, latestKnownBlock } = ctx.value;
+  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
+    });
+  }
+  if (isBeforeOrEqualTo(latestIndexedBlock, latestKnownBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`latestIndexedBlock` must be before or same as `latestKnownBlock`."
+    });
+  }
+}
+var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => z6.object({
+  chainStatus: z6.literal(ChainIndexingStatusIds.Queued),
+  config: z6.discriminatedUnion("rangeType", [
+    z6.object({
+      rangeType: z6.literal(RangeTypeIds.LeftBounded),
+      startBlock: makeBlockRefSchema(valueLabel)
+    }),
+    z6.object({
+      rangeType: z6.literal(RangeTypeIds.Bounded),
+      startBlock: makeBlockRefSchema(valueLabel),
+      endBlock: makeBlockRefSchema(valueLabel)
+    })
+  ])
+}).check(invariant_chainSnapshotQueuedBlocks);
+var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => z6.object({
+  chainStatus: z6.literal(ChainIndexingStatusIds.Backfill),
+  config: z6.discriminatedUnion("rangeType", [
+    z6.object({
+      rangeType: z6.literal(RangeTypeIds.LeftBounded),
+      startBlock: makeBlockRefSchema(valueLabel)
+    }),
+    z6.object({
+      rangeType: z6.literal(RangeTypeIds.Bounded),
+      startBlock: makeBlockRefSchema(valueLabel),
+      endBlock: makeBlockRefSchema(valueLabel)
+    })
+  ]),
+  latestIndexedBlock: makeBlockRefSchema(valueLabel),
+  backfillEndBlock: makeBlockRefSchema(valueLabel)
+}).check(invariant_chainSnapshotBackfillBlocks);
+var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => z6.object({
+  chainStatus: z6.literal(ChainIndexingStatusIds.Completed),
+  config: z6.object({
+    rangeType: z6.literal(RangeTypeIds.Bounded),
+    startBlock: makeBlockRefSchema(valueLabel),
+    endBlock: makeBlockRefSchema(valueLabel)
+  }),
+  latestIndexedBlock: makeBlockRefSchema(valueLabel)
+}).check(invariant_chainSnapshotCompletedBlocks);
+var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => z6.object({
+  chainStatus: z6.literal(ChainIndexingStatusIds.Following),
+  config: z6.object({
+    rangeType: z6.literal(RangeTypeIds.LeftBounded),
+    startBlock: makeBlockRefSchema(valueLabel)
+  }),
+  latestIndexedBlock: makeBlockRefSchema(valueLabel),
+  latestKnownBlock: makeBlockRefSchema(valueLabel)
+}).check(invariant_chainSnapshotFollowingBlocks);
+
+// src/indexing-status/zod-schema/omnichain-indexing-status-snapshot.ts
+function invariant_omnichainSnapshotStatusIsConsistentWithChainSnapshot(ctx) {
+  const snapshot = ctx.value;
+  const chains = Array.from(snapshot.chains.values());
+  const expectedOmnichainStatus = getOmnichainIndexingStatus(chains);
+  const actualOmnichainStatus = snapshot.omnichainStatus;
+  if (expectedOmnichainStatus !== actualOmnichainStatus) {
+    ctx.issues.push({
+      code: "custom",
+      input: snapshot,
+      message: `'${actualOmnichainStatus}' is an invalid omnichainStatus. Expected '${expectedOmnichainStatus}' based on the statuses of individual chains.`
+    });
+  }
+}
+function invariant_omnichainIndexingCursorLowerThanEarliestStartBlockAcrossQueuedChains(ctx) {
+  const snapshot = ctx.value;
+  const queuedChains = Array.from(snapshot.chains.values()).filter(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Queued
+  );
+  if (queuedChains.length === 0) {
+    return;
+  }
+  const queuedChainStartBlocks = queuedChains.map((chain) => chain.config.startBlock.timestamp);
+  const queuedChainEarliestStartBlock = Math.min(...queuedChainStartBlocks);
+  if (snapshot.omnichainIndexingCursor >= queuedChainEarliestStartBlock) {
+    ctx.issues.push({
+      code: "custom",
+      input: snapshot,
+      message: "`omnichainIndexingCursor` must be lower than the earliest start block across all queued chains."
+    });
+  }
+}
+function invariant_omnichainIndexingCursorLowerThanOrEqualToLatestBackfillEndBlockAcrossBackfillChains(ctx) {
+  const snapshot = ctx.value;
+  const backfillChains = Array.from(snapshot.chains.values()).filter(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill
+  );
+  if (backfillChains.length === 0) {
+    return;
+  }
+  const backfillEndBlocks = backfillChains.map((chain) => chain.backfillEndBlock.timestamp);
+  const highestBackfillEndBlock = Math.max(...backfillEndBlocks);
+  if (snapshot.omnichainIndexingCursor > highestBackfillEndBlock) {
+    ctx.issues.push({
+      code: "custom",
+      input: snapshot,
+      message: "`omnichainIndexingCursor` must be lower than or equal to the highest `backfillEndBlock` across all backfill chains."
+    });
+  }
+}
+function invariant_omnichainIndexingCursorIsEqualToHighestLatestIndexedBlockAcrossIndexedChain(ctx) {
+  const snapshot = ctx.value;
+  const indexedChains = Array.from(snapshot.chains.values()).filter(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill || chain.chainStatus === ChainIndexingStatusIds.Completed || chain.chainStatus === ChainIndexingStatusIds.Following
+  );
+  if (indexedChains.length === 0) {
+    return;
+  }
+  const indexedChainLatestIndexedBlocks = indexedChains.map(
+    (chain) => chain.latestIndexedBlock.timestamp
+  );
+  const indexedChainHighestLatestIndexedBlock = Math.max(...indexedChainLatestIndexedBlocks);
+  if (snapshot.omnichainIndexingCursor !== indexedChainHighestLatestIndexedBlock) {
+    ctx.issues.push({
+      code: "custom",
+      input: snapshot,
+      message: "`omnichainIndexingCursor` must be same as the highest `latestIndexedBlock` across all indexed chains."
+    });
+  }
+}
+function invariant_omnichainSnapshotUnstartedHasValidChains(ctx) {
+  const snapshot = ctx.value;
+  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(
+    Array.from(snapshot.chains.values())
+  );
+  if (hasValidChains === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: snapshot,
+      message: `For omnichain status snapshot 'unstarted', all chains must have "queued" status.`
+    });
+  }
+}
+function invariant_omnichainStatusSnapshotBackfillHasValidChains(ctx) {
+  const snapshot = ctx.value;
+  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(
+    Array.from(snapshot.chains.values())
+  );
+  if (hasValidChains === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: snapshot,
+      message: `For omnichain status snapshot 'backfill', at least one chain must be in "backfill" status and each chain has to have a status of either "queued", "backfill" or "completed".`
+    });
+  }
+}
+function invariant_omnichainStatusSnapshotCompletedHasValidChains(ctx) {
+  const snapshot = ctx.value;
+  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(
+    Array.from(snapshot.chains.values())
+  );
+  if (hasValidChains === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: snapshot,
+      message: `For omnichain status snapshot 'completed', all chains must have "completed" status.`
+    });
+  }
+}
+function invariant_omnichainStatusSnapshotFollowingHasValidChains(ctx) {
+  const snapshot = ctx.value;
+  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(
+    Array.from(snapshot.chains.values())
+  );
+  if (hasValidChains === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: snapshot,
+      message: "For omnichainStatus 'following', at least one chain must be in 'following' status."
+    });
+  }
+}
+var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => z7.object({
+  omnichainStatus: z7.literal(OmnichainIndexingStatusIds.Unstarted),
+  chains: z7.map(
+    makeChainIdSchema(),
+    z7.discriminatedUnion("chainStatus", [
+      makeChainIndexingStatusSnapshotQueuedSchema(valueLabel)
+    ]),
+    {
+      error: "Chains indexing statuses must be a Map with ChainId as keys and ChainIndexingStatusSnapshot as values."
+    }
+  ),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+}).check(invariant_omnichainSnapshotUnstartedHasValidChains);
+var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => z7.object({
+  omnichainStatus: z7.literal(OmnichainIndexingStatusIds.Backfill),
+  chains: z7.map(
+    makeChainIdSchema(),
+    z7.discriminatedUnion("chainStatus", [
+      makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
+      makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
+      makeChainIndexingStatusSnapshotCompletedSchema(valueLabel)
+    ]),
+    {
+      error: "Chains indexing statuses must be a Map with ChainId as keys and ChainIndexingStatusSnapshot as values."
+    }
+  ),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+}).check(invariant_omnichainStatusSnapshotBackfillHasValidChains);
+var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => z7.object({
+  omnichainStatus: z7.literal(OmnichainIndexingStatusIds.Completed),
+  chains: z7.map(
+    makeChainIdSchema(),
+    z7.discriminatedUnion("chainStatus", [
+      makeChainIndexingStatusSnapshotCompletedSchema(valueLabel)
+    ]),
+    {
+      error: "Chains indexing statuses must be a Map with ChainId as keys and ChainIndexingStatusSnapshot as values."
+    }
+  ),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+}).check(invariant_omnichainStatusSnapshotCompletedHasValidChains);
+var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => z7.object({
+  omnichainStatus: z7.literal(OmnichainIndexingStatusIds.Following),
+  chains: z7.map(
+    makeChainIdSchema(),
+    z7.discriminatedUnion("chainStatus", [
+      makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
+      makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
+      makeChainIndexingStatusSnapshotFollowingSchema(valueLabel),
+      makeChainIndexingStatusSnapshotCompletedSchema(valueLabel)
+    ]),
+    {
+      error: "Chains indexing statuses must be a Map with ChainId as keys and ChainIndexingStatusSnapshot as values."
+    }
+  ),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+}).check(invariant_omnichainStatusSnapshotFollowingHasValidChains);
+var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => z7.discriminatedUnion("omnichainStatus", [
+  makeOmnichainIndexingStatusSnapshotUnstartedSchema(valueLabel),
+  makeOmnichainIndexingStatusSnapshotBackfillSchema(valueLabel),
+  makeOmnichainIndexingStatusSnapshotCompletedSchema(valueLabel),
+  makeOmnichainIndexingStatusSnapshotFollowingSchema(valueLabel)
+]).check(invariant_omnichainSnapshotStatusIsConsistentWithChainSnapshot).check(invariant_omnichainIndexingCursorLowerThanEarliestStartBlockAcrossQueuedChains).check(
+  invariant_omnichainIndexingCursorLowerThanOrEqualToLatestBackfillEndBlockAcrossBackfillChains
+).check(invariant_omnichainIndexingCursorIsEqualToHighestLatestIndexedBlockAcrossIndexedChain);
+var makeSerializedOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => z7.object({
+  omnichainStatus: z7.literal(OmnichainIndexingStatusIds.Unstarted),
+  chains: z7.record(
+    makeChainIdStringSchema(),
+    z7.discriminatedUnion("chainStatus", [
+      makeChainIndexingStatusSnapshotQueuedSchema(valueLabel)
+    ])
+  ),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+});
+var makeSerializedOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => z7.object({
+  omnichainStatus: z7.literal(OmnichainIndexingStatusIds.Backfill),
+  chains: z7.record(
+    makeChainIdStringSchema(),
+    z7.discriminatedUnion("chainStatus", [
+      makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
+      makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
+      makeChainIndexingStatusSnapshotCompletedSchema(valueLabel)
+    ])
+  ),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+});
+var makeSerializedOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => z7.object({
+  omnichainStatus: z7.literal(OmnichainIndexingStatusIds.Completed),
+  chains: z7.record(
+    makeChainIdStringSchema(),
+    z7.discriminatedUnion("chainStatus", [
+      makeChainIndexingStatusSnapshotCompletedSchema(valueLabel)
+    ])
+  ),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+});
+var makeSerializedOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => z7.object({
+  omnichainStatus: z7.literal(OmnichainIndexingStatusIds.Following),
+  chains: z7.record(
+    makeChainIdStringSchema(),
+    z7.discriminatedUnion("chainStatus", [
+      makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
+      makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
+      makeChainIndexingStatusSnapshotFollowingSchema(valueLabel),
+      makeChainIndexingStatusSnapshotCompletedSchema(valueLabel)
+    ])
+  ),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+});
+var makeSerializedOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Value") => z7.discriminatedUnion("omnichainStatus", [
+  makeSerializedOmnichainIndexingStatusSnapshotUnstartedSchema(valueLabel),
+  makeSerializedOmnichainIndexingStatusSnapshotBackfillSchema(valueLabel),
+  makeSerializedOmnichainIndexingStatusSnapshotCompletedSchema(valueLabel),
+  makeSerializedOmnichainIndexingStatusSnapshotFollowingSchema(valueLabel)
+]);
+
+// src/indexing-status/zod-schema/cross-chain-indexing-status-snapshot.ts
+function invariant_slowestChainEqualsToOmnichainSnapshotTime(ctx) {
+  const { slowestChainIndexingCursor, omnichainSnapshot } = ctx.value;
+  const { omnichainIndexingCursor } = omnichainSnapshot;
+  if (slowestChainIndexingCursor !== omnichainIndexingCursor) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `'slowestChainIndexingCursor' must be equal to 'omnichainSnapshot.omnichainIndexingCursor'`
+    });
+  }
+}
+function invariant_snapshotTimeIsTheHighestKnownBlockTimestamp(ctx) {
+  const { snapshotTime, omnichainSnapshot } = ctx.value;
+  const chains = Array.from(omnichainSnapshot.chains.values());
+  const highestKnownBlockTimestamp = getHighestKnownBlockTimestamp(chains);
+  if (snapshotTime < highestKnownBlockTimestamp) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `'snapshotTime' (${snapshotTime}) must be greater than or equal to the "highest known block timestamp" (${highestKnownBlockTimestamp})`
+    });
+  }
+}
+var makeCrossChainIndexingStatusSnapshotOmnichainSchema = (valueLabel = "Cross-chain Indexing Status Snapshot Omnichain") => z8.object({
+  strategy: z8.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") => z8.discriminatedUnion("strategy", [
+  makeCrossChainIndexingStatusSnapshotOmnichainSchema(valueLabel)
+]);
+var makeSerializedCrossChainIndexingStatusSnapshotSchema = (valueLabel = "Serialized Cross-chain Indexing Status Snapshot") => z8.object({
+  strategy: z8.enum(CrossChainIndexingStrategyIds),
+  slowestChainIndexingCursor: makeUnixTimestampSchema(valueLabel),
+  snapshotTime: makeUnixTimestampSchema(valueLabel),
+  omnichainSnapshot: makeSerializedOmnichainIndexingStatusSnapshotSchema(valueLabel)
+});
+
+// src/indexing-status/zod-schema/realtime-indexing-status-projection.ts
+function invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime(ctx) {
+  const projection = ctx.value;
+  const { snapshot, projectedAt } = projection;
+  if (snapshot.snapshotTime > projectedAt) {
+    ctx.issues.push({
+      code: "custom",
+      input: projection,
+      message: "`projectedAt` must be after or same as `snapshot.snapshotTime`."
+    });
+  }
+}
+function invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect(ctx) {
+  const projection = ctx.value;
+  const { projectedAt, snapshot, worstCaseDistance } = projection;
+  const expectedWorstCaseDistance = projectedAt - snapshot.slowestChainIndexingCursor;
+  if (worstCaseDistance !== expectedWorstCaseDistance) {
+    ctx.issues.push({
+      code: "custom",
+      input: projection,
+      message: "`worstCaseDistance` must be the exact difference between `projectedAt` and `snapshot.slowestChainIndexingCursor`."
+    });
+  }
+}
+var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => z9.object({
+  projectedAt: makeUnixTimestampSchema(valueLabel).describe(
+    "The timestamp representing 'now' as of the time this projection was generated."
+  ),
+  worstCaseDistance: makeDurationSchema(valueLabel).describe(
+    "The distance between `projectedAt` and `snapshot.slowestChainIndexingCursor` in seconds. This is a worst-case distance because it assumes no indexing progress has been made since `snapshot.snapshotTime` and that each indexed chain has added a new block as of `projectedAt`."
+  ),
+  snapshot: makeCrossChainIndexingStatusSnapshotSchema(valueLabel).describe(
+    "The cross-chain indexing status snapshot that this projection is based on."
+  )
+}).check(invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime).check(invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect);
+var makeSerializedRealtimeIndexingStatusProjectionSchema = (valueLabel = "Value") => z9.object({
+  snapshot: makeSerializedCrossChainIndexingStatusSnapshotSchema(valueLabel).describe(
+    "The cross-chain indexing status snapshot that this projection is based on."
+  ),
+  projectedAt: makeUnixTimestampSchema(valueLabel).describe(
+    "The timestamp representing 'now' as of the time this projection was generated."
+  ),
+  worstCaseDistance: makeDurationSchema(valueLabel).describe(
+    "The distance between `projectedAt` and `snapshot.slowestChainIndexingCursor` in seconds. This is a worst-case distance because it assumes no indexing progress has been made since `snapshot.snapshotTime` and that each indexed chain has added a new block as of `projectedAt`."
+  )
+});
+
+// src/stack-info/zod-schemas/ensindexer-stack-info.ts
+import { z as z11 } from "zod/v4";
+
+// src/ensdb/zod-schemas/config.ts
+import { z as z10 } from "zod/v4";
+var makeEnsDbVersionInfoSchema = (valueLabel) => {
+  const label = valueLabel ?? "EnsDbVersionInfo";
+  return z10.object({
+    postgresql: z10.string().nonempty(`${label}.postgresql must be a non-empty string`).describe("Version of the PostgreSQL server hosting the ENSDb instance.")
+  });
+};
+var makeEnsDbPublicConfigSchema = (valueLabel) => {
+  const label = valueLabel ?? "EnsDbPublicConfig";
+  return z10.object({
+    versionInfo: makeEnsDbVersionInfoSchema(`${label}.versionInfo`)
+  });
+};
+
+// src/stack-info/zod-schemas/ensindexer-stack-info.ts
+function makeSerializedEnsIndexerStackInfoSchema(valueLabel) {
+  const label = valueLabel ?? "ENSIndexerStackInfo";
+  return z11.object({
+    ensDb: makeEnsDbPublicConfigSchema(`${label}.ensDb`),
+    ensIndexer: makeSerializedEnsIndexerPublicConfigSchema(`${label}.ensIndexer`),
+    ensRainbow: makeEnsRainbowPublicConfigSchema(`${label}.ensRainbow`)
+  });
+}
+function invariant_ensRainbowCompatibilityWithEnsIndexer(ctx) {
+  const { ensIndexer, ensRainbow } = ctx.value;
+  const { clientLabelSet } = ensIndexer;
+  const { serverLabelSet } = ensRainbow;
+  if (clientLabelSet.labelSetId !== serverLabelSet.labelSetId) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `ENSRainbow's label set (id: ${serverLabelSet.labelSetId}) must be the same as ENSIndexer's label set (id: ${clientLabelSet.labelSetId}).`
+    });
+  }
+  if (clientLabelSet.labelSetVersion > serverLabelSet.highestLabelSetVersion) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `ENSRainbow's server label set version (highest: ${serverLabelSet.highestLabelSetVersion}) must be greater than or equal to ENSIndexer's client label set version (current: ${clientLabelSet.labelSetVersion}).`
+    });
+  }
+}
+function makeEnsIndexerStackInfoSchema(valueLabel) {
+  const label = valueLabel ?? "ENSIndexerStackInfo";
+  return z11.object({
+    ensDb: makeEnsDbPublicConfigSchema(`${label}.ensDb`),
+    ensIndexer: makeEnsIndexerPublicConfigSchema(`${label}.ensIndexer`),
+    ensRainbow: makeEnsRainbowPublicConfigSchema(`${label}.ensRainbow`)
+  }).check(invariant_ensRainbowCompatibilityWithEnsIndexer);
+}
+
+// src/stack-info/zod-schemas/ensnode-stack-info.ts
+function invariant_ensApiCompatibilityWithEnsIndexerAndEnsRainbow(ctx) {
+  const { ensApi, ensIndexer, ensRainbow } = ctx.value;
+  if (ensIndexer.versionInfo.ensDb !== ensApi.versionInfo.ensApi) {
+    ctx.issues.push({
+      code: "custom",
+      path: ["ensIndexer", "versionInfo", "ensDb"],
+      input: ensIndexer.versionInfo.ensDb,
+      message: `Version Mismatch: ENSDB@${ensIndexer.versionInfo.ensDb} !== ENSApi@${ensApi.versionInfo.ensApi}`
+    });
+  }
+  if (ensIndexer.versionInfo.ensIndexer !== ensApi.versionInfo.ensApi) {
+    ctx.issues.push({
+      code: "custom",
+      path: ["ensIndexer", "versionInfo", "ensIndexer"],
+      input: ensIndexer.versionInfo.ensIndexer,
+      message: `Version Mismatch: ENSIndexer@${ensIndexer.versionInfo.ensIndexer} !== ENSApi@${ensApi.versionInfo.ensApi}`
+    });
+  }
+  if (ensRainbow.versionInfo.ensRainbow !== ensApi.versionInfo.ensApi) {
+    ctx.issues.push({
+      code: "custom",
+      path: ["ensRainbow", "versionInfo", "ensRainbow"],
+      input: ensRainbow.versionInfo.ensRainbow,
+      message: `Version Mismatch: ENSRainbow@${ensRainbow.versionInfo.ensRainbow} !== ENSApi@${ensApi.versionInfo.ensApi}`
+    });
+  }
+  if (ensIndexer.versionInfo.ensNormalize !== ensApi.versionInfo.ensNormalize) {
+    ctx.issues.push({
+      code: "custom",
+      path: ["ensIndexer", "versionInfo", "ensNormalize"],
+      input: ensIndexer.versionInfo.ensNormalize,
+      message: `Dependency Version Mismatch: '@adraffy/ens-normalize' version must be the same between ENSIndexer and ENSApi. Found ENSApi@${ensApi.versionInfo.ensNormalize} and ENSIndexer@${ensIndexer.versionInfo.ensNormalize}`
+    });
+  }
+}
+function makeSerializedEnsNodeStackInfoSchema(valueLabel) {
+  const label = valueLabel ?? "ENSNodeStackInfo";
+  return makeSerializedEnsIndexerStackInfoSchema(label).extend({
+    ensApi: makeSerializedEnsApiPublicConfigSchema(`${label}.ensApi`)
+  });
+}
+function makeEnsNodeStackInfoSchema(valueLabel) {
+  const label = valueLabel ?? "ENSNodeStackInfo";
+  return makeEnsIndexerStackInfoSchema(label).extend({
+    ensApi: makeEnsApiPublicConfigSchema(`${label}.ensApi`)
+  }).check(invariant_ensApiCompatibilityWithEnsIndexerAndEnsRainbow).check(invariant_ensRainbowCompatibilityWithEnsIndexer);
+}
+
+// src/ensnode/api/indexing-status/response.ts
+var EnsApiIndexingStatusResponseCodes = {
+  /**
+   * Represents that the indexing status is available.
+   */
+  Ok: "ok",
+  /**
+   * Represents that the indexing status is unavailable.
+   */
+  Error: "error"
+};
+
+// src/ensnode/api/indexing-status/zod-schemas.ts
+var makeEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => z12.strictObject({
+  responseCode: z12.literal(EnsApiIndexingStatusResponseCodes.Ok),
+  realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel),
+  stackInfo: makeEnsNodeStackInfoSchema(valueLabel)
+});
+var makeEnsApiIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => z12.strictObject({
+  responseCode: z12.literal(EnsApiIndexingStatusResponseCodes.Error)
+});
+var makeEnsApiIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => z12.discriminatedUnion("responseCode", [
+  makeEnsApiIndexingStatusResponseOkSchema(valueLabel),
+  makeEnsApiIndexingStatusResponseErrorSchema(valueLabel)
+]);
+var makeIndexingStatusResponseSchema = makeEnsApiIndexingStatusResponseSchema;
+var makeSerializedEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => z12.object({
+  responseCode: z12.literal(EnsApiIndexingStatusResponseCodes.Ok),
+  realtimeProjection: makeSerializedRealtimeIndexingStatusProjectionSchema(valueLabel),
+  stackInfo: makeSerializedEnsNodeStackInfoSchema(valueLabel)
+});
+var makeSerializedEnsApiIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => z12.discriminatedUnion("responseCode", [
+  makeSerializedEnsApiIndexingStatusResponseOkSchema(valueLabel),
+  makeEnsApiIndexingStatusResponseErrorSchema(valueLabel)
+]);
+
+// src/ensnode/api/name-tokens/examples.ts
+var nameTokensResponseOkExample = {
+  responseCode: "ok",
+  registeredNameTokens: {
+    domainId: "0xee6c4522aab0003e8d14cd40a6af439055fd2577951148c14b6cea9a53475835",
+    name: "vitalik.eth",
+    tokens: [
+      {
+        token: {
+          assetNamespace: "erc721",
+          contract: {
+            chainId: 1,
+            address: "0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85"
+          },
+          tokenId: "0xaf2caa1c2ca1d027f1ac823b529d0a67cd144264b2789fa2ea4d63a67c7103cc"
+        },
+        ownership: {
+          ownershipType: "fully-onchain",
+          owner: {
+            chainId: 1,
+            address: "0x220866b1a2219f40e72f5c628b65d54268ca3a9d"
+          }
+        },
+        mintStatus: "minted"
+      }
+    ],
+    expiresAt: 2461152330,
+    accurateAsOf: 17e8
+  }
+};
+var nameTokensServiceUnavailableExample = {
+  responseCode: "error",
+  errorCode: "unsupported-ensindexer-config",
+  error: {
+    message: "Name Tokens API is not available",
+    details: "Connected ENSIndexer must have all following plugins active: registrars, tokenscope"
+  }
+};
+var nameTokensNotIndexedExample = {
+  responseCode: "error",
+  errorCode: "name-tokens-not-indexed",
+  error: {
+    message: "No indexed Name Tokens found",
+    details: "This ENSNode instance has not been configured to index tokens for the requested name: 'vitalik.eth'"
+  }
+};
+
+// src/ensnode/api/name-tokens/zod-schemas.ts
+import { namehashInterpretedName } from "enssdk";
+import { z as z15 } from "zod/v4";
+
+// src/tokenscope/name-token.ts
+import { getParentInterpretedName } from "enssdk";
+import { isAddressEqual as isAddressEqual3, zeroAddress as zeroAddress3 } from "viem";
+import { DatasourceNames } from "@ensnode/datasources";
+
+// src/shared/account-id.ts
+import { isAddressEqual } from "viem";
+var accountIdEqual = (a, b) => {
+  return a.chainId === b.chainId && isAddressEqual(a.address, b.address);
+};
+
+// src/shared/datasource-contract.ts
+import {
+  maybeGetDatasource
+} from "@ensnode/datasources";
+var maybeGetDatasourceContract = (namespaceId, datasourceName, contractName) => {
+  const datasource = maybeGetDatasource(namespaceId, datasourceName);
+  if (!datasource) return void 0;
+  const address = datasource.contracts[contractName]?.address;
+  if (address === void 0 || Array.isArray(address)) return void 0;
+  return {
+    chainId: datasource.chain.id,
+    address
+  };
+};
+var getDatasourceContract = (namespaceId, datasourceName, contractName) => {
+  const contract = maybeGetDatasourceContract(namespaceId, datasourceName, contractName);
+  if (!contract) {
+    throw new Error(
+      `Expected contract not found for ${namespaceId} ${datasourceName} ${contractName}`
+    );
+  }
+  return contract;
+};
+var makeContractMatcher = (namespace, b) => (datasourceName, contractName) => {
+  const a = maybeGetDatasourceContract(namespace, datasourceName, contractName);
+  return a && accountIdEqual(a, b);
+};
+
+// src/tokenscope/assets.ts
+import {
+  stringifyAssetId
+} from "enssdk";
+import { isAddressEqual as isAddressEqual2, zeroAddress as zeroAddress2 } from "viem";
+import { prettifyError } from "zod/v4";
+
+// src/tokenscope/zod-schemas.ts
+import { AssetId as CaipAssetId } from "caip";
+import { AssetNamespaces } from "enssdk";
+import { zeroAddress } from "viem";
+import { z as z13 } from "zod/v4";
+var tokenIdSchemaSerializable = z13.string();
+var tokenIdSchemaNative = z13.preprocess(
+  (v) => typeof v === "string" ? BigInt(v) : v,
+  z13.bigint().positive()
+);
+function makeTokenIdSchema(_valueLabel = "Token ID Schema", serializable = false) {
+  if (serializable) {
+    return tokenIdSchemaSerializable;
+  } else {
+    return tokenIdSchemaNative;
+  }
+}
+var makeAssetIdSchema = (valueLabel = "Asset ID Schema", serializable) => {
+  return z13.object({
+    assetNamespace: z13.enum(AssetNamespaces),
+    contract: makeAccountIdSchema(valueLabel),
+    tokenId: makeTokenIdSchema(valueLabel, serializable ?? false)
+  });
+};
+var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => z13.preprocess((v) => {
+  if (typeof v === "string") {
+    const result = new CaipAssetId(v);
+    return {
+      assetNamespace: result.assetName.namespace,
+      contract: {
+        chainId: Number(result.chainId.reference),
+        address: result.assetName.reference
+      },
+      tokenId: result.tokenId
+    };
+  }
+  return v;
+}, makeAssetIdSchema(valueLabel));
+var makeDomainAssetSchema = (valueLabel = "Domain Asset Schema") => makeAssetIdSchema(valueLabel).extend({
+  domainId: makeNodeSchema(`${valueLabel}.domainId`)
+});
+function invariant_nameTokenOwnershipHasNonZeroAddressOwner(ctx) {
+  const ownership = ctx.value;
+  if (ctx.value.owner.address === zeroAddress) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `Name Token Ownership with '${ownership.ownershipType}' must have 'address' other than the zero address.`
+    });
+  }
+}
+var makeNameTokenOwnershipNameWrapperSchema = (valueLabel = "Name Token Ownership NameWrapper") => z13.object({
+  ownershipType: z13.literal(NameTokenOwnershipTypes.NameWrapper),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
+var makeNameTokenOwnershipFullyOnchainSchema = (valueLabel = "Name Token Ownership Fully Onchain") => z13.object({
+  ownershipType: z13.literal(NameTokenOwnershipTypes.FullyOnchain),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
+var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => z13.object({
+  ownershipType: z13.literal(NameTokenOwnershipTypes.Burned),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasZeroAddressOwner);
+var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => z13.object({
+  ownershipType: z13.literal(NameTokenOwnershipTypes.Unknown),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
+function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
+  const ownership = ctx.value;
+  if (ctx.value.owner.address !== zeroAddress) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `Name Token Ownership with '${ownership.ownershipType}' must have 'address' set to the zero address.`
+    });
+  }
+}
+var makeNameTokenOwnershipSchema = (valueLabel = "Name Token Ownership") => z13.discriminatedUnion("ownershipType", [
+  makeNameTokenOwnershipNameWrapperSchema(valueLabel),
+  makeNameTokenOwnershipFullyOnchainSchema(valueLabel),
+  makeNameTokenOwnershipBurnedSchema(valueLabel),
+  makeNameTokenOwnershipUnknownSchema(valueLabel)
+]);
+var makeNameTokenSchema = (valueLabel = "Name Token Schema", serializable) => z13.object({
+  token: makeAssetIdSchema(`${valueLabel}.token`, serializable),
+  ownership: makeNameTokenOwnershipSchema(`${valueLabel}.ownership`),
+  mintStatus: z13.enum(NFTMintStatuses)
+});
+
+// src/tokenscope/assets.ts
+var NFTMintStatuses = {
+  Minted: "minted",
+  Burned: "burned"
+};
+
+// src/tokenscope/name-token.ts
+var NameTokenOwnershipTypes = {
+  /**
+   * Name Token is owned by NameWrapper account.
+   */
+  NameWrapper: "namewrapper",
+  /**
+   * Name Token is owned fully onchain.
+   *
+   * This ownership type can only apply to direct subnames of `.eth`
+   */
+  FullyOnchain: "fully-onchain",
+  /**
+   * Name Token ownership has been transferred to the null address.
+   */
+  Burned: "burned",
+  /**
+   * Name Token ownership is unknown.
+   */
+  Unknown: "unknown"
+};
+
+// src/ensnode/api/shared/errors/zod-schemas.ts
+import { z as z14 } from "zod/v4";
+var makeErrorResponseSchema = () => z14.object({
+  message: z14.string().describe("A description of the error that occurred."),
+  details: z14.optional(z14.unknown()).describe("Additional details about the error.")
+});
+
+// src/ensnode/api/name-tokens/response.ts
+var NameTokensResponseCodes = {
+  /**
+   * Represents a response when Name Tokens API can respond with requested data.
+   */
+  Ok: "ok",
+  /**
+   * Represents a response when Name Tokens API could not respond with requested data.
+   */
+  Error: "error"
+};
+var NameTokensResponseErrorCodes = {
+  /**
+   * Name tokens not indexed
+   *
+   * Represents an error when tokens for the requested name are not indexed by
+   * the ENSNode instance's configuration.
+   */
+  NameTokensNotIndexed: "name-tokens-not-indexed",
+  /**
+   * Unsupported ENSIndexer Config
+   *
+   * Represents a prerequisites error when connected ENSIndexer config lacks
+   * params required to enable Name Tokens API.
+   */
+  EnsIndexerConfigUnsupported: "unsupported-ensindexer-config",
+  /**
+   * Unsupported Indexing Status
+   *
+   * Represents a prerequisites error when Indexing Status has not yet reached
+   * status required to enable Name Tokens API.
+   */
+  IndexingStatusUnsupported: "unsupported-indexing-status"
+};
+
+// src/ensnode/api/name-tokens/zod-schemas.ts
+var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", serializable) => z15.object({
+  domainId: makeNodeSchema(`${valueLabel}.domainId`),
+  name: makeReinterpretedNameSchema(valueLabel),
+  tokens: z15.array(makeNameTokenSchema(`${valueLabel}.tokens`, serializable)).nonempty(),
+  expiresAt: makeUnixTimestampSchema(`${valueLabel}.expiresAt`),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
+}).check(function invariant_nameIsAssociatedWithDomainId(ctx) {
+  const { name, domainId } = ctx.value;
+  if (namehashInterpretedName(name) !== domainId) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `'name' must be associated with 'domainId': ${domainId}`
+    });
+  }
+}).check(
+  function invariant_nameTokensOwnershipTypeNameWrapperRequiresOwnershipTypeFullyOnchainOrUnknown(ctx) {
+    const { tokens } = ctx.value;
+    const containsOwnershipNameWrapper = tokens.some(
+      (t) => t.ownership.ownershipType === NameTokenOwnershipTypes.NameWrapper
+    );
+    const containsOwnershipFullyOnchainOrUnknown = tokens.some(
+      (t) => t.ownership.ownershipType === NameTokenOwnershipTypes.FullyOnchain || t.ownership.ownershipType === NameTokenOwnershipTypes.Unknown
+    );
+    if (containsOwnershipNameWrapper && !containsOwnershipFullyOnchainOrUnknown) {
+      ctx.issues.push({
+        code: "custom",
+        input: ctx.value,
+        message: `'tokens' must contain name token with ownership type 'fully-onchain' or 'unknown' when name token with ownership type 'namewrapper' in listed`
+      });
+    }
+  }
+).check(function invariant_nameTokensContainAtMostOneWithOwnershipTypeEffective(ctx) {
+  const { tokens } = ctx.value;
+  const tokensCountWithOwnershipFullyOnchain = tokens.filter(
+    (t) => t.ownership.ownershipType === NameTokenOwnershipTypes.FullyOnchain
+  ).length;
+  if (tokensCountWithOwnershipFullyOnchain > 1) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `'tokens' must contain at most one name token with ownership type 'fully-onchain', current count: ${tokensCountWithOwnershipFullyOnchain}`
+    });
+  }
+});
+var makeNameTokensResponseOkSchema = (valueLabel = "Name Tokens Response OK", serializable) => z15.strictObject({
+  responseCode: z15.literal(NameTokensResponseCodes.Ok),
+  registeredNameTokens: makeRegisteredNameTokenSchema(`${valueLabel}.nameTokens`, serializable)
+});
+var makeNameTokensResponseErrorNameTokensNotIndexedSchema = (_valueLabel = "Name Tokens Response Error Name Not Indexed") => z15.strictObject({
+  responseCode: z15.literal(NameTokensResponseCodes.Error),
+  errorCode: z15.literal(NameTokensResponseErrorCodes.NameTokensNotIndexed),
+  error: makeErrorResponseSchema()
+});
+var makeNameTokensResponseErrorEnsIndexerConfigUnsupported = (_valueLabel = "Name Tokens Response Error ENSIndexer Config Unsupported") => z15.strictObject({
+  responseCode: z15.literal(NameTokensResponseCodes.Error),
+  errorCode: z15.literal(NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported),
+  error: makeErrorResponseSchema()
+});
+var makeNameTokensResponseErrorNameIndexingStatusUnsupported = (_valueLabel = "Name Tokens Response Error Indexing Status Unsupported") => z15.strictObject({
+  responseCode: z15.literal(NameTokensResponseCodes.Error),
+  errorCode: z15.literal(NameTokensResponseErrorCodes.IndexingStatusUnsupported),
+  error: makeErrorResponseSchema()
+});
+var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => z15.discriminatedUnion("errorCode", [
+  makeNameTokensResponseErrorNameTokensNotIndexedSchema(valueLabel),
+  makeNameTokensResponseErrorEnsIndexerConfigUnsupported(valueLabel),
+  makeNameTokensResponseErrorNameIndexingStatusUnsupported(valueLabel)
+]);
+var makeNameTokensResponseSchema = (valueLabel = "Name Tokens Response", serializable) => {
+  return z15.discriminatedUnion("responseCode", [
+    makeNameTokensResponseOkSchema(valueLabel, serializable ?? false),
+    makeNameTokensResponseErrorSchema(valueLabel)
+  ]);
+};
+
+// src/ensnode/api/realtime/zod-schemas.ts
+import { z as z16 } from "zod/v4";
+var realtimeResponseSchemaOk = z16.object({
+  maxWorstCaseDistance: makeDurationSchema().describe(
+    "The requested maximum acceptable worst-case indexing distance in seconds."
+  ),
+  slowestChainIndexingCursor: makeUnixTimestampSchema().describe(
+    "The timestamp of the slowest chain's latest indexed block."
+  ),
+  worstCaseDistance: makeDurationSchema().describe(
+    "The actual worst-case distance in seconds between 'now' and the slowest chain's indexing cursor. This allows your client to programmatically determine whether the ENSNode instance is sufficiently synchronized for your use case."
+  )
+});
+var realtimeResponseSchemaError = makeErrorResponseSchema();
+
+// src/ensnode/api/registrar-actions/examples.ts
+var registrarActionsResponseOkExample = {
+  responseCode: "ok",
+  registrarActions: [
+    {
+      action: {
+        type: "registration",
+        id: "0x0000000000000000000000000000000000000000000000000000000000000001",
+        incrementalDuration: 31536e3,
+        registrant: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
+        registrationLifecycle: {
+          subregistry: {
+            subregistryId: {
+              chainId: 1,
+              address: "0x253553366da8546fc250f225fe3d25d0c782303b"
+            },
+            node: "0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae"
+          },
+          node: "0xee6c4522aab0003e8d14cd40a6af439055fd2577951148c14b6cea9a53475835",
+          expiresAt: 1893456e3
+        },
+        pricing: {
+          baseCost: { amount: "1000000000000000", currency: "ETH" },
+          premium: { amount: "0", currency: "ETH" },
+          total: { amount: "1000000000000000", currency: "ETH" }
+        },
+        referral: { encodedReferrer: null, decodedReferrer: null },
+        block: { timestamp: 17e8, number: 185e5 },
+        transactionHash: "0x0000000000000000000000000000000000000000000000000000000000000001",
+        eventIds: ["0x0000000000000000000000000000000000000000000000000000000000000001"]
+      },
+      name: "vitalik.eth"
+    }
+  ],
+  pageContext: {
+    page: 1,
+    recordsPerPage: 25,
+    totalRecords: 1,
+    totalPages: 1,
+    hasNext: false,
+    hasPrev: false,
+    startIndex: 0,
+    endIndex: 0
+  },
+  accurateAsOf: 17e8
+};
+
+// src/ensnode/api/registrar-actions/zod-schemas.ts
+import { namehashInterpretedName as namehashInterpretedName2 } from "enssdk";
+import { z as z19 } from "zod/v4";
+
+// src/registrars/zod-schemas.ts
+import { z as z17 } from "zod/v4";
+
+// src/registrars/encoded-referrer.ts
+import { isNormalizedAddress, toNormalizedAddress as toNormalizedAddress2 } from "enssdk";
+import { pad, size as size2, slice, zeroAddress as zeroAddress4 } from "viem";
+var ENCODED_REFERRER_BYTE_OFFSET = 12;
+var ENCODED_REFERRER_BYTE_LENGTH = 32;
+var EXPECTED_ENCODED_REFERRER_PADDING = pad("0x", {
+  size: ENCODED_REFERRER_BYTE_OFFSET,
+  dir: "left"
+});
+var ZERO_ENCODED_REFERRER = pad("0x", {
+  size: ENCODED_REFERRER_BYTE_LENGTH,
+  dir: "left"
+});
+function decodeEncodedReferrer(encodedReferrer) {
+  if (size2(encodedReferrer) !== ENCODED_REFERRER_BYTE_LENGTH) {
+    throw new Error(
+      `Encoded referrer value must be represented by ${ENCODED_REFERRER_BYTE_LENGTH} bytes.`
+    );
+  }
+  const padding = slice(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
+  if (padding !== EXPECTED_ENCODED_REFERRER_PADDING) return zeroAddress4;
+  const decodedReferrer = slice(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
+  try {
+    return toNormalizedAddress2(decodedReferrer);
+  } catch {
+    throw new Error(`Decoded referrer value must be a valid EVM address.`);
+  }
+}
+
+// src/shared/serialize.ts
+function serializeChainId(chainId) {
+  return chainId.toString();
+}
+
+// src/registrars/registrar-action.ts
+var RegistrarActionTypes = {
+  Registration: "registration",
+  Renewal: "renewal"
+};
+
+// src/registrars/zod-schemas.ts
+var makeSubregistrySchema = (valueLabel = "Subregistry") => z17.object({
+  subregistryId: makeAccountIdSchema(`${valueLabel} Subregistry ID`),
+  node: makeNodeSchema(`${valueLabel} Node`)
+});
+var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => z17.object({
+  subregistry: makeSubregistrySchema(`${valueLabel} Subregistry`),
+  node: makeNodeSchema(`${valueLabel} Node`),
+  expiresAt: makeUnixTimestampSchema(`${valueLabel} Expires at`)
+});
+function invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium(ctx) {
+  const { baseCost, premium, total } = ctx.value;
+  const actualTotal = addPrices(baseCost, premium);
+  if (!isPriceEqual(actualTotal, total)) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `'total' must be equal to the sum of 'baseCost' and 'premium'`
+    });
+  }
+}
+var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => z17.union([
+  // pricing available
+  z17.object({
+    baseCost: makePriceEthSchema(`${valueLabel} Base Cost`),
+    premium: makePriceEthSchema(`${valueLabel} Premium`),
+    total: makePriceEthSchema(`${valueLabel} Total`)
+  }).check(invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium).transform((v) => v),
+  // pricing unknown
+  z17.object({
+    baseCost: z17.null(),
+    premium: z17.null(),
+    total: z17.null()
+  }).transform((v) => v)
+]);
+var makeSerializedRegistrarActionPricingSchema = (valueLabel = "Serialized Registrar Action Pricing") => z17.union([
+  // pricing available
+  z17.object({
+    baseCost: makeSerializedPriceEthSchema(`${valueLabel} Base Cost`),
+    premium: makeSerializedPriceEthSchema(`${valueLabel} Premium`),
+    total: makeSerializedPriceEthSchema(`${valueLabel} Total`)
+  }),
+  // pricing unknown
+  z17.object({
+    baseCost: z17.null(),
+    premium: z17.null(),
+    total: z17.null()
+  })
+]);
+function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
+  const { encodedReferrer, decodedReferrer } = ctx.value;
+  try {
+    const expectedDecodedReferrer = decodeEncodedReferrer(encodedReferrer);
+    if (decodedReferrer !== expectedDecodedReferrer) {
+      ctx.issues.push({
+        code: "custom",
+        input: ctx.value,
+        message: `'decodedReferrer' must be based on 'encodedReferrer'`
+      });
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: errorMessage
+    });
+  }
+}
+var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => z17.union([
+  // referral available
+  z17.object({
+    encodedReferrer: makeHexStringSchema(
+      { bytesCount: ENCODED_REFERRER_BYTE_LENGTH },
+      `${valueLabel} Encoded Referrer`
+    ),
+    decodedReferrer: makeNormalizedAddressSchema(`${valueLabel} Decoded Referrer`)
+  }).check(invariant_registrarActionDecodedReferrerBasedOnRawReferrer),
+  // referral not applicable
+  z17.object({
+    encodedReferrer: z17.null(),
+    decodedReferrer: z17.null()
+  })
+]);
+function invariant_eventIdsInitialElementIsTheActionId(ctx) {
+  const { id, eventIds } = ctx.value;
+  if (eventIds[0] !== id) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "The initial element of `eventIds` must be the `id` value"
+    });
+  }
+}
+var EventIdSchema = z17.string().nonempty();
+var EventIdsSchema = z17.array(EventIdSchema).min(1).transform((v) => v);
+var makeBaseRegistrarActionSchemaWithoutCheck = (valueLabel = "Base Registrar Action") => z17.object({
+  id: EventIdSchema,
+  incrementalDuration: makeDurationSchema(`${valueLabel} Incremental Duration`),
+  registrant: makeNormalizedAddressSchema(`${valueLabel} Registrant`),
+  registrationLifecycle: makeRegistrationLifecycleSchema(`${valueLabel} Registration Lifecycle`),
+  pricing: makeRegistrarActionPricingSchema(`${valueLabel} Pricing`),
+  referral: makeRegistrarActionReferralSchema(`${valueLabel} Referral`),
+  block: makeBlockRefSchema(`${valueLabel} Block`),
+  transactionHash: makeTransactionHashSchema(`${valueLabel} Transaction Hash`),
+  eventIds: EventIdsSchema
+});
+var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => makeBaseRegistrarActionSchemaWithoutCheck(valueLabel).check(
+  invariant_eventIdsInitialElementIsTheActionId
+);
+var makeRegistrarActionRegistrationSchema = (valueLabel = "Registration ") => makeBaseRegistrarActionSchema(valueLabel).extend({
+  type: z17.literal(RegistrarActionTypes.Registration)
+});
+var makeRegistrarActionRenewalSchema = (valueLabel = "Renewal") => makeBaseRegistrarActionSchema(valueLabel).extend({
+  type: z17.literal(RegistrarActionTypes.Renewal)
+});
+var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => z17.discriminatedUnion("type", [
+  makeRegistrarActionRegistrationSchema(`${valueLabel} Registration`),
+  makeRegistrarActionRenewalSchema(`${valueLabel} Renewal`)
+]);
+var makeSerializedBaseRegistrarActionSchema = (valueLabel = "Serialized Base Registrar Action") => makeBaseRegistrarActionSchemaWithoutCheck(valueLabel).extend({
+  pricing: makeSerializedRegistrarActionPricingSchema(`${valueLabel} Pricing`)
+});
+var makeSerializedRegistrarActionRegistrationSchema = (valueLabel = "Serialized Registration") => makeSerializedBaseRegistrarActionSchema(valueLabel).extend({
+  type: z17.literal(RegistrarActionTypes.Registration)
+});
+var makeSerializedRegistrarActionRenewalSchema = (valueLabel = "Serialized Renewal") => makeSerializedBaseRegistrarActionSchema(valueLabel).extend({
+  type: z17.literal(RegistrarActionTypes.Renewal)
+});
+var makeSerializedRegistrarActionSchema = (valueLabel = "Serialized Registrar Action") => z17.discriminatedUnion("type", [
+  makeSerializedRegistrarActionRegistrationSchema(`${valueLabel} Registration`),
+  makeSerializedRegistrarActionRenewalSchema(`${valueLabel} Renewal`)
+]);
+
+// src/ensnode/api/shared/pagination/zod-schemas.ts
+import { z as z18 } from "zod/v4";
+
+// src/ensnode/api/shared/pagination/request.ts
+var RECORDS_PER_PAGE_MAX = 100;
+
+// src/ensnode/api/shared/pagination/zod-schemas.ts
+var makeRequestPageParamsSchema = (valueLabel = "RequestPageParams") => z18.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") => z18.object({
+  totalRecords: z18.literal(0),
+  totalPages: z18.literal(1),
+  hasNext: z18.literal(false),
+  hasPrev: z18.literal(false)
+}).extend(makeRequestPageParamsSchema(valueLabel).shape);
+function invariant_responsePageWithRecordsIsCorrect(ctx) {
+  const { hasNext, hasPrev, recordsPerPage, page, totalRecords, startIndex, endIndex } = ctx.value;
+  const expectedHasNext = page * recordsPerPage < totalRecords;
+  if (hasNext !== expectedHasNext) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `hasNext must be equal to '${expectedHasNext ? "true" : "false"}'`
+    });
+  }
+  const expectedHasPrev = page > 1;
+  if (hasPrev !== expectedHasPrev) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `hasPrev must be equal to '${expectedHasPrev ? "true" : "false"}'`
+    });
+  }
+  if (endIndex < startIndex) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `endIndex must be greater than or equal to startIndex`
+    });
+  }
+  if (endIndex >= totalRecords) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `endIndex must be lower than totalRecords`
+    });
+  }
+}
+var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => z18.object({
+  totalRecords: makePositiveIntegerSchema(`${valueLabel}.totalRecords`),
+  totalPages: makePositiveIntegerSchema(`${valueLabel}.totalPages`),
+  hasNext: z18.boolean(),
+  hasPrev: z18.boolean(),
+  startIndex: makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`),
+  endIndex: makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`)
+}).extend(makeRequestPageParamsSchema(valueLabel).shape).check(invariant_responsePageWithRecordsIsCorrect);
+var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => z18.union([
+  makeResponsePageContextSchemaWithNoRecords(valueLabel),
+  makeResponsePageContextSchemaWithRecords(valueLabel)
+]);
+
+// src/ensnode/api/registrar-actions/response.ts
+var RegistrarActionsResponseCodes = {
+  /**
+   * Represents that Registrar Actions are available.
+   */
+  Ok: "ok",
+  /**
+   * Represents that Registrar Actions are unavailable.
+   */
+  Error: "error"
+};
+
+// src/ensnode/api/registrar-actions/zod-schemas.ts
+function invariant_registrationLifecycleNodeMatchesName(ctx) {
+  const { name, action } = ctx.value;
+  const expectedNode = action.registrationLifecycle.node;
+  const actualNode = namehashInterpretedName2(name);
+  if (actualNode !== expectedNode) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `The 'action.registrationLifecycle.node' must match namehash of 'name'`
+    });
+  }
+}
+var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => z19.object({
+  action: makeRegistrarActionSchema(valueLabel),
+  name: makeReinterpretedNameSchema(valueLabel)
+}).check(invariant_registrationLifecycleNodeMatchesName);
+var makeSerializedNamedRegistrarActionSchema = (valueLabel = "Serialized Named Registrar Action") => z19.object({
+  action: makeSerializedRegistrarActionSchema(valueLabel),
+  name: makeReinterpretedNameSchema(valueLabel)
+});
+var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => z19.object({
+  responseCode: z19.literal(RegistrarActionsResponseCodes.Ok),
+  registrarActions: z19.array(makeNamedRegistrarActionSchema(valueLabel)),
+  pageContext: makeResponsePageContextSchema(`${valueLabel}.pageContext`),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
+});
+var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => z19.strictObject({
+  responseCode: z19.literal(RegistrarActionsResponseCodes.Error),
+  error: makeErrorResponseSchema()
+});
+var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => z19.discriminatedUnion("responseCode", [
+  makeRegistrarActionsResponseOkSchema(valueLabel),
+  makeRegistrarActionsResponseErrorSchema(valueLabel)
+]);
+var makeSerializedRegistrarActionsResponseOkSchema = (valueLabel = "Serialized Registrar Actions Response OK") => z19.object({
+  responseCode: z19.literal(RegistrarActionsResponseCodes.Ok),
+  registrarActions: z19.array(makeSerializedNamedRegistrarActionSchema(valueLabel)),
+  pageContext: makeResponsePageContextSchema(`${valueLabel}.pageContext`),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
+});
+
+// src/ensnode/api/resolution/examples.ts
+var resolveRecordsResponseExample = {
+  records: {
+    addresses: { "60": "0xd8da6bf26964af9d7eed9e03e53415d37aa96045" },
+    texts: {
+      description: "mi pinxe lo crino tcati"
+    }
+  },
+  accelerationRequested: false,
+  accelerationAttempted: false
+};
+var resolvePrimaryNameResponseExample = {
+  name: "jesse.base.eth",
+  accelerationRequested: false,
+  accelerationAttempted: false
+};
+var resolvePrimaryNamesResponseExample = {
+  names: {
+    "1": "jesse.base.eth",
+    "10": null,
+    "8453": "jesse.base.eth",
+    "42161": null,
+    "59144": null,
+    "534352": null
+  },
+  accelerationRequested: false,
+  accelerationAttempted: false
+};
+
+// src/ensnode/api/resolution/zod-schemas.ts
+import { z as z20 } from "zod/v4";
+var makeResolverRecordsResponseSchema = () => z20.object({
+  name: z20.string().nullable().optional(),
+  addresses: z20.record(z20.string(), z20.string().nullable()).optional(),
+  texts: z20.record(z20.string(), z20.string().nullable()).optional(),
+  contenthash: z20.string().nullable().optional(),
+  pubkey: z20.object({ x: z20.string(), y: z20.string() }).nullable().optional(),
+  dnszonehash: z20.string().nullable().optional(),
+  version: z20.string().nullable().optional(),
+  abi: z20.object({ contentType: z20.string(), data: z20.string() }).nullable().optional(),
+  interfaces: z20.record(z20.string(), z20.string().nullable()).optional()
+});
+var makeResolveRecordsResponseSchema = () => z20.object({
+  records: makeResolverRecordsResponseSchema(),
+  accelerationRequested: z20.boolean(),
+  accelerationAttempted: z20.boolean(),
+  // TODO: Find a better way to handle recursive types, patch solution is .unknown()
+  trace: z20.array(z20.unknown()).optional()
+});
+var makeResolvePrimaryNameResponseSchema = () => z20.object({
+  name: z20.string().nullable(),
+  accelerationRequested: z20.boolean(),
+  accelerationAttempted: z20.boolean(),
+  trace: z20.array(z20.unknown()).optional()
+});
+var makeResolvePrimaryNamesResponseSchema = () => z20.object({
+  names: z20.record(z20.number(), z20.string().nullable()),
+  accelerationRequested: z20.boolean(),
+  accelerationAttempted: z20.boolean(),
+  trace: z20.array(z20.unknown()).optional()
+});
+
+// src/ensnode/api/shared/errors/examples.ts
+var errorResponseBadRequestExample = {
+  message: "Invalid Input"
+};
+var errorResponseInvalidNameExample = {
+  message: "Invalid Input",
+  details: {
+    errors: [],
+    properties: {
+      name: { errors: ["Must be normalized, see https://docs.ens.domains/resolution/names/"] }
+    }
+  }
+};
+var errorResponseInvalidAddressExample = {
+  message: "Invalid Input",
+  details: {
+    errors: [],
+    properties: { address: { errors: ["EVM address must be a valid EVM address"] } }
+  }
+};
+var errorResponseInternalServerErrorExample = {
+  message: "Internal Server Error"
+};
+
+// src/omnigraph-api/example-queries.ts
+import { asInterpretedName, toNormalizedAddress as toNormalizedAddress3 } from "enssdk";
+import { DatasourceNames as DatasourceNames2, ENSNamespaceIds as ENSNamespaceIds3 } from "@ensnode/datasources";
+import { accounts } from "@ensnode/datasources/devnet";
+var SEPOLIA_V2_V2_ETH_REGISTRY = maybeGetDatasourceContract(
+  ENSNamespaceIds3.SepoliaV2,
+  DatasourceNames2.ENSv2Root,
+  "ETHRegistry"
+);
+var SEPOLIA_V2_V2_ETH_REGISTRAR = maybeGetDatasourceContract(
+  ENSNamespaceIds3.SepoliaV2,
+  DatasourceNames2.ENSv2Root,
+  "ETHRegistrar"
+);
+var ENS_TEST_ENV_V2_ETH_REGISTRY = maybeGetDatasourceContract(
+  ENSNamespaceIds3.EnsTestEnv,
+  DatasourceNames2.ENSv2Root,
+  "ETHRegistry"
+);
+var ENS_TEST_ENV_V2_ETH_REGISTRAR = maybeGetDatasourceContract(
+  ENSNamespaceIds3.EnsTestEnv,
+  DatasourceNames2.ENSv2Root,
+  "ETHRegistrar"
+);
+var VITALIK_ADDRESS = toNormalizedAddress3("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045");
+var _SEPOLIA_V2_USER_ADDRESS = toNormalizedAddress3("0x2f8e8b1126e75fde0b7f731e7cb5847eba2d2574");
+var SEPOLIA_V2_ADDRESS_WITH_LOT_OF_NAMES = toNormalizedAddress3(
+  "0x205d2686da3bf33f64c17f21462c51b5ead462cf"
+);
+var DEVNET_NAME_WITH_OWNED_RESOLVER = asInterpretedName("example.eth");
+var SEPOLIA_V2_NAME_WITH_OWNED_RESOLVER = asInterpretedName("sfmonicdebmig.eth");
+var SEPOLIA_V2_TEST_NAME = asInterpretedName("test-name.eth");
+function getGraphqlApiExampleQueryById(id) {
+  const found = graphqlApiExampleQueryById.get(id);
+  if (!found) {
+    throw new Error(`Unknown GraphQL API example query id: ${id}`);
+  }
+  return found;
+}
+var GRAPHQL_API_EXAMPLE_QUERIES = [
+  ////////////////
+  // Hello World
+  ////////////////
+  {
+    id: "hello-world",
+    query: `#
+# Welcome to this interactive playground for
+# ENSNode's GraphQL API!
+#
+# You can get started by typing your query here or by using
+# the Explorer on the left to select the data you want to query.
+#
+# There are also example queries in the tabs above \u261D\uFE0F
+query HelloWorld {
+  domain(by: { name: "eth" }) { canonical { name { interpreted } } owner { address } }
+}`,
+    variables: { default: {} }
+  },
+  /////////////////
+  // Find Domains
+  /////////////////
+  {
+    id: "find-domains",
+    query: `
+query FindDomains(
+  $name: DomainsNameFilter!
+  $order: DomainsOrderInput
+) {
+  domains(
+    where: { name: $name }
+    order: $order
+    first: 20
+  ) {
+    edges {
+      node {
+        __typename
+        id
+        label { interpreted hash }
+        canonical { name { interpreted } }
+
+        registration { expiry event { timestamp } }
+      }
+    }
+  }
+}`,
+    variables: {
+      default: { name: { starts_with: "vitalik" }, order: { by: "NAME", dir: "DESC" } },
+      [ENSNamespaceIds3.EnsTestEnv]: {
+        name: { starts_with: "c" },
+        order: { by: "NAME", dir: "DESC" }
+      },
+      [ENSNamespaceIds3.SepoliaV2]: {
+        name: { starts_with: "test-na" },
+        order: { by: "NAME", dir: "DESC" }
+      }
+    }
+  },
+  ///////////////////
+  // Domain By Name
+  ///////////////////
+  {
+    id: "domain-by-name",
+    query: `
+query DomainByName($name: InterpretedName!) {
+  domain(by: {name: $name}) {
+    __typename
+    id
+    label { interpreted hash }
+    canonical { name { interpreted } node path { id } }
+    owner { address }
+    subregistry { contract { chainId address } }
+
+    ... on ENSv1Domain {
+      rootRegistryOwner { address }
+    }
+  }
+}`,
+    variables: {
+      default: { name: "eth" },
+      [ENSNamespaceIds3.SepoliaV2]: { name: SEPOLIA_V2_TEST_NAME }
+    }
+  },
+  //////////////////////
+  // Domain Subdomains
+  //////////////////////
+  {
+    id: "domain-subdomains",
+    query: `
+query DomainSubdomains($name: InterpretedName!) {
+  domain(by: {name: $name}) {
+    canonical { name { interpreted } }
+    subdomains(first: 10) {
+      edges {
+        node {
+          canonical { name { interpreted } }
+        }
+      }
+    }
+  }
+}`,
+    variables: { default: { name: "eth" } }
+  },
+  /////////////////
+  // Domain Events
+  /////////////////
+  {
+    id: "domain-events",
+    query: `
+query DomainEvents($name: InterpretedName!) {
+  domain(by: {name: $name}) {
+    events {
+      totalCount
+      edges {
+        node {
+          from
+          to
+          topics
+          data
+          timestamp
+          transactionHash
+        }
+      }
+    }
+  }
+}`,
+    variables: {
+      default: { name: "newowner.eth" },
+      [ENSNamespaceIds3.SepoliaV2]: { name: "sfmonicdebmig.eth" }
+    }
+  },
+  ////////////////////
+  // Account Domains
+  ////////////////////
+  {
+    id: "domains-by-address",
+    query: `
+query AccountDomains(
+  $address: Address!
+) {
+  account(by: { address: $address }) {
+    domains {
+      edges {
+        node {
+          label { interpreted }
+          canonical { name { interpreted } }
+        }
+      }
+    }
+  }
+}`,
+    variables: {
+      default: { address: VITALIK_ADDRESS },
+      [ENSNamespaceIds3.EnsTestEnv]: { address: accounts.owner.address },
+      [ENSNamespaceIds3.SepoliaV2]: { address: SEPOLIA_V2_ADDRESS_WITH_LOT_OF_NAMES }
+    }
+  },
+  ////////////////////
+  // Account Events
+  ////////////////////
+  {
+    id: "account-events",
+    query: `
+query AccountEvents(
+  $address: Address!
+) {
+  account(by: { address: $address }) {
+    events { totalCount edges { node { topics data timestamp } } }
+  }
+}`,
+    variables: {
+      default: { address: VITALIK_ADDRESS },
+      [ENSNamespaceIds3.EnsTestEnv]: { address: accounts.deployer.address },
+      [ENSNamespaceIds3.SepoliaV2]: { address: SEPOLIA_V2_ADDRESS_WITH_LOT_OF_NAMES }
+    }
+  },
+  /////////////////////
+  // Registry Domains
+  /////////////////////
+  {
+    id: "registry-domains",
+    query: `
+query RegistryDomains(
+  $registry: AccountIdInput!
+) {
+  registry(by: { contract: $registry }) {
+    domains {
+      edges {
+        node {
+          label { interpreted }
+          canonical { name { interpreted } }
+        }
+      }
+    }
+  }
+}`,
+    variables: {
+      // TODO: this only accesses v2 registries, so we default to ens-test-env for now
+      default: { registry: ENS_TEST_ENV_V2_ETH_REGISTRY },
+      [ENSNamespaceIds3.SepoliaV2]: { registry: SEPOLIA_V2_V2_ETH_REGISTRY }
+    }
+  },
+  ////////////////////////////
+  // Permissions By Contract
+  ////////////////////////////
+  {
+    id: "permissions-by-contract",
+    query: `
+query PermissionsByContract(
+  $contract: AccountIdInput!
+) {
+  permissions(by: { contract: $contract }) {
+    resources {
+      edges {
+        node {
+          resource
+          users {
+            edges {
+              node {
+                id
+                user { address }
+                roles
+              }
+            }
+          }
+        }
+      }
+    }
+    events { totalCount edges { node { topics data timestamp } } }
+  }
+}`,
+    variables: {
+      // TODO: same as above
+      default: { contract: ENS_TEST_ENV_V2_ETH_REGISTRAR },
+      // TODO: example response is empty for this address on Sepolia V2
+      [ENSNamespaceIds3.SepoliaV2]: { contract: SEPOLIA_V2_V2_ETH_REGISTRAR }
+    }
+  },
+  ////////////////////////
+  // Permissions By User
+  ////////////////////////
+  {
+    id: "permissions-by-user",
+    query: `
+query PermissionsByUser($address: Address!) {
+  account(by: { address: $address }) {
+    permissions {
+      edges {
+        node {
+          resource
+          roles
+        }
+      }
+    }
+  }
+}`,
+    variables: {
+      default: { address: accounts.deployer.address },
+      // TODO: example response is empty for this address on Sepolia V2
+      [ENSNamespaceIds3.SepoliaV2]: { address: SEPOLIA_V2_ADDRESS_WITH_LOT_OF_NAMES }
+    }
+  },
+  //////////////////////////////////
+  // Account Resolver Permissions
+  //////////////////////////////////
+  {
+    id: "account-resolver-permissions",
+    query: `
+query AccountResolverPermissions($address: Address!) {
+  account(by: { address: $address }) {
+    resolverPermissions {
+      edges {
+        node {
+          resolver {
+            contract {
+              address
+            }
+          }
+        }
+      }
+    }
+  }
+}`,
+    variables: {
+      default: { address: accounts.deployer.address },
+      [ENSNamespaceIds3.SepoliaV2]: { address: SEPOLIA_V2_ADDRESS_WITH_LOT_OF_NAMES }
+    }
+  },
+  //////////////////////////////
+  // Domain's Assigned Resolver
+  //////////////////////////////
+  {
+    id: "domain-resolver",
+    query: `
+query DomainResolver($name: InterpretedName!) {
+  domain(by: { name: $name }) {
+    resolver {
+      assigned {
+        records { edges { node { node keys coinTypes } } }
+        permissions { resources { edges { node { resource users { edges { node { user { address } roles } } } } } } }
+        events { totalCount edges { node { topics data timestamp } } }
+      }
+    }
+  }
+}`,
+    variables: {
+      default: { name: "vitalik.eth" },
+      [ENSNamespaceIds3.EnsTestEnv]: { name: DEVNET_NAME_WITH_OWNED_RESOLVER },
+      [ENSNamespaceIds3.SepoliaV2]: { name: SEPOLIA_V2_NAME_WITH_OWNED_RESOLVER }
+    }
+  },
+  //////////////
+  // Namegraph
+  //////////////
+  {
+    id: "namegraph",
+    query: `
+query Namegraph {
+  root {
+    id
+    domains {
+      edges {
+        node {
+          canonical { name { interpreted } }
+
+          subdomains {
+            edges {
+              node {
+                canonical { name { interpreted } }
+
+                subdomains {
+                  edges {
+                    node {
+                      canonical { name { interpreted } }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}`,
+    variables: { default: {} }
+  }
+];
+var graphqlApiExampleQueryById = new Map(
+  GRAPHQL_API_EXAMPLE_QUERIES.map((entry) => [entry.id, entry])
+);
+
+// src/rpc/eip-165.ts
+var EIP_165_ABI = [
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "interfaceID",
+        type: "bytes4"
+      }
+    ],
+    name: "supportsInterface",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+async function supportsInterface({
+  publicClient,
+  interfaceId: selector,
+  address
+}) {
+  try {
+    return await publicClient.readContract({
+      abi: EIP_165_ABI,
+      functionName: "supportsInterface",
+      address,
+      args: [selector]
+    });
+  } catch {
+    return false;
+  }
+}
+var makeSupportsInterfaceReader = (interfaceId) => (args) => supportsInterface({
+  ...args,
+  interfaceId
+});
+
+// src/rpc/is-extended-resolver.ts
+var IExtendedResolverInterfaceId = "0x9061b923";
+var isExtendedResolver = makeSupportsInterfaceReader(IExtendedResolverInterfaceId);
+
+// src/shared/config/build-rpc-urls.ts
+import {
+  arbitrum,
+  arbitrumSepolia,
+  base,
+  baseSepolia,
+  linea,
+  lineaSepolia,
+  mainnet,
+  optimism,
+  optimismSepolia,
+  scroll,
+  scrollSepolia,
+  sepolia
+} from "viem/chains";
+function buildAlchemyBaseUrl(chainId, key) {
+  switch (chainId) {
+    case mainnet.id:
+      return `eth-mainnet.g.alchemy.com/v2/${key}`;
+    case sepolia.id:
+      return `eth-sepolia.g.alchemy.com/v2/${key}`;
+    case arbitrum.id:
+      return `arb-mainnet.g.alchemy.com/v2/${key}`;
+    case arbitrumSepolia.id:
+      return `arb-sepolia.g.alchemy.com/v2/${key}`;
+    case base.id:
+      return `base-mainnet.g.alchemy.com/v2/${key}`;
+    case baseSepolia.id:
+      return `base-sepolia.g.alchemy.com/v2/${key}`;
+    case optimism.id:
+      return `opt-mainnet.g.alchemy.com/v2/${key}`;
+    case optimismSepolia.id:
+      return `opt-sepolia.g.alchemy.com/v2/${key}`;
+    case linea.id:
+      return `linea-mainnet.g.alchemy.com/v2/${key}`;
+    case lineaSepolia.id:
+      return `linea-sepolia.g.alchemy.com/v2/${key}`;
+    case scroll.id:
+      return `scroll-mainnet.g.alchemy.com/v2/${key}`;
+    case scrollSepolia.id:
+      return `scroll-sepolia.g.alchemy.com/v2/${key}`;
+    default:
+      return void 0;
+  }
+}
+function buildDRPCUrl(chainId, key) {
+  switch (chainId) {
+    case mainnet.id:
+      return `https://lb.drpc.live/ethereum/${key}`;
+    case sepolia.id:
+      return `https://lb.drpc.live/ethereum-sepolia/${key}`;
+    case arbitrum.id:
+      return `https://lb.drpc.live/arbitrum/${key}`;
+    case arbitrumSepolia.id:
+      return `https://lb.drpc.live/arbitrum-sepolia/${key}`;
+    case base.id:
+      return `https://lb.drpc.live/base/${key}`;
+    case baseSepolia.id:
+      return `https://lb.drpc.live/base-sepolia/${key}`;
+    case optimism.id:
+      return `https://lb.drpc.live/optimism/${key}`;
+    case optimismSepolia.id:
+      return `https://lb.drpc.live/optimism-sepolia/${key}`;
+    case linea.id:
+      return `https://lb.drpc.live/linea/${key}`;
+    case lineaSepolia.id:
+      return `https://lb.drpc.live/linea-sepolia/${key}`;
+    case scroll.id:
+      return `https://lb.drpc.live/scroll/${key}`;
+    case scrollSepolia.id:
+      return `https://lb.drpc.live/scroll-sepolia/${key}`;
+    default:
+      return void 0;
+  }
+}
+function buildQuickNodeURL(chainId, apiKey, endpointName) {
+  switch (chainId) {
+    case mainnet.id:
+      return `${endpointName}.quiknode.pro/${apiKey}`;
+    case sepolia.id:
+      return `${endpointName}.ethereum-sepolia.quiknode.pro/${apiKey}`;
+    case arbitrum.id:
+      return `${endpointName}.arbitrum-mainnet.quiknode.pro/${apiKey}`;
+    case arbitrumSepolia.id:
+      return `${endpointName}.arbitrum-sepolia.quiknode.pro/${apiKey}`;
+    case base.id:
+      return `${endpointName}.base-mainnet.quiknode.pro/${apiKey}`;
+    case baseSepolia.id:
+      return `${endpointName}.base-sepolia.quiknode.pro/${apiKey}`;
+    case optimism.id:
+      return `${endpointName}.optimism.quiknode.pro/${apiKey}`;
+    case optimismSepolia.id:
+      return `${endpointName}.optimism-sepolia.quiknode.pro/${apiKey}`;
+    case linea.id:
+      return `${endpointName}.linea-mainnet.quiknode.pro/${apiKey}`;
+    case lineaSepolia.id:
+      return void 0;
+    case scroll.id:
+      return `${endpointName}.scroll-mainnet.quiknode.pro/${apiKey}`;
+    case scrollSepolia.id:
+      return `${endpointName}.scroll-testnet.quiknode.pro/${apiKey}`;
+    default:
+      return void 0;
+  }
+}
+function alchemySupportsChain(chainId) {
+  return buildAlchemyBaseUrl(chainId, "") !== void 0;
+}
+function dRPCSupportsChain(chainId) {
+  return buildDRPCUrl(chainId, "") !== void 0;
+}
+function quickNodeSupportsChain(chainId) {
+  return buildQuickNodeURL(chainId, "", "") !== void 0;
+}
+
+// src/shared/config/pretty-printing.ts
+function configJSONReplacer(key, value) {
+  if (value instanceof URL) return value.href;
+  if (key === "abi") return "(truncated ABI output)";
+  if (value instanceof Map) return Object.fromEntries(value);
+  if (value instanceof Set) return Array.from(value);
+  return value;
+}
+var stringifyConfig = (json, options = { pretty: false }) => JSON.stringify(json, configJSONReplacer, options.pretty ? 2 : void 0);
+
+// src/shared/config/redacting.ts
+var REDACTED = "*****";
+function redactUrl(url) {
+  return new URL(`/${REDACTED}`, url.origin);
+}
+function redactString(_) {
+  return REDACTED;
+}
+function redactRpcConfigs(rpcConfigs) {
+  const redactedRpcConfigs = /* @__PURE__ */ new Map();
+  for (const [chainId, rpcConfig] of rpcConfigs.entries()) {
+    const redactedHttpRPCs = rpcConfig.httpRPCs.map(redactUrl);
+    const redactedWebsocketRPC = rpcConfig.websocketRPC ? redactUrl(rpcConfig.websocketRPC) : void 0;
+    redactedRpcConfigs.set(chainId, {
+      httpRPCs: redactedHttpRPCs,
+      websocketRPC: redactedWebsocketRPC
+    });
+  }
+  return redactedRpcConfigs;
+}
+
+// src/shared/config/rpc-configs-from-env.ts
+import {
+  ensTestEnvChain,
+  getENSNamespace
+} from "@ensnode/datasources";
+var RpcAutoGenModes = {
+  /**
+   * Auto-generates only HTTP RPCs for supported chains.
+   */
+  HttpOnly: "http-only",
+  /**
+   * Auto-generates both HTTP and WebSocket RPCs for supported chains.
+   */
+  HttpAndWs: "http-and-ws"
+};
+var DEFAULT_RPC_AUTO_GEN_MODE = RpcAutoGenModes.HttpOnly;
+function buildRpcAutoGenMode(env) {
+  const mode = env.RPC_AUTO_GEN_MODE;
+  if (!mode) {
+    return DEFAULT_RPC_AUTO_GEN_MODE;
+  }
+  if (!Object.values(RpcAutoGenModes).includes(mode)) {
+    throw new Error(
+      `Invalid RPC_AUTO_GEN_MODE env var: ${mode}. Valid values are: ${Object.values(RpcAutoGenModes).join(", ")}`
+    );
+  }
+  return mode;
+}
+function buildRpcConfigsFromEnv(env, namespace) {
+  const alchemyApiKey = env.ALCHEMY_API_KEY;
+  const quickNodeApiKey = env.QUICKNODE_API_KEY;
+  const quickNodeEndpointName = env.QUICKNODE_ENDPOINT_NAME;
+  const dRPCKey = env.DRPC_API_KEY;
+  if (quickNodeApiKey && !quickNodeEndpointName) {
+    throw new Error(
+      "Use of the QUICKNODE_API_KEY environment variable requires use of the QUICKNODE_ENDPOINT_NAME environment variable as well."
+    );
+  }
+  if (quickNodeEndpointName && !quickNodeApiKey) {
+    throw new Error(
+      "Use of the QUICKNODE_ENDPOINT_NAME environment variable requires use of the QUICKNODE_API_KEY environment variable as well."
+    );
+  }
+  const chainsInNamespace = Object.entries(getENSNamespace(namespace)).map(
+    ([, datasource]) => datasource.chain
+  );
+  const rpcAutoGenMode = buildRpcAutoGenMode(env);
+  const rpcConfigs = {};
+  for (const chain of chainsInNamespace) {
+    const specificValue = env[`RPC_URL_${chain.id}`];
+    if (specificValue) {
+      rpcConfigs[serializeChainId(chain.id)] = specificValue;
+      continue;
+    }
+    if (chain.id === ensTestEnvChain.id) {
+      rpcConfigs[serializeChainId(ensTestEnvChain.id)] = ensTestEnvChain.rpcUrls.default.http[0];
+      continue;
+    }
+    const httpUrls = [
+      // alchemy, if specified and available
+      alchemyApiKey && alchemySupportsChain(chain.id) && `https://${buildAlchemyBaseUrl(chain.id, alchemyApiKey)}`,
+      // QuickNode, if specified and available
+      quickNodeApiKey && quickNodeEndpointName && quickNodeSupportsChain(chain.id) && `https://${buildQuickNodeURL(chain.id, quickNodeApiKey, quickNodeEndpointName)}`,
+      // dRPC, if specified and available
+      dRPCKey && dRPCSupportsChain(chain.id) && buildDRPCUrl(chain.id, dRPCKey)
+    ];
+    const wsUrl = rpcAutoGenMode === RpcAutoGenModes.HttpAndWs && alchemyApiKey && alchemySupportsChain(chain.id) && //
+    `wss://${buildAlchemyBaseUrl(chain.id, alchemyApiKey)}`;
+    const urls = [...httpUrls, wsUrl].filter(Boolean);
+    if (urls.length > 0) {
+      rpcConfigs[serializeChainId(chain.id)] = urls.join(
+        ","
+      );
+    }
+  }
+  return rpcConfigs;
+}
+
+// src/shared/config/validatons.ts
+import { getENSRootChainId as getENSRootChainId2 } from "@ensnode/datasources";
+
+// src/shared/url.ts
+function isHttpProtocol(url) {
+  return ["http:", "https:"].includes(url.protocol);
+}
+function isWebSocketProtocol(url) {
+  return ["ws:", "wss:"].includes(url.protocol);
+}
+
+// src/shared/config/validatons.ts
+function invariant_rpcEndpointConfigIncludesAtLeastOneHTTPProtocolURL(ctx) {
+  const endpoints = ctx.value;
+  const httpEndpoints = endpoints.filter(isHttpProtocol);
+  if (httpEndpoints.length < 1) {
+    ctx.issues.push({
+      code: "custom",
+      input: endpoints,
+      message: `RPC endpoint configuration for a chain must include at least one http/https protocol URL.`
+    });
+  }
+}
+function invariant_rpcEndpointConfigIncludesAtMostOneWebSocketsProtocolURL(ctx) {
+  const endpoints = ctx.value;
+  const wsEndpoints = endpoints.filter(isWebSocketProtocol);
+  if (wsEndpoints.length > 1) {
+    ctx.issues.push({
+      code: "custom",
+      input: endpoints,
+      message: `RPC endpoint configuration for a chain must include at most one websocket (ws/wss) protocol URL.`
+    });
+  }
+}
+function invariant_rpcConfigsSpecifiedForRootChain(ctx) {
+  const { value: config } = ctx;
+  const ensRootChainId = getENSRootChainId2(config.namespace);
+  if (!config.rpcConfigs.has(ensRootChainId)) {
+    ctx.issues.push({
+      code: "custom",
+      input: config,
+      message: `An RPC Config for the ENS Root Chain ('${ensRootChainId}') is required, but none was specified.`
+    });
+  }
+}
+
+// src/shared/config/zod-schemas.ts
+import { z as z22 } from "zod/v4";
+import { ENSNamespaceIds as ENSNamespaceIds4 } from "@ensnode/datasources";
+
+// src/shared/deserialize.ts
+import z21, { prettifyError as prettifyError2 } from "zod/v4";
+function deserializeChainId(maybeChainId, valueLabel) {
+  const schema = makeChainIdStringSchema(valueLabel);
+  const parsed = schema.safeParse(maybeChainId);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize ChainId:
+${prettifyError2(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+
+// src/shared/config/zod-schemas.ts
+var RpcConfigSchema = z22.string().transform((val) => val.split(",")).pipe(z22.array(makeUrlSchema("RPC URL"))).check(invariant_rpcEndpointConfigIncludesAtLeastOneHTTPProtocolURL).check(invariant_rpcEndpointConfigIncludesAtMostOneWebSocketsProtocolURL);
+var RpcConfigsSchema = z22.record(makeChainIdStringSchema("RPC URL"), RpcConfigSchema, {
+  error: "Chains configuration must be an object mapping valid chain IDs to their configs."
+}).transform((records) => {
+  const rpcConfigs = /* @__PURE__ */ new Map();
+  for (const [chainIdString, rpcConfig] of Object.entries(records)) {
+    const httpRPCs = rpcConfig.filter(isHttpProtocol);
+    const websocketRPC = rpcConfig.find(isWebSocketProtocol);
+    rpcConfigs.set(deserializeChainId(chainIdString), {
+      httpRPCs,
+      websocketRPC
+    });
+  }
+  return rpcConfigs;
+});
+var ENSNamespaceSchema = z22.enum(ENSNamespaceIds4, {
+  error: ({ input }) => `Invalid NAMESPACE. Got '${input}', but supported ENS namespaces are: ${Object.keys(ENSNamespaceIds4).join(", ")}`
+});
+var PortNumberSchema = z22.coerce.number({ error: "PORT must be a number." }).int({ error: "PORT must be an integer." }).min(1, { error: "PORT must be greater than or equal to 1." }).max(65535, { error: "PORT must be less than or equal to 65535." });
+var OptionalPortNumberSchema = PortNumberSchema.optional();
+var TheGraphApiKeySchema = z22.string().optional();
+
+// src/shared/config-templates.ts
+import { ENSNamespaceIds as ENSNamespaceIds5 } from "@ensnode/datasources";
+var ConfigTemplateIds = {
+  Mainnet: "mainnet",
+  Sepolia: "sepolia",
+  Alpha: "alpha",
+  AlphaSepolia: "alpha-sepolia"
+};
+function isConfigTemplateSubgraphCompatible(configTemplateId) {
+  switch (configTemplateId) {
+    // these ConfigTemplates are run with SUBGRAPH_COMPAT, meaning they are Subgraph Compatible
+    case ConfigTemplateIds.Mainnet:
+    case ConfigTemplateIds.Sepolia:
+      return true;
+    // these instances are NOT run with SUBGRAPH_COMPAT, meaning they are NOT Subgraph Compatible
+    case ConfigTemplateIds.Alpha:
+    case ConfigTemplateIds.AlphaSepolia:
+      return false;
+    default:
+      throw new Error("never");
+  }
+}
+function namespaceForConfigTemplateId(configTemplateId) {
+  switch (configTemplateId) {
+    case ConfigTemplateIds.Alpha:
+    case ConfigTemplateIds.Mainnet:
+      return ENSNamespaceIds5.Mainnet;
+    case ConfigTemplateIds.AlphaSepolia:
+    case ConfigTemplateIds.Sepolia:
+      return ENSNamespaceIds5.Sepolia;
+    default:
+      throw new Error("never");
+  }
+}
+
+// src/shared/datasources-with-ensv2-contracts.ts
+import {
+  DatasourceNames as DatasourceNames3,
+  maybeGetDatasource as maybeGetDatasource2
+} from "@ensnode/datasources";
+var DATASOURCE_NAMES_WITH_ENSv2_CONTRACTS = [
+  DatasourceNames3.ENSv2Root
+];
+var getDatasourcesWithENSv2Contracts = (namespace) => DATASOURCE_NAMES_WITH_ENSv2_CONTRACTS.map(
+  (datasourceName) => maybeGetDatasource2(namespace, datasourceName)
+).filter((datasource) => !!datasource).map((datasource) => {
+  if (!datasource.contracts.Registry || !datasource.contracts.EnhancedAccessControl) {
+    throw new Error(
+      `Invariant: Datasource does not define 'Registry' and 'EnhancedAccessControl' contracts. Defined contracts: ${JSON.stringify(Object.keys(datasource.contracts))}`
+    );
+  }
+  return datasource;
+});
+
+// src/shared/datasources-with-resolvers.ts
+import {
+  DatasourceNames as DatasourceNames4,
+  maybeGetDatasource as maybeGetDatasource3
+} from "@ensnode/datasources";
+var DATASOURCE_NAMES_WITH_RESOLVERS = [
+  DatasourceNames4.ENSRoot,
+  DatasourceNames4.Basenames,
+  DatasourceNames4.Lineanames,
+  DatasourceNames4.ThreeDNSOptimism,
+  DatasourceNames4.ThreeDNSBase,
+  // all datasources that define ENSv2 contracts also define Resolver
+  ...DATASOURCE_NAMES_WITH_ENSv2_CONTRACTS
+];
+var getDatasourcesWithResolvers = (namespace) => DATASOURCE_NAMES_WITH_RESOLVERS.map(
+  (datasourceName) => maybeGetDatasource3(namespace, datasourceName)
+).filter((datasource) => !!datasource).map((datasource) => {
+  if (!datasource.contracts.Resolver) {
+    throw new Error(
+      `Invariant: Datasource does not define a 'Resolver' contract. Defined contracts: ${JSON.stringify(Object.keys(datasource.contracts))}`
+    );
+  }
+  return datasource;
+});
+
+// src/shared/interpretation/interpret-address.ts
+import { isAddressEqual as isAddressEqual4, zeroAddress as zeroAddress5 } from "viem";
+var interpretAddress = (owner) => isAddressEqual4(zeroAddress5, owner) ? null : owner;
+
+// src/shared/interpretation/interpret-record-values.ts
+import { isInterpretedName, toNormalizedAddress as toNormalizedAddress4 } from "enssdk";
+import { isAddress as isAddress2, isAddressEqual as isAddressEqual5, zeroAddress as zeroAddress6 } from "viem";
+
+// src/shared/null-bytes.ts
+var hasNullByte = (value) => value.indexOf("\0") !== -1;
+
+// src/shared/interpretation/interpret-record-values.ts
+function interpretNameRecordValue(value) {
+  if (value === "") return null;
+  if (!isInterpretedName(value)) return null;
+  return value;
+}
+function interpretAddressRecordValue(value) {
+  if (hasNullByte(value)) return null;
+  if (value === "") return null;
+  if (value === "0x") return null;
+  if (!isAddress2(value, { strict: false })) return value;
+  if (isAddressEqual5(value, zeroAddress6)) return null;
+  return toNormalizedAddress4(value);
+}
+function interpretTextRecordKey(key) {
+  if (hasNullByte(key)) return null;
+  if (key === "") return null;
+  return key;
+}
+function interpretTextRecordValue(value) {
+  if (hasNullByte(value)) return null;
+  if (value === "") return null;
+  return value;
+}
+
+// src/shared/interpretation/interpret-resolver-values.ts
+import { size as size3, zeroHash } from "viem";
+function interpretContenthashValue(value) {
+  if (size3(value) === 0) return null;
+  return value;
+}
+function interpretPubkeyValue(x, y) {
+  if (x === zeroHash && y === zeroHash) return null;
+  return { x, y };
+}
+function interpretDnszonehashValue(value) {
+  if (size3(value) === 0) return null;
+  return value;
+}
+
+// src/shared/log-level.ts
+import { z as z23 } from "zod/v4";
+var LogLevelSchema = z23.enum(["fatal", "error", "warn", "info", "debug", "trace", "silent"]);
+function getLogLevelFromEnv(env, defaultLogLevel) {
+  try {
+    return LogLevelSchema.default(defaultLogLevel).parse(env.LOG_LEVEL);
+  } catch {
+    console.warn(
+      `Invalid LOG_LEVEL '${env.LOG_LEVEL}', expected one of '${Object.values(LogLevelSchema.enum).join("' | '")}' defaulting to '${defaultLogLevel}'`
+    );
+    return defaultLogLevel;
+  }
+}
+
+// src/shared/protocol-acceleration/is-bridged-resolver.ts
+import {
+  makeENSv1DomainId,
+  makeENSv1VirtualRegistryId
+} from "enssdk";
+import { DatasourceNames as DatasourceNames7, maybeGetDatasource as maybeGetDatasource4 } from "@ensnode/datasources";
+
+// src/shared/managed-names.ts
+import {
+  asInterpretedName as asInterpretedName2,
+  ENS_ROOT_NAME,
+  namehashInterpretedName as namehashInterpretedName3,
+  stringifyAccountId
+} from "enssdk";
+import { DatasourceNames as DatasourceNames5 } from "@ensnode/datasources";
+
+// src/shared/to-json.ts
+var toJson = (value, options) => JSON.stringify(
+  value,
+  (_key, val) => typeof val === "bigint" ? String(val) : val,
+  options?.pretty ? 2 : void 0
+);
+
+// src/shared/managed-names.ts
+var MANAGED_NAME_BY_NAMESPACE = {
+  sepolia: {
+    "base.eth": "basetest.eth",
+    "linea.eth": "linea-sepolia.eth"
+  }
+};
+var getContractsByManagedName = (namespace) => {
+  const ensRootRegistry = getDatasourceContract(
+    namespace,
+    DatasourceNames5.ENSRoot,
+    "ENSv1Registry"
+  );
+  const ensRootRegistryOld = getDatasourceContract(
+    namespace,
+    DatasourceNames5.ENSRoot,
+    "ENSv1RegistryOld"
+  );
+  const ethnamesNameWrapper = getDatasourceContract(
+    namespace,
+    DatasourceNames5.ENSRoot,
+    "NameWrapper"
+  );
+  const basenamesRegistry = maybeGetDatasourceContract(
+    namespace,
+    DatasourceNames5.Basenames,
+    "Registry"
+  );
+  const lineanamesRegistry = maybeGetDatasourceContract(
+    namespace,
+    DatasourceNames5.Lineanames,
+    "Registry"
+  );
+  const lineanamesNameWrapper = maybeGetDatasourceContract(
+    namespace,
+    DatasourceNames5.Lineanames,
+    "NameWrapper"
+  );
+  return {
+    [ENS_ROOT_NAME]: {
+      registry: ensRootRegistry,
+      contracts: [ensRootRegistry, ensRootRegistryOld]
+    },
+    eth: {
+      registry: ensRootRegistry,
+      contracts: [
+        getDatasourceContract(namespace, DatasourceNames5.ENSRoot, "BaseRegistrar"),
+        getDatasourceContract(
+          namespace,
+          DatasourceNames5.ENSRoot,
+          "UnwrappedEthRegistrarController"
+        ),
+        maybeGetDatasourceContract(
+          namespace,
+          DatasourceNames5.ENSRoot,
+          "LegacyEthRegistrarController"
+        ),
+        maybeGetDatasourceContract(
+          namespace,
+          DatasourceNames5.ENSRoot,
+          "WrappedEthRegistrarController"
+        ),
+        maybeGetDatasourceContract(
+          namespace,
+          DatasourceNames5.ENSRoot,
+          "UniversalRegistrarRenewalWithReferrer"
+        ),
+        ethnamesNameWrapper
+      ].filter((c) => !!c)
+    },
+    ...basenamesRegistry && {
+      "base.eth": {
+        registry: basenamesRegistry,
+        contracts: [
+          basenamesRegistry,
+          maybeGetDatasourceContract(namespace, DatasourceNames5.Basenames, "BaseRegistrar"),
+          maybeGetDatasourceContract(namespace, DatasourceNames5.Basenames, "EARegistrarController"),
+          maybeGetDatasourceContract(namespace, DatasourceNames5.Basenames, "RegistrarController"),
+          maybeGetDatasourceContract(
+            namespace,
+            DatasourceNames5.Basenames,
+            "UpgradeableRegistrarController"
+          )
+        ].filter((c) => !!c)
+      }
+    },
+    ...lineanamesRegistry && {
+      "linea.eth": {
+        registry: lineanamesRegistry,
+        contracts: [
+          lineanamesRegistry,
+          maybeGetDatasourceContract(namespace, DatasourceNames5.Lineanames, "BaseRegistrar"),
+          maybeGetDatasourceContract(
+            namespace,
+            DatasourceNames5.Lineanames,
+            "EthRegistrarController"
+          ),
+          lineanamesNameWrapper
+        ].filter((c) => !!c)
+      }
+    }
+  };
+};
+var cache = /* @__PURE__ */ new Map();
+var getManagedName = (namespace, contract) => {
+  const cacheKey = `${namespace}:${stringifyAccountId(contract)}`;
+  const cached = cache.get(cacheKey);
+  if (cached !== void 0) return cached;
+  for (const [managedName, group] of Object.entries(getContractsByManagedName(namespace))) {
+    const isAnyOfTheContracts = group.contracts.some(
+      (_contract) => accountIdEqual(_contract, contract)
+    );
+    if (isAnyOfTheContracts) {
+      const namespaceSpecific = MANAGED_NAME_BY_NAMESPACE[namespace]?.[managedName];
+      const name = asInterpretedName2(namespaceSpecific ?? managedName);
+      const node = namehashInterpretedName3(name);
+      const result = { name, node, registry: group.registry };
+      cache.set(cacheKey, result);
+      return result;
+    }
+  }
+  throw new Error(
+    `The following contract ${toJson(contract, { pretty: true })} does not have a configured Managed Name in namespace '${namespace}'.`
+  );
+};
+
+// src/shared/root-registry.ts
+import { makeENSv1RegistryId, makeENSv2RegistryId } from "enssdk";
+import { DatasourceNames as DatasourceNames6 } from "@ensnode/datasources";
+var getENSv1RootRegistry = (namespace) => getDatasourceContract(namespace, DatasourceNames6.ENSRoot, "ENSv1Registry");
+
+// src/shared/protocol-acceleration/is-bridged-resolver.ts
+var cache2 = /* @__PURE__ */ new Map();
+var getBridgedResolverConfigs = (namespace) => {
+  const cached = cache2.get(namespace);
+  if (cached) return cached;
+  const configs = [];
+  const basenames = maybeGetDatasource4(namespace, DatasourceNames7.Basenames);
+  if (basenames) {
+    const resolver = getDatasourceContract(
+      namespace,
+      DatasourceNames7.ENSRoot,
+      "BasenamesL1Resolver"
+    );
+    const registry = getDatasourceContract(namespace, DatasourceNames7.Basenames, "Registry");
+    const { node } = getManagedName(namespace, registry);
+    configs.push({
+      resolver,
+      originDomainId: makeENSv1DomainId(getENSv1RootRegistry(namespace), node),
+      targetRegistry: registry,
+      targetRegistryId: makeENSv1VirtualRegistryId(registry, node)
+    });
+  }
+  const lineanames = maybeGetDatasource4(namespace, DatasourceNames7.Lineanames);
+  if (lineanames) {
+    const resolver = getDatasourceContract(
+      namespace,
+      DatasourceNames7.ENSRoot,
+      "LineanamesL1Resolver"
+    );
+    const registry = getDatasourceContract(namespace, DatasourceNames7.Lineanames, "Registry");
+    const { node } = getManagedName(namespace, registry);
+    configs.push({
+      resolver,
+      originDomainId: makeENSv1DomainId(getENSv1RootRegistry(namespace), node),
+      targetRegistry: registry,
+      targetRegistryId: makeENSv1VirtualRegistryId(registry, node)
+    });
+  }
+  cache2.set(namespace, configs);
+  return configs;
+};
+function isBridgedResolver(namespace, resolver) {
+  return getBridgedResolverConfigs(namespace).find(
+    (config) => accountIdEqual(config.resolver, resolver)
+  ) ?? null;
+}
+
+// src/shared/protocol-acceleration/is-ensip-19-reverse-resolver.ts
+import { DatasourceNames as DatasourceNames8 } from "@ensnode/datasources";
+function isKnownENSIP19ReverseResolver(namespace, resolver) {
+  const resolverEq = makeContractMatcher(namespace, resolver);
+  return [
+    // DefaultReverseResolver (default.reverse)
+    resolverEq(DatasourceNames8.ReverseResolverRoot, "DefaultReverseResolver3"),
+    // the following are each ChainReverseResolver ([coinType].reverse)
+    resolverEq(DatasourceNames8.ReverseResolverRoot, "BaseReverseResolver"),
+    resolverEq(DatasourceNames8.ReverseResolverRoot, "LineaReverseResolver"),
+    resolverEq(DatasourceNames8.ReverseResolverRoot, "OptimismReverseResolver"),
+    resolverEq(DatasourceNames8.ReverseResolverRoot, "ArbitrumReverseResolver"),
+    resolverEq(DatasourceNames8.ReverseResolverRoot, "ScrollReverseResolver")
+  ].some(Boolean);
+}
+
+// src/shared/protocol-acceleration/is-static-resolver.ts
+import { DatasourceNames as DatasourceNames9 } from "@ensnode/datasources";
+function isStaticResolver(namespace, resolver) {
+  const resolverEq = makeContractMatcher(namespace, resolver);
+  return [
+    // ENS Root Chain
+    resolverEq(DatasourceNames9.ReverseResolverRoot, "DefaultPublicResolver0"),
+    resolverEq(DatasourceNames9.ReverseResolverRoot, "DefaultPublicResolver1"),
+    resolverEq(DatasourceNames9.ReverseResolverRoot, "DefaultPublicResolver2"),
+    resolverEq(DatasourceNames9.ReverseResolverRoot, "DefaultPublicResolver3"),
+    resolverEq(DatasourceNames9.ReverseResolverRoot, "DefaultPublicResolver4"),
+    resolverEq(DatasourceNames9.ReverseResolverRoot, "DefaultPublicResolver5"),
+    resolverEq(DatasourceNames9.ENSRoot, "ArgentResolver"),
+    resolverEq(DatasourceNames9.ENSRoot, "LoopringResolver"),
+    // Basenames
+    resolverEq(DatasourceNames9.Basenames, "L2Resolver1"),
+    resolverEq(DatasourceNames9.Basenames, "L2Resolver2"),
+    // Lineanames
+    resolverEq(DatasourceNames9.Lineanames, "DefaultPublicResolver"),
+    // ThreeDNS
+    resolverEq(DatasourceNames9.ThreeDNSBase, "Resolver"),
+    resolverEq(DatasourceNames9.ThreeDNSOptimism, "Resolver")
+  ].some(Boolean);
+}
+function staticResolverImplementsAddressRecordDefaulting(namespace, resolver) {
+  const resolverEq = makeContractMatcher(namespace, resolver);
+  return [
+    // ENS Root Chain
+    resolverEq(DatasourceNames9.ReverseResolverRoot, "DefaultPublicResolver5"),
+    // Base Chain
+    resolverEq(DatasourceNames9.Basenames, "L2Resolver2")
+  ].some(Boolean);
+}
+
+// src/shared/thegraph.ts
+import { ENSNamespaceIds as ENSNamespaceIds6 } from "@ensnode/datasources";
+var canFallbackToTheGraph = ({
+  namespace,
+  theGraphApiKey,
+  isSubgraphCompatible: isSubgraphCompatible2
+}) => {
+  if (!isSubgraphCompatible2) return { canFallback: false, reason: "not-subgraph-compatible" };
+  const hasApiKey = theGraphApiKey !== void 0;
+  if (!hasApiKey) return { canFallback: false, reason: "no-api-key" };
+  const url = makeTheGraphSubgraphUrl(namespace, theGraphApiKey);
+  if (url === null) return { canFallback: false, reason: "no-subgraph-url" };
+  return { canFallback: true, url };
+};
+var makeTheGraphSubgraphUrl = (namespace, apiKey) => {
+  switch (namespace) {
+    case ENSNamespaceIds6.Mainnet:
+      return `https://gateway.thegraph.com/api/${apiKey}/subgraphs/id/5XqPmWe6gjyrJtFn9cLy237i4cWw2j9HcUJEXsP5qGtH`;
+    case ENSNamespaceIds6.Sepolia:
+      return `https://gateway.thegraph.com/api/${apiKey}/subgraphs/id/G1SxZs317YUb9nQX3CC98hDyvxfMJNZH5pPRGpNrtvwN`;
+    case ENSNamespaceIds6.SepoliaV2:
+    case ENSNamespaceIds6.EnsTestEnv:
+      return null;
+    default:
+      throw new Error("never");
+  }
+};
+export {
+  ConfigTemplateIds,
+  DATASOURCE_NAMES_WITH_ENSv2_CONTRACTS,
+  DATASOURCE_NAMES_WITH_RESOLVERS,
+  ENSNamespaceSchema,
+  GRAPHQL_API_EXAMPLE_QUERIES,
+  OptionalPortNumberSchema,
+  PortNumberSchema,
+  RpcConfigsSchema,
+  TheGraphApiKeySchema,
+  TheGraphCannotFallbackReasonSchema,
+  TheGraphFallbackSchema,
+  alchemySupportsChain,
+  buildAlchemyBaseUrl,
+  buildDRPCUrl,
+  buildQuickNodeURL,
+  buildRpcAutoGenMode,
+  buildRpcConfigsFromEnv,
+  canFallbackToTheGraph,
+  dRPCSupportsChain,
+  errorResponseBadRequestExample,
+  errorResponseInternalServerErrorExample,
+  errorResponseInvalidAddressExample,
+  errorResponseInvalidNameExample,
+  getDatasourcesWithENSv2Contracts,
+  getDatasourcesWithResolvers,
+  getGraphqlApiExampleQueryById,
+  getLogLevelFromEnv,
+  interpretAddress,
+  interpretAddressRecordValue,
+  interpretContenthashValue,
+  interpretDnszonehashValue,
+  interpretNameRecordValue,
+  interpretPubkeyValue,
+  interpretTextRecordKey,
+  interpretTextRecordValue,
+  invariant_ensRainbowSupportedLabelSetAndVersion,
+  invariant_isSubgraphCompatibleRequirements,
+  invariant_rpcConfigsSpecifiedForRootChain,
+  invariant_rpcEndpointConfigIncludesAtLeastOneHTTPProtocolURL,
+  invariant_rpcEndpointConfigIncludesAtMostOneWebSocketsProtocolURL,
+  isBridgedResolver,
+  isConfigTemplateSubgraphCompatible,
+  isExtendedResolver,
+  isKnownENSIP19ReverseResolver,
+  isStaticResolver,
+  makeAccountIdSchema,
+  makeAccountIdStringSchema,
+  makeAssetIdSchema,
+  makeAssetIdStringSchema,
+  makeBaseRegistrarActionSchema,
+  makeBlockNumberSchema,
+  makeBlockRefSchema,
+  makeBooleanStringSchema,
+  makeChainIdSchema,
+  makeChainIdStringSchema,
+  makeCoinTypeSchema,
+  makeCoinTypeStringSchema,
+  makeCommaSeparatedList,
+  makeDatetimeSchema,
+  makeDefaultableChainIdSchema,
+  makeDefaultableChainIdStringSchema,
+  makeDomainAssetSchema,
+  makeDurationSchema,
+  makeENSApiPublicConfigSchema,
+  makeENSIndexerPublicConfigSchema,
+  makeENSIndexerVersionInfoSchema,
+  makeENSNamespaceIdSchema,
+  makeEnsApiIndexingStatusResponseErrorSchema,
+  makeEnsApiIndexingStatusResponseOkSchema,
+  makeEnsApiIndexingStatusResponseSchema,
+  makeEnsApiPublicConfigSchema,
+  makeEnsIndexerPublicConfigSchema,
+  makeEnsIndexerSchemaNameSchema,
+  makeEnsIndexerVersionInfoSchema,
+  makeErrorResponseSchema,
+  makeFiniteNonNegativeNumberSchema,
+  makeFullyPinnedLabelSetSchema,
+  makeHexStringSchema,
+  makeIndexedChainIdsSchema,
+  makeIndexingStatusResponseSchema,
+  makeIntegerSchema,
+  makeNameTokenOwnershipBurnedSchema,
+  makeNameTokenOwnershipFullyOnchainSchema,
+  makeNameTokenOwnershipNameWrapperSchema,
+  makeNameTokenOwnershipSchema,
+  makeNameTokenOwnershipUnknownSchema,
+  makeNameTokenSchema,
+  makeNameTokensResponseErrorEnsIndexerConfigUnsupported,
+  makeNameTokensResponseErrorNameIndexingStatusUnsupported,
+  makeNameTokensResponseErrorNameTokensNotIndexedSchema,
+  makeNameTokensResponseErrorSchema,
+  makeNameTokensResponseOkSchema,
+  makeNameTokensResponseSchema,
+  makeNamedRegistrarActionSchema,
+  makeNodeSchema,
+  makeNonNegativeIntegerSchema,
+  makeNormalizedAddressSchema,
+  makePluginsListSchema,
+  makePositiveIntegerSchema,
+  makePriceCurrencySchema,
+  makePriceDaiSchema,
+  makePriceEnsTokensSchema,
+  makePriceEthSchema,
+  makePriceSchema,
+  makePriceUsdcSchema,
+  makeRegisteredNameTokenSchema,
+  makeRegistrarActionRegistrationSchema,
+  makeRegistrarActionRenewalSchema,
+  makeRegistrarActionSchema,
+  makeRegistrarActionsResponseErrorSchema,
+  makeRegistrarActionsResponseOkSchema,
+  makeRegistrarActionsResponseSchema,
+  makeRegistrationLifecycleSchema,
+  makeReinterpretedNameSchema,
+  makeRequestPageParamsSchema,
+  makeResolvePrimaryNameResponseSchema,
+  makeResolvePrimaryNamesResponseSchema,
+  makeResolveRecordsResponseSchema,
+  makeResponsePageContextSchema,
+  makeResponsePageContextSchemaWithNoRecords,
+  makeResponsePageContextSchemaWithRecords,
+  makeSerializedEnsApiIndexingStatusResponseOkSchema,
+  makeSerializedEnsApiIndexingStatusResponseSchema,
+  makeSerializedEnsApiPublicConfigSchema,
+  makeSerializedEnsIndexerPublicConfigSchema,
+  makeSerializedIndexedChainIdsSchema,
+  makeSerializedPriceCurrencySchema,
+  makeSerializedPriceEthSchema,
+  makeSerializedRegistrarActionPricingSchema,
+  makeSerializedRegistrarActionSchema,
+  makeSerializedRegistrarActionsResponseOkSchema,
+  makeSupportsInterfaceReader,
+  makeTokenIdSchema,
+  makeTransactionHashSchema,
+  makeUnixTimestampSchema,
+  makeUrlSchema,
+  nameTokensNotIndexedExample,
+  nameTokensResponseOkExample,
+  nameTokensServiceUnavailableExample,
+  namespaceForConfigTemplateId,
+  quickNodeSupportsChain,
+  realtimeResponseSchemaError,
+  realtimeResponseSchemaOk,
+  redactRpcConfigs,
+  redactString,
+  redactUrl,
+  registrarActionsResponseOkExample,
+  resolvePrimaryNameResponseExample,
+  resolvePrimaryNamesResponseExample,
+  resolveRecordsResponseExample,
+  staticResolverImplementsAddressRecordDefaulting,
+  stringifyConfig
+};
+//# sourceMappingURL=internal.js.map