@ensnode/ensnode-sdk 0.0.0-next-20260420155209 → 0.0.0-next-20260421160559

package/dist/index.cjs

@@ -37,16 +37,16 @@ __export(index_exports, {
   ClientError: () => ClientError,
   CrossChainIndexingStrategyIds: () => CrossChainIndexingStrategyIds,
   CurrencyIds: () => CurrencyIds,
-  DEFAULT_ENSNODE_API_URL_MAINNET: () => DEFAULT_ENSNODE_API_URL_MAINNET,
-  DEFAULT_ENSNODE_API_URL_SEPOLIA: () => DEFAULT_ENSNODE_API_URL_SEPOLIA,
+  DEFAULT_ENSNODE_URL_MAINNET: () => DEFAULT_ENSNODE_URL_MAINNET,
+  DEFAULT_ENSNODE_URL_SEPOLIA: () => DEFAULT_ENSNODE_URL_SEPOLIA,
   ENCODED_REFERRER_BYTE_LENGTH: () => ENCODED_REFERRER_BYTE_LENGTH,
   ENCODED_REFERRER_BYTE_OFFSET: () => ENCODED_REFERRER_BYTE_OFFSET,
   ENSNamespaceIds: () => import_datasources13.ENSNamespaceIds,
   EXPECTED_ENCODED_REFERRER_PADDING: () => EXPECTED_ENCODED_REFERRER_PADDING,
-  EnsApiClient: () => EnsApiClient,
   EnsApiIndexingStatusResponseCodes: () => EnsApiIndexingStatusResponseCodes,
   EnsIndexerClient: () => EnsIndexerClient,
   EnsIndexerIndexingStatusResponseCodes: () => EnsIndexerIndexingStatusResponseCodes,
+  EnsNodeClient: () => EnsNodeClient,
   ForwardResolutionProtocolStep: () => ForwardResolutionProtocolStep,
   IndexingStatusResponseCodes: () => IndexingStatusResponseCodes,
   LruCache: () => LruCache,
@@ -82,6 +82,7 @@ __export(index_exports, {
   buildBlockRefRange: () => buildBlockRefRange,
   buildCrossChainIndexingStatusSnapshotOmnichain: () => buildCrossChainIndexingStatusSnapshotOmnichain,
   buildEncodedReferrer: () => buildEncodedReferrer,
+  buildEnsNodeStackInfo: () => buildEnsNodeStackInfo,
   buildEnsRainbowClientLabelSet: () => buildEnsRainbowClientLabelSet,
   buildIndexedBlockranges: () => buildIndexedBlockranges,
   buildLabelSetId: () => buildLabelSetId,
@@ -90,7 +91,9 @@ __export(index_exports, {
   buildPageContext: () => buildPageContext,
   buildUnresolvedIdentity: () => buildUnresolvedIdentity,
   buildUnvalidatedCrossChainIndexingStatusSnapshot: () => buildUnvalidatedCrossChainIndexingStatusSnapshot,
+  buildUnvalidatedEnsApiPublicConfig: () => buildUnvalidatedEnsApiPublicConfig,
   buildUnvalidatedEnsIndexerPublicConfig: () => buildUnvalidatedEnsIndexerPublicConfig,
+  buildUnvalidatedEnsNodeStackInfo: () => buildUnvalidatedEnsNodeStackInfo,
   buildUnvalidatedOmnichainIndexingStatusSnapshot: () => buildUnvalidatedOmnichainIndexingStatusSnapshot,
   buildUnvalidatedRealtimeIndexingStatusProjection: () => buildUnvalidatedRealtimeIndexingStatusProjection,
   checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill: () => checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill,
@@ -104,19 +107,18 @@ __export(index_exports, {
   deserializeBlockRef: () => deserializeBlockRef,
   deserializeChainId: () => deserializeChainId,
   deserializeChainIndexingStatusSnapshot: () => deserializeChainIndexingStatusSnapshot,
-  deserializeConfigResponse: () => deserializeConfigResponse,
   deserializeCrossChainIndexingStatusSnapshot: () => deserializeCrossChainIndexingStatusSnapshot,
   deserializeDatetime: () => deserializeDatetime,
   deserializeDuration: () => deserializeDuration,
   deserializeENSApiPublicConfig: () => deserializeENSApiPublicConfig,
   deserializeENSIndexerPublicConfig: () => deserializeENSIndexerPublicConfig,
-  deserializeEnsApiConfigResponse: () => deserializeEnsApiConfigResponse,
   deserializeEnsApiIndexingStatusResponse: () => deserializeEnsApiIndexingStatusResponse,
   deserializeEnsApiPublicConfig: () => deserializeEnsApiPublicConfig,
   deserializeEnsIndexerConfigResponse: () => deserializeEnsIndexerConfigResponse,
   deserializeEnsIndexerIndexingStatusResponse: () => deserializeEnsIndexerIndexingStatusResponse,
   deserializeEnsIndexerPublicConfig: () => deserializeEnsIndexerPublicConfig,
-  deserializeErrorResponse: () => deserializeErrorResponse,
+  deserializeEnsNodeStackInfo: () => deserializeEnsNodeStackInfo,
+  deserializeErrorResponse: () => deserializeErrorResponse2,
   deserializeIndexingStatusResponse: () => deserializeIndexingStatusResponse,
   deserializeOmnichainIndexingStatusSnapshot: () => deserializeOmnichainIndexingStatusSnapshot,
   deserializePriceDai: () => deserializePriceDai,
@@ -204,19 +206,18 @@ __export(index_exports, {
   serializeAssetId: () => serializeAssetId,
   serializeChainId: () => serializeChainId,
   serializeChainIndexingSnapshots: () => serializeChainIndexingSnapshots,
-  serializeConfigResponse: () => serializeConfigResponse,
   serializeCrossChainIndexingStatusSnapshot: () => serializeCrossChainIndexingStatusSnapshot,
   serializeCrossChainIndexingStatusSnapshotOmnichain: () => serializeCrossChainIndexingStatusSnapshotOmnichain,
   serializeDatetime: () => serializeDatetime,
   serializeDomainAssetId: () => serializeDomainAssetId,
   serializeENSApiPublicConfig: () => serializeENSApiPublicConfig,
   serializeENSIndexerPublicConfig: () => serializeENSIndexerPublicConfig,
-  serializeEnsApiConfigResponse: () => serializeEnsApiConfigResponse,
   serializeEnsApiIndexingStatusResponse: () => serializeEnsApiIndexingStatusResponse,
   serializeEnsApiPublicConfig: () => serializeEnsApiPublicConfig,
   serializeEnsIndexerConfigResponse: () => serializeEnsIndexerConfigResponse,
   serializeEnsIndexerIndexingStatusResponse: () => serializeEnsIndexerIndexingStatusResponse,
   serializeEnsIndexerPublicConfig: () => serializeEnsIndexerPublicConfig,
+  serializeEnsNodeStackInfo: () => serializeEnsNodeStackInfo,
   serializeIndexedChainIds: () => serializeIndexedChainIds,
   serializeIndexingStatusResponse: () => serializeIndexingStatusResponse,
   serializeNameToken: () => serializeNameToken,
@@ -536,9 +537,8 @@ var makeLabelSetIdSchema = (valueLabel = "Label set ID") => {
     error: `${valueLabel} can only contain lowercase letters (a-z) and hyphens (-)`
   });
 };
-var makeLabelSetVersionSchema = (valueLabel = "Label set version") => {
-  return import_v42.z.coerce.number({ error: `${valueLabel} must be an integer.` }).pipe(makeNonNegativeIntegerSchema(valueLabel));
-};
+var makeLabelSetVersionSchema = (valueLabel = "Label set version") => makeNonNegativeIntegerSchema(valueLabel);
+var makeLabelSetVersionStringSchema = (valueLabel = "Label set version") => import_v42.z.coerce.number({ error: `${valueLabel} must be a non-negative integer` }).pipe(makeLabelSetVersionSchema(valueLabel));
 var makeEnsRainbowPublicConfigSchema = (valueLabel = "EnsRainbowPublicConfig") => import_v42.z.object({
   version: import_v42.z.string().nonempty({ error: `${valueLabel}.version must be a non-empty string.` }),
   labelSet: import_v42.z.object({
@@ -583,7 +583,7 @@ function buildLabelSetId(maybeLabelSetId) {
   return makeLabelSetIdSchema("LabelSetId").parse(maybeLabelSetId);
 }
 function buildLabelSetVersion(maybeLabelSetVersion) {
-  return makeLabelSetVersionSchema("LabelSetVersion").parse(maybeLabelSetVersion);
+  return makeLabelSetVersionStringSchema("LabelSetVersion").parse(maybeLabelSetVersion);
 }
 function buildEnsRainbowClientLabelSet(labelSetId, labelSetVersion) {
   if (labelSetVersion !== void 0 && labelSetId === void 0) {
@@ -650,7 +650,7 @@ var makeFullyPinnedLabelSetSchema = (valueLabel = "Label set") => {
   }
   return import_v43.z.object({
     labelSetId: makeLabelSetIdSchema(valueLabelLabelSetId),
-    labelSetVersion: makeLabelSetVersionSchema(valueLabelLabelSetVersion)
+    labelSetVersion: makeLabelSetVersionStringSchema(valueLabelLabelSetVersion)
   });
 };
 var makeNonEmptyStringSchema = (valueLabel = "Value") => import_v43.z.string().nonempty({ error: `${valueLabel} must be a non-empty string.` });
@@ -802,12 +802,6 @@ ${(0, import_v47.prettifyError)(parsed.error)}
 }
 var deserializeENSApiPublicConfig = deserializeEnsApiPublicConfig;
 
-// src/ensapi/api/config/deserialize.ts
-function deserializeEnsApiConfigResponse(maybeResponse) {
-  return deserializeEnsApiPublicConfig(maybeResponse);
-}
-var deserializeConfigResponse = deserializeEnsApiConfigResponse;
-
 // src/ensindexer/config/serialize.ts
 function serializeIndexedChainIds(indexedChainIds) {
   return Array.from(indexedChainIds);
@@ -847,13 +841,17 @@ function serializeEnsApiPublicConfig(config) {
 }
 var serializeENSApiPublicConfig = serializeEnsApiPublicConfig;
 
-// src/ensapi/api/config/serialize.ts
-function serializeEnsApiConfigResponse(response) {
-  return serializeEnsApiPublicConfig(response);
+// src/ensindexer/api/config/deserialize.ts
+function deserializeEnsIndexerConfigResponse(maybeResponse) {
+  return deserializeEnsIndexerPublicConfig(maybeResponse, "EnsIndexerConfigResponse");
+}
+
+// src/ensindexer/api/config/serialize.ts
+function serializeEnsIndexerConfigResponse(response) {
+  return serializeEnsIndexerPublicConfig(response);
 }
-var serializeConfigResponse = serializeEnsApiConfigResponse;
 
-// src/ensapi/api/indexing-status/deserialize.ts
+// src/ensindexer/api/indexing-status/deserialize.ts
 var import_v418 = require("zod/v4");
 
 // src/indexing-status/deserialize/realtime-indexing-status-projection.ts
@@ -1780,8 +1778,8 @@ ${(0, import_v416.prettifyError)(parsed.error)}
   return parsed.data;
 }
 
-// src/ensapi/api/indexing-status/response.ts
-var EnsApiIndexingStatusResponseCodes = {
+// src/ensindexer/api/indexing-status/response.ts
+var EnsIndexerIndexingStatusResponseCodes = {
   /**
    * Represents that the indexing status is available.
    */
@@ -1791,33 +1789,32 @@ var EnsApiIndexingStatusResponseCodes = {
    */
   Error: "error"
 };
-var IndexingStatusResponseCodes = EnsApiIndexingStatusResponseCodes;
 
-// src/ensapi/api/indexing-status/zod-schemas.ts
+// src/ensindexer/api/indexing-status/zod-schemas.ts
 var import_v417 = require("zod/v4");
-var makeEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v417.z.strictObject({
-  responseCode: import_v417.z.literal(EnsApiIndexingStatusResponseCodes.Ok),
+var makeEnsIndexerIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v417.z.strictObject({
+  responseCode: import_v417.z.literal(EnsIndexerIndexingStatusResponseCodes.Ok),
   realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel)
 });
-var makeEnsApiIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v417.z.strictObject({
-  responseCode: import_v417.z.literal(EnsApiIndexingStatusResponseCodes.Error)
+var makeEnsIndexerIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v417.z.strictObject({
+  responseCode: import_v417.z.literal(EnsIndexerIndexingStatusResponseCodes.Error)
 });
-var makeEnsApiIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v417.z.discriminatedUnion("responseCode", [
-  makeEnsApiIndexingStatusResponseOkSchema(valueLabel),
-  makeEnsApiIndexingStatusResponseErrorSchema(valueLabel)
+var makeEnsIndexerIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v417.z.discriminatedUnion("responseCode", [
+  makeEnsIndexerIndexingStatusResponseOkSchema(valueLabel),
+  makeEnsIndexerIndexingStatusResponseErrorSchema(valueLabel)
 ]);
-var makeSerializedEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => import_v417.z.strictObject({
-  responseCode: import_v417.z.literal(EnsApiIndexingStatusResponseCodes.Ok),
+var makeSerializedEnsIndexerIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => import_v417.z.strictObject({
+  responseCode: import_v417.z.literal(EnsIndexerIndexingStatusResponseCodes.Ok),
   realtimeProjection: makeSerializedRealtimeIndexingStatusProjectionSchema(valueLabel)
 });
-var makeSerializedEnsApiIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => import_v417.z.discriminatedUnion("responseCode", [
-  makeSerializedEnsApiIndexingStatusResponseOkSchema(valueLabel),
-  makeEnsApiIndexingStatusResponseErrorSchema(valueLabel)
+var makeSerializedEnsIndexerIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => import_v417.z.discriminatedUnion("responseCode", [
+  makeSerializedEnsIndexerIndexingStatusResponseOkSchema(valueLabel),
+  makeEnsIndexerIndexingStatusResponseErrorSchema(valueLabel)
 ]);
 
-// src/ensapi/api/indexing-status/deserialize.ts
-function buildUnvalidatedEnsApiIndexingStatusResponse(serializedResponse) {
-  if (serializedResponse.responseCode !== EnsApiIndexingStatusResponseCodes.Ok) {
+// src/ensindexer/api/indexing-status/deserialize.ts
+function buildUnvalidatedEnsIndexerIndexingStatusResponse(serializedResponse) {
+  if (serializedResponse.responseCode !== EnsIndexerIndexingStatusResponseCodes.Ok) {
     return serializedResponse;
   }
   return {
@@ -1827,18 +1824,17 @@ function buildUnvalidatedEnsApiIndexingStatusResponse(serializedResponse) {
     )
   };
 }
-function deserializeEnsApiIndexingStatusResponse(maybeResponse) {
-  const parsed = makeSerializedEnsApiIndexingStatusResponseSchema().transform(buildUnvalidatedEnsApiIndexingStatusResponse).pipe(makeEnsApiIndexingStatusResponseSchema()).safeParse(maybeResponse);
+function deserializeEnsIndexerIndexingStatusResponse(maybeResponse) {
+  const parsed = makeSerializedEnsIndexerIndexingStatusResponseSchema().transform(buildUnvalidatedEnsIndexerIndexingStatusResponse).pipe(makeEnsIndexerIndexingStatusResponseSchema()).safeParse(maybeResponse);
   if (parsed.error) {
     throw new Error(
-      `Cannot deserialize EnsApiIndexingStatusResponse:
+      `Cannot deserialize EnsIndexerIndexingStatusResponse:
 ${(0, import_v418.prettifyError)(parsed.error)}
 `
     );
   }
   return parsed.data;
 }
-var deserializeIndexingStatusResponse = deserializeEnsApiIndexingStatusResponse;
 
 // src/shared/serialize.ts
 function serializeChainId(chainId) {
@@ -1936,247 +1932,622 @@ function serializeRealtimeIndexingStatusProjection(indexingProjection) {
   };
 }
 
-// src/ensapi/api/indexing-status/serialize.ts
-function serializeEnsApiIndexingStatusResponse(response) {
+// src/ensindexer/api/indexing-status/serialize.ts
+function serializeEnsIndexerIndexingStatusResponse(response) {
   switch (response.responseCode) {
-    case EnsApiIndexingStatusResponseCodes.Ok:
+    case EnsIndexerIndexingStatusResponseCodes.Ok:
       return {
         responseCode: response.responseCode,
         realtimeProjection: serializeRealtimeIndexingStatusProjection(response.realtimeProjection)
       };
-    case EnsApiIndexingStatusResponseCodes.Error:
+    case EnsIndexerIndexingStatusResponseCodes.Error:
       return response;
   }
 }
-var serializeIndexingStatusResponse = serializeEnsApiIndexingStatusResponse;
-
-// src/ensapi/api/name-tokens/deserialize.ts
-var import_v423 = require("zod/v4");
-
-// src/ensapi/api/name-tokens/zod-schemas.ts
-var import_enssdk5 = require("enssdk");
-var import_v422 = require("zod/v4");
-
-// src/tokenscope/name-token.ts
-var import_enssdk4 = require("enssdk");
-var import_viem6 = require("viem");
-var import_datasources4 = require("@ensnode/datasources");
-
-// src/shared/account-id.ts
-var import_viem3 = require("viem");
-var accountIdEqual = (a, b) => {
-  return a.chainId === b.chainId && (0, import_viem3.isAddressEqual)(a.address, b.address);
-};
-
-// src/shared/datasource-contract.ts
-var import_datasources3 = require("@ensnode/datasources");
-var maybeGetDatasourceContract = (namespaceId, datasourceName, contractName) => {
-  const datasource = (0, import_datasources3.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
-var import_enssdk3 = require("enssdk");
-var import_viem5 = require("viem");
+// src/ensindexer/api/shared/errors/deserialize.ts
 var import_v420 = require("zod/v4");
 
-// src/tokenscope/zod-schemas.ts
-var import_caip2 = require("caip");
-var import_enssdk2 = require("enssdk");
-var import_viem4 = require("viem");
+// src/ensindexer/api/shared/errors/zod-schemas.ts
 var import_v419 = require("zod/v4");
-var tokenIdSchemaSerializable = import_v419.z.string();
-var tokenIdSchemaNative = import_v419.z.preprocess(
-  (v) => typeof v === "string" ? BigInt(v) : v,
-  import_v419.z.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 import_v419.z.object({
-    assetNamespace: import_v419.z.enum(import_enssdk2.AssetNamespaces),
-    contract: makeAccountIdSchema(valueLabel),
-    tokenId: makeTokenIdSchema(valueLabel, serializable ?? false)
-  });
-};
-var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => import_v419.z.preprocess((v) => {
-  if (typeof v === "string") {
-    const result = new import_caip2.AssetId(v);
-    return {
-      assetNamespace: result.assetName.namespace,
-      contract: {
-        chainId: Number(result.chainId.reference),
-        address: result.assetName.reference
-      },
-      tokenId: result.tokenId
-    };
-  }
-  return v;
-}, makeAssetIdSchema(valueLabel));
-function invariant_nameTokenOwnershipHasNonZeroAddressOwner(ctx) {
-  const ownership = ctx.value;
-  if (ctx.value.owner.address === import_viem4.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") => import_v419.z.object({
-  ownershipType: import_v419.z.literal(NameTokenOwnershipTypes.NameWrapper),
-  owner: makeAccountIdSchema(`${valueLabel}.owner`)
-}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
-var makeNameTokenOwnershipFullyOnchainSchema = (valueLabel = "Name Token Ownership Fully Onchain") => import_v419.z.object({
-  ownershipType: import_v419.z.literal(NameTokenOwnershipTypes.FullyOnchain),
-  owner: makeAccountIdSchema(`${valueLabel}.owner`)
-}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
-var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => import_v419.z.object({
-  ownershipType: import_v419.z.literal(NameTokenOwnershipTypes.Burned),
-  owner: makeAccountIdSchema(`${valueLabel}.owner`)
-}).check(invariant_nameTokenOwnershipHasZeroAddressOwner);
-var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => import_v419.z.object({
-  ownershipType: import_v419.z.literal(NameTokenOwnershipTypes.Unknown),
-  owner: makeAccountIdSchema(`${valueLabel}.owner`)
-}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
-function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
-  const ownership = ctx.value;
-  if (ctx.value.owner.address !== import_viem4.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") => import_v419.z.discriminatedUnion("ownershipType", [
-  makeNameTokenOwnershipNameWrapperSchema(valueLabel),
-  makeNameTokenOwnershipFullyOnchainSchema(valueLabel),
-  makeNameTokenOwnershipBurnedSchema(valueLabel),
-  makeNameTokenOwnershipUnknownSchema(valueLabel)
-]);
-var makeNameTokenSchema = (valueLabel = "Name Token Schema", serializable) => import_v419.z.object({
-  token: makeAssetIdSchema(`${valueLabel}.token`, serializable),
-  ownership: makeNameTokenOwnershipSchema(`${valueLabel}.ownership`),
-  mintStatus: import_v419.z.enum(NFTMintStatuses)
+var ErrorResponseSchema = import_v419.z.object({
+  message: import_v419.z.string(),
+  details: import_v419.z.optional(import_v419.z.unknown())
 });
 
-// src/tokenscope/assets.ts
-function serializeAssetId(assetId) {
-  return {
-    assetNamespace: assetId.assetNamespace,
-    contract: assetId.contract,
-    tokenId: assetId.tokenId.toString()
-  };
-}
-function deserializeAssetId(maybeAssetId, valueLabel) {
-  const schema = makeAssetIdSchema(valueLabel);
-  const parsed = schema.safeParse(maybeAssetId);
+// src/ensindexer/api/shared/errors/deserialize.ts
+function deserializeErrorResponse(maybeErrorResponse) {
+  const parsed = ErrorResponseSchema.safeParse(maybeErrorResponse);
   if (parsed.error) {
-    throw new RangeError(`Cannot deserialize AssetId:
+    throw new Error(`Cannot deserialize ErrorResponse:
 ${(0, import_v420.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
 }
-function parseAssetId(maybeAssetId, valueLabel) {
-  const schema = makeAssetIdStringSchema(valueLabel);
-  const parsed = schema.safeParse(maybeAssetId);
-  if (parsed.error) {
-    throw new RangeError(`Cannot parse AssetId:
-${(0, import_v420.prettifyError)(parsed.error)}
-`);
+
+// src/ensindexer/client.ts
+var EnsIndexerClient = class {
+  constructor(options) {
+    this.options = options;
+  }
+  getOptions() {
+    return Object.freeze({
+      url: new URL(this.options.url.href)
+    });
   }
-  return parsed.data;
-}
-var buildAssetId = (contract, tokenId, assetNamespace) => {
-  return {
-    assetNamespace,
-    contract,
-    tokenId
-  };
-};
-function serializeDomainAssetId(domainAsset) {
-  return {
-    ...serializeAssetId(domainAsset),
-    domainId: domainAsset.domainId
-  };
-}
-var NFTMintStatuses = {
-  Minted: "minted",
-  Burned: "burned"
-};
-var formatNFTTransferEventMetadata = (metadata) => {
-  const assetIdString = (0, import_enssdk3.stringifyAssetId)(metadata.nft);
-  return [
-    `Event: ${metadata.eventHandlerName}`,
-    `Chain ID: ${metadata.chainId}`,
-    `Block Number: ${metadata.blockNumber}`,
-    `Transaction Hash: ${metadata.transactionHash}`,
-    `NFT: ${assetIdString}`
-  ].map((line) => ` - ${line}`).join("\n");
-};
-var NFTTransferTypes = {
-  /**
-   * Initial transfer from zeroAddress to a non-zeroAddress
-   * Can happen at most once to a NFT AssetId
-   *
-   * Invariants:
-   * - NFT is not indexed and therefore has no previous mint status or owner
-   * - new NFT mint status is `minted`
-   * - new NFT owner is a non-zeroAddress
-   */
-  Mint: "mint",
   /**
-   * Subsequent transfer from zeroAddress to a non-zeroAddress
-   * Can happen any number of times to a NFT AssetId as it passes in a cycle from
-   * mint -> burn -> remint -> burn -> remint -> ...
+   * Fetch ENSIndexer Config
    *
-   * Invariants:
-   * - NFT is indexed
-   * - previous NFT mint status was `burned`
-   * - previous NFT owner is the zeroAddress
-   * - new NFT mint status is `minted`
-   * - new NFT owner is a non-zeroAddress
-   */
-  Remint: "remint",
-  /**
-   * Special transfer type for improperly implemented NFT contracts that allow a NFT
-   * that is currently minted to be reminted before an intermediate burn.
+   * Fetch the ENSIndexer's configuration.
    *
-   * Transfer from zeroAddress to non-zeroAddress for an indexed NFT where the
-   * previously indexed nft had status `minted` with a non-zeroAddress owner.
+   * @returns {EnsIndexerConfigResponse}
    *
-   * Invariants:
-   * - NFT is indexed
-   * - previous NFT mint status was `minted`
-   * - previous NFT owner was a non-zeroAddress
-   * - new NFT mint status is `minted`
-   * - new NFT owner is a non-zeroAddress
+   * @throws if the ENSIndexer request fails
+   * @throws if the ENSIndexer returns a non-ok response
+   * @throws if the ENSIndexer response breaks required invariants
+   */
+  async config() {
+    const url = new URL(`/api/config`, this.options.url);
+    const response = await fetch(url);
+    let responseData;
+    try {
+      responseData = await response.json();
+    } catch {
+      throw new Error("Malformed response data: invalid JSON");
+    }
+    if (!response.ok) {
+      const errorResponse = deserializeErrorResponse(responseData);
+      throw new Error(`Fetching ENSIndexer Config Failed: ${errorResponse.message}`);
+    }
+    return deserializeEnsIndexerConfigResponse(
+      responseData
+    );
+  }
+  /**
+   * Fetch ENSIndexer Indexing Status
+   *
+   * @returns {EnsIndexerIndexingStatusResponse}
+   *
+   * @throws if the ENSIndexer request fails
+   * @throws if the ENSIndexer returns a non-ok response
+   * @throws if the ENSIndexer response breaks required invariants
+   */
+  async indexingStatus() {
+    const url = new URL(`/api/indexing-status`, this.options.url);
+    const response = await fetch(url);
+    let responseData;
+    try {
+      responseData = await response.json();
+    } catch {
+      throw new Error("Malformed response data: invalid JSON");
+    }
+    if (!response.ok) {
+      let errorResponse;
+      try {
+        errorResponse = deserializeErrorResponse(responseData);
+      } catch {
+      }
+      if (typeof errorResponse !== "undefined") {
+        throw new Error(`Fetching ENSIndexer Indexing Status Failed: ${errorResponse.message}`);
+      }
+    }
+    return deserializeEnsIndexerIndexingStatusResponse(
+      responseData
+    );
+  }
+};
+
+// src/ensindexer/config/compatibility.ts
+function validateEnsIndexerPublicConfigCompatibility(configA, configB) {
+  if (configA.indexedChainIds.symmetricDifference(configB.indexedChainIds).size > 0) {
+    throw new Error(
+      [
+        `'indexedChainIds' must be compatible.`,
+        `Stored Config 'indexedChainIds': '${Array.from(configA.indexedChainIds).join(", ")}'.`,
+        `Current Config 'indexedChainIds': '${Array.from(configB.indexedChainIds).join(", ")}'.`
+      ].join(" ")
+    );
+  }
+  if (configA.isSubgraphCompatible !== configB.isSubgraphCompatible) {
+    throw new Error(
+      [
+        `'isSubgraphCompatible' flag must be compatible.`,
+        `Stored Config 'isSubgraphCompatible' flag: '${configA.isSubgraphCompatible}'.`,
+        `Current Config 'isSubgraphCompatible' flag: '${configB.isSubgraphCompatible}'.`
+      ].join(" ")
+    );
+  }
+  if (configA.namespace !== configB.namespace) {
+    throw new Error(
+      [
+        `'namespace' must be compatible.`,
+        `Stored Config 'namespace': '${configA.namespace}'.`,
+        `Current Config 'namespace': '${configB.namespace}'.`
+      ].join(" ")
+    );
+  }
+  if (configA.labelSet.labelSetId !== configB.labelSet.labelSetId) {
+    throw new Error(
+      [
+        `'labelSet.labelSetId' must be compatible.`,
+        `Stored Config 'labelSet.labelSetId': '${configA.labelSet.labelSetId}'.`,
+        `Current Config 'labelSet.labelSetId': '${configB.labelSet.labelSetId}'.`
+      ].join(" ")
+    );
+  }
+  if (configA.labelSet.labelSetVersion !== configB.labelSet.labelSetVersion) {
+    throw new Error(
+      [
+        `'labelSet.labelSetVersion' must be compatible.`,
+        `Stored Config 'labelSet.labelSetVersion': '${configA.labelSet.labelSetVersion}'.`,
+        `Current Config 'labelSet.labelSetVersion': '${configB.labelSet.labelSetVersion}'.`
+      ].join(" ")
+    );
+  }
+  const configAPluginsSet = new Set(configA.plugins);
+  const configBPluginsSet = new Set(configB.plugins);
+  if (configAPluginsSet.symmetricDifference(configBPluginsSet).size > 0) {
+    throw new Error(
+      [
+        `'plugins' must be compatible.`,
+        `Stored Config 'plugins': '${configA.plugins.join(", ")}'.`,
+        `Current Config 'plugins': '${configB.plugins.join(", ")}'.`
+      ].join(" ")
+    );
+  }
+}
+
+// src/ensindexer/config/label-utils.ts
+var import_viem3 = require("viem");
+function labelHashToBytes(labelHash) {
+  try {
+    if (labelHash.length !== 66) {
+      throw new Error(`Invalid labelHash length ${labelHash.length} characters (expected 66)`);
+    }
+    if (labelHash !== labelHash.toLowerCase()) {
+      throw new Error("Labelhash must be in lowercase");
+    }
+    if (!labelHash.startsWith("0x")) {
+      throw new Error("Labelhash must be 0x-prefixed");
+    }
+    const bytes = (0, import_viem3.hexToBytes)(labelHash);
+    if (bytes.length !== 32) {
+      throw new Error(`Invalid labelHash length ${bytes.length} bytes (expected 32)`);
+    }
+    return bytes;
+  } catch (e) {
+    if (e instanceof Error) {
+      throw e;
+    }
+    throw new Error("Invalid hex format");
+  }
+}
+
+// src/ensindexer/config/parsing.ts
+function parseNonNegativeInteger(maybeNumber) {
+  const trimmed = maybeNumber.trim();
+  if (!trimmed) {
+    throw new Error("Input cannot be empty");
+  }
+  if (trimmed === "-0") {
+    throw new Error("Negative zero is not a valid non-negative integer");
+  }
+  const num = Number(maybeNumber);
+  if (Number.isNaN(num)) {
+    throw new Error(`"${maybeNumber}" is not a valid number`);
+  }
+  if (!Number.isFinite(num)) {
+    throw new Error(`"${maybeNumber}" is not a finite number`);
+  }
+  if (!Number.isInteger(num)) {
+    throw new Error(`"${maybeNumber}" is not an integer`);
+  }
+  if (num < 0) {
+    throw new Error(`"${maybeNumber}" is not a non-negative integer`);
+  }
+  return num;
+}
+
+// src/ensindexer/config/validate/ensindexer-public-config.ts
+var import_v421 = require("zod/v4");
+function validateEnsIndexerPublicConfig(unvalidatedConfig) {
+  const schema = makeEnsIndexerPublicConfigSchema();
+  const result = schema.safeParse(unvalidatedConfig);
+  if (!result.success) {
+    throw new Error(`Invalid ENSIndexerPublicConfig: ${(0, import_v421.prettifyError)(result.error)}`);
+  }
+  return result.data;
+}
+
+// src/ensindexer/config/validate/ensindexer-version-info.ts
+var import_v422 = require("zod/v4");
+function validateEnsIndexerVersionInfo(unvalidatedVersionInfo) {
+  const schema = makeEnsIndexerVersionInfoSchema();
+  const result = schema.safeParse(unvalidatedVersionInfo);
+  if (!result.success) {
+    throw new Error(`Invalid EnsIndexerVersionInfo: ${(0, import_v422.prettifyError)(result.error)}`);
+  }
+  return result.data;
+}
+
+// src/ensnode/api/indexing-status/deserialize.ts
+var import_v427 = require("zod/v4");
+
+// src/stack-info/deserialize/ensnode-stack-info.ts
+var import_v425 = require("zod/v4");
+
+// src/stack-info/zod-schemas/ensnode-stack-info.ts
+var import_v424 = require("zod/v4");
+
+// src/ensdb/zod-schemas/config.ts
+var import_v423 = require("zod/v4");
+var makeEnsDbVersionInfoSchema = (valueLabel) => {
+  const label = valueLabel ?? "EnsDbVersionInfo";
+  return import_v423.z.object({
+    postgresql: import_v423.z.string().nonempty(`${label}.postgresql must be a non-empty string`).describe("Version of the PostgreSQL server hosting the ENSDb instance.")
+  }).describe(label);
+};
+var makeEnsDbPublicConfigSchema = (valueLabel) => {
+  const label = valueLabel ?? "EnsDbPublicConfig";
+  return import_v423.z.object({
+    versionInfo: makeEnsDbVersionInfoSchema(`${label}.versionInfo`)
+  }).describe(label);
+};
+
+// src/stack-info/zod-schemas/ensnode-stack-info.ts
+function makeSerializedEnsNodeStackInfoSchema(valueLabel) {
+  const label = valueLabel ?? "ENSNodeStackInfo";
+  return import_v424.z.object({
+    ensApi: makeSerializedEnsApiPublicConfigSchema(`${label}.ensApi`),
+    ensDb: makeEnsDbPublicConfigSchema(`${label}.ensDb`),
+    ensIndexer: makeSerializedEnsIndexerPublicConfigSchema(`${label}.ensIndexer`),
+    ensRainbow: makeEnsRainbowPublicConfigSchema(`${label}.ensRainbow`).optional()
+  });
+}
+function makeEnsNodeStackInfoSchema(valueLabel) {
+  const label = valueLabel ?? "ENSNodeStackInfo";
+  return import_v424.z.object({
+    ensApi: makeEnsApiPublicConfigSchema(`${label}.ensApi`),
+    ensDb: makeEnsDbPublicConfigSchema(`${label}.ensDb`),
+    ensIndexer: makeEnsIndexerPublicConfigSchema(`${label}.ensIndexer`),
+    ensRainbow: makeEnsRainbowPublicConfigSchema(`${label}.ensRainbow`).optional()
+  });
+}
+
+// src/stack-info/deserialize/ensnode-stack-info.ts
+function buildUnvalidatedEnsNodeStackInfo(serializedStackInfo) {
+  const { ensApi, ensIndexer, ...rest } = serializedStackInfo;
+  return {
+    ...rest,
+    ensApi: buildUnvalidatedEnsApiPublicConfig(ensApi),
+    ensIndexer: buildUnvalidatedEnsIndexerPublicConfig(ensIndexer)
+  };
+}
+function deserializeEnsNodeStackInfo(maybeStackInfo, valueLabel) {
+  const parsed = makeSerializedEnsNodeStackInfoSchema(valueLabel).transform(buildUnvalidatedEnsNodeStackInfo).pipe(makeEnsNodeStackInfoSchema(valueLabel)).safeParse(maybeStackInfo);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize EnsNodeStackInfo:
+${(0, import_v425.prettifyError)(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+
+// 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"
+};
+var IndexingStatusResponseCodes = EnsApiIndexingStatusResponseCodes;
+
+// src/ensnode/api/indexing-status/zod-schemas.ts
+var import_v426 = require("zod/v4");
+var makeEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v426.z.strictObject({
+  responseCode: import_v426.z.literal(EnsApiIndexingStatusResponseCodes.Ok),
+  realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel),
+  stackInfo: makeEnsNodeStackInfoSchema(valueLabel)
+});
+var makeEnsApiIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v426.z.strictObject({
+  responseCode: import_v426.z.literal(EnsApiIndexingStatusResponseCodes.Error)
+});
+var makeEnsApiIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v426.z.discriminatedUnion("responseCode", [
+  makeEnsApiIndexingStatusResponseOkSchema(valueLabel),
+  makeEnsApiIndexingStatusResponseErrorSchema(valueLabel)
+]);
+var makeSerializedEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => import_v426.z.object({
+  responseCode: import_v426.z.literal(EnsApiIndexingStatusResponseCodes.Ok),
+  realtimeProjection: makeSerializedRealtimeIndexingStatusProjectionSchema(valueLabel),
+  stackInfo: makeSerializedEnsNodeStackInfoSchema(valueLabel)
+});
+var makeSerializedEnsApiIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => import_v426.z.discriminatedUnion("responseCode", [
+  makeSerializedEnsApiIndexingStatusResponseOkSchema(valueLabel),
+  makeEnsApiIndexingStatusResponseErrorSchema(valueLabel)
+]);
+
+// src/ensnode/api/indexing-status/deserialize.ts
+function buildUnvalidatedEnsApiIndexingStatusResponse(serializedResponse) {
+  if (serializedResponse.responseCode !== EnsApiIndexingStatusResponseCodes.Ok) {
+    return serializedResponse;
+  }
+  const { realtimeProjection, stackInfo, ...rest } = serializedResponse;
+  return {
+    realtimeProjection: buildUnvalidatedRealtimeIndexingStatusProjection(realtimeProjection),
+    stackInfo: buildUnvalidatedEnsNodeStackInfo(stackInfo),
+    ...rest
+  };
+}
+function deserializeEnsApiIndexingStatusResponse(maybeResponse) {
+  const parsed = makeSerializedEnsApiIndexingStatusResponseSchema().transform(buildUnvalidatedEnsApiIndexingStatusResponse).pipe(makeEnsApiIndexingStatusResponseSchema()).safeParse(maybeResponse);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize EnsApiIndexingStatusResponse:
+${(0, import_v427.prettifyError)(parsed.error)}
+`
+    );
+  }
+  return parsed.data;
+}
+var deserializeIndexingStatusResponse = deserializeEnsApiIndexingStatusResponse;
+
+// src/stack-info/serialize/ensnode-stack-info.ts
+function serializeEnsNodeStackInfo(stackInfo) {
+  return {
+    ensApi: serializeEnsApiPublicConfig(stackInfo.ensApi),
+    ensDb: stackInfo.ensDb,
+    ensIndexer: serializeEnsIndexerPublicConfig(stackInfo.ensIndexer),
+    ensRainbow: stackInfo.ensRainbow
+  };
+}
+
+// src/ensnode/api/indexing-status/serialize.ts
+function serializeEnsApiIndexingStatusResponse(response) {
+  switch (response.responseCode) {
+    case EnsApiIndexingStatusResponseCodes.Ok:
+      return {
+        responseCode: response.responseCode,
+        realtimeProjection: serializeRealtimeIndexingStatusProjection(response.realtimeProjection),
+        stackInfo: serializeEnsNodeStackInfo(response.stackInfo)
+      };
+    case EnsApiIndexingStatusResponseCodes.Error:
+      return response;
+  }
+}
+var serializeIndexingStatusResponse = serializeEnsApiIndexingStatusResponse;
+
+// src/ensnode/api/name-tokens/deserialize.ts
+var import_v432 = require("zod/v4");
+
+// src/ensnode/api/name-tokens/zod-schemas.ts
+var import_enssdk5 = require("enssdk");
+var import_v431 = require("zod/v4");
+
+// src/tokenscope/name-token.ts
+var import_enssdk4 = require("enssdk");
+var import_viem7 = require("viem");
+var import_datasources4 = require("@ensnode/datasources");
+
+// src/shared/account-id.ts
+var import_viem4 = require("viem");
+var accountIdEqual = (a, b) => {
+  return a.chainId === b.chainId && (0, import_viem4.isAddressEqual)(a.address, b.address);
+};
+
+// src/shared/datasource-contract.ts
+var import_datasources3 = require("@ensnode/datasources");
+var maybeGetDatasourceContract = (namespaceId, datasourceName, contractName) => {
+  const datasource = (0, import_datasources3.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
+var import_enssdk3 = require("enssdk");
+var import_viem6 = require("viem");
+var import_v429 = require("zod/v4");
+
+// src/tokenscope/zod-schemas.ts
+var import_caip2 = require("caip");
+var import_enssdk2 = require("enssdk");
+var import_viem5 = require("viem");
+var import_v428 = require("zod/v4");
+var tokenIdSchemaSerializable = import_v428.z.string();
+var tokenIdSchemaNative = import_v428.z.preprocess(
+  (v) => typeof v === "string" ? BigInt(v) : v,
+  import_v428.z.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 import_v428.z.object({
+    assetNamespace: import_v428.z.enum(import_enssdk2.AssetNamespaces),
+    contract: makeAccountIdSchema(valueLabel),
+    tokenId: makeTokenIdSchema(valueLabel, serializable ?? false)
+  });
+};
+var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => import_v428.z.preprocess((v) => {
+  if (typeof v === "string") {
+    const result = new import_caip2.AssetId(v);
+    return {
+      assetNamespace: result.assetName.namespace,
+      contract: {
+        chainId: Number(result.chainId.reference),
+        address: result.assetName.reference
+      },
+      tokenId: result.tokenId
+    };
+  }
+  return v;
+}, makeAssetIdSchema(valueLabel));
+function invariant_nameTokenOwnershipHasNonZeroAddressOwner(ctx) {
+  const ownership = ctx.value;
+  if (ctx.value.owner.address === import_viem5.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") => import_v428.z.object({
+  ownershipType: import_v428.z.literal(NameTokenOwnershipTypes.NameWrapper),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
+var makeNameTokenOwnershipFullyOnchainSchema = (valueLabel = "Name Token Ownership Fully Onchain") => import_v428.z.object({
+  ownershipType: import_v428.z.literal(NameTokenOwnershipTypes.FullyOnchain),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
+var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => import_v428.z.object({
+  ownershipType: import_v428.z.literal(NameTokenOwnershipTypes.Burned),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasZeroAddressOwner);
+var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => import_v428.z.object({
+  ownershipType: import_v428.z.literal(NameTokenOwnershipTypes.Unknown),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
+function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
+  const ownership = ctx.value;
+  if (ctx.value.owner.address !== import_viem5.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") => import_v428.z.discriminatedUnion("ownershipType", [
+  makeNameTokenOwnershipNameWrapperSchema(valueLabel),
+  makeNameTokenOwnershipFullyOnchainSchema(valueLabel),
+  makeNameTokenOwnershipBurnedSchema(valueLabel),
+  makeNameTokenOwnershipUnknownSchema(valueLabel)
+]);
+var makeNameTokenSchema = (valueLabel = "Name Token Schema", serializable) => import_v428.z.object({
+  token: makeAssetIdSchema(`${valueLabel}.token`, serializable),
+  ownership: makeNameTokenOwnershipSchema(`${valueLabel}.ownership`),
+  mintStatus: import_v428.z.enum(NFTMintStatuses)
+});
+
+// src/tokenscope/assets.ts
+function serializeAssetId(assetId) {
+  return {
+    assetNamespace: assetId.assetNamespace,
+    contract: assetId.contract,
+    tokenId: assetId.tokenId.toString()
+  };
+}
+function deserializeAssetId(maybeAssetId, valueLabel) {
+  const schema = makeAssetIdSchema(valueLabel);
+  const parsed = schema.safeParse(maybeAssetId);
+  if (parsed.error) {
+    throw new RangeError(`Cannot deserialize AssetId:
+${(0, import_v429.prettifyError)(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+function parseAssetId(maybeAssetId, valueLabel) {
+  const schema = makeAssetIdStringSchema(valueLabel);
+  const parsed = schema.safeParse(maybeAssetId);
+  if (parsed.error) {
+    throw new RangeError(`Cannot parse AssetId:
+${(0, import_v429.prettifyError)(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+var buildAssetId = (contract, tokenId, assetNamespace) => {
+  return {
+    assetNamespace,
+    contract,
+    tokenId
+  };
+};
+function serializeDomainAssetId(domainAsset) {
+  return {
+    ...serializeAssetId(domainAsset),
+    domainId: domainAsset.domainId
+  };
+}
+var NFTMintStatuses = {
+  Minted: "minted",
+  Burned: "burned"
+};
+var formatNFTTransferEventMetadata = (metadata) => {
+  const assetIdString = (0, import_enssdk3.stringifyAssetId)(metadata.nft);
+  return [
+    `Event: ${metadata.eventHandlerName}`,
+    `Chain ID: ${metadata.chainId}`,
+    `Block Number: ${metadata.blockNumber}`,
+    `Transaction Hash: ${metadata.transactionHash}`,
+    `NFT: ${assetIdString}`
+  ].map((line) => ` - ${line}`).join("\n");
+};
+var NFTTransferTypes = {
+  /**
+   * Initial transfer from zeroAddress to a non-zeroAddress
+   * Can happen at most once to a NFT AssetId
+   *
+   * Invariants:
+   * - NFT is not indexed and therefore has no previous mint status or owner
+   * - new NFT mint status is `minted`
+   * - new NFT owner is a non-zeroAddress
+   */
+  Mint: "mint",
+  /**
+   * Subsequent transfer from zeroAddress to a non-zeroAddress
+   * Can happen any number of times to a NFT AssetId as it passes in a cycle from
+   * mint -> burn -> remint -> burn -> remint -> ...
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous NFT mint status was `burned`
+   * - previous NFT owner is the zeroAddress
+   * - new NFT mint status is `minted`
+   * - new NFT owner is a non-zeroAddress
+   */
+  Remint: "remint",
+  /**
+   * Special transfer type for improperly implemented NFT contracts that allow a NFT
+   * that is currently minted to be reminted before an intermediate burn.
+   *
+   * Transfer from zeroAddress to non-zeroAddress for an indexed NFT where the
+   * previously indexed nft had status `minted` with a non-zeroAddress owner.
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous NFT mint status was `minted`
+   * - previous NFT owner was a non-zeroAddress
+   * - new NFT mint status is `minted`
+   * - new NFT owner is a non-zeroAddress
    */
   MintedRemint: "minted-remint",
   /**
@@ -2243,11 +2614,11 @@ var NFTTransferTypes = {
 };
 var getNFTTransferType = (from, to, allowMintedRemint, metadata, currentlyIndexedOwner) => {
   const isIndexed = currentlyIndexedOwner !== void 0;
-  const isIndexedAsMinted = isIndexed && !(0, import_viem5.isAddressEqual)(currentlyIndexedOwner, import_viem5.zeroAddress);
-  const isMint = (0, import_viem5.isAddressEqual)(from, import_viem5.zeroAddress);
-  const isBurn = (0, import_viem5.isAddressEqual)(to, import_viem5.zeroAddress);
-  const isSelfTransfer = (0, import_viem5.isAddressEqual)(from, to);
-  if (isIndexed && !(0, import_viem5.isAddressEqual)(currentlyIndexedOwner, from)) {
+  const isIndexedAsMinted = isIndexed && !(0, import_viem6.isAddressEqual)(currentlyIndexedOwner, import_viem6.zeroAddress);
+  const isMint = (0, import_viem6.isAddressEqual)(from, import_viem6.zeroAddress);
+  const isBurn = (0, import_viem6.isAddressEqual)(to, import_viem6.zeroAddress);
+  const isSelfTransfer = (0, import_viem6.isAddressEqual)(from, to);
+  if (isIndexed && !(0, import_viem6.isAddressEqual)(currentlyIndexedOwner, from)) {
     if (isMint && allowMintedRemint) {
     } else {
       throw new Error(
@@ -2388,7 +2759,7 @@ function getNameTokenOwnership(namespaceId, name, owner) {
       owner
     };
   }
-  if ((0, import_viem6.isAddressEqual)(owner.address, import_viem6.zeroAddress)) {
+  if ((0, import_viem7.isAddressEqual)(owner.address, import_viem7.zeroAddress)) {
     return {
       ownershipType: NameTokenOwnershipTypes.Burned,
       owner
@@ -2408,14 +2779,14 @@ function getNameTokenOwnership(namespaceId, name, owner) {
   };
 }
 
-// src/ensapi/api/shared/errors/zod-schemas.ts
-var import_v421 = require("zod/v4");
-var ErrorResponseSchema = import_v421.z.object({
-  message: import_v421.z.string(),
-  details: import_v421.z.optional(import_v421.z.unknown())
+// src/ensnode/api/shared/errors/zod-schemas.ts
+var import_v430 = require("zod/v4");
+var ErrorResponseSchema2 = import_v430.z.object({
+  message: import_v430.z.string(),
+  details: import_v430.z.optional(import_v430.z.unknown())
 });
 
-// src/ensapi/api/name-tokens/response.ts
+// src/ensnode/api/name-tokens/response.ts
 var NameTokensResponseCodes = {
   /**
    * Represents a response when Name Tokens API can respond with requested data.
@@ -2450,11 +2821,11 @@ var NameTokensResponseErrorCodes = {
   IndexingStatusUnsupported: "unsupported-indexing-status"
 };
 
-// src/ensapi/api/name-tokens/zod-schemas.ts
-var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", serializable) => import_v422.z.object({
+// src/ensnode/api/name-tokens/zod-schemas.ts
+var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", serializable) => import_v431.z.object({
   domainId: makeNodeSchema(`${valueLabel}.domainId`),
   name: makeReinterpretedNameSchema(valueLabel),
-  tokens: import_v422.z.array(makeNameTokenSchema(`${valueLabel}.tokens`, serializable)).nonempty(),
+  tokens: import_v431.z.array(makeNameTokenSchema(`${valueLabel}.tokens`, serializable)).nonempty(),
   expiresAt: makeUnixTimestampSchema(`${valueLabel}.expiresAt`),
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 }).check(function invariant_nameIsAssociatedWithDomainId(ctx) {
@@ -2496,51 +2867,51 @@ var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", seria
     });
   }
 });
-var makeNameTokensResponseOkSchema = (valueLabel = "Name Tokens Response OK", serializable) => import_v422.z.strictObject({
-  responseCode: import_v422.z.literal(NameTokensResponseCodes.Ok),
+var makeNameTokensResponseOkSchema = (valueLabel = "Name Tokens Response OK", serializable) => import_v431.z.strictObject({
+  responseCode: import_v431.z.literal(NameTokensResponseCodes.Ok),
   registeredNameTokens: makeRegisteredNameTokenSchema(`${valueLabel}.nameTokens`, serializable)
 });
-var makeNameTokensResponseErrorNameTokensNotIndexedSchema = (_valueLabel = "Name Tokens Response Error Name Not Indexed") => import_v422.z.strictObject({
-  responseCode: import_v422.z.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v422.z.literal(NameTokensResponseErrorCodes.NameTokensNotIndexed),
-  error: ErrorResponseSchema
+var makeNameTokensResponseErrorNameTokensNotIndexedSchema = (_valueLabel = "Name Tokens Response Error Name Not Indexed") => import_v431.z.strictObject({
+  responseCode: import_v431.z.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v431.z.literal(NameTokensResponseErrorCodes.NameTokensNotIndexed),
+  error: ErrorResponseSchema2
 });
-var makeNameTokensResponseErrorEnsIndexerConfigUnsupported = (_valueLabel = "Name Tokens Response Error ENSIndexer Config Unsupported") => import_v422.z.strictObject({
-  responseCode: import_v422.z.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v422.z.literal(NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported),
-  error: ErrorResponseSchema
+var makeNameTokensResponseErrorEnsIndexerConfigUnsupported = (_valueLabel = "Name Tokens Response Error ENSIndexer Config Unsupported") => import_v431.z.strictObject({
+  responseCode: import_v431.z.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v431.z.literal(NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported),
+  error: ErrorResponseSchema2
 });
-var makeNameTokensResponseErrorNameIndexingStatusUnsupported = (_valueLabel = "Name Tokens Response Error Indexing Status Unsupported") => import_v422.z.strictObject({
-  responseCode: import_v422.z.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v422.z.literal(NameTokensResponseErrorCodes.IndexingStatusUnsupported),
-  error: ErrorResponseSchema
+var makeNameTokensResponseErrorNameIndexingStatusUnsupported = (_valueLabel = "Name Tokens Response Error Indexing Status Unsupported") => import_v431.z.strictObject({
+  responseCode: import_v431.z.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v431.z.literal(NameTokensResponseErrorCodes.IndexingStatusUnsupported),
+  error: ErrorResponseSchema2
 });
-var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => import_v422.z.discriminatedUnion("errorCode", [
+var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => import_v431.z.discriminatedUnion("errorCode", [
   makeNameTokensResponseErrorNameTokensNotIndexedSchema(valueLabel),
   makeNameTokensResponseErrorEnsIndexerConfigUnsupported(valueLabel),
   makeNameTokensResponseErrorNameIndexingStatusUnsupported(valueLabel)
 ]);
 var makeNameTokensResponseSchema = (valueLabel = "Name Tokens Response", serializable) => {
-  return import_v422.z.discriminatedUnion("responseCode", [
+  return import_v431.z.discriminatedUnion("responseCode", [
     makeNameTokensResponseOkSchema(valueLabel, serializable ?? false),
     makeNameTokensResponseErrorSchema(valueLabel)
   ]);
 };
 
-// src/ensapi/api/name-tokens/deserialize.ts
+// src/ensnode/api/name-tokens/deserialize.ts
 function deserializedNameTokensResponse(maybeResponse) {
   const parsed = makeNameTokensResponseSchema("Name Tokens Response", false).safeParse(
     maybeResponse
   );
   if (parsed.error) {
     throw new Error(`Cannot deserialize NameTokensResponse:
-${(0, import_v423.prettifyError)(parsed.error)}
+${(0, import_v432.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
 }
 
-// src/ensapi/api/name-tokens/prerequisites.ts
+// src/ensnode/api/name-tokens/prerequisites.ts
 var nameTokensPrerequisites = Object.freeze({
   /**
    * Required plugins to enable Name Tokens API routes.
@@ -2579,7 +2950,7 @@ var nameTokensPrerequisites = Object.freeze({
   }
 });
 
-// src/ensapi/api/name-tokens/serialize.ts
+// src/ensnode/api/name-tokens/serialize.ts
 function serializeRegisteredNameTokens({
   domainId,
   name,
@@ -2607,42 +2978,42 @@ function serializeNameTokensResponse(response) {
   }
 }
 
-// src/ensapi/api/registrar-actions/deserialize.ts
-var import_v427 = require("zod/v4");
+// src/ensnode/api/registrar-actions/deserialize.ts
+var import_v436 = require("zod/v4");
 
-// src/ensapi/api/registrar-actions/zod-schemas.ts
+// src/ensnode/api/registrar-actions/zod-schemas.ts
 var import_enssdk7 = require("enssdk");
-var import_v426 = require("zod/v4");
+var import_v435 = require("zod/v4");
 
 // src/registrars/zod-schemas.ts
-var import_v424 = require("zod/v4");
+var import_v433 = require("zod/v4");
 
 // src/registrars/encoded-referrer.ts
 var import_enssdk6 = require("enssdk");
-var import_viem7 = require("viem");
+var import_viem8 = require("viem");
 var ENCODED_REFERRER_BYTE_OFFSET = 12;
 var ENCODED_REFERRER_BYTE_LENGTH = 32;
-var EXPECTED_ENCODED_REFERRER_PADDING = (0, import_viem7.pad)("0x", {
+var EXPECTED_ENCODED_REFERRER_PADDING = (0, import_viem8.pad)("0x", {
   size: ENCODED_REFERRER_BYTE_OFFSET,
   dir: "left"
 });
-var ZERO_ENCODED_REFERRER = (0, import_viem7.pad)("0x", {
+var ZERO_ENCODED_REFERRER = (0, import_viem8.pad)("0x", {
   size: ENCODED_REFERRER_BYTE_LENGTH,
   dir: "left"
 });
 function buildEncodedReferrer(address) {
   if (!(0, import_enssdk6.isNormalizedAddress)(address)) throw new Error(`Address '${address}' is not normalized.`);
-  return (0, import_viem7.pad)(address, { size: ENCODED_REFERRER_BYTE_LENGTH, dir: "left" });
+  return (0, import_viem8.pad)(address, { size: ENCODED_REFERRER_BYTE_LENGTH, dir: "left" });
 }
 function decodeEncodedReferrer(encodedReferrer) {
-  if ((0, import_viem7.size)(encodedReferrer) !== ENCODED_REFERRER_BYTE_LENGTH) {
+  if ((0, import_viem8.size)(encodedReferrer) !== ENCODED_REFERRER_BYTE_LENGTH) {
     throw new Error(
       `Encoded referrer value must be represented by ${ENCODED_REFERRER_BYTE_LENGTH} bytes.`
     );
   }
-  const padding = (0, import_viem7.slice)(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
-  if (padding !== EXPECTED_ENCODED_REFERRER_PADDING) return import_viem7.zeroAddress;
-  const decodedReferrer = (0, import_viem7.slice)(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
+  const padding = (0, import_viem8.slice)(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
+  if (padding !== EXPECTED_ENCODED_REFERRER_PADDING) return import_viem8.zeroAddress;
+  const decodedReferrer = (0, import_viem8.slice)(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
   try {
     return (0, import_enssdk6.toNormalizedAddress)(decodedReferrer);
   } catch {
@@ -2689,11 +3060,11 @@ function serializeRegistrarAction(registrarAction) {
 }
 
 // src/registrars/zod-schemas.ts
-var makeSubregistrySchema = (valueLabel = "Subregistry") => import_v424.z.object({
+var makeSubregistrySchema = (valueLabel = "Subregistry") => import_v433.z.object({
   subregistryId: makeAccountIdSchema(`${valueLabel} Subregistry ID`),
   node: makeNodeSchema(`${valueLabel} Node`)
 });
-var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => import_v424.z.object({
+var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => import_v433.z.object({
   subregistry: makeSubregistrySchema(`${valueLabel} Subregistry`),
   node: makeNodeSchema(`${valueLabel} Node`),
   expiresAt: makeUnixTimestampSchema(`${valueLabel} Expires at`)
@@ -2709,18 +3080,18 @@ function invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium(ctx) {
     });
   }
 }
-var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => import_v424.z.union([
+var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => import_v433.z.union([
   // pricing available
-  import_v424.z.object({
+  import_v433.z.object({
     baseCost: makePriceEthSchema(`${valueLabel} Base Cost`),
     premium: makePriceEthSchema(`${valueLabel} Premium`),
     total: makePriceEthSchema(`${valueLabel} Total`)
   }).check(invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium).transform((v) => v),
   // pricing unknown
-  import_v424.z.object({
-    baseCost: import_v424.z.null(),
-    premium: import_v424.z.null(),
-    total: import_v424.z.null()
+  import_v433.z.object({
+    baseCost: import_v433.z.null(),
+    premium: import_v433.z.null(),
+    total: import_v433.z.null()
   }).transform((v) => v)
 ]);
 function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
@@ -2743,9 +3114,9 @@ function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
     });
   }
 }
-var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => import_v424.z.union([
+var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => import_v433.z.union([
   // referral available
-  import_v424.z.object({
+  import_v433.z.object({
     encodedReferrer: makeHexStringSchema(
       { bytesCount: ENCODED_REFERRER_BYTE_LENGTH },
       `${valueLabel} Encoded Referrer`
@@ -2753,9 +3124,9 @@ var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral
     decodedReferrer: makeNormalizedAddressSchema(`${valueLabel} Decoded Referrer`)
   }).check(invariant_registrarActionDecodedReferrerBasedOnRawReferrer),
   // referral not applicable
-  import_v424.z.object({
-    encodedReferrer: import_v424.z.null(),
-    decodedReferrer: import_v424.z.null()
+  import_v433.z.object({
+    encodedReferrer: import_v433.z.null(),
+    decodedReferrer: import_v433.z.null()
   })
 ]);
 function invariant_eventIdsInitialElementIsTheActionId(ctx) {
@@ -2768,9 +3139,9 @@ function invariant_eventIdsInitialElementIsTheActionId(ctx) {
     });
   }
 }
-var EventIdSchema = import_v424.z.string().nonempty();
-var EventIdsSchema = import_v424.z.array(EventIdSchema).min(1).transform((v) => v);
-var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => import_v424.z.object({
+var EventIdSchema = import_v433.z.string().nonempty();
+var EventIdsSchema = import_v433.z.array(EventIdSchema).min(1).transform((v) => v);
+var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => import_v433.z.object({
   id: EventIdSchema,
   incrementalDuration: makeDurationSchema(`${valueLabel} Incremental Duration`),
   registrant: makeNormalizedAddressSchema(`${valueLabel} Registrant`),
@@ -2784,38 +3155,38 @@ var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => im
   eventIds: EventIdsSchema
 }).check(invariant_eventIdsInitialElementIsTheActionId);
 var makeRegistrarActionRegistrationSchema = (valueLabel = "Registration ") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: import_v424.z.literal(RegistrarActionTypes.Registration)
+  type: import_v433.z.literal(RegistrarActionTypes.Registration)
 });
 var makeRegistrarActionRenewalSchema = (valueLabel = "Renewal") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: import_v424.z.literal(RegistrarActionTypes.Renewal)
+  type: import_v433.z.literal(RegistrarActionTypes.Renewal)
 });
-var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => import_v424.z.discriminatedUnion("type", [
+var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => import_v433.z.discriminatedUnion("type", [
   makeRegistrarActionRegistrationSchema(`${valueLabel} Registration`),
   makeRegistrarActionRenewalSchema(`${valueLabel} Renewal`)
 ]);
 
-// src/ensapi/api/shared/pagination/zod-schemas.ts
-var import_v425 = require("zod/v4");
+// src/ensnode/api/shared/pagination/zod-schemas.ts
+var import_v434 = require("zod/v4");
 
-// src/ensapi/api/shared/pagination/request.ts
+// src/ensnode/api/shared/pagination/request.ts
 var RECORDS_PER_PAGE_DEFAULT = 10;
 var RECORDS_PER_PAGE_MAX = 100;
 
-// src/ensapi/api/shared/pagination/zod-schemas.ts
-var makeRequestPageParamsSchema = (valueLabel = "RequestPageParams") => import_v425.z.object({
+// src/ensnode/api/shared/pagination/zod-schemas.ts
+var makeRequestPageParamsSchema = (valueLabel = "RequestPageParams") => import_v434.z.object({
   page: makePositiveIntegerSchema(`${valueLabel}.page`),
   recordsPerPage: makePositiveIntegerSchema(`${valueLabel}.recordsPerPage`).max(
     RECORDS_PER_PAGE_MAX,
     `${valueLabel}.recordsPerPage must not exceed ${RECORDS_PER_PAGE_MAX}`
   )
 });
-var makeResponsePageContextSchemaWithNoRecords = (valueLabel = "ResponsePageContextWithNoRecords") => import_v425.z.object({
-  totalRecords: import_v425.z.literal(0),
-  totalPages: import_v425.z.literal(1),
-  hasNext: import_v425.z.literal(false),
-  hasPrev: import_v425.z.literal(false),
-  startIndex: import_v425.z.undefined(),
-  endIndex: import_v425.z.undefined()
+var makeResponsePageContextSchemaWithNoRecords = (valueLabel = "ResponsePageContextWithNoRecords") => import_v434.z.object({
+  totalRecords: import_v434.z.literal(0),
+  totalPages: import_v434.z.literal(1),
+  hasNext: import_v434.z.literal(false),
+  hasPrev: import_v434.z.literal(false),
+  startIndex: import_v434.z.undefined(),
+  endIndex: import_v434.z.undefined()
 }).extend(makeRequestPageParamsSchema(valueLabel).shape);
 function invariant_responsePageWithRecordsIsCorrect(ctx) {
   const { hasNext, hasPrev, recordsPerPage, page, totalRecords, startIndex, endIndex } = ctx.value;
@@ -2850,20 +3221,20 @@ function invariant_responsePageWithRecordsIsCorrect(ctx) {
     });
   }
 }
-var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => import_v425.z.object({
+var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => import_v434.z.object({
   totalRecords: makePositiveIntegerSchema(`${valueLabel}.totalRecords`),
   totalPages: makePositiveIntegerSchema(`${valueLabel}.totalPages`),
-  hasNext: import_v425.z.boolean(),
-  hasPrev: import_v425.z.boolean(),
+  hasNext: import_v434.z.boolean(),
+  hasPrev: import_v434.z.boolean(),
   startIndex: makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`),
   endIndex: makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`)
 }).extend(makeRequestPageParamsSchema(valueLabel).shape).check(invariant_responsePageWithRecordsIsCorrect);
-var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => import_v425.z.union([
+var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => import_v434.z.union([
   makeResponsePageContextSchemaWithNoRecords(valueLabel),
   makeResponsePageContextSchemaWithRecords(valueLabel)
 ]);
 
-// src/ensapi/api/registrar-actions/response.ts
+// src/ensnode/api/registrar-actions/response.ts
 var RegistrarActionsResponseCodes = {
   /**
    * Represents that Registrar Actions are available.
@@ -2875,7 +3246,7 @@ var RegistrarActionsResponseCodes = {
   Error: "error"
 };
 
-// src/ensapi/api/registrar-actions/zod-schemas.ts
+// src/ensnode/api/registrar-actions/zod-schemas.ts
 function invariant_registrationLifecycleNodeMatchesName(ctx) {
   const { name, action } = ctx.value;
   const expectedNode = action.registrationLifecycle.node;
@@ -2888,39 +3259,39 @@ function invariant_registrationLifecycleNodeMatchesName(ctx) {
     });
   }
 }
-var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => import_v426.z.object({
+var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => import_v435.z.object({
   action: makeRegistrarActionSchema(valueLabel),
   name: makeReinterpretedNameSchema(valueLabel)
 }).check(invariant_registrationLifecycleNodeMatchesName);
-var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => import_v426.z.object({
-  responseCode: import_v426.z.literal(RegistrarActionsResponseCodes.Ok),
-  registrarActions: import_v426.z.array(makeNamedRegistrarActionSchema(valueLabel)),
+var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => import_v435.z.object({
+  responseCode: import_v435.z.literal(RegistrarActionsResponseCodes.Ok),
+  registrarActions: import_v435.z.array(makeNamedRegistrarActionSchema(valueLabel)),
   pageContext: makeResponsePageContextSchema(`${valueLabel}.pageContext`),
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 });
-var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => import_v426.z.strictObject({
-  responseCode: import_v426.z.literal(RegistrarActionsResponseCodes.Error),
-  error: ErrorResponseSchema
+var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => import_v435.z.strictObject({
+  responseCode: import_v435.z.literal(RegistrarActionsResponseCodes.Error),
+  error: ErrorResponseSchema2
 });
-var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => import_v426.z.discriminatedUnion("responseCode", [
+var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => import_v435.z.discriminatedUnion("responseCode", [
   makeRegistrarActionsResponseOkSchema(valueLabel),
   makeRegistrarActionsResponseErrorSchema(valueLabel)
 ]);
 
-// src/ensapi/api/registrar-actions/deserialize.ts
+// src/ensnode/api/registrar-actions/deserialize.ts
 function deserializeRegistrarActionsResponse(maybeResponse) {
   const parsed = makeRegistrarActionsResponseSchema().safeParse(maybeResponse);
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize RegistrarActionsResponse:
-${(0, import_v427.prettifyError)(parsed.error)}
+${(0, import_v436.prettifyError)(parsed.error)}
 `
     );
   }
   return parsed.data;
 }
 
-// src/ensapi/api/registrar-actions/request.ts
+// src/ensnode/api/registrar-actions/request.ts
 var RegistrarActionsFilterTypes = {
   BySubregistryNode: "bySubregistryNode",
   WithEncodedReferral: "withEncodedReferral",
@@ -2940,7 +3311,7 @@ var RegistrarActionsOrders = {
   LatestRegistrarActions: "orderBy[timestamp]=desc"
 };
 
-// src/ensapi/api/registrar-actions/filters.ts
+// src/ensnode/api/registrar-actions/filters.ts
 function byParentNode(parentNode) {
   if (typeof parentNode === "undefined") {
     return void 0;
@@ -2993,7 +3364,7 @@ var registrarActionsFilter = {
   endTimestamp
 };
 
-// src/ensapi/api/registrar-actions/prerequisites.ts
+// src/ensnode/api/registrar-actions/prerequisites.ts
 var registrarActionsRequiredPlugins = [
   "subgraph" /* Subgraph */,
   "basenames" /* Basenames */,
@@ -3025,7 +3396,7 @@ function hasRegistrarActionsIndexingStatusSupport(omnichainIndexingStatusId) {
   };
 }
 
-// src/ensapi/api/registrar-actions/serialize.ts
+// src/ensnode/api/registrar-actions/serialize.ts
 function serializeNamedRegistrarAction({
   action,
   name
@@ -3049,19 +3420,19 @@ function serializeRegistrarActionsResponse(response) {
   }
 }
 
-// src/ensapi/api/shared/errors/deserialize.ts
-var import_v428 = require("zod/v4");
-function deserializeErrorResponse(maybeErrorResponse) {
-  const parsed = ErrorResponseSchema.safeParse(maybeErrorResponse);
+// src/ensnode/api/shared/errors/deserialize.ts
+var import_v437 = require("zod/v4");
+function deserializeErrorResponse2(maybeErrorResponse) {
+  const parsed = ErrorResponseSchema2.safeParse(maybeErrorResponse);
   if (parsed.error) {
     throw new Error(`Cannot deserialize ErrorResponse:
-${(0, import_v428.prettifyError)(parsed.error)}
+${(0, import_v437.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
 }
 
-// src/ensapi/api/shared/pagination/build-page-context.ts
+// src/ensnode/api/shared/pagination/build-page-context.ts
 function buildPageContext(page, recordsPerPage, totalRecords) {
   const totalPages = Math.max(1, Math.ceil(totalRecords / recordsPerPage));
   if (page > totalPages) {
@@ -3096,7 +3467,7 @@ function buildPageContext(page, recordsPerPage, totalRecords) {
   };
 }
 
-// src/ensapi/client-error.ts
+// src/ensnode/client-error.ts
 var ClientError = class _ClientError extends Error {
   details;
   constructor(message, details) {
@@ -3109,17 +3480,17 @@ var ClientError = class _ClientError extends Error {
   }
 };
 
-// src/ensapi/deployments.ts
+// src/ensnode/deployments.ts
 var import_datasources5 = require("@ensnode/datasources");
-var DEFAULT_ENSNODE_API_URL_MAINNET = "https://api.alpha.ensnode.io";
-var DEFAULT_ENSNODE_API_URL_SEPOLIA = "https://api.alpha-sepolia.ensnode.io";
+var DEFAULT_ENSNODE_URL_MAINNET = "https://api.alpha.ensnode.io";
+var DEFAULT_ENSNODE_URL_SEPOLIA = "https://api.alpha-sepolia.ensnode.io";
 var getDefaultEnsNodeUrl = (namespace) => {
   const effectiveNamespace = namespace ?? import_datasources5.ENSNamespaceIds.Mainnet;
   switch (effectiveNamespace) {
     case import_datasources5.ENSNamespaceIds.Mainnet:
-      return new URL(DEFAULT_ENSNODE_API_URL_MAINNET);
+      return new URL(DEFAULT_ENSNODE_URL_MAINNET);
     case import_datasources5.ENSNamespaceIds.Sepolia:
-      return new URL(DEFAULT_ENSNODE_API_URL_SEPOLIA);
+      return new URL(DEFAULT_ENSNODE_URL_SEPOLIA);
     default:
       throw new Error(
         `ENSNamespaceId ${effectiveNamespace} does not have a default ENSNode URL defined`
@@ -3127,8 +3498,8 @@ var getDefaultEnsNodeUrl = (namespace) => {
   }
 };
 
-// src/ensapi/client.ts
-var EnsApiClient = class _EnsApiClient {
+// src/ensnode/client.ts
+var EnsNodeClient = class _EnsNodeClient {
   options;
   static defaultOptions() {
     return {
@@ -3137,7 +3508,7 @@ var EnsApiClient = class _EnsApiClient {
   }
   constructor(options = {}) {
     this.options = {
-      ..._EnsApiClient.defaultOptions(),
+      ..._EnsNodeClient.defaultOptions(),
       ...options
     };
   }
@@ -3293,43 +3664,17 @@ var EnsApiClient = class _EnsApiClient {
    * ```
    */
   async resolvePrimaryNames(address, options) {
-    const url = new URL(`/api/resolve/primary-names/${address}`, this.options.url);
-    if (options?.chainIds) url.searchParams.set("chainIds", options.chainIds.join(","));
-    if (options?.trace) url.searchParams.set("trace", "true");
-    if (options?.accelerate) url.searchParams.set("accelerate", "true");
-    const response = await fetch(url);
-    if (!response.ok) {
-      const error = await response.json();
-      throw ClientError.fromErrorResponse(error);
-    }
-    const data = await response.json();
-    return data;
-  }
-  /**
-   * Fetch ENSApi Config
-   *
-   * Fetch the ENSApi's configuration.
-   *
-   * @returns {EnsApiConfigResponse}
-   *
-   * @throws if the ENSApi request fails
-   * @throws if the ENSApi returns a non-ok response
-   * @throws if the ENSApi response breaks required invariants
-   */
-  async config() {
-    const url = new URL(`/api/config`, this.options.url);
+    const url = new URL(`/api/resolve/primary-names/${address}`, this.options.url);
+    if (options?.chainIds) url.searchParams.set("chainIds", options.chainIds.join(","));
+    if (options?.trace) url.searchParams.set("trace", "true");
+    if (options?.accelerate) url.searchParams.set("accelerate", "true");
     const response = await fetch(url);
-    let responseData;
-    try {
-      responseData = await response.json();
-    } catch {
-      throw new Error("Malformed response data: invalid JSON");
-    }
     if (!response.ok) {
-      const errorResponse = deserializeErrorResponse(responseData);
-      throw new Error(`Fetching ENSApi Config Failed: ${errorResponse.message}`);
+      const error = await response.json();
+      throw ClientError.fromErrorResponse(error);
     }
-    return deserializeEnsApiConfigResponse(responseData);
+    const data = await response.json();
+    return data;
   }
   /**
    * Fetch ENSApi Indexing Status
@@ -3352,7 +3697,7 @@ var EnsApiClient = class _EnsApiClient {
     if (!response.ok) {
       let errorResponse;
       try {
-        errorResponse = deserializeErrorResponse(responseData);
+        errorResponse = deserializeErrorResponse2(responseData);
       } catch {
       }
       if (typeof errorResponse !== "undefined") {
@@ -3383,13 +3728,13 @@ var EnsApiClient = class _EnsApiClient {
    * ```ts
    * import {
    *   registrarActionsFilter,
-   *   EnsApiClient,
+   *   EnsNodeClient,
    * } from "@ensnode/ensnode-sdk";
    * import { ETH_NODE, namehashInterpretedName, asInterpretedName } from "enssdk";
    *
    * const BASE_NODE = namehashInterpretedName(asInterpretedName("base.eth"));
    *
-   * const client: EnsApiClient;
+   * const client: EnsNodeClient;
    *
    * // Get first page with default page size (10 records)
    * const response = await client.registrarActions();
@@ -3475,259 +3820,50 @@ var EnsApiClient = class _EnsApiClient {
       );
       return beginTimestampFilter ? { key: "beginTimestamp", value: beginTimestampFilter.value.toString() } : null;
     };
-    const buildEndTimestampArg = (filters) => {
-      const endTimestampFilter = filters?.find(
-        (f) => f.filterType === RegistrarActionsFilterTypes.EndTimestamp
-      );
-      return endTimestampFilter ? { key: "endTimestamp", value: endTimestampFilter.value.toString() } : null;
-    };
-    const buildOrderArg = (order) => {
-      switch (order) {
-        case RegistrarActionsOrders.LatestRegistrarActions: {
-          const [field, direction] = order.split("=");
-          return {
-            key: `sort[${field}]`,
-            value: `${direction}`
-          };
-        }
-      }
-    };
-    const url = buildUrlPath(request.filters);
-    if (request.order) {
-      const orderArgs = buildOrderArg(request.order);
-      url.searchParams.set(orderArgs.key, orderArgs.value);
-    }
-    if (request.page) {
-      url.searchParams.set("page", request.page.toString());
-    }
-    if (request.recordsPerPage) {
-      url.searchParams.set("recordsPerPage", request.recordsPerPage.toString());
-    }
-    const referralArg = buildWithReferralArg(request.filters);
-    if (referralArg) {
-      url.searchParams.set(referralArg.key, referralArg.value);
-    }
-    const decodedReferrerArg = buildDecodedReferrerArg(request.filters);
-    if (decodedReferrerArg) {
-      url.searchParams.set(decodedReferrerArg.key, decodedReferrerArg.value);
-    }
-    const beginTimestampArg = buildBeginTimestampArg(request.filters);
-    if (beginTimestampArg) {
-      url.searchParams.set(beginTimestampArg.key, beginTimestampArg.value);
-    }
-    const endTimestampArg = buildEndTimestampArg(request.filters);
-    if (endTimestampArg) {
-      url.searchParams.set(endTimestampArg.key, endTimestampArg.value);
-    }
-    const response = await fetch(url);
-    let responseData;
-    try {
-      responseData = await response.json();
-    } catch {
-      throw new Error("Malformed response data: invalid JSON");
-    }
-    if (!response.ok) {
-      let errorResponse;
-      try {
-        errorResponse = deserializeErrorResponse(responseData);
-      } catch {
-        console.log("Registrar Actions API: handling a known server error.");
-      }
-      if (typeof errorResponse !== "undefined") {
-        throw new Error(`Fetching ENSNode Registrar Actions Failed: ${errorResponse.message}`);
-      }
-    }
-    return deserializeRegistrarActionsResponse(responseData);
-  }
-  /**
-   * Fetch Name Tokens for requested name.
-   *
-   * @param request.name - Name for which Name Tokens will be fetched.
-   * @returns {NameTokensResponse}
-   *
-   * @throws if the ENSNode request fails
-   * @throws if the ENSNode API returns an error response
-   * @throws if the ENSNode response breaks required invariants
-   *
-   * @example
-   * ```ts
-   * import {
-   *   EnsApiClient,
-   * } from "@ensnode/ensnode-sdk";
-   * import { namehashInterpretedName, asInterpretedName } from "enssdk";
-   *
-   * const VITALIK_NAME = asInterpretedName("vitalik.eth");
-   * const VITALIK_DOMAIN_ID = namehashInterpretedName(VITALIK_NAME);
-   *
-   * const client: EnsApiClient;
-   *
-   * // get latest name token records from the indexed subregistry based on the requested name
-   * const response = await client.nameTokens({
-   *   name: VITALIK_NAME,
-   * });
-   *
-   * const response = await client.nameTokens({
-   *   domainId: VITALIK_DOMAIN_ID,
-   * })
-   * ```
-   */
-  async nameTokens(request) {
-    const url = new URL(`/api/name-tokens`, this.options.url);
-    if (request.name !== void 0) {
-      url.searchParams.set("name", request.name);
-    } else if (request.domainId !== void 0) {
-      url.searchParams.set("domainId", request.domainId);
-    }
-    const response = await fetch(url);
-    let responseData;
-    try {
-      responseData = await response.json();
-    } catch {
-      throw new Error("Malformed response data: invalid JSON");
-    }
-    if (!response.ok) {
-      let errorResponse;
-      try {
-        errorResponse = deserializeErrorResponse(responseData);
-      } catch {
-        console.log("Name Tokens API: handling a known server error.");
-      }
-      if (typeof errorResponse !== "undefined") {
-        throw new Error(`Fetching ENSNode Name Tokens Failed: ${errorResponse.message}`);
-      }
-    }
-    return deserializedNameTokensResponse(responseData);
-  }
-};
-
-// src/ensindexer/api/config/deserialize.ts
-function deserializeEnsIndexerConfigResponse(maybeResponse) {
-  return deserializeEnsIndexerPublicConfig(maybeResponse, "EnsIndexerConfigResponse");
-}
-
-// src/ensindexer/api/config/serialize.ts
-function serializeEnsIndexerConfigResponse(response) {
-  return serializeEnsIndexerPublicConfig(response);
-}
-
-// src/ensindexer/api/indexing-status/deserialize.ts
-var import_v430 = require("zod/v4");
-
-// src/ensindexer/api/indexing-status/response.ts
-var EnsIndexerIndexingStatusResponseCodes = {
-  /**
-   * Represents that the indexing status is available.
-   */
-  Ok: "ok",
-  /**
-   * Represents that the indexing status is unavailable.
-   */
-  Error: "error"
-};
-
-// src/ensindexer/api/indexing-status/zod-schemas.ts
-var import_v429 = require("zod/v4");
-var makeEnsIndexerIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v429.z.strictObject({
-  responseCode: import_v429.z.literal(EnsIndexerIndexingStatusResponseCodes.Ok),
-  realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel)
-});
-var makeEnsIndexerIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v429.z.strictObject({
-  responseCode: import_v429.z.literal(EnsIndexerIndexingStatusResponseCodes.Error)
-});
-var makeEnsIndexerIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v429.z.discriminatedUnion("responseCode", [
-  makeEnsIndexerIndexingStatusResponseOkSchema(valueLabel),
-  makeEnsIndexerIndexingStatusResponseErrorSchema(valueLabel)
-]);
-var makeSerializedEnsIndexerIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => import_v429.z.strictObject({
-  responseCode: import_v429.z.literal(EnsIndexerIndexingStatusResponseCodes.Ok),
-  realtimeProjection: makeSerializedRealtimeIndexingStatusProjectionSchema(valueLabel)
-});
-var makeSerializedEnsIndexerIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => import_v429.z.discriminatedUnion("responseCode", [
-  makeSerializedEnsIndexerIndexingStatusResponseOkSchema(valueLabel),
-  makeEnsIndexerIndexingStatusResponseErrorSchema(valueLabel)
-]);
-
-// src/ensindexer/api/indexing-status/deserialize.ts
-function buildUnvalidatedEnsIndexerIndexingStatusResponse(serializedResponse) {
-  if (serializedResponse.responseCode !== EnsIndexerIndexingStatusResponseCodes.Ok) {
-    return serializedResponse;
-  }
-  return {
-    ...serializedResponse,
-    realtimeProjection: buildUnvalidatedRealtimeIndexingStatusProjection(
-      serializedResponse.realtimeProjection
-    )
-  };
-}
-function deserializeEnsIndexerIndexingStatusResponse(maybeResponse) {
-  const parsed = makeSerializedEnsIndexerIndexingStatusResponseSchema().transform(buildUnvalidatedEnsIndexerIndexingStatusResponse).pipe(makeEnsIndexerIndexingStatusResponseSchema()).safeParse(maybeResponse);
-  if (parsed.error) {
-    throw new Error(
-      `Cannot deserialize EnsIndexerIndexingStatusResponse:
-${(0, import_v430.prettifyError)(parsed.error)}
-`
-    );
-  }
-  return parsed.data;
-}
-
-// src/ensindexer/api/indexing-status/serialize.ts
-function serializeEnsIndexerIndexingStatusResponse(response) {
-  switch (response.responseCode) {
-    case EnsIndexerIndexingStatusResponseCodes.Ok:
-      return {
-        responseCode: response.responseCode,
-        realtimeProjection: serializeRealtimeIndexingStatusProjection(response.realtimeProjection)
-      };
-    case EnsIndexerIndexingStatusResponseCodes.Error:
-      return response;
-  }
-}
-
-// src/ensindexer/api/shared/errors/deserialize.ts
-var import_v432 = require("zod/v4");
-
-// src/ensindexer/api/shared/errors/zod-schemas.ts
-var import_v431 = require("zod/v4");
-var ErrorResponseSchema2 = import_v431.z.object({
-  message: import_v431.z.string(),
-  details: import_v431.z.optional(import_v431.z.unknown())
-});
-
-// src/ensindexer/api/shared/errors/deserialize.ts
-function deserializeErrorResponse2(maybeErrorResponse) {
-  const parsed = ErrorResponseSchema2.safeParse(maybeErrorResponse);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize ErrorResponse:
-${(0, import_v432.prettifyError)(parsed.error)}
-`);
-  }
-  return parsed.data;
-}
-
-// src/ensindexer/client.ts
-var EnsIndexerClient = class {
-  constructor(options) {
-    this.options = options;
-  }
-  getOptions() {
-    return Object.freeze({
-      url: new URL(this.options.url.href)
-    });
-  }
-  /**
-   * Fetch ENSIndexer Config
-   *
-   * Fetch the ENSIndexer's configuration.
-   *
-   * @returns {EnsIndexerConfigResponse}
-   *
-   * @throws if the ENSIndexer request fails
-   * @throws if the ENSIndexer returns a non-ok response
-   * @throws if the ENSIndexer response breaks required invariants
-   */
-  async config() {
-    const url = new URL(`/api/config`, this.options.url);
+    const buildEndTimestampArg = (filters) => {
+      const endTimestampFilter = filters?.find(
+        (f) => f.filterType === RegistrarActionsFilterTypes.EndTimestamp
+      );
+      return endTimestampFilter ? { key: "endTimestamp", value: endTimestampFilter.value.toString() } : null;
+    };
+    const buildOrderArg = (order) => {
+      switch (order) {
+        case RegistrarActionsOrders.LatestRegistrarActions: {
+          const [field, direction] = order.split("=");
+          return {
+            key: `sort[${field}]`,
+            value: `${direction}`
+          };
+        }
+      }
+    };
+    const url = buildUrlPath(request.filters);
+    if (request.order) {
+      const orderArgs = buildOrderArg(request.order);
+      url.searchParams.set(orderArgs.key, orderArgs.value);
+    }
+    if (request.page) {
+      url.searchParams.set("page", request.page.toString());
+    }
+    if (request.recordsPerPage) {
+      url.searchParams.set("recordsPerPage", request.recordsPerPage.toString());
+    }
+    const referralArg = buildWithReferralArg(request.filters);
+    if (referralArg) {
+      url.searchParams.set(referralArg.key, referralArg.value);
+    }
+    const decodedReferrerArg = buildDecodedReferrerArg(request.filters);
+    if (decodedReferrerArg) {
+      url.searchParams.set(decodedReferrerArg.key, decodedReferrerArg.value);
+    }
+    const beginTimestampArg = buildBeginTimestampArg(request.filters);
+    if (beginTimestampArg) {
+      url.searchParams.set(beginTimestampArg.key, beginTimestampArg.value);
+    }
+    const endTimestampArg = buildEndTimestampArg(request.filters);
+    if (endTimestampArg) {
+      url.searchParams.set(endTimestampArg.key, endTimestampArg.value);
+    }
     const response = await fetch(url);
     let responseData;
     try {
@@ -3736,24 +3872,57 @@ var EnsIndexerClient = class {
       throw new Error("Malformed response data: invalid JSON");
     }
     if (!response.ok) {
-      const errorResponse = deserializeErrorResponse2(responseData);
-      throw new Error(`Fetching ENSIndexer Config Failed: ${errorResponse.message}`);
+      let errorResponse;
+      try {
+        errorResponse = deserializeErrorResponse2(responseData);
+      } catch {
+        console.log("Registrar Actions API: handling a known server error.");
+      }
+      if (typeof errorResponse !== "undefined") {
+        throw new Error(`Fetching ENSNode Registrar Actions Failed: ${errorResponse.message}`);
+      }
     }
-    return deserializeEnsIndexerConfigResponse(
-      responseData
-    );
+    return deserializeRegistrarActionsResponse(responseData);
   }
   /**
-   * Fetch ENSIndexer Indexing Status
+   * Fetch Name Tokens for requested name.
    *
-   * @returns {EnsIndexerIndexingStatusResponse}
+   * @param request.name - Name for which Name Tokens will be fetched.
+   * @returns {NameTokensResponse}
    *
-   * @throws if the ENSIndexer request fails
-   * @throws if the ENSIndexer returns a non-ok response
-   * @throws if the ENSIndexer response breaks required invariants
+   * @throws if the ENSNode request fails
+   * @throws if the ENSNode API returns an error response
+   * @throws if the ENSNode response breaks required invariants
+   *
+   * @example
+   * ```ts
+   * import {
+   *   EnsNodeClient,
+   * } from "@ensnode/ensnode-sdk";
+   * import { namehashInterpretedName, asInterpretedName } from "enssdk";
+   *
+   * const VITALIK_NAME = asInterpretedName("vitalik.eth");
+   * const VITALIK_DOMAIN_ID = namehashInterpretedName(VITALIK_NAME);
+   *
+   * const client: EnsNodeClient;
+   *
+   * // get latest name token records from the indexed subregistry based on the requested name
+   * const response = await client.nameTokens({
+   *   name: VITALIK_NAME,
+   * });
+   *
+   * const response = await client.nameTokens({
+   *   domainId: VITALIK_DOMAIN_ID,
+   * })
+   * ```
    */
-  async indexingStatus() {
-    const url = new URL(`/api/indexing-status`, this.options.url);
+  async nameTokens(request) {
+    const url = new URL(`/api/name-tokens`, this.options.url);
+    if (request.name !== void 0) {
+      url.searchParams.set("name", request.name);
+    } else if (request.domainId !== void 0) {
+      url.searchParams.set("domainId", request.domainId);
+    }
     const response = await fetch(url);
     let responseData;
     try {
@@ -3766,150 +3935,16 @@ var EnsIndexerClient = class {
       try {
         errorResponse = deserializeErrorResponse2(responseData);
       } catch {
+        console.log("Name Tokens API: handling a known server error.");
       }
       if (typeof errorResponse !== "undefined") {
-        throw new Error(`Fetching ENSIndexer Indexing Status Failed: ${errorResponse.message}`);
+        throw new Error(`Fetching ENSNode Name Tokens Failed: ${errorResponse.message}`);
       }
     }
-    return deserializeEnsIndexerIndexingStatusResponse(
-      responseData
-    );
+    return deserializedNameTokensResponse(responseData);
   }
 };
 
-// src/ensindexer/config/compatibility.ts
-function validateEnsIndexerPublicConfigCompatibility(configA, configB) {
-  if (configA.indexedChainIds.symmetricDifference(configB.indexedChainIds).size > 0) {
-    throw new Error(
-      [
-        `'indexedChainIds' must be compatible.`,
-        `Stored Config 'indexedChainIds': '${Array.from(configA.indexedChainIds).join(", ")}'.`,
-        `Current Config 'indexedChainIds': '${Array.from(configB.indexedChainIds).join(", ")}'.`
-      ].join(" ")
-    );
-  }
-  if (configA.isSubgraphCompatible !== configB.isSubgraphCompatible) {
-    throw new Error(
-      [
-        `'isSubgraphCompatible' flag must be compatible.`,
-        `Stored Config 'isSubgraphCompatible' flag: '${configA.isSubgraphCompatible}'.`,
-        `Current Config 'isSubgraphCompatible' flag: '${configB.isSubgraphCompatible}'.`
-      ].join(" ")
-    );
-  }
-  if (configA.namespace !== configB.namespace) {
-    throw new Error(
-      [
-        `'namespace' must be compatible.`,
-        `Stored Config 'namespace': '${configA.namespace}'.`,
-        `Current Config 'namespace': '${configB.namespace}'.`
-      ].join(" ")
-    );
-  }
-  if (configA.labelSet.labelSetId !== configB.labelSet.labelSetId) {
-    throw new Error(
-      [
-        `'labelSet.labelSetId' must be compatible.`,
-        `Stored Config 'labelSet.labelSetId': '${configA.labelSet.labelSetId}'.`,
-        `Current Config 'labelSet.labelSetId': '${configB.labelSet.labelSetId}'.`
-      ].join(" ")
-    );
-  }
-  if (configA.labelSet.labelSetVersion !== configB.labelSet.labelSetVersion) {
-    throw new Error(
-      [
-        `'labelSet.labelSetVersion' must be compatible.`,
-        `Stored Config 'labelSet.labelSetVersion': '${configA.labelSet.labelSetVersion}'.`,
-        `Current Config 'labelSet.labelSetVersion': '${configB.labelSet.labelSetVersion}'.`
-      ].join(" ")
-    );
-  }
-  const configAPluginsSet = new Set(configA.plugins);
-  const configBPluginsSet = new Set(configB.plugins);
-  if (configAPluginsSet.symmetricDifference(configBPluginsSet).size > 0) {
-    throw new Error(
-      [
-        `'plugins' must be compatible.`,
-        `Stored Config 'plugins': '${configA.plugins.join(", ")}'.`,
-        `Current Config 'plugins': '${configB.plugins.join(", ")}'.`
-      ].join(" ")
-    );
-  }
-}
-
-// src/ensindexer/config/label-utils.ts
-var import_viem8 = require("viem");
-function labelHashToBytes(labelHash) {
-  try {
-    if (labelHash.length !== 66) {
-      throw new Error(`Invalid labelHash length ${labelHash.length} characters (expected 66)`);
-    }
-    if (labelHash !== labelHash.toLowerCase()) {
-      throw new Error("Labelhash must be in lowercase");
-    }
-    if (!labelHash.startsWith("0x")) {
-      throw new Error("Labelhash must be 0x-prefixed");
-    }
-    const bytes = (0, import_viem8.hexToBytes)(labelHash);
-    if (bytes.length !== 32) {
-      throw new Error(`Invalid labelHash length ${bytes.length} bytes (expected 32)`);
-    }
-    return bytes;
-  } catch (e) {
-    if (e instanceof Error) {
-      throw e;
-    }
-    throw new Error("Invalid hex format");
-  }
-}
-
-// src/ensindexer/config/parsing.ts
-function parseNonNegativeInteger(maybeNumber) {
-  const trimmed = maybeNumber.trim();
-  if (!trimmed) {
-    throw new Error("Input cannot be empty");
-  }
-  if (trimmed === "-0") {
-    throw new Error("Negative zero is not a valid non-negative integer");
-  }
-  const num = Number(maybeNumber);
-  if (Number.isNaN(num)) {
-    throw new Error(`"${maybeNumber}" is not a valid number`);
-  }
-  if (!Number.isFinite(num)) {
-    throw new Error(`"${maybeNumber}" is not a finite number`);
-  }
-  if (!Number.isInteger(num)) {
-    throw new Error(`"${maybeNumber}" is not an integer`);
-  }
-  if (num < 0) {
-    throw new Error(`"${maybeNumber}" is not a non-negative integer`);
-  }
-  return num;
-}
-
-// src/ensindexer/config/validate/ensindexer-public-config.ts
-var import_v433 = require("zod/v4");
-function validateEnsIndexerPublicConfig(unvalidatedConfig) {
-  const schema = makeEnsIndexerPublicConfigSchema();
-  const result = schema.safeParse(unvalidatedConfig);
-  if (!result.success) {
-    throw new Error(`Invalid ENSIndexerPublicConfig: ${(0, import_v433.prettifyError)(result.error)}`);
-  }
-  return result.data;
-}
-
-// src/ensindexer/config/validate/ensindexer-version-info.ts
-var import_v434 = require("zod/v4");
-function validateEnsIndexerVersionInfo(unvalidatedVersionInfo) {
-  const schema = makeEnsIndexerVersionInfoSchema();
-  const result = schema.safeParse(unvalidatedVersionInfo);
-  if (!result.success) {
-    throw new Error(`Invalid EnsIndexerVersionInfo: ${(0, import_v434.prettifyError)(result.error)}`);
-  }
-  return result.data;
-}
-
 // src/identity/identity.ts
 var import_datasources6 = require("@ensnode/datasources");
 
@@ -3947,14 +3982,14 @@ function isResolvedIdentity(identity) {
 }
 
 // src/indexing-status/deserialize/chain-indexing-status-snapshot.ts
-var import_v435 = require("zod/v4");
+var import_v438 = require("zod/v4");
 function deserializeChainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
   const schema = makeChainIndexingStatusSnapshotSchema(valueLabel);
   const parsed = schema.safeParse(maybeSnapshot);
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize into ChainIndexingStatusSnapshot:
-${(0, import_v435.prettifyError)(parsed.error)}
+${(0, import_v438.prettifyError)(parsed.error)}
 `
     );
   }
@@ -3972,26 +4007,26 @@ function createRealtimeIndexingStatusProjection(snapshot, now) {
 }
 
 // src/indexing-status/validate/chain-indexing-status-snapshot.ts
-var import_v436 = require("zod/v4");
+var import_v439 = require("zod/v4");
 function validateChainIndexingStatusSnapshot(unvalidatedSnapshot, valueLabel) {
   const schema = makeChainIndexingStatusSnapshotSchema(valueLabel);
   const parsed = schema.safeParse(unvalidatedSnapshot);
   if (parsed.error) {
     throw new Error(`Invalid ChainIndexingStatusSnapshot:
-${(0, import_v436.prettifyError)(parsed.error)}
+${(0, import_v439.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
 }
 
 // src/indexing-status/validate/realtime-indexing-status-projection.ts
-var import_v437 = require("zod/v4");
+var import_v440 = require("zod/v4");
 function validateRealtimeIndexingStatusProjection(unvalidatedProjection, valueLabel) {
   const schema = makeRealtimeIndexingStatusProjectionSchema(valueLabel);
   const parsed = schema.safeParse(unvalidatedProjection);
   if (parsed.error) {
     throw new Error(`Invalid RealtimeIndexingStatusProjection:
-${(0, import_v437.prettifyError)(parsed.error)}
+${(0, import_v440.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4174,13 +4209,13 @@ var import_getUnixTime2 = require("date-fns/getUnixTime");
 var import_getUnixTime = require("date-fns/getUnixTime");
 
 // src/shared/deserialize.ts
-var import_v438 = __toESM(require("zod/v4"), 1);
+var import_v441 = __toESM(require("zod/v4"), 1);
 function deserializeChainId(maybeChainId, valueLabel) {
   const schema = makeChainIdStringSchema(valueLabel);
   const parsed = schema.safeParse(maybeChainId);
   if (parsed.error) {
     throw new Error(`Cannot deserialize ChainId:
-${(0, import_v438.prettifyError)(parsed.error)}
+${(0, import_v441.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4190,7 +4225,7 @@ function deserializeDatetime(maybeDatetime, valueLabel) {
   const parsed = schema.safeParse(maybeDatetime);
   if (parsed.error) {
     throw new Error(`Cannot deserialize Datetime:
-${(0, import_v438.prettifyError)(parsed.error)}
+${(0, import_v441.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4200,7 +4235,7 @@ function deserializeUnixTimestamp(maybeTimestamp, valueLabel) {
   const parsed = schema.safeParse(maybeTimestamp);
   if (parsed.error) {
     throw new Error(`Cannot deserialize Unix Timestamp:
-${(0, import_v438.prettifyError)(parsed.error)}
+${(0, import_v441.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4210,7 +4245,7 @@ function deserializeUrl(maybeUrl, valueLabel) {
   const parsed = schema.safeParse(maybeUrl);
   if (parsed.error) {
     throw new Error(`Cannot deserialize URL:
-${(0, import_v438.prettifyError)(parsed.error)}
+${(0, import_v441.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4220,7 +4255,7 @@ function deserializeBlockNumber(maybeBlockNumber, valueLabel) {
   const parsed = schema.safeParse(maybeBlockNumber);
   if (parsed.error) {
     throw new Error(`Cannot deserialize BlockNumber:
-${(0, import_v438.prettifyError)(parsed.error)}
+${(0, import_v441.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4230,17 +4265,17 @@ function deserializeBlockRef(maybeBlockRef, valueLabel) {
   const parsed = schema.safeParse(maybeBlockRef);
   if (parsed.error) {
     throw new Error(`Cannot deserialize BlockRef:
-${(0, import_v438.prettifyError)(parsed.error)}
+${(0, import_v441.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
 }
 function deserializeDuration(maybeDuration, valueLabel) {
-  const schema = import_v438.default.coerce.number().pipe(makeDurationSchema(valueLabel));
+  const schema = import_v441.default.coerce.number().pipe(makeDurationSchema(valueLabel));
   const parsed = schema.safeParse(maybeDuration);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize Duration:
-${(0, import_v438.prettifyError)(parsed.error)}
+${(0, import_v441.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4250,7 +4285,7 @@ function parseAccountId(maybeAccountId, valueLabel) {
   const parsed = schema.safeParse(maybeAccountId);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize AccountId:
-${(0, import_v438.prettifyError)(parsed.error)}
+${(0, import_v441.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4260,7 +4295,7 @@ function deserializePriceEth(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceEth:
-${(0, import_v438.prettifyError)(parsed.error)}
+${(0, import_v441.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4270,7 +4305,7 @@ function deserializePriceUsdc(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceUsdc:
-${(0, import_v438.prettifyError)(parsed.error)}
+${(0, import_v441.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4280,7 +4315,7 @@ function deserializePriceDai(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceDai:
-${(0, import_v438.prettifyError)(parsed.error)}
+${(0, import_v441.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4525,6 +4560,16 @@ function isWebSocketProtocol(url) {
   return ["ws:", "wss:"].includes(url.protocol);
 }
 
+// src/stack-info/ensnode-stack-info.ts
+function buildEnsNodeStackInfo(ensApiPublicConfig, ensDbPublicConfig) {
+  return {
+    ensApi: ensApiPublicConfig,
+    ensDb: ensDbPublicConfig,
+    ensIndexer: ensApiPublicConfig.ensIndexerPublicConfig,
+    ensRainbow: ensApiPublicConfig.ensIndexerPublicConfig.ensRainbowPublicConfig
+  };
+}
+
 // src/subgraph-api/prerequisites.ts
 function hasSubgraphApiConfigSupport(config) {
   const supported = config.plugins.includes("subgraph" /* Subgraph */);