@ensnode/ensnode-sdk 1.2.0 → 1.3.1

package/dist/index.js

@@ -7,25 +7,6 @@ import { z as z3 } from "zod/v4";
 // src/ensindexer/config/zod-schemas.ts
 import z2 from "zod/v4";
 
-// src/ens/is-normalized.ts
-import { normalize } from "viem/ens";
-function isNormalizedName(name) {
-  try {
-    return name === normalize(name);
-  } catch {
-    return false;
-  }
-}
-function isNormalizedLabel(label) {
-  if (label === "") return false;
-  if (label.includes(".")) return false;
-  try {
-    return label === normalize(label);
-  } catch {
-    return false;
-  }
-}
-
 // src/shared/account-id.ts
 import { isAddressEqual } from "viem";
 var accountIdEqual = (a, b) => {
@@ -179,9 +160,39 @@ function isEncodedLabelHash(maybeEncodedLabelHash) {
   return expectedFormatting && includesLabelHash;
 }
 
+// src/ens/is-normalized.ts
+import { normalize } from "viem/ens";
+function isNormalizedName(name) {
+  try {
+    return name === normalize(name);
+  } catch {
+    return false;
+  }
+}
+function isNormalizedLabel(label) {
+  if (label === "") return false;
+  if (label.includes(".")) return false;
+  try {
+    return label === normalize(label);
+  } catch {
+    return false;
+  }
+}
+
 // src/ens/names.ts
 import { ens_beautify } from "@adraffy/ens-normalize";
+var ENS_ROOT = "";
 var getNameHierarchy = (name) => name.split(".").map((_, i, labels) => labels.slice(i).join("."));
+var getParentNameFQDN = (name) => {
+  if (name === ENS_ROOT) {
+    throw new Error("There is no parent name for ENS Root.");
+  }
+  const labels = name.split(".");
+  if (labels.length === 1) {
+    return ENS_ROOT;
+  }
+  return labels.slice(1).join(".");
+};
 var beautifyName = (name) => {
   const beautifiedLabels = name.split(".").map((label) => {
     if (isNormalizedLabel(label)) {
@@ -424,7 +435,7 @@ var makeAccountIdSchema = (valueLabel = "AccountId") => z.strictObject({
   chainId: makeChainIdSchema(`${valueLabel} chain ID`),
   address: makeLowercaseAddressSchema(`${valueLabel} address`)
 });
-var makeSerializedAccountIdSchema = (valueLabel = "Account ID") => z.coerce.string().transform((v) => {
+var makeAccountIdStringSchema = (valueLabel = "Account ID String") => z.coerce.string().transform((v) => {
   const result = new CaipAccountId(v);
   return {
     chainId: Number(result.chainId.reference),
@@ -436,7 +447,7 @@ var makeHexStringSchema = (options, valueLabel = "String representation of bytes
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
-      message: `${valueLabel} must start with '0x'.`
+      message: `${valueLabel} must be a hexadecimal value which starts with '0x'.`
     });
   }
 }).transform((v) => v).check(function invariant_encodesRequiredBytesCount(ctx) {
@@ -546,8 +557,8 @@ ${prettifyError(parsed.error)}
   }
   return parsed.data;
 }
-function deserializeAccountId(maybeAccountId, valueLabel) {
-  const schema = makeSerializedAccountIdSchema(valueLabel);
+function parseAccountId(maybeAccountId, valueLabel) {
+  const schema = makeAccountIdStringSchema(valueLabel);
   const parsed = schema.safeParse(maybeAccountId);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize AccountId:
@@ -565,181 +576,65 @@ function addDuration(timestamp, duration) {
   return deserializeUnixTimestamp(timestamp + duration, "UnixTimestamp");
 }
 
-// src/shared/cache/background-revalidation-scheduler.ts
-var BackgroundRevalidationScheduler = class {
-  activeSchedules = /* @__PURE__ */ new Map();
-  /**
-   * Schedule a revalidation function to run on a recurring interval.
-   *
-   * @param config Configuration object for the schedule
-   * @returns The revalidate function that can be passed to `cancel()` to stop the schedule
-   */
-  schedule(config) {
-    const { revalidate, interval, initialDelay = 0, onError } = config;
-    if (this.activeSchedules.has(revalidate)) {
-      return revalidate;
+// src/shared/cache/swr-cache.ts
+var SWRCache = class {
+  constructor(options) {
+    this.options = options;
+    if (options.proactiveRevalidationInterval) {
+      this.backgroundInterval = setInterval(
+        () => this.revalidate(),
+        secondsToMilliseconds(options.proactiveRevalidationInterval)
+      );
     }
-    const metadata = {
-      config,
-      timeoutId: null,
-      inProgress: false
-    };
-    this.activeSchedules.set(revalidate, metadata);
-    const executeRevalidation = async () => {
-      if (metadata.inProgress) return;
-      metadata.inProgress = true;
-      try {
-        await revalidate();
-      } catch (error) {
-        onError?.(error);
-      } finally {
-        metadata.inProgress = false;
-      }
-    };
-    const scheduleNext = () => {
-      if (!this.activeSchedules.has(revalidate)) return;
-      metadata.timeoutId = setTimeout(() => {
-        if (this.activeSchedules.has(revalidate)) {
-          executeRevalidation().then(() => scheduleNext());
-        }
-      }, interval);
-    };
-    if (initialDelay > 0) {
-      metadata.timeoutId = setTimeout(() => {
-        if (this.activeSchedules.has(revalidate)) {
-          executeRevalidation().then(() => scheduleNext());
+    if (options.proactivelyInitialize) this.revalidate();
+  }
+  cache = null;
+  inProgressRevalidate = null;
+  backgroundInterval = null;
+  async revalidate() {
+    if (!this.inProgressRevalidate) {
+      this.inProgressRevalidate = this.options.fn().then((result) => {
+        this.cache = {
+          result,
+          updatedAt: getUnixTime(/* @__PURE__ */ new Date())
+        };
+      }).catch((error) => {
+        if (!this.cache) {
+          this.cache = {
+            // ensure thrown value is always an Error instance
+            result: error instanceof Error ? error : new Error(String(error)),
+            updatedAt: getUnixTime(/* @__PURE__ */ new Date())
+          };
         }
-      }, initialDelay);
-    } else {
-      scheduleNext();
+      }).finally(() => {
+        this.inProgressRevalidate = null;
+      });
     }
-    return revalidate;
+    return this.inProgressRevalidate;
   }
   /**
-   * Cancel a scheduled revalidation by its revalidate function.
+   * Read the most recently cached result from the `SWRCache`.
    *
-   * @param revalidate The revalidation function returned from `schedule()`
-   */
-  cancel(revalidate) {
-    const metadata = this.activeSchedules.get(revalidate);
-    if (!metadata) return;
-    if (metadata.timeoutId !== null) {
-      clearTimeout(metadata.timeoutId);
-    }
-    this.activeSchedules.delete(revalidate);
-  }
-  /**
-   * Cancel all active schedules.
+   * @returns a `ValueType` that was most recently successfully returned by `fn` or `Error` if `fn`
+   * has never successfully returned.
    */
-  cancelAll() {
-    for (const [, metadata] of this.activeSchedules) {
-      if (metadata.timeoutId !== null) {
-        clearTimeout(metadata.timeoutId);
-      }
+  async read() {
+    if (!this.cache) await this.revalidate();
+    if (!this.cache) throw new Error("never");
+    if (durationBetween(this.cache.updatedAt, getUnixTime(/* @__PURE__ */ new Date())) > this.options.ttl) {
+      this.revalidate();
     }
-    this.activeSchedules.clear();
+    return this.cache.result;
   }
   /**
-   * Get the count of active schedules.
-   * Useful for debugging and monitoring.
-   *
-   * @returns The number of currently active schedules
-   */
-  getActiveScheduleCount() {
-    return this.activeSchedules.size;
-  }
-};
-
-// src/shared/cache/swr-cache.ts
-var bgRevalidationScheduler = new BackgroundRevalidationScheduler();
-var SWRCache = class _SWRCache {
-  options;
-  cache;
-  /**
-   * Optional promise of the current in-progress attempt to revalidate the `cache`.
-   *
-   * If null, no revalidation attempt is currently in progress.
-   * If not null, identifies the revalidation attempt that is currently in progress.
-   *
-   * Used to enforce no concurrent revalidation attempts.
-   */
-  inProgressRevalidate;
-  /**
-   * The callback function being managed by `BackgroundRevalidationScheduler`.
-   *
-   * If null, no background revalidation is scheduled.
-   * If not null, identifies the background revalidation that is currently scheduled.
-   *
-   * Used to enforce no concurrent background revalidation attempts.
-   */
-  scheduledBackgroundRevalidate;
-  constructor(options) {
-    this.cache = null;
-    this.inProgressRevalidate = null;
-    this.scheduledBackgroundRevalidate = null;
-    this.options = options;
-  }
-  /**
-   * Asynchronously create a new `SWRCache` instance.
-   *
-   * @param options - The {@link SWRCacheOptions} for the SWR cache.
-   * @returns a new `SWRCache` instance.
+   * Destroys the background revalidation interval, if exists.
    */
-  static async create(options) {
-    const cache = new _SWRCache(options);
-    if (cache.options.proactivelyInitialize) {
-      cache.readCache();
+  destroy() {
+    if (this.backgroundInterval) {
+      clearInterval(this.backgroundInterval);
+      this.backgroundInterval = null;
     }
-    return cache;
   }
-  revalidate = async () => {
-    if (this.inProgressRevalidate) {
-      return this.inProgressRevalidate;
-    }
-    return this.options.fn().then((value) => {
-      this.cache = {
-        value,
-        updatedAt: getUnixTime(/* @__PURE__ */ new Date())
-      };
-      return this.cache;
-    }).catch(() => {
-      return null;
-    }).finally(() => {
-      this.inProgressRevalidate = null;
-      if (this.options.revalidationInterval === void 0) {
-        return;
-      }
-      if (this.scheduledBackgroundRevalidate) {
-        bgRevalidationScheduler.cancel(this.scheduledBackgroundRevalidate);
-      }
-      const backgroundRevalidate = async () => {
-        this.revalidate();
-      };
-      this.scheduledBackgroundRevalidate = bgRevalidationScheduler.schedule({
-        revalidate: backgroundRevalidate,
-        interval: secondsToMilliseconds(this.options.revalidationInterval)
-      });
-    });
-  };
-  /**
-   * Read the most recently cached `CachedValue` from the `SWRCache`.
-   *
-   * @returns a `CachedValue` holding a `value` of `ValueType` that was most recently successfully returned by `fn`
-   *          or `null` if `fn` has never successfully returned and has always thrown an error,
-   */
-  readCache = async () => {
-    if (!this.cache) {
-      this.inProgressRevalidate = this.revalidate();
-      return this.inProgressRevalidate;
-    }
-    if (durationBetween(this.cache.updatedAt, getUnixTime(/* @__PURE__ */ new Date())) <= this.options.ttl) {
-      return this.cache;
-    }
-    if (!this.inProgressRevalidate) {
-      this.inProgressRevalidate = this.revalidate();
-    }
-    return this.cache;
-  };
 };
 
 // src/shared/cache/ttl-cache.ts
@@ -810,6 +705,28 @@ var TtlCache = class {
 // src/shared/collections.ts
 var uniq = (arr) => [...new Set(arr)];
 
+// src/shared/datasource-contract.ts
+import { maybeGetDatasource } from "@ensnode/datasources";
+var maybeGetDatasourceContract = (namespaceId, datasourceName, contractName) => {
+  const datasource = maybeGetDatasource(namespaceId, datasourceName);
+  if (!datasource) return void 0;
+  const address = datasource.contracts[contractName]?.address;
+  if (address === void 0 || Array.isArray(address)) return void 0;
+  return {
+    chainId: datasource.chain.id,
+    address
+  };
+};
+var getDatasourceContract = (namespaceId, datasourceName, contractName) => {
+  const contract = maybeGetDatasourceContract(namespaceId, datasourceName, contractName);
+  if (!contract) {
+    throw new Error(
+      `Expected contract not found for ${namespaceId} ${datasourceName} ${contractName}`
+    );
+  }
+  return contract;
+};
+
 // src/shared/labelhash.ts
 import { keccak256 as keccak2562, stringToBytes } from "viem";
 var labelhashLiteralLabel = (label) => keccak2562(stringToBytes(label));
@@ -868,7 +785,7 @@ function serializePrice(price) {
 function serializePriceEth(price) {
   return serializePrice(price);
 }
-function serializeAccountId(accountId) {
+function formatAccountId(accountId) {
   return CaipAccountId2.format({
     chainId: { namespace: "eip155", reference: accountId.chainId.toString() },
     address: accountId.address
@@ -1844,152 +1761,748 @@ function serializeConfigResponse(response) {
 import { prettifyError as prettifyError5 } from "zod/v4";
 
 // src/api/indexing-status/zod-schemas.ts
-import z11 from "zod/v4";
-
-// src/api/registrar-actions/zod-schemas.ts
-import { namehash as namehash2 } from "viem/ens";
-import z6 from "zod/v4";
-
-// src/api/shared/errors/zod-schemas.ts
 import z5 from "zod/v4";
-var ErrorResponseSchema = z5.object({
-  message: z5.string(),
-  details: z5.optional(z5.unknown())
-});
 
-// src/api/registrar-actions/response.ts
-var RegistrarActionsResponseCodes = {
+// src/api/indexing-status/response.ts
+var IndexingStatusResponseCodes = {
   /**
-   * Represents that Registrar Actions are available.
+   * Represents that the indexing status is available.
    */
   Ok: "ok",
   /**
-   * Represents that Registrar Actions are unavailable.
+   * Represents that the indexing status is unavailable.
    */
   Error: "error"
 };
 
-// src/api/registrar-actions/zod-schemas.ts
-function invariant_registrationLifecycleNodeMatchesName(ctx) {
-  const { name, action } = ctx.value;
-  const expectedNode = action.registrationLifecycle.node;
-  const actualNode = namehash2(name);
-  if (actualNode !== expectedNode) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: `The 'action.registrationLifecycle.node' must match namehash of 'name'`
-    });
-  }
-}
-var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => z6.object({
-  action: makeRegistrarActionSchema(valueLabel),
-  name: makeReinterpretedNameSchema(valueLabel)
-}).check(invariant_registrationLifecycleNodeMatchesName);
-var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => z6.strictObject({
-  responseCode: z6.literal(RegistrarActionsResponseCodes.Ok),
-  registrarActions: z6.array(makeNamedRegistrarActionSchema(valueLabel))
+// src/api/indexing-status/zod-schemas.ts
+var makeIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => z5.strictObject({
+  responseCode: z5.literal(IndexingStatusResponseCodes.Ok),
+  realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel)
 });
-var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => z6.strictObject({
-  responseCode: z6.literal(RegistrarActionsResponseCodes.Error),
-  error: ErrorResponseSchema
+var makeIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => z5.strictObject({
+  responseCode: z5.literal(IndexingStatusResponseCodes.Error)
 });
-var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => z6.discriminatedUnion("responseCode", [
-  makeRegistrarActionsResponseOkSchema(valueLabel),
-  makeRegistrarActionsResponseErrorSchema(valueLabel)
+var makeIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => z5.discriminatedUnion("responseCode", [
+  makeIndexingStatusResponseOkSchema(valueLabel),
+  makeIndexingStatusResponseErrorSchema(valueLabel)
 ]);
 
-// src/api/shared/pagination/zod-schemas.ts
-import z7 from "zod/v4";
-
-// src/api/shared/pagination/request.ts
-var RECORDS_PER_PAGE_DEFAULT = 10;
-var RECORDS_PER_PAGE_MAX = 100;
-
-// ../ens-referrals/src/address.ts
-import { isAddress as isAddress3 } from "viem";
-
-// ../ens-referrals/src/encoding.ts
-import { getAddress, pad, size as size2, slice, zeroAddress } from "viem";
-var ENCODED_REFERRER_BYTE_OFFSET = 12;
-var ENCODED_REFERRER_BYTE_LENGTH = 32;
-var EXPECTED_ENCODED_REFERRER_PADDING = pad("0x", {
-  size: ENCODED_REFERRER_BYTE_OFFSET,
-  dir: "left"
-});
-var ZERO_ENCODED_REFERRER = pad("0x", {
-  size: ENCODED_REFERRER_BYTE_LENGTH,
-  dir: "left"
-});
-function decodeEncodedReferrer(encodedReferrer) {
-  if (size2(encodedReferrer) !== ENCODED_REFERRER_BYTE_LENGTH) {
-    throw new Error(
-      `Encoded referrer value must be represented by ${ENCODED_REFERRER_BYTE_LENGTH} bytes.`
-    );
-  }
-  const padding = slice(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
-  if (padding !== EXPECTED_ENCODED_REFERRER_PADDING) {
-    return zeroAddress;
+// src/api/indexing-status/deserialize.ts
+function deserializeIndexingStatusResponse(maybeResponse) {
+  const parsed = makeIndexingStatusResponseSchema().safeParse(maybeResponse);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize IndexingStatusResponse:
+${prettifyError5(parsed.error)}
+`);
   }
-  const decodedReferrer = slice(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
-  try {
-    return getAddress(decodedReferrer);
-  } catch {
-    throw new Error(`Decoded referrer value must be a valid EVM address.`);
+  return parsed.data;
+}
+
+// src/api/indexing-status/serialize.ts
+function serializeIndexingStatusResponse(response) {
+  switch (response.responseCode) {
+    case IndexingStatusResponseCodes.Ok:
+      return {
+        responseCode: response.responseCode,
+        realtimeProjection: serializeRealtimeIndexingStatusProjection(response.realtimeProjection)
+      };
+    case IndexingStatusResponseCodes.Error:
+      return response;
   }
 }
 
-// ../ens-referrals/src/leaderboard-page.ts
-var REFERRERS_PER_LEADERBOARD_PAGE_MAX = 100;
+// src/api/name-tokens/deserialize.ts
+import { prettifyError as prettifyError7 } from "zod/v4";
 
-// ../ens-referrals/src/link.ts
-import { getAddress as getAddress2 } from "viem";
+// src/api/name-tokens/zod-schemas.ts
+import { namehash as namehash2 } from "viem";
+import z8 from "zod/v4";
 
-// ../ens-referrals/src/referrer-detail.ts
-var ReferrerDetailTypeIds = {
+// src/tokenscope/assets.ts
+import { AssetId as CaipAssetId2 } from "caip";
+import { isAddressEqual as isAddressEqual3, zeroAddress as zeroAddress3 } from "viem";
+import { prettifyError as prettifyError6 } from "zod/v4";
+
+// src/tokenscope/zod-schemas.ts
+import { AssetId as CaipAssetId } from "caip";
+import { zeroAddress as zeroAddress2 } from "viem";
+import z6 from "zod/v4";
+
+// src/tokenscope/name-token.ts
+import { isAddressEqual as isAddressEqual2, zeroAddress } from "viem";
+import { DatasourceNames } from "@ensnode/datasources";
+var NameTokenOwnershipTypes = {
   /**
-   * Represents a referrer who is ranked on the leaderboard.
+   * Name Token is owned by NameWrapper account.
    */
-  Ranked: "ranked",
+  NameWrapper: "namewrapper",
   /**
-   * Represents a referrer who is not ranked on the leaderboard.
+   * Name Token is owned fully onchain.
+   *
+   * This ownership type can only apply to direct subnames of `.eth`
    */
-  Unranked: "unranked"
+  FullyOnchain: "fully-onchain",
+  /**
+   * Name Token ownership has been transferred to the null address.
+   */
+  Burned: "burned",
+  /**
+   * Name Token ownership is unknown.
+   */
+  Unknown: "unknown"
 };
-
-// src/registrars/zod-schemas.ts
-import z8 from "zod/v4";
-
-// src/registrars/subregistry.ts
-function serializeSubregistry(subregistry) {
+function serializeNameToken(nameToken) {
   return {
-    subregistryId: serializeAccountId(subregistry.subregistryId),
-    node: subregistry.node
+    token: serializeAssetId(nameToken.token),
+    ownership: nameToken.ownership,
+    mintStatus: nameToken.mintStatus
   };
 }
-
-// src/registrars/registration-lifecycle.ts
-function serializeRegistrationLifecycle(registrationLifecycle) {
+function getNameWrapperAccounts(namespaceId) {
+  const ethnamesNameWrapperAccount = getDatasourceContract(
+    namespaceId,
+    DatasourceNames.ENSRoot,
+    "NameWrapper"
+  );
+  const lineanamesNameWrapperAccount = maybeGetDatasourceContract(
+    namespaceId,
+    DatasourceNames.Lineanames,
+    "NameWrapper"
+  );
+  const nameWrapperAccounts = [
+    // NameWrapper for direct subnames of .eth is defined for all ENS namespaces
+    ethnamesNameWrapperAccount
+  ];
+  if (lineanamesNameWrapperAccount) {
+    nameWrapperAccounts.push(lineanamesNameWrapperAccount);
+  }
+  return nameWrapperAccounts;
+}
+function getNameTokenOwnership(namespaceId, name, owner) {
+  const nameWrapperAccounts = getNameWrapperAccounts(namespaceId);
+  const hasNameWrapperOwnership = nameWrapperAccounts.some(
+    (nameWrapperAccount) => accountIdEqual(owner, nameWrapperAccount)
+  );
+  if (hasNameWrapperOwnership) {
+    return {
+      ownershipType: NameTokenOwnershipTypes.NameWrapper,
+      owner
+    };
+  }
+  if (isAddressEqual2(owner.address, zeroAddress)) {
+    return {
+      ownershipType: NameTokenOwnershipTypes.Burned,
+      owner
+    };
+  }
+  const parentName = getParentNameFQDN(name);
+  if (parentName === "eth") {
+    return {
+      ownershipType: NameTokenOwnershipTypes.FullyOnchain,
+      owner
+    };
+  }
   return {
-    subregistry: serializeSubregistry(registrationLifecycle.subregistry),
-    node: registrationLifecycle.node,
-    expiresAt: registrationLifecycle.expiresAt
+    ownershipType: NameTokenOwnershipTypes.Unknown,
+    owner
   };
 }
 
-// src/registrars/registrar-action.ts
-var RegistrarActionTypes = {
-  Registration: "registration",
-  Renewal: "renewal"
-};
-function isRegistrarActionPricingAvailable(registrarActionPricing) {
-  const { baseCost, premium, total } = registrarActionPricing;
-  return baseCost !== null && premium !== null && total !== null;
-}
-function isRegistrarActionReferralAvailable(registrarActionReferral) {
-  const { encodedReferrer, decodedReferrer } = registrarActionReferral;
-  return encodedReferrer !== null && decodedReferrer !== null;
-}
+// src/tokenscope/zod-schemas.ts
+var makeAssetIdSchema = (valueLabel = "Asset ID Schema") => z6.object({
+  assetNamespace: z6.enum(AssetNamespaces),
+  contract: makeAccountIdSchema(valueLabel),
+  tokenId: z6.preprocess((v) => typeof v === "string" ? BigInt(v) : v, z6.bigint().positive())
+});
+var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => z6.preprocess((v) => {
+  if (typeof v === "string") {
+    const result = new CaipAssetId(v);
+    return {
+      assetNamespace: result.assetName.namespace,
+      contract: {
+        chainId: Number(result.chainId.reference),
+        address: result.assetName.reference
+      },
+      tokenId: result.tokenId
+    };
+  }
+  return v;
+}, makeAssetIdSchema(valueLabel));
+function invariant_nameTokenOwnershipHasNonZeroAddressOwner(ctx) {
+  const ownership = ctx.value;
+  if (ctx.value.owner.address === zeroAddress2) {
+    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") => z6.object({
+  ownershipType: z6.literal(NameTokenOwnershipTypes.NameWrapper),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
+var makeNameTokenOwnershipFullyOnchainSchema = (valueLabel = "Name Token Ownership Fully Onchain") => z6.object({
+  ownershipType: z6.literal(NameTokenOwnershipTypes.FullyOnchain),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
+var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => z6.object({
+  ownershipType: z6.literal(NameTokenOwnershipTypes.Burned),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasZeroAddressOwner);
+var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => z6.object({
+  ownershipType: z6.literal(NameTokenOwnershipTypes.Unknown),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
+function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
+  const ownership = ctx.value;
+  if (ctx.value.owner.address !== zeroAddress2) {
+    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") => z6.discriminatedUnion("ownershipType", [
+  makeNameTokenOwnershipNameWrapperSchema(valueLabel),
+  makeNameTokenOwnershipFullyOnchainSchema(valueLabel),
+  makeNameTokenOwnershipBurnedSchema(valueLabel),
+  makeNameTokenOwnershipUnknownSchema(valueLabel)
+]);
+var makeNameTokenSchema = (valueLabel = "Name Token Schema") => z6.object({
+  token: makeAssetIdSchema(`${valueLabel}.token`),
+  ownership: makeNameTokenOwnershipSchema(`${valueLabel}.ownership`),
+  mintStatus: z6.enum(NFTMintStatuses)
+});
+
+// src/tokenscope/assets.ts
+var AssetNamespaces = {
+  ERC721: "erc721",
+  ERC1155: "erc1155"
+};
+function serializeAssetId(assetId) {
+  return {
+    assetNamespace: assetId.assetNamespace,
+    contract: assetId.contract,
+    tokenId: uint256ToHex32(assetId.tokenId)
+  };
+}
+function deserializeAssetId(maybeAssetId, valueLabel) {
+  const schema = makeAssetIdSchema(valueLabel);
+  const parsed = schema.safeParse(maybeAssetId);
+  if (parsed.error) {
+    throw new RangeError(`Cannot deserialize AssetId:
+${prettifyError6(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+function formatAssetId(assetId) {
+  const { assetNamespace, contract, tokenId } = serializeAssetId(assetId);
+  return CaipAssetId2.format({
+    chainId: { namespace: "eip155", reference: contract.chainId.toString() },
+    assetName: { namespace: assetNamespace, reference: contract.address },
+    tokenId
+  }).toLowerCase();
+}
+function parseAssetId(maybeAssetId, valueLabel) {
+  const schema = makeAssetIdStringSchema(valueLabel);
+  const parsed = schema.safeParse(maybeAssetId);
+  if (parsed.error) {
+    throw new RangeError(`Cannot parse AssetId:
+${prettifyError6(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 serializedAssetId = serializeAssetId(metadata.nft);
+  return [
+    `Event: ${metadata.eventHandlerName}`,
+    `Chain ID: ${metadata.chainId}`,
+    `Block Number: ${metadata.blockNumber}`,
+    `Transaction Hash: ${metadata.transactionHash}`,
+    `NFT: ${serializedAssetId}`
+  ].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",
+  /**
+   * Transfer from a non-zeroAddress to zeroAddress
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous NFT mint status was `minted`
+   * - previous NFT owner is a non-zeroAddress
+   * - new NFT mint status is `burned`
+   * - new NFT owner is the zeroAddress
+   */
+  Burn: "burn",
+  /**
+   * Transfer from a non-zeroAddress to a distinct non-zeroAddress
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous and new NFT mint status is `minted`
+   * - previous and new NFT owner are distinct non-zeroAddress
+   */
+  Transfer: "transfer",
+  /**
+   * Transfer from a non-zeroAddress to the same non-zeroAddress
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous and new NFT mint status is `minted`
+   * - previous and new NFT owner are equivalent non-zeroAddress
+   */
+  SelfTransfer: "self-transfer",
+  /**
+   * Transfer from zeroAddress to zeroAddress for an indexed NFT
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous and new NFT mint status is `burned`
+   * - previous and new NFT owner are zeroAddress
+   */
+  RemintBurn: "remint-burn",
+  /**
+   * Special transfer type for improperly implemented NFT contracts that allow a NFT
+   * that is currently minted to be reminted again before an intermediate burn.
+   *
+   * Transfer from zeroAddress to 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 `burned`
+   * - new NFT owner is the zeroAddress
+   */
+  MintedRemintBurn: "minted-remint-burn",
+  /**
+   * Transfer from zeroAddress to zeroAddress for an unindexed NFT
+   *
+   * Invariants:
+   * - NFT is not indexed and therefore has no previous mint status or owner
+   * - NFT should remain unindexed and without any mint status or owner
+   */
+  MintBurn: "mint-burn"
+};
+var getNFTTransferType = (from, to, allowMintedRemint, metadata, currentlyIndexedOwner) => {
+  const isIndexed = currentlyIndexedOwner !== void 0;
+  const isIndexedAsMinted = isIndexed && !isAddressEqual3(currentlyIndexedOwner, zeroAddress3);
+  const isMint = isAddressEqual3(from, zeroAddress3);
+  const isBurn = isAddressEqual3(to, zeroAddress3);
+  const isSelfTransfer = isAddressEqual3(from, to);
+  if (isIndexed && !isAddressEqual3(currentlyIndexedOwner, from)) {
+    if (isMint && allowMintedRemint) {
+    } else {
+      throw new Error(
+        `Error: Sending from ${from} conflicts with currently indexed owner ${currentlyIndexedOwner}.
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    }
+  }
+  if (isSelfTransfer) {
+    if (isMint) {
+      if (!isIndexed) {
+        return NFTTransferTypes.MintBurn;
+      } else if (!isIndexedAsMinted) {
+        return NFTTransferTypes.RemintBurn;
+      } else if (allowMintedRemint) {
+        return NFTTransferTypes.MintedRemintBurn;
+      } else {
+        throw new Error(
+          `Error: Invalid state transition from minted -> remint-burn
+${formatNFTTransferEventMetadata(metadata)}`
+        );
+      }
+    } else {
+      if (!isIndexed) {
+        throw new Error(
+          `Error: Invalid state transition from unindexed -> self-transfer
+${formatNFTTransferEventMetadata(metadata)}`
+        );
+      } else if (!isIndexedAsMinted) {
+        throw new Error(
+          `Error: invalid state transition from burned -> self-transfer
+${formatNFTTransferEventMetadata(metadata)}`
+        );
+      } else {
+        return NFTTransferTypes.SelfTransfer;
+      }
+    }
+  } else if (isMint) {
+    if (!isIndexed) {
+      return NFTTransferTypes.Mint;
+    } else if (!isIndexedAsMinted) {
+      return NFTTransferTypes.Remint;
+    } else if (allowMintedRemint) {
+      return NFTTransferTypes.MintedRemint;
+    } else {
+      throw new Error(
+        `Error: Invalid state transition from minted -> mint
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    }
+  } else if (isBurn) {
+    if (!isIndexed) {
+      throw new Error(
+        `Error: Invalid state transition from unindexed -> burn
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    } else if (!isIndexedAsMinted) {
+      throw new Error(
+        `Error: Invalid state transition from burned -> burn
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    } else {
+      return NFTTransferTypes.Burn;
+    }
+  } else {
+    if (!isIndexed) {
+      throw new Error(
+        `Error: Invalid state transition from unindexed -> transfer
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    } else if (!isIndexedAsMinted) {
+      throw new Error(
+        `Error: Invalid state transition from burned -> transfer
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    } else {
+      return NFTTransferTypes.Transfer;
+    }
+  }
+};
+
+// src/api/shared/errors/zod-schemas.ts
+import z7 from "zod/v4";
+var ErrorResponseSchema = z7.object({
+  message: z7.string(),
+  details: z7.optional(z7.unknown())
+});
+
+// src/api/name-tokens/response.ts
+var NameTokensResponseCodes = {
+  /**
+   * Represents a response when Name Tokens API can respond with requested data.
+   */
+  Ok: "ok",
+  /**
+   * Represents a response when Name Tokens API could not respond with requested data.
+   */
+  Error: "error"
+};
+var NameTokensResponseErrorCodes = {
+  /**
+   * Name tokens not indexed
+   *
+   * Represents an error when tokens for the requested name are not indexed by
+   * the ENSNode instance's configuration.
+   */
+  NameTokensNotIndexed: "name-tokens-not-indexed",
+  /**
+   * Unsupported ENSIndexer Config
+   *
+   * Represents a prerequisites error when connected ENSIndexer config lacks
+   * params required to enable Name Tokens API.
+   */
+  EnsIndexerConfigUnsupported: "unsupported-ensindexer-config",
+  /**
+   * Unsupported Indexing Status
+   *
+   * Represents a prerequisites error when Indexing Status has not yet reached
+   * status required to enable Name Tokens API.
+   */
+  IndexingStatusUnsupported: "unsupported-indexing-status"
+};
+
+// src/api/name-tokens/zod-schemas.ts
+function invariant_nameIsAssociatedWithDomainId(ctx) {
+  const { name, domainId } = ctx.value;
+  if (namehash2(name) !== domainId) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `'name' must be associated with 'domainId': ${domainId}`
+    });
+  }
+}
+function invariant_nameTokensOwnershipTypeNameWrapperRequiresOwnershipTypeFullyOnchainOrUnknown(ctx) {
+  const { tokens } = ctx.value;
+  const containsOwnershipNameWrapper = tokens.some(
+    (t) => t.ownership.ownershipType === NameTokenOwnershipTypes.NameWrapper
+  );
+  const containsOwnershipFullyOnchainOrUnknown = tokens.some(
+    (t) => t.ownership.ownershipType === NameTokenOwnershipTypes.FullyOnchain || t.ownership.ownershipType === NameTokenOwnershipTypes.Unknown
+  );
+  if (containsOwnershipNameWrapper && !containsOwnershipFullyOnchainOrUnknown) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `'tokens' must contain name token with ownership type 'fully-onchain' or 'unknown' when name token with ownership type 'namewrapper' in listed`
+    });
+  }
+}
+function invariant_nameTokensContainAtMostOneWithOwnershipTypeEffective(ctx) {
+  const { tokens } = ctx.value;
+  const tokensCountWithOwnershipFullyOnchain = tokens.filter(
+    (t) => t.ownership.ownershipType === NameTokenOwnershipTypes.FullyOnchain
+  ).length;
+  if (tokensCountWithOwnershipFullyOnchain > 1) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `'tokens' must contain at most one name token with ownership type 'fully-onchain', current count: ${tokensCountWithOwnershipFullyOnchain}`
+    });
+  }
+}
+var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token") => z8.object({
+  domainId: makeNodeSchema(`${valueLabel}.domainId`),
+  name: makeReinterpretedNameSchema(valueLabel),
+  tokens: z8.array(makeNameTokenSchema(`${valueLabel}.tokens`)).nonempty(),
+  expiresAt: makeUnixTimestampSchema(`${valueLabel}.expiresAt`),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
+}).check(invariant_nameIsAssociatedWithDomainId).check(invariant_nameTokensContainAtMostOneWithOwnershipTypeEffective).check(invariant_nameTokensOwnershipTypeNameWrapperRequiresOwnershipTypeFullyOnchainOrUnknown);
+var makeNameTokensResponseOkSchema = (valueLabel = "Name Tokens Response OK") => z8.strictObject({
+  responseCode: z8.literal(NameTokensResponseCodes.Ok),
+  registeredNameTokens: makeRegisteredNameTokenSchema(`${valueLabel}.nameTokens`)
+});
+var makeNameTokensResponseErrorNameTokensNotIndexedSchema = (_valueLabel = "Name Tokens Response Error Name Not Indexed") => z8.strictObject({
+  responseCode: z8.literal(NameTokensResponseCodes.Error),
+  errorCode: z8.literal(NameTokensResponseErrorCodes.NameTokensNotIndexed),
+  error: ErrorResponseSchema
+});
+var makeNameTokensResponseErrorEnsIndexerConfigUnsupported = (_valueLabel = "Name Tokens Response Error ENSIndexer Config Unsupported") => z8.strictObject({
+  responseCode: z8.literal(NameTokensResponseCodes.Error),
+  errorCode: z8.literal(NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported),
+  error: ErrorResponseSchema
+});
+var makeNameTokensResponseErrorNameIndexingStatusUnsupported = (_valueLabel = "Name Tokens Response Error Indexing Status Unsupported") => z8.strictObject({
+  responseCode: z8.literal(NameTokensResponseCodes.Error),
+  errorCode: z8.literal(NameTokensResponseErrorCodes.IndexingStatusUnsupported),
+  error: ErrorResponseSchema
+});
+var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => z8.discriminatedUnion("errorCode", [
+  makeNameTokensResponseErrorNameTokensNotIndexedSchema(valueLabel),
+  makeNameTokensResponseErrorEnsIndexerConfigUnsupported(valueLabel),
+  makeNameTokensResponseErrorNameIndexingStatusUnsupported(valueLabel)
+]);
+var makeNameTokensResponseSchema = (valueLabel = "Name Tokens Response") => z8.discriminatedUnion("responseCode", [
+  makeNameTokensResponseOkSchema(valueLabel),
+  makeNameTokensResponseErrorSchema(valueLabel)
+]);
+
+// src/api/name-tokens/deserialize.ts
+function deserializedNameTokensResponse(maybeResponse) {
+  const parsed = makeNameTokensResponseSchema().safeParse(maybeResponse);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize NameTokensResponse:
+${prettifyError7(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+
+// src/api/name-tokens/prerequisites.ts
+var nameTokensPrerequisites = Object.freeze({
+  /**
+   * Required plugins to enable Name Tokens API routes.
+   *
+   * 1. `registrars` plugin is required so that data in the `registrationLifecycles`
+   *    table is populated.
+   * 2. `tokenscope` plugin is required so that data in the `nameTokens`
+   *    table is populated.
+   */
+  requiredPlugins: ["registrars" /* Registrars */, "tokenscope" /* TokenScope */],
+  /**
+   * Check if provided ENSApiPublicConfig supports the Name Tokens API.
+   */
+  hasEnsIndexerConfigSupport(config) {
+    return nameTokensPrerequisites.requiredPlugins.every(
+      (plugin) => config.plugins.includes(plugin)
+    );
+  },
+  /**
+   * Required Indexing Status IDs
+   *
+   * Database indexes are created by the time the omnichain indexing status
+   * is either `completed` or `following`.
+   */
+  supportedIndexingStatusIds: [
+    OmnichainIndexingStatusIds.Completed,
+    OmnichainIndexingStatusIds.Following
+  ],
+  /**
+   * Check if provided indexing status supports the Name Tokens API.
+   */
+  hasIndexingStatusSupport(omnichainIndexingStatusId) {
+    return nameTokensPrerequisites.supportedIndexingStatusIds.some(
+      (supportedIndexingStatusId) => supportedIndexingStatusId === omnichainIndexingStatusId
+    );
+  }
+});
+
+// src/api/name-tokens/serialize.ts
+function serializeRegisteredNameTokens({
+  domainId,
+  name,
+  tokens,
+  expiresAt,
+  accurateAsOf
+}) {
+  return {
+    domainId,
+    name,
+    tokens: tokens.map(serializeNameToken),
+    expiresAt,
+    accurateAsOf
+  };
+}
+function serializeNameTokensResponse(response) {
+  switch (response.responseCode) {
+    case NameTokensResponseCodes.Ok:
+      return {
+        responseCode: response.responseCode,
+        registeredNameTokens: serializeRegisteredNameTokens(response.registeredNameTokens)
+      };
+    case NameTokensResponseCodes.Error:
+      return response;
+  }
+}
+
+// src/api/registrar-actions/deserialize.ts
+import { prettifyError as prettifyError8 } from "zod/v4";
+
+// src/api/registrar-actions/zod-schemas.ts
+import { namehash as namehash3 } from "viem/ens";
+import z11 from "zod/v4";
+
+// ../ens-referrals/src/address.ts
+import { isAddress as isAddress3 } from "viem";
+
+// ../ens-referrals/src/encoding.ts
+import { getAddress, pad, size as size2, slice, zeroAddress as zeroAddress4 } from "viem";
+var ENCODED_REFERRER_BYTE_OFFSET = 12;
+var ENCODED_REFERRER_BYTE_LENGTH = 32;
+var EXPECTED_ENCODED_REFERRER_PADDING = pad("0x", {
+  size: ENCODED_REFERRER_BYTE_OFFSET,
+  dir: "left"
+});
+var ZERO_ENCODED_REFERRER = pad("0x", {
+  size: ENCODED_REFERRER_BYTE_LENGTH,
+  dir: "left"
+});
+function decodeEncodedReferrer(encodedReferrer) {
+  if (size2(encodedReferrer) !== ENCODED_REFERRER_BYTE_LENGTH) {
+    throw new Error(
+      `Encoded referrer value must be represented by ${ENCODED_REFERRER_BYTE_LENGTH} bytes.`
+    );
+  }
+  const padding = slice(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
+  if (padding !== EXPECTED_ENCODED_REFERRER_PADDING) {
+    return zeroAddress4;
+  }
+  const decodedReferrer = slice(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
+  try {
+    return getAddress(decodedReferrer);
+  } catch {
+    throw new Error(`Decoded referrer value must be a valid EVM address.`);
+  }
+}
+
+// ../ens-referrals/src/leaderboard-page.ts
+var REFERRERS_PER_LEADERBOARD_PAGE_MAX = 100;
+
+// ../ens-referrals/src/link.ts
+import { getAddress as getAddress2 } from "viem";
+
+// ../ens-referrals/src/referrer-detail.ts
+var ReferrerDetailTypeIds = {
+  /**
+   * Represents a referrer who is ranked on the leaderboard.
+   */
+  Ranked: "ranked",
+  /**
+   * Represents a referrer who is not ranked on the leaderboard.
+   */
+  Unranked: "unranked"
+};
+
+// src/registrars/zod-schemas.ts
+import z9 from "zod/v4";
+
+// src/registrars/registrar-action.ts
+var RegistrarActionTypes = {
+  Registration: "registration",
+  Renewal: "renewal"
+};
+function isRegistrarActionPricingAvailable(registrarActionPricing) {
+  const { baseCost, premium, total } = registrarActionPricing;
+  return baseCost !== null && premium !== null && total !== null;
+}
+function isRegistrarActionReferralAvailable(registrarActionReferral) {
+  const { encodedReferrer, decodedReferrer } = registrarActionReferral;
+  return encodedReferrer !== null && decodedReferrer !== null;
+}
 function serializeRegistrarActionPricing(pricing) {
   if (isRegistrarActionPricingAvailable(pricing)) {
     return {
@@ -2006,7 +2519,7 @@ function serializeRegistrarAction(registrarAction) {
     type: registrarAction.type,
     incrementalDuration: registrarAction.incrementalDuration,
     registrant: registrarAction.registrant,
-    registrationLifecycle: serializeRegistrationLifecycle(registrarAction.registrationLifecycle),
+    registrationLifecycle: registrarAction.registrationLifecycle,
     pricing: serializeRegistrarActionPricing(registrarAction.pricing),
     referral: registrarAction.referral,
     block: registrarAction.block,
@@ -2016,11 +2529,11 @@ function serializeRegistrarAction(registrarAction) {
 }
 
 // src/registrars/zod-schemas.ts
-var makeSubregistrySchema = (valueLabel = "Subregistry") => z8.object({
-  subregistryId: makeSerializedAccountIdSchema(`${valueLabel} Subregistry ID`),
+var makeSubregistrySchema = (valueLabel = "Subregistry") => z9.object({
+  subregistryId: makeAccountIdSchema(`${valueLabel} Subregistry ID`),
   node: makeNodeSchema(`${valueLabel} Node`)
 });
-var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => z8.object({
+var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => z9.object({
   subregistry: makeSubregistrySchema(`${valueLabel} Subregistry`),
   node: makeNodeSchema(`${valueLabel} Node`),
   expiresAt: makeUnixTimestampSchema(`${valueLabel} Expires at`)
@@ -2036,18 +2549,18 @@ function invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium(ctx) {
     });
   }
 }
-var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => z8.union([
+var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => z9.union([
   // pricing available
-  z8.object({
+  z9.object({
     baseCost: makePriceEthSchema(`${valueLabel} Base Cost`),
     premium: makePriceEthSchema(`${valueLabel} Premium`),
     total: makePriceEthSchema(`${valueLabel} Total`)
   }).check(invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium).transform((v) => v),
   // pricing unknown
-  z8.object({
-    baseCost: z8.null(),
-    premium: z8.null(),
-    total: z8.null()
+  z9.object({
+    baseCost: z9.null(),
+    premium: z9.null(),
+    total: z9.null()
   }).transform((v) => v)
 ]);
 function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
@@ -2070,9 +2583,9 @@ function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
     });
   }
 }
-var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => z8.union([
+var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => z9.union([
   // referral available
-  z8.object({
+  z9.object({
     encodedReferrer: makeHexStringSchema(
       { bytesCount: ENCODED_REFERRER_BYTE_LENGTH },
       `${valueLabel} Encoded Referrer`
@@ -2080,9 +2593,9 @@ var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral
     decodedReferrer: makeLowercaseAddressSchema(`${valueLabel} Decoded Referrer`)
   }).check(invariant_registrarActionDecodedReferrerBasedOnRawReferrer),
   // referral not applicable
-  z8.object({
-    encodedReferrer: z8.null(),
-    decodedReferrer: z8.null()
+  z9.object({
+    encodedReferrer: z9.null(),
+    decodedReferrer: z9.null()
   })
 ]);
 function invariant_eventIdsInitialElementIsTheActionId(ctx) {
@@ -2095,9 +2608,9 @@ function invariant_eventIdsInitialElementIsTheActionId(ctx) {
     });
   }
 }
-var EventIdSchema = z8.string().nonempty();
-var EventIdsSchema = z8.array(EventIdSchema).min(1).transform((v) => v);
-var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => z8.object({
+var EventIdSchema = z9.string().nonempty();
+var EventIdsSchema = z9.array(EventIdSchema).min(1).transform((v) => v);
+var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => z9.object({
   id: EventIdSchema,
   incrementalDuration: makeDurationSchema(`${valueLabel} Incremental Duration`),
   registrant: makeLowercaseAddressSchema(`${valueLabel} Registrant`),
@@ -2111,168 +2624,135 @@ var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => z8
   eventIds: EventIdsSchema
 }).check(invariant_eventIdsInitialElementIsTheActionId);
 var makeRegistrarActionRegistrationSchema = (valueLabel = "Registration ") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: z8.literal(RegistrarActionTypes.Registration)
+  type: z9.literal(RegistrarActionTypes.Registration)
 });
 var makeRegistrarActionRenewalSchema = (valueLabel = "Renewal") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: z8.literal(RegistrarActionTypes.Renewal)
+  type: z9.literal(RegistrarActionTypes.Renewal)
 });
-var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => z8.discriminatedUnion("type", [
+var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => z9.discriminatedUnion("type", [
   makeRegistrarActionRegistrationSchema(`${valueLabel} Registration`),
   makeRegistrarActionRenewalSchema(`${valueLabel} Renewal`)
 ]);
 
-// src/shared/config/build-rpc-urls.ts
-import {
-  arbitrum,
-  arbitrumSepolia,
-  base,
-  baseSepolia,
-  holesky,
-  linea,
-  lineaSepolia,
-  mainnet,
-  optimism,
-  optimismSepolia,
-  scroll,
-  scrollSepolia,
-  sepolia
-} from "viem/chains";
-
-// src/shared/config/rpc-configs-from-env.ts
-import { getENSNamespace } from "@ensnode/datasources";
-
-// src/shared/config/validatons.ts
-import { getENSRootChainId as getENSRootChainId2 } from "@ensnode/datasources";
-function invariant_rpcEndpointConfigIncludesAtLeastOneHTTPProtocolURL(ctx) {
-  const endpoints = ctx.value;
-  const httpEndpoints = endpoints.filter(isHttpProtocol);
-  if (httpEndpoints.length < 1) {
+// src/api/shared/pagination/zod-schemas.ts
+import z10 from "zod/v4";
+
+// src/api/shared/pagination/request.ts
+var RECORDS_PER_PAGE_DEFAULT = 10;
+var RECORDS_PER_PAGE_MAX = 100;
+
+// src/api/shared/pagination/zod-schemas.ts
+var makeRequestPageParamsSchema = (valueLabel = "RequestPageParams") => z10.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") => z10.object({
+  totalRecords: z10.literal(0),
+  totalPages: z10.literal(1),
+  hasNext: z10.literal(false),
+  hasPrev: z10.literal(false),
+  startIndex: z10.undefined(),
+  endIndex: z10.undefined()
+}).extend(makeRequestPageParamsSchema(valueLabel).shape);
+function invariant_responsePageWithRecordsIsCorrect(ctx) {
+  const { hasNext, hasPrev, recordsPerPage, page, totalRecords, startIndex, endIndex } = ctx.value;
+  const expectedHasNext = page * recordsPerPage < totalRecords;
+  if (hasNext !== expectedHasNext) {
     ctx.issues.push({
       code: "custom",
-      input: endpoints,
-      message: `RPC endpoint configuration for a chain must include at least one http/https protocol URL.`
+      input: ctx.value,
+      message: `hasNext must be equal to '${expectedHasNext ? "true" : "false"}'`
     });
   }
-}
-function invariant_rpcEndpointConfigIncludesAtMostOneWebSocketsProtocolURL(ctx) {
-  const endpoints = ctx.value;
-  const wsEndpoints = endpoints.filter(isWebSocketProtocol);
-  if (wsEndpoints.length > 1) {
+  const expectedHasPrev = page > 1;
+  if (hasPrev !== expectedHasPrev) {
     ctx.issues.push({
       code: "custom",
-      input: endpoints,
-      message: `RPC endpoint configuration for a chain must include at most one websocket (ws/wss) protocol URL.`
+      input: ctx.value,
+      message: `hasPrev must be equal to '${expectedHasPrev ? "true" : "false"}'`
     });
   }
-}
-
-// src/shared/config/zod-schemas.ts
-import { z as z9 } from "zod/v4";
-import { ENSNamespaceIds as ENSNamespaceIds3 } from "@ensnode/datasources";
-var DatabaseSchemaNameSchema = z9.string({
-  error: "DATABASE_SCHEMA is required."
-}).trim().min(1, {
-  error: "DATABASE_SCHEMA is required and cannot be an empty string."
-});
-var RpcConfigSchema = z9.string().transform((val) => val.split(",")).pipe(z9.array(makeUrlSchema("RPC URL"))).check(invariant_rpcEndpointConfigIncludesAtLeastOneHTTPProtocolURL).check(invariant_rpcEndpointConfigIncludesAtMostOneWebSocketsProtocolURL);
-var RpcConfigsSchema = z9.record(makeChainIdStringSchema("RPC URL"), RpcConfigSchema, {
-  error: "Chains configuration must be an object mapping valid chain IDs to their configs."
-}).transform((records) => {
-  const rpcConfigs = /* @__PURE__ */ new Map();
-  for (const [chainIdString, rpcConfig] of Object.entries(records)) {
-    const httpRPCs = rpcConfig.filter(isHttpProtocol);
-    const websocketRPC = rpcConfig.find(isWebSocketProtocol);
-    rpcConfigs.set(deserializeChainId(chainIdString), {
-      httpRPCs,
-      websocketRPC
+  if (endIndex < startIndex) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `endIndex must be greater than or equal to startIndex`
     });
   }
-  return rpcConfigs;
-});
-var EnsIndexerUrlSchema = makeUrlSchema("ENSINDEXER_URL");
-var ENSNamespaceSchema = z9.enum(ENSNamespaceIds3, {
-  error: ({ input }) => `Invalid NAMESPACE. Got '${input}', but supported ENS namespaces are: ${Object.keys(ENSNamespaceIds3).join(", ")}`
-});
-var PortSchema = z9.coerce.number({ error: "PORT must be a number." }).min(1, { error: "PORT must be greater than 1." }).max(65535, { error: "PORT must be less than 65535" }).optional();
-var TheGraphApiKeySchema = z9.string().optional();
-
-// src/shared/datasources-with-resolvers.ts
-import {
-  DatasourceNames,
-  maybeGetDatasource
-} from "@ensnode/datasources";
-var DATASOURCE_NAMES_WITH_RESOLVERS = [
-  DatasourceNames.ENSRoot,
-  DatasourceNames.Basenames,
-  DatasourceNames.Lineanames,
-  DatasourceNames.ThreeDNSOptimism,
-  DatasourceNames.ThreeDNSBase
-];
-
-// src/shared/log-level.ts
-import { z as z10 } from "zod/v4";
-var LogLevelSchema = z10.enum(["fatal", "error", "warn", "info", "debug", "trace", "silent"]);
-
-// src/shared/protocol-acceleration/interpret-record-values.ts
-import { isAddress as isAddress4, isAddressEqual as isAddressEqual2, zeroAddress as zeroAddress2 } from "viem";
+  if (endIndex >= totalRecords) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `endIndex must be lower than totalRecords`
+    });
+  }
+}
+var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => z10.object({
+  totalRecords: makePositiveIntegerSchema(`${valueLabel}.totalRecords`),
+  totalPages: makePositiveIntegerSchema(`${valueLabel}.totalPages`),
+  hasNext: z10.boolean(),
+  hasPrev: z10.boolean(),
+  startIndex: makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`),
+  endIndex: makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`)
+}).extend(makeRequestPageParamsSchema(valueLabel).shape).check(invariant_responsePageWithRecordsIsCorrect);
+var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => z10.union([
+  makeResponsePageContextSchemaWithNoRecords(valueLabel),
+  makeResponsePageContextSchemaWithRecords(valueLabel)
+]);
 
-// src/api/indexing-status/response.ts
-var IndexingStatusResponseCodes = {
+// src/api/registrar-actions/response.ts
+var RegistrarActionsResponseCodes = {
   /**
-   * Represents that the indexing status is available.
+   * Represents that Registrar Actions are available.
    */
   Ok: "ok",
   /**
-   * Represents that the indexing status is unavailable.
+   * Represents that Registrar Actions are unavailable.
    */
   Error: "error"
 };
 
-// src/api/indexing-status/zod-schemas.ts
-var makeIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => z11.strictObject({
-  responseCode: z11.literal(IndexingStatusResponseCodes.Ok),
-  realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel)
+// src/api/registrar-actions/zod-schemas.ts
+function invariant_registrationLifecycleNodeMatchesName(ctx) {
+  const { name, action } = ctx.value;
+  const expectedNode = action.registrationLifecycle.node;
+  const actualNode = namehash3(name);
+  if (actualNode !== expectedNode) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `The 'action.registrationLifecycle.node' must match namehash of 'name'`
+    });
+  }
+}
+var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => z11.object({
+  action: makeRegistrarActionSchema(valueLabel),
+  name: makeReinterpretedNameSchema(valueLabel)
+}).check(invariant_registrationLifecycleNodeMatchesName);
+var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => z11.strictObject({
+  responseCode: z11.literal(RegistrarActionsResponseCodes.Ok),
+  registrarActions: z11.array(makeNamedRegistrarActionSchema(valueLabel)),
+  pageContext: makeResponsePageContextSchema(`${valueLabel}.pageContext`)
 });
-var makeIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => z11.strictObject({
-  responseCode: z11.literal(IndexingStatusResponseCodes.Error)
+var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => z11.strictObject({
+  responseCode: z11.literal(RegistrarActionsResponseCodes.Error),
+  error: ErrorResponseSchema
 });
-var makeIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => z11.discriminatedUnion("responseCode", [
-  makeIndexingStatusResponseOkSchema(valueLabel),
-  makeIndexingStatusResponseErrorSchema(valueLabel)
+var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => z11.discriminatedUnion("responseCode", [
+  makeRegistrarActionsResponseOkSchema(valueLabel),
+  makeRegistrarActionsResponseErrorSchema(valueLabel)
 ]);
 
-// src/api/indexing-status/deserialize.ts
-function deserializeIndexingStatusResponse(maybeResponse) {
-  const parsed = makeIndexingStatusResponseSchema().safeParse(maybeResponse);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize IndexingStatusResponse:
-${prettifyError5(parsed.error)}
-`);
-  }
-  return parsed.data;
-}
-
-// src/api/indexing-status/serialize.ts
-function serializeIndexingStatusResponse(response) {
-  switch (response.responseCode) {
-    case IndexingStatusResponseCodes.Ok:
-      return {
-        responseCode: response.responseCode,
-        realtimeProjection: serializeRealtimeIndexingStatusProjection(response.realtimeProjection)
-      };
-    case IndexingStatusResponseCodes.Error:
-      return response;
-  }
-}
-
 // src/api/registrar-actions/deserialize.ts
-import { prettifyError as prettifyError6 } from "zod/v4";
 function deserializeRegistrarActionsResponse(maybeResponse) {
   const parsed = makeRegistrarActionsResponseSchema().safeParse(maybeResponse);
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize RegistrarActionsResponse:
-${prettifyError6(parsed.error)}
+${prettifyError8(parsed.error)}
 `
     );
   }
@@ -2282,7 +2762,8 @@ ${prettifyError6(parsed.error)}
 // src/api/registrar-actions/request.ts
 var RegistrarActionsFilterTypes = {
   BySubregistryNode: "bySubregistryNode",
-  WithEncodedReferral: "withEncodedReferral"
+  WithEncodedReferral: "withEncodedReferral",
+  ByDecodedReferrer: "byDecodedReferrer"
 };
 var RegistrarActionsOrders = {
   LatestRegistrarActions: "orderBy[timestamp]=desc"
@@ -2306,9 +2787,19 @@ function withReferral(withReferral2) {
     filterType: RegistrarActionsFilterTypes.WithEncodedReferral
   };
 }
+function byDecodedReferrer(decodedReferrer) {
+  if (typeof decodedReferrer === "undefined") {
+    return void 0;
+  }
+  return {
+    filterType: RegistrarActionsFilterTypes.ByDecodedReferrer,
+    value: decodedReferrer
+  };
+}
 var registrarActionsFilter = {
   byParentNode,
-  withReferral
+  withReferral,
+  byDecodedReferrer
 };
 
 // src/api/registrar-actions/prerequisites.ts
@@ -2361,12 +2852,50 @@ var registrarActionsPrerequisites = Object.freeze({
   }
 });
 
+// src/registrars/basenames-subregistry.ts
+import {
+  DatasourceNames as DatasourceNames2,
+  ENSNamespaceIds as ENSNamespaceIds3,
+  maybeGetDatasource as maybeGetDatasource2
+} from "@ensnode/datasources";
+function getBasenamesSubregistryId(namespace) {
+  const datasource = maybeGetDatasource2(namespace, DatasourceNames2.Basenames);
+  if (!datasource) {
+    throw new Error(`Datasource not found for ${namespace} ${DatasourceNames2.Basenames}`);
+  }
+  const address = datasource.contracts.BaseRegistrar?.address;
+  if (address === void 0 || Array.isArray(address)) {
+    throw new Error(`BaseRegistrar contract not found or has multiple addresses for ${namespace}`);
+  }
+  return {
+    chainId: datasource.chain.id,
+    address
+  };
+}
+function getBasenamesSubregistryManagedName(namespaceId) {
+  switch (namespaceId) {
+    case ENSNamespaceIds3.Mainnet:
+      return "base.eth";
+    case ENSNamespaceIds3.Sepolia:
+      return "basetest.eth";
+    case ENSNamespaceIds3.Holesky:
+    case ENSNamespaceIds3.EnsTestEnv:
+      throw new Error(
+        `No registrar managed name is known for the 'basenames' subregistry within the "${namespaceId}" namespace.`
+      );
+  }
+}
+
 // src/registrars/ethnames-subregistry.ts
-import { DatasourceNames as DatasourceNames2, maybeGetDatasource as maybeGetDatasource2 } from "@ensnode/datasources";
+import {
+  DatasourceNames as DatasourceNames3,
+  ENSNamespaceIds as ENSNamespaceIds4,
+  maybeGetDatasource as maybeGetDatasource3
+} from "@ensnode/datasources";
 function getEthnamesSubregistryId(namespace) {
-  const datasource = maybeGetDatasource2(namespace, DatasourceNames2.ENSRoot);
+  const datasource = maybeGetDatasource3(namespace, DatasourceNames3.ENSRoot);
   if (!datasource) {
-    throw new Error(`Datasource not found for ${namespace} ${DatasourceNames2.ENSRoot}`);
+    throw new Error(`Datasource not found for ${namespace} ${DatasourceNames3.ENSRoot}`);
   }
   const address = datasource.contracts.BaseRegistrar?.address;
   if (address === void 0 || Array.isArray(address)) {
@@ -2377,6 +2906,49 @@ function getEthnamesSubregistryId(namespace) {
     address
   };
 }
+function getEthnamesSubregistryManagedName(namespaceId) {
+  switch (namespaceId) {
+    case ENSNamespaceIds4.Mainnet:
+    case ENSNamespaceIds4.Sepolia:
+    case ENSNamespaceIds4.Holesky:
+    case ENSNamespaceIds4.EnsTestEnv:
+      return "eth";
+  }
+}
+
+// src/registrars/lineanames-subregistry.ts
+import {
+  DatasourceNames as DatasourceNames4,
+  ENSNamespaceIds as ENSNamespaceIds5,
+  maybeGetDatasource as maybeGetDatasource4
+} from "@ensnode/datasources";
+function getLineanamesSubregistryId(namespace) {
+  const datasource = maybeGetDatasource4(namespace, DatasourceNames4.Lineanames);
+  if (!datasource) {
+    throw new Error(`Datasource not found for ${namespace} ${DatasourceNames4.Lineanames}`);
+  }
+  const address = datasource.contracts.BaseRegistrar?.address;
+  if (address === void 0 || Array.isArray(address)) {
+    throw new Error(`BaseRegistrar contract not found or has multiple addresses for ${namespace}`);
+  }
+  return {
+    chainId: datasource.chain.id,
+    address
+  };
+}
+function getLineanamesSubregistryManagedName(namespaceId) {
+  switch (namespaceId) {
+    case ENSNamespaceIds5.Mainnet:
+      return "linea.eth";
+    case ENSNamespaceIds5.Sepolia:
+      return "linea-sepolia.eth";
+    case ENSNamespaceIds5.Holesky:
+    case ENSNamespaceIds5.EnsTestEnv:
+      throw new Error(
+        `No registrar managed name is known for the 'Lineanames' subregistry within the "${namespaceId}" namespace.`
+      );
+  }
+}
 
 // src/api/registrar-actions/serialize.ts
 function serializeNamedRegistrarAction({
@@ -2393,7 +2965,8 @@ function serializeRegistrarActionsResponse(response) {
     case RegistrarActionsResponseCodes.Ok:
       return {
         responseCode: response.responseCode,
-        registrarActions: response.registrarActions.map(serializeNamedRegistrarAction)
+        registrarActions: response.registrarActions.map(serializeNamedRegistrarAction),
+        pageContext: response.pageContext
       };
     case RegistrarActionsResponseCodes.Error:
       return response;
@@ -2401,17 +2974,52 @@ function serializeRegistrarActionsResponse(response) {
 }
 
 // src/api/shared/errors/deserialize.ts
-import { prettifyError as prettifyError7 } from "zod/v4";
+import { prettifyError as prettifyError9 } from "zod/v4";
 function deserializeErrorResponse(maybeErrorResponse) {
   const parsed = ErrorResponseSchema.safeParse(maybeErrorResponse);
   if (parsed.error) {
     throw new Error(`Cannot deserialize ErrorResponse:
-${prettifyError7(parsed.error)}
+${prettifyError9(parsed.error)}
 `);
   }
   return parsed.data;
 }
 
+// src/api/shared/pagination/build-page-context.ts
+function buildPageContext(page, recordsPerPage, totalRecords) {
+  const totalPages = Math.max(1, Math.ceil(totalRecords / recordsPerPage));
+  if (page > totalPages) {
+    throw new Error(`Invalid page: page ${page} exceeds total pages ${totalPages}.`);
+  }
+  if (totalRecords === 0) {
+    return {
+      page,
+      recordsPerPage,
+      totalRecords: 0,
+      totalPages: 1,
+      hasNext: false,
+      hasPrev: false,
+      startIndex: void 0,
+      endIndex: void 0
+    };
+  }
+  const startIndex = (page - 1) * recordsPerPage;
+  const maxTheoreticalIndexOnPage = startIndex + (recordsPerPage - 1);
+  const endIndex = Math.min(maxTheoreticalIndexOnPage, totalRecords - 1);
+  const hasNext = maxTheoreticalIndexOnPage < totalRecords - 1;
+  const hasPrev = page > 1;
+  return {
+    page,
+    recordsPerPage,
+    totalRecords,
+    totalPages,
+    hasNext,
+    hasPrev,
+    startIndex,
+    endIndex
+  };
+}
+
 // src/client-error.ts
 var ClientError = class _ClientError extends Error {
   details;
@@ -2426,7 +3034,7 @@ var ClientError = class _ClientError extends Error {
 };
 
 // src/ensanalytics/deserialize.ts
-import { prettifyError as prettifyError8 } from "zod/v4";
+import { prettifyError as prettifyError10 } from "zod/v4";
 
 // src/ensanalytics/zod-schemas.ts
 import z12 from "zod/v4";
@@ -2511,9 +3119,9 @@ var makeAggregatedReferrerMetricsSchema = (valueLabel = "AggregatedReferrerMetri
 });
 var makeReferrerLeaderboardPageContextSchema = (valueLabel = "ReferrerLeaderboardPageContext") => z12.object({
   page: makePositiveIntegerSchema(`${valueLabel}.page`),
-  itemsPerPage: makePositiveIntegerSchema(`${valueLabel}.itemsPerPage`).max(
+  recordsPerPage: makePositiveIntegerSchema(`${valueLabel}.recordsPerPage`).max(
     REFERRERS_PER_LEADERBOARD_PAGE_MAX,
-    `${valueLabel}.itemsPerPage must not exceed ${REFERRERS_PER_LEADERBOARD_PAGE_MAX}`
+    `${valueLabel}.recordsPerPage must not exceed ${REFERRERS_PER_LEADERBOARD_PAGE_MAX}`
   ),
   totalRecords: makeNonNegativeIntegerSchema(`${valueLabel}.totalRecords`),
   totalPages: makePositiveIntegerSchema(`${valueLabel}.totalPages`),
@@ -2524,9 +3132,9 @@ var makeReferrerLeaderboardPageContextSchema = (valueLabel = "ReferrerLeaderboar
 });
 var makeReferrerLeaderboardPageSchema = (valueLabel = "ReferrerLeaderboardPage") => z12.object({
   rules: makeReferralProgramRulesSchema(`${valueLabel}.rules`),
-  referrers: z12.array(makeAwardedReferrerMetricsSchema(`${valueLabel}.referrers[item]`)),
+  referrers: z12.array(makeAwardedReferrerMetricsSchema(`${valueLabel}.referrers[record]`)),
   aggregatedMetrics: makeAggregatedReferrerMetricsSchema(`${valueLabel}.aggregatedMetrics`),
-  paginationContext: makeReferrerLeaderboardPageContextSchema(`${valueLabel}.paginationContext`),
+  pageContext: makeReferrerLeaderboardPageContextSchema(`${valueLabel}.pageContext`),
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 });
 var makeReferrerLeaderboardPageResponseOkSchema = (valueLabel = "ReferrerLeaderboardPageResponseOk") => z12.object({
@@ -2580,7 +3188,7 @@ function deserializeReferrerLeaderboardPageResponse(maybeResponse, valueLabel) {
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize SerializedReferrerLeaderboardPageResponse:
-${prettifyError8(parsed.error)}
+${prettifyError10(parsed.error)}
 `
     );
   }
@@ -2591,7 +3199,7 @@ function deserializeReferrerDetailResponse(maybeResponse, valueLabel) {
   const parsed = schema.safeParse(maybeResponse);
   if (parsed.error) {
     throw new Error(`Cannot deserialize ReferrerDetailResponse:
-${prettifyError8(parsed.error)}
+${prettifyError10(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2859,7 +3467,7 @@ var ENSNodeClient = class _ENSNodeClient {
    *
    * @param request - Pagination parameters
    * @param request.page - The page number to retrieve (1-indexed, default: 1)
-   * @param request.itemsPerPage - Number of items per page (default: 25, max: 100)
+   * @param request.recordsPerPage - Number of records per page (default: 25, max: 100)
    * @returns {ReferrerLeaderboardPageResponse}
    *
    * @throws if the ENSNode request fails
@@ -2868,28 +3476,28 @@ var ENSNodeClient = class _ENSNodeClient {
    *
    * @example
    * ```typescript
-   * // Get first page with default page size (25 items)
+   * // Get first page with default page size (25 records)
    * const response = await client.getReferrerLeaderboardPage();
    * if (response.responseCode === ReferrerLeaderboardPageResponseCodes.Ok) {
    *   const {
    *     aggregatedMetrics,
    *     referrers,
    *     rules,
-   *     paginationContext,
+   *     pageContext,
    *     updatedAt
    *   } = response.data;
    *   console.log(aggregatedMetrics);
    *   console.log(referrers);
    *   console.log(rules);
    *   console.log(updatedAt);
-   *   console.log(`Page ${paginationContext.page} of ${paginationContext.totalPages}`);
+   *   console.log(`Page ${pageContext.page} of ${pageContext.totalPages}`);
    * }
    * ```
    *
    * @example
    * ```typescript
-   * // Get second page with 50 items per page
-   * const response = await client.getReferrerLeaderboardPage({ page: 2, itemsPerPage: 50 });
+   * // Get second page with 50 records per page
+   * const response = await client.getReferrerLeaderboardPage({ page: 2, recordsPerPage: 50 });
    * ```
    *
    * @example
@@ -2906,8 +3514,8 @@ var ENSNodeClient = class _ENSNodeClient {
   async getReferrerLeaderboardPage(request) {
     const url = new URL(`/ensanalytics/referrers`, this.options.url);
     if (request?.page) url.searchParams.set("page", request.page.toString());
-    if (request?.itemsPerPage)
-      url.searchParams.set("itemsPerPage", request.itemsPerPage.toString());
+    if (request?.recordsPerPage)
+      url.searchParams.set("recordsPerPage", request.recordsPerPage.toString());
     const response = await fetch(url);
     let responseData;
     try {
@@ -3012,11 +3620,13 @@ var ENSNodeClient = class _ENSNodeClient {
   /**
    * Fetch ENSNode Registrar Actions
    *
-   * @param {RegistrarActionsRequestFilter} request.filter is
-   *        an optional request filter configuration.
-   * @param {number} request.limit sets the maximum count of results in the response.
-   * @param {RegistrarActionsRequestOrder} request.order sets the order of
-   *        results in the response by field and direction.
+   * Retrieves a paginated list of registrar actions with optional filters.
+   *
+   * @param request is a request configuration.
+   * @param request.page sets the page number to retrieve (1-indexed, default: 1)
+   * @param request.recordsPerPage sets the number of records per page (default: 10, max: 100)
+   * @param request.filters is an optional request filter configuration.
+   * @param request.order sets the order of results in the response by field and direction.
    * @returns {RegistrarActionsResponse}
    *
    * @throws if the ENSNode request fails
@@ -3026,23 +3636,25 @@ var ENSNodeClient = class _ENSNodeClient {
    * @example
    * ```ts
    * import {
-   *   registrarActionsFilter,,
+   *   registrarActionsFilter,
    *   ENSNodeClient,
    * } from "@ensnode/ensnode-sdk";
    * import { namehash } from "viem/ens";
    *
    * const client: ENSNodeClient;
    *
-   * // get latest registrar action records across all indexed subregistries
-   * // NOTE: when no `limit` value is passed,
-   * //       the default RESPONSE_ITEMS_PER_PAGE_DEFAULT applies.
-   * const registrarActions = await client.registrarActions();
+   * // Get first page with default page size (10 records)
+   * const response = await client.registrarActions();
+   * if (response.responseCode === RegistrarActionsResponseCodes.Ok) {
+   *   const { registrarActions, pageContext } = response;
+   *   console.log(registrarActions);
+   *   console.log(`Page ${pageContext.page} of ${pageContext.totalPages}`);
+   * }
    *
-   * // get latest 5 registrar action records across all indexed subregistries
-   * // NOTE: when a `limit` value is passed, it must be lower than or equal to
-   * //       the RESPONSE_ITEMS_PER_PAGE_MAX value.
-   * const registrarActions = await client.registrarActions({
-   *   limit: 5,
+   * // Get second page with 25 records per page
+   * const response = await client.registrarActions({
+   *   page: 2,
+   *   recordsPerPage: 25,
    * });
    *
    * // get latest registrar action records associated with
@@ -3056,11 +3668,16 @@ var ENSNodeClient = class _ENSNodeClient {
    *   filters: [registrarActionsFilter.withReferral(true)],
    * });
    *
+   * // get latest registrar action records for a specific decoded referrer
+   * await client.registrarActions({
+   *   filters: [registrarActionsFilter.byDecodedReferrer("0x1234567890123456789012345678901234567890")],
+   * });
+   *
    * // get latest 10 registrar action records associated with
    * // subregistry managing `base.eth` name
    * await client.registrarActions({
    *   filters: [registrarActionsFilter.byParentNode(namehash('base.eth'))],
-   *   limit: 10
+   *   recordsPerPage: 10
    * });
    * ```
    */
@@ -3077,6 +3694,12 @@ var ENSNodeClient = class _ENSNodeClient {
       );
       return withReferralFilter ? { key: "withReferral", value: "true" } : null;
     };
+    const buildDecodedReferrerArg = (filters) => {
+      const decodedReferrerFilter = filters?.find(
+        (f) => f.filterType === RegistrarActionsFilterTypes.ByDecodedReferrer
+      );
+      return decodedReferrerFilter ? { key: "decodedReferrer", value: decodedReferrerFilter.value } : null;
+    };
     const buildOrderArg = (order) => {
       switch (order) {
         case RegistrarActionsOrders.LatestRegistrarActions: {
@@ -3093,13 +3716,76 @@ var ENSNodeClient = class _ENSNodeClient {
       const orderArgs = buildOrderArg(request.order);
       url.searchParams.set(orderArgs.key, orderArgs.value);
     }
-    if (request.itemsPerPage) {
-      url.searchParams.set("itemsPerPage", request.itemsPerPage.toString());
+    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 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 {
+   *   ENSNodeClient,
+   * } from "@ensnode/ensnode-sdk";
+   * import { namehash } from "viem/ens";
+   *
+   * const client: ENSNodeClient;
+   *
+   * // get latest name token records from the indexed subregistry based on the requested name
+   * const response = await client.nameTokens({
+   *   name: "vitalik.eth"
+   * });
+   *
+   * const response = await client.nameTokens({
+   *   domainId: "0xee6c4522aab0003e8d14cd40a6af439055fd2577951148c14b6cea9a53475835" // namehash('vitalik.eth')
+   * })
+   * ```
+   */
+  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 {
+      url.searchParams.set("domainId", request.domainId);
+    }
     const response = await fetch(url);
     let responseData;
     try {
@@ -3112,18 +3798,18 @@ var ENSNodeClient = class _ENSNodeClient {
       try {
         errorResponse = deserializeErrorResponse(responseData);
       } catch {
-        console.log("Registrar Actions API: handling a known server error.");
+        console.log("Name Tokens API: handling a known server error.");
       }
       if (typeof errorResponse !== "undefined") {
-        throw new Error(`Fetching ENSNode Registrar Actions Failed: ${errorResponse.message}`);
+        throw new Error(`Fetching ENSNode Name Tokens Failed: ${errorResponse.message}`);
       }
     }
-    return deserializeRegistrarActionsResponse(responseData);
+    return deserializedNameTokensResponse(responseData);
   }
 };
 
 // src/identity/identity.ts
-import { getENSRootChainId as getENSRootChainId3 } from "@ensnode/datasources";
+import { getENSRootChainId as getENSRootChainId2 } from "@ensnode/datasources";
 
 // src/identity/types.ts
 var ResolutionStatusIds = {
@@ -3150,7 +3836,7 @@ var ResolutionStatusIds = {
 function buildUnresolvedIdentity(address, namespaceId, chainId) {
   return {
     resolutionStatus: ResolutionStatusIds.Unresolved,
-    chainId: chainId ?? getENSRootChainId3(namespaceId),
+    chainId: chainId ?? getENSRootChainId2(namespaceId),
     address
   };
 }
@@ -3159,245 +3845,24 @@ function isResolvedIdentity(identity) {
 }
 
 // src/resolution/ensip19-chainid.ts
-import { mainnet as mainnet2 } from "viem/chains";
-import { getENSRootChainId as getENSRootChainId4 } from "@ensnode/datasources";
+import { mainnet } from "viem/chains";
+import { getENSRootChainId as getENSRootChainId3 } from "@ensnode/datasources";
 var getResolvePrimaryNameChainIdParam = (chainId, namespaceId) => {
-  const ensRootChainId = getENSRootChainId4(namespaceId);
-  return chainId === ensRootChainId ? mainnet2.id : chainId;
+  const ensRootChainId = getENSRootChainId3(namespaceId);
+  return chainId === ensRootChainId ? mainnet.id : chainId;
 };
 var translateDefaultableChainIdToChainId = (chainId, namespaceId) => {
-  return chainId === DEFAULT_EVM_CHAIN_ID ? getENSRootChainId4(namespaceId) : chainId;
+  return chainId === DEFAULT_EVM_CHAIN_ID ? getENSRootChainId3(namespaceId) : chainId;
 };
 
 // src/resolution/resolver-records-selection.ts
 var isSelectionEmpty = (selection) => !selection.name && !selection.addresses?.length && !selection.texts?.length;
 
-// src/tokenscope/assets.ts
-import { AssetId as CaipAssetId } from "caip";
-import { isAddressEqual as isAddressEqual3, zeroAddress as zeroAddress3 } from "viem";
-var AssetNamespaces = {
-  ERC721: "erc721",
-  ERC1155: "erc1155"
-};
-function serializeAssetId(assetId) {
-  const { assetNamespace, contract, tokenId } = assetId;
-  return CaipAssetId.format({
-    chainId: { namespace: "eip155", reference: contract.chainId.toString() },
-    assetName: { namespace: assetNamespace, reference: contract.address },
-    tokenId: uint256ToHex32(tokenId)
-  }).toLowerCase();
-}
-var buildAssetId = (contract, tokenId, assetNamespace) => {
-  return {
-    assetNamespace,
-    contract,
-    tokenId
-  };
-};
-var NFTMintStatuses = {
-  Minted: "minted",
-  Burned: "burned"
-};
-var formatNFTTransferEventMetadata = (metadata) => {
-  const serializedAssetId = serializeAssetId(metadata.nft);
-  return [
-    `Event: ${metadata.eventHandlerName}`,
-    `Chain ID: ${metadata.chainId}`,
-    `Block Number: ${metadata.blockNumber}`,
-    `Transaction Hash: ${metadata.transactionHash}`,
-    `NFT: ${serializedAssetId}`
-  ].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",
-  /**
-   * Transfer from a non-zeroAddress to zeroAddress
-   *
-   * Invariants:
-   * - NFT is indexed
-   * - previous NFT mint status was `minted`
-   * - previous NFT owner is a non-zeroAddress
-   * - new NFT mint status is `burned`
-   * - new NFT owner is the zeroAddress
-   */
-  Burn: "burn",
-  /**
-   * Transfer from a non-zeroAddress to a distinct non-zeroAddress
-   *
-   * Invariants:
-   * - NFT is indexed
-   * - previous and new NFT mint status is `minted`
-   * - previous and new NFT owner are distinct non-zeroAddress
-   */
-  Transfer: "transfer",
-  /**
-   * Transfer from a non-zeroAddress to the same non-zeroAddress
-   *
-   * Invariants:
-   * - NFT is indexed
-   * - previous and new NFT mint status is `minted`
-   * - previous and new NFT owner are equivalent non-zeroAddress
-   */
-  SelfTransfer: "self-transfer",
-  /**
-   * Transfer from zeroAddress to zeroAddress for an indexed NFT
-   *
-   * Invariants:
-   * - NFT is indexed
-   * - previous and new NFT mint status is `burned`
-   * - previous and new NFT owner are zeroAddress
-   */
-  RemintBurn: "remint-burn",
-  /**
-   * Special transfer type for improperly implemented NFT contracts that allow a NFT
-   * that is currently minted to be reminted again before an intermediate burn.
-   *
-   * Transfer from zeroAddress to 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 `burned`
-   * - new NFT owner is the zeroAddress
-   */
-  MintedRemintBurn: "minted-remint-burn",
-  /**
-   * Transfer from zeroAddress to zeroAddress for an unindexed NFT
-   *
-   * Invariants:
-   * - NFT is not indexed and therefore has no previous mint status or owner
-   * - NFT should remain unindexed and without any mint status or owner
-   */
-  MintBurn: "mint-burn"
-};
-var getNFTTransferType = (from, to, allowMintedRemint, metadata, currentlyIndexedOwner) => {
-  const isIndexed = currentlyIndexedOwner !== void 0;
-  const isIndexedAsMinted = isIndexed && !isAddressEqual3(currentlyIndexedOwner, zeroAddress3);
-  const isMint = isAddressEqual3(from, zeroAddress3);
-  const isBurn = isAddressEqual3(to, zeroAddress3);
-  const isSelfTransfer = isAddressEqual3(from, to);
-  if (isIndexed && !isAddressEqual3(currentlyIndexedOwner, from)) {
-    if (isMint && allowMintedRemint) {
-    } else {
-      throw new Error(
-        `Error: Sending from ${from} conflicts with currently indexed owner ${currentlyIndexedOwner}.
-${formatNFTTransferEventMetadata(metadata)}`
-      );
-    }
-  }
-  if (isSelfTransfer) {
-    if (isMint) {
-      if (!isIndexed) {
-        return NFTTransferTypes.MintBurn;
-      } else if (!isIndexedAsMinted) {
-        return NFTTransferTypes.RemintBurn;
-      } else if (allowMintedRemint) {
-        return NFTTransferTypes.MintedRemintBurn;
-      } else {
-        throw new Error(
-          `Error: Invalid state transition from minted -> remint-burn
-${formatNFTTransferEventMetadata(metadata)}`
-        );
-      }
-    } else {
-      if (!isIndexed) {
-        throw new Error(
-          `Error: Invalid state transition from unindexed -> self-transfer
-${formatNFTTransferEventMetadata(metadata)}`
-        );
-      } else if (!isIndexedAsMinted) {
-        throw new Error(
-          `Error: invalid state transition from burned -> self-transfer
-${formatNFTTransferEventMetadata(metadata)}`
-        );
-      } else {
-        return NFTTransferTypes.SelfTransfer;
-      }
-    }
-  } else if (isMint) {
-    if (!isIndexed) {
-      return NFTTransferTypes.Mint;
-    } else if (!isIndexedAsMinted) {
-      return NFTTransferTypes.Remint;
-    } else if (allowMintedRemint) {
-      return NFTTransferTypes.MintedRemint;
-    } else {
-      throw new Error(
-        `Error: Invalid state transition from minted -> mint
-${formatNFTTransferEventMetadata(metadata)}`
-      );
-    }
-  } else if (isBurn) {
-    if (!isIndexed) {
-      throw new Error(
-        `Error: Invalid state transition from unindexed -> burn
-${formatNFTTransferEventMetadata(metadata)}`
-      );
-    } else if (!isIndexedAsMinted) {
-      throw new Error(
-        `Error: Invalid state transition from burned -> burn
-${formatNFTTransferEventMetadata(metadata)}`
-      );
-    } else {
-      return NFTTransferTypes.Burn;
-    }
-  } else {
-    if (!isIndexed) {
-      throw new Error(
-        `Error: Invalid state transition from unindexed -> transfer
-${formatNFTTransferEventMetadata(metadata)}`
-      );
-    } else if (!isIndexedAsMinted) {
-      throw new Error(
-        `Error: Invalid state transition from burned -> transfer
-${formatNFTTransferEventMetadata(metadata)}`
-      );
-    } else {
-      return NFTTransferTypes.Transfer;
-    }
-  }
-};
-
-// src/tracing/index.ts
+// src/tracing/ens-protocol-tracing.ts
+var PROTOCOL_ATTRIBUTE_PREFIX = "ens";
+var ATTR_PROTOCOL_NAME = `${PROTOCOL_ATTRIBUTE_PREFIX}.protocol`;
+var ATTR_PROTOCOL_STEP = `${PROTOCOL_ATTRIBUTE_PREFIX}.protocol.step`;
+var ATTR_PROTOCOL_STEP_RESULT = `${PROTOCOL_ATTRIBUTE_PREFIX}.protocol.step.result`;
 var TraceableENSProtocol = /* @__PURE__ */ ((TraceableENSProtocol2) => {
   TraceableENSProtocol2["ForwardResolution"] = "forward-resolution";
   TraceableENSProtocol2["ReverseResolution"] = "reverse-resolution";
@@ -3422,10 +3887,6 @@ var ReverseResolutionProtocolStep = /* @__PURE__ */ ((ReverseResolutionProtocolS
   ReverseResolutionProtocolStep2["VerifyResolvedAddressMatchesAddress"] = "verify-resolved-address-matches-address";
   return ReverseResolutionProtocolStep2;
 })(ReverseResolutionProtocolStep || {});
-var PROTOCOL_ATTRIBUTE_PREFIX = "ens";
-var ATTR_PROTOCOL_NAME = `${PROTOCOL_ATTRIBUTE_PREFIX}.protocol`;
-var ATTR_PROTOCOL_STEP = `${PROTOCOL_ATTRIBUTE_PREFIX}.protocol.step`;
-var ATTR_PROTOCOL_STEP_RESULT = `${PROTOCOL_ATTRIBUTE_PREFIX}.protocol.step.result`;
 export {
   ADDR_REVERSE_NODE,
   ATTR_PROTOCOL_NAME,
@@ -3442,6 +3903,7 @@ export {
   DEFAULT_EVM_COIN_TYPE,
   ENSNamespaceIds,
   ENSNodeClient,
+  ENS_ROOT,
   ETH_COIN_TYPE,
   ETH_NODE,
   ForwardResolutionProtocolStep,
@@ -3450,6 +3912,9 @@ export {
   LruCache,
   NFTMintStatuses,
   NFTTransferTypes,
+  NameTokenOwnershipTypes,
+  NameTokensResponseCodes,
+  NameTokensResponseErrorCodes,
   OmnichainIndexingStatusIds,
   PROTOCOL_ATTRIBUTE_PREFIX,
   PluginName,
@@ -3482,6 +3947,7 @@ export {
   buildEnsRainbowClientLabelSet,
   buildLabelSetId,
   buildLabelSetVersion,
+  buildPageContext,
   buildUnresolvedIdentity,
   checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill,
   checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted,
@@ -3494,7 +3960,7 @@ export {
   decodeDNSEncodedLiteralName,
   decodeDNSEncodedName,
   decodeEncodedReferrer,
-  deserializeAccountId,
+  deserializeAssetId,
   deserializeBlockNumber,
   deserializeBlockRef,
   deserializeBlockrange,
@@ -3515,18 +3981,30 @@ export {
   deserializeRegistrarActionsResponse,
   deserializeUnixTimestamp,
   deserializeUrl,
+  deserializedNameTokensResponse,
   durationBetween,
   encodeLabelHash,
   evmChainIdToCoinType,
+  formatAccountId,
+  formatAssetId,
   formatNFTTransferEventMetadata,
+  getBasenamesSubregistryId,
+  getBasenamesSubregistryManagedName,
   getCurrencyInfo,
+  getDatasourceContract,
   getENSRootChainId,
   getEthnamesSubregistryId,
+  getEthnamesSubregistryManagedName,
   getLatestIndexedBlockRef,
+  getLineanamesSubregistryId,
+  getLineanamesSubregistryManagedName,
   getNFTTransferType,
   getNameHierarchy,
+  getNameTokenOwnership,
+  getNameWrapperAccounts,
   getOmnichainIndexingCursor,
   getOmnichainIndexingStatus,
+  getParentNameFQDN,
   getResolvePrimaryNameChainIdParam,
   getTimestampForHighestOmnichainKnownBlock,
   getTimestampForLowestOmnichainStartBlock,
@@ -3552,6 +4030,10 @@ export {
   literalLabelsToLiteralName,
   makeENSApiPublicConfigSchema,
   makeSubdomainNode,
+  maybeGetDatasourceContract,
+  nameTokensPrerequisites,
+  parseAccountId,
+  parseAssetId,
   parseNonNegativeInteger,
   parseReverseName,
   priceDai,
@@ -3560,17 +4042,19 @@ export {
   registrarActionsFilter,
   registrarActionsPrerequisites,
   reverseName,
-  serializeAccountId,
   serializeAssetId,
   serializeChainId,
   serializeChainIndexingSnapshots,
   serializeConfigResponse,
   serializeCrossChainIndexingStatusSnapshotOmnichain,
   serializeDatetime,
+  serializeDomainAssetId,
   serializeENSApiPublicConfig,
   serializeENSIndexerPublicConfig,
   serializeIndexedChainIds,
   serializeIndexingStatusResponse,
+  serializeNameToken,
+  serializeNameTokensResponse,
   serializeNamedRegistrarAction,
   serializeOmnichainIndexingStatusSnapshot,
   serializePrice,
@@ -3578,11 +4062,10 @@ export {
   serializeRealtimeIndexingStatusProjection,
   serializeReferrerDetailResponse,
   serializeReferrerLeaderboardPageResponse,
+  serializeRegisteredNameTokens,
   serializeRegistrarAction,
   serializeRegistrarActionPricing,
   serializeRegistrarActionsResponse,
-  serializeRegistrationLifecycle,
-  serializeSubregistry,
   serializeUrl,
   sortChainStatusesByStartBlockAsc,
   stripNullBytes,