@ensnode/ensnode-sdk 1.3.1 → 1.5.0

package/dist/index.js

@@ -2,10 +2,10 @@
 import { prettifyError as prettifyError2, ZodError } from "zod/v4";
 
 // src/ensapi/config/zod-schemas.ts
-import { z as z3 } from "zod/v4";
+import { z as z4 } from "zod/v4";
 
 // src/ensindexer/config/zod-schemas.ts
-import z2 from "zod/v4";
+import { z as z2 } from "zod/v4";
 
 // src/shared/account-id.ts
 import { isAddressEqual } from "viem";
@@ -77,7 +77,7 @@ import { prettifyError } from "zod/v4";
 // src/shared/zod-schemas.ts
 import { AccountId as CaipAccountId } from "caip";
 import { isAddress as isAddress2, isHex as isHex2, size } from "viem";
-import z from "zod/v4";
+import { z } from "zod/v4";
 
 // src/ens/index.ts
 import { getENSRootChainId } from "@ensnode/datasources";
@@ -106,12 +106,14 @@ var bigintToCoinType = (value) => {
 };
 
 // src/ens/constants.ts
-import { namehash } from "viem";
+import { namehash, zeroHash } from "viem";
 var ROOT_NODE = namehash("");
 var ETH_NODE = namehash("eth");
 var BASENAMES_NODE = namehash("base.eth");
 var LINEANAMES_NODE = namehash("linea.eth");
 var ADDR_REVERSE_NODE = namehash("addr.reverse");
+var NODE_ANY = zeroHash;
+var ROOT_RESOURCE = 0n;
 
 // src/ens/dns-encoded-name.ts
 import { bytesToString, hexToBytes } from "viem";
@@ -160,6 +162,10 @@ function isEncodedLabelHash(maybeEncodedLabelHash) {
   return expectedFormatting && includesLabelHash;
 }
 
+// src/ens/fuses.ts
+var PARENT_CANNOT_CONTROL = 65536;
+var isPccFuseSet = (fuses) => (fuses & PARENT_CANNOT_CONTROL) === PARENT_CANNOT_CONTROL;
+
 // src/ens/is-normalized.ts
 import { normalize } from "viem/ens";
 function isNormalizedName(name) {
@@ -330,7 +336,7 @@ function addPrices(...prices) {
   );
 }
 
-// src/shared/reinterpretation.ts
+// src/shared/interpretation/reinterpretation.ts
 import { labelhash as labelToLabelHash } from "viem";
 function reinterpretLabel(label) {
   if (label === "") {
@@ -706,7 +712,9 @@ var TtlCache = class {
 var uniq = (arr) => [...new Set(arr)];
 
 // src/shared/datasource-contract.ts
-import { maybeGetDatasource } from "@ensnode/datasources";
+import {
+  maybeGetDatasource
+} from "@ensnode/datasources";
 var maybeGetDatasourceContract = (namespaceId, datasourceName, contractName) => {
   const datasource = maybeGetDatasource(namespaceId, datasourceName);
   if (!datasource) return void 0;
@@ -726,12 +734,60 @@ var getDatasourceContract = (namespaceId, datasourceName, contractName) => {
   }
   return contract;
 };
+var makeContractMatcher = (namespace, b) => (datasourceName, contractName) => {
+  const a = maybeGetDatasourceContract(namespace, datasourceName, contractName);
+  return a && accountIdEqual(a, b);
+};
+
+// src/shared/interpretation/interpret-address.ts
+import { isAddressEqual as isAddressEqual2, zeroAddress } from "viem";
+var interpretAddress = (owner) => isAddressEqual2(zeroAddress, owner) ? null : owner;
+
+// src/shared/interpretation/interpret-record-values.ts
+import { isAddress as isAddress3, isAddressEqual as isAddressEqual3, zeroAddress as zeroAddress2 } from "viem";
+
+// src/shared/null-bytes.ts
+var hasNullByte = (value) => value.indexOf("\0") !== -1;
+var stripNullBytes = (value) => value.replaceAll("\0", "");
+
+// src/shared/interpretation/interpret-record-values.ts
+function interpretNameRecordValue(value) {
+  if (value === "") return null;
+  if (!isNormalizedName(value)) return null;
+  return value;
+}
+function interpretAddressRecordValue(value) {
+  if (hasNullByte(value)) return null;
+  if (value === "") return null;
+  if (value === "0x") return null;
+  if (!isAddress3(value)) return value;
+  if (isAddressEqual3(value, zeroAddress2)) return null;
+  return asLowerCaseAddress(value);
+}
+function interpretTextRecordKey(key) {
+  if (hasNullByte(key)) return null;
+  if (key === "") return null;
+  return key;
+}
+function interpretTextRecordValue(value) {
+  if (hasNullByte(value)) return null;
+  if (value === "") return null;
+  return value;
+}
+
+// src/shared/interpretation/interpret-tokenid.ts
+var interpretTokenIdAsLabelHash = (tokenId) => uint256ToHex32(tokenId);
+var interpretTokenIdAsNode = (tokenId) => uint256ToHex32(tokenId);
+
+// src/shared/interpretation/interpreted-names-and-labels.ts
+import { isHex as isHex3 } from "viem";
+import { labelhash } from "viem/ens";
 
 // src/shared/labelhash.ts
 import { keccak256 as keccak2562, stringToBytes } from "viem";
 var labelhashLiteralLabel = (label) => keccak2562(stringToBytes(label));
 
-// src/shared/interpretation.ts
+// src/shared/interpretation/interpreted-names-and-labels.ts
 function literalLabelToInterpretedLabel(label) {
   if (isNormalizedLabel(label)) return label;
   return encodeLabelHash(labelhashLiteralLabel(label));
@@ -745,10 +801,39 @@ function interpretedLabelsToInterpretedName(labels) {
 function literalLabelsToLiteralName(labels) {
   return labels.join(".");
 }
-
-// src/shared/null-bytes.ts
-var hasNullByte = (value) => value.indexOf("\0") !== -1;
-var stripNullBytes = (value) => value.replaceAll("\0", "");
+function interpretedNameToInterpretedLabels(name) {
+  return name.split(".");
+}
+function encodedLabelToLabelhash(label) {
+  if (label.length !== 66) return null;
+  if (label.indexOf("[") !== 0) return null;
+  if (label.indexOf("]") !== 65) return null;
+  const hash = `0x${label.slice(1, 65)}`;
+  if (!isHex3(hash)) return null;
+  return hash;
+}
+function isInterpetedLabel(label) {
+  if (label.startsWith("[")) {
+    const labelHash = encodedLabelToLabelhash(label);
+    if (labelHash === null) return false;
+  }
+  return isNormalizedLabel(label);
+}
+function isInterpretedName(name) {
+  return name.split(".").every(isInterpetedLabel);
+}
+function interpretedNameToLabelHashPath(name) {
+  return interpretedNameToInterpretedLabels(name).map((label) => {
+    if (!isInterpetedLabel(label)) {
+      throw new Error(
+        `Invariant(interpretedNameToLabelHashPath): Expected InterpretedLabel, received '${label}'.`
+      );
+    }
+    const maybeLabelHash = encodedLabelToLabelhash(label);
+    if (maybeLabelHash !== null) return maybeLabelHash;
+    return labelhash(label);
+  }).toReversed();
+}
 
 // src/shared/numbers.ts
 function bigIntToNumber(n) {
@@ -765,8 +850,16 @@ function bigIntToNumber(n) {
   return Number(n);
 }
 
+// src/shared/root-registry.ts
+import { DatasourceNames } from "@ensnode/datasources";
+var getENSv1Registry = (namespace) => getDatasourceContract(namespace, DatasourceNames.ENSRoot, "ENSv1Registry");
+var isENSv1Registry = (namespace, contract) => accountIdEqual(getENSv1Registry(namespace), contract);
+var getENSv2RootRegistry = (namespace) => getDatasourceContract(namespace, DatasourceNames.ENSRoot, "RootRegistry");
+var getENSv2RootRegistryId = (namespace) => makeRegistryId(getENSv2RootRegistry(namespace));
+var isENSv2RootRegistry = (namespace, contract) => accountIdEqual(getENSv2RootRegistry(namespace), contract);
+
 // src/shared/serialize.ts
-import { AccountId as CaipAccountId2 } from "caip";
+import { AccountId as CaipAccountId2, AssetId as CaipAssetId } from "caip";
 function serializeChainId(chainId) {
   return chainId.toString();
 }
@@ -791,6 +884,23 @@ function formatAccountId(accountId) {
     address: accountId.address
   }).toLowerCase();
 }
+function formatAssetId({
+  assetNamespace,
+  contract: { chainId, address },
+  tokenId
+}) {
+  return CaipAssetId.format({
+    chainId: { namespace: "eip155", reference: chainId.toString() },
+    assetName: { namespace: assetNamespace, reference: address },
+    tokenId: uint256ToHex32(tokenId)
+  }).toLowerCase();
+}
+
+// src/shared/types.ts
+var AssetNamespaces = {
+  ERC721: "erc721",
+  ERC1155: "erc1155"
+};
 
 // src/shared/url.ts
 function isHttpProtocol(url) {
@@ -812,6 +922,7 @@ var PluginName = /* @__PURE__ */ ((PluginName2) => {
   PluginName2["ProtocolAcceleration"] = "protocol-acceleration";
   PluginName2["Registrars"] = "registrars";
   PluginName2["TokenScope"] = "tokenscope";
+  PluginName2["ENSv2"] = "ensv2";
   return PluginName2;
 })(PluginName || {});
 
@@ -908,20 +1019,29 @@ var makeENSIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") =
   versionInfo: makeENSIndexerVersionInfoSchema(`${valueLabel}.versionInfo`)
 }).check(invariant_isSubgraphCompatibleRequirements);
 
-// src/ensapi/config/zod-schemas.ts
+// src/shared/config/thegraph.ts
+import { z as z3 } from "zod/v4";
 var TheGraphCannotFallbackReasonSchema = z3.enum({
   NotSubgraphCompatible: "not-subgraph-compatible",
   NoApiKey: "no-api-key",
   NoSubgraphUrl: "no-subgraph-url"
 });
-var TheGraphFallbackSchema = z3.strictObject({
-  canFallback: z3.boolean(),
-  reason: TheGraphCannotFallbackReasonSchema.nullable()
-});
+var TheGraphFallbackSchema = z3.discriminatedUnion("canFallback", [
+  z3.strictObject({
+    canFallback: z3.literal(true),
+    url: z3.string()
+  }),
+  z3.strictObject({
+    canFallback: z3.literal(false),
+    reason: TheGraphCannotFallbackReasonSchema
+  })
+]);
+
+// src/ensapi/config/zod-schemas.ts
 function makeENSApiPublicConfigSchema(valueLabel) {
   const label = valueLabel ?? "ENSApiPublicConfig";
-  return z3.strictObject({
-    version: z3.string().min(1, `${label}.version must be a non-empty string`),
+  return z4.strictObject({
+    version: z4.string().min(1, `${label}.version must be a non-empty string`),
     theGraphFallback: TheGraphFallbackSchema,
     ensIndexerPublicConfig: makeENSIndexerPublicConfigSchema(`${label}.ensIndexerPublicConfig`)
   });
@@ -1064,7 +1184,7 @@ function serializeENSIndexerPublicConfig(config) {
 import { prettifyError as prettifyError4 } from "zod/v4";
 
 // src/ensindexer/indexing-status/zod-schemas.ts
-import z4 from "zod/v4";
+import { z as z5 } from "zod/v4";
 
 // src/ensindexer/indexing-status/types.ts
 var ChainIndexingConfigTypeIds = {
@@ -1490,7 +1610,7 @@ function invariant_snapshotTimeIsTheHighestKnownBlockTimestamp(ctx) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
-      message: `'snapshotTime' must be greater than or equal to  the "highest known block timestamp" (${highestKnownBlockTimestamp})`
+      message: `'snapshotTime' (${snapshotTime}) must be greater than or equal to the "highest known block timestamp" (${highestKnownBlockTimestamp})`
     });
   }
 }
@@ -1520,52 +1640,52 @@ function invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect(ct
 }
 
 // src/ensindexer/indexing-status/zod-schemas.ts
-var makeChainIndexingConfigSchema = (valueLabel = "Value") => z4.discriminatedUnion("configType", [
-  z4.strictObject({
-    configType: z4.literal(ChainIndexingConfigTypeIds.Indefinite),
+var makeChainIndexingConfigSchema = (valueLabel = "Value") => z5.discriminatedUnion("configType", [
+  z5.strictObject({
+    configType: z5.literal(ChainIndexingConfigTypeIds.Indefinite),
     startBlock: makeBlockRefSchema(valueLabel)
   }),
-  z4.strictObject({
-    configType: z4.literal(ChainIndexingConfigTypeIds.Definite),
+  z5.strictObject({
+    configType: z5.literal(ChainIndexingConfigTypeIds.Definite),
     startBlock: makeBlockRefSchema(valueLabel),
     endBlock: makeBlockRefSchema(valueLabel)
   })
 ]);
-var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => z4.strictObject({
-  chainStatus: z4.literal(ChainIndexingStatusIds.Queued),
+var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => z5.strictObject({
+  chainStatus: z5.literal(ChainIndexingStatusIds.Queued),
   config: makeChainIndexingConfigSchema(valueLabel)
 }).check(invariant_chainSnapshotQueuedBlocks);
-var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => z4.strictObject({
-  chainStatus: z4.literal(ChainIndexingStatusIds.Backfill),
+var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => z5.strictObject({
+  chainStatus: z5.literal(ChainIndexingStatusIds.Backfill),
   config: makeChainIndexingConfigSchema(valueLabel),
   latestIndexedBlock: makeBlockRefSchema(valueLabel),
   backfillEndBlock: makeBlockRefSchema(valueLabel)
 }).check(invariant_chainSnapshotBackfillBlocks);
-var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => z4.strictObject({
-  chainStatus: z4.literal(ChainIndexingStatusIds.Completed),
-  config: z4.strictObject({
-    configType: z4.literal(ChainIndexingConfigTypeIds.Definite),
+var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => z5.strictObject({
+  chainStatus: z5.literal(ChainIndexingStatusIds.Completed),
+  config: z5.strictObject({
+    configType: z5.literal(ChainIndexingConfigTypeIds.Definite),
     startBlock: makeBlockRefSchema(valueLabel),
     endBlock: makeBlockRefSchema(valueLabel)
   }),
   latestIndexedBlock: makeBlockRefSchema(valueLabel)
 }).check(invariant_chainSnapshotCompletedBlocks);
-var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => z4.strictObject({
-  chainStatus: z4.literal(ChainIndexingStatusIds.Following),
-  config: z4.strictObject({
-    configType: z4.literal(ChainIndexingConfigTypeIds.Indefinite),
+var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => z5.strictObject({
+  chainStatus: z5.literal(ChainIndexingStatusIds.Following),
+  config: z5.strictObject({
+    configType: z5.literal(ChainIndexingConfigTypeIds.Indefinite),
     startBlock: makeBlockRefSchema(valueLabel)
   }),
   latestIndexedBlock: makeBlockRefSchema(valueLabel),
   latestKnownBlock: makeBlockRefSchema(valueLabel)
 }).check(invariant_chainSnapshotFollowingBlocks);
-var makeChainIndexingStatusSnapshotSchema = (valueLabel = "Value") => z4.discriminatedUnion("chainStatus", [
+var makeChainIndexingStatusSnapshotSchema = (valueLabel = "Value") => z5.discriminatedUnion("chainStatus", [
   makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
   makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
   makeChainIndexingStatusSnapshotCompletedSchema(valueLabel),
   makeChainIndexingStatusSnapshotFollowingSchema(valueLabel)
 ]);
-var makeChainIndexingStatusesSchema = (valueLabel = "Value") => z4.record(makeChainIdStringSchema(), makeChainIndexingStatusSnapshotSchema(valueLabel), {
+var makeChainIndexingStatusesSchema = (valueLabel = "Value") => z5.record(makeChainIdStringSchema(), makeChainIndexingStatusSnapshotSchema(valueLabel), {
   error: "Chains indexing statuses must be an object mapping valid chain IDs to their indexing status snapshots."
 }).transform((serializedChainsIndexingStatus) => {
   const chainsIndexingStatus = /* @__PURE__ */ new Map();
@@ -1574,29 +1694,29 @@ var makeChainIndexingStatusesSchema = (valueLabel = "Value") => z4.record(makeCh
   }
   return chainsIndexingStatus;
 });
-var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => z4.strictObject({
-  omnichainStatus: z4.literal(OmnichainIndexingStatusIds.Unstarted),
+var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => z5.strictObject({
+  omnichainStatus: z5.literal(OmnichainIndexingStatusIds.Unstarted),
   chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainSnapshotUnstartedHasValidChains).transform((chains) => chains),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => z4.strictObject({
-  omnichainStatus: z4.literal(OmnichainIndexingStatusIds.Backfill),
+var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => z5.strictObject({
+  omnichainStatus: z5.literal(OmnichainIndexingStatusIds.Backfill),
   chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotBackfillHasValidChains).transform(
     (chains) => chains
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => z4.strictObject({
-  omnichainStatus: z4.literal(OmnichainIndexingStatusIds.Completed),
+var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => z5.strictObject({
+  omnichainStatus: z5.literal(OmnichainIndexingStatusIds.Completed),
   chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotCompletedHasValidChains).transform((chains) => chains),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => z4.strictObject({
-  omnichainStatus: z4.literal(OmnichainIndexingStatusIds.Following),
+var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => z5.strictObject({
+  omnichainStatus: z5.literal(OmnichainIndexingStatusIds.Following),
   chains: makeChainIndexingStatusesSchema(valueLabel),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => z4.discriminatedUnion("omnichainStatus", [
+var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => z5.discriminatedUnion("omnichainStatus", [
   makeOmnichainIndexingStatusSnapshotUnstartedSchema(valueLabel),
   makeOmnichainIndexingStatusSnapshotBackfillSchema(valueLabel),
   makeOmnichainIndexingStatusSnapshotCompletedSchema(valueLabel),
@@ -1604,16 +1724,16 @@ var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexin
 ]).check(invariant_omnichainSnapshotStatusIsConsistentWithChainSnapshot).check(invariant_omnichainIndexingCursorLowerThanEarliestStartBlockAcrossQueuedChains).check(
   invariant_omnichainIndexingCursorLowerThanOrEqualToLatestBackfillEndBlockAcrossBackfillChains
 ).check(invariant_omnichainIndexingCursorIsEqualToHighestLatestIndexedBlockAcrossIndexedChain);
-var makeCrossChainIndexingStatusSnapshotOmnichainSchema = (valueLabel = "Cross-chain Indexing Status Snapshot Omnichain") => z4.strictObject({
-  strategy: z4.literal(CrossChainIndexingStrategyIds.Omnichain),
+var makeCrossChainIndexingStatusSnapshotOmnichainSchema = (valueLabel = "Cross-chain Indexing Status Snapshot Omnichain") => z5.strictObject({
+  strategy: z5.literal(CrossChainIndexingStrategyIds.Omnichain),
   slowestChainIndexingCursor: makeUnixTimestampSchema(valueLabel),
   snapshotTime: makeUnixTimestampSchema(valueLabel),
   omnichainSnapshot: makeOmnichainIndexingStatusSnapshotSchema(valueLabel)
 }).check(invariant_slowestChainEqualsToOmnichainSnapshotTime).check(invariant_snapshotTimeIsTheHighestKnownBlockTimestamp);
-var makeCrossChainIndexingStatusSnapshotSchema = (valueLabel = "Cross-chain Indexing Status Snapshot") => z4.discriminatedUnion("strategy", [
+var makeCrossChainIndexingStatusSnapshotSchema = (valueLabel = "Cross-chain Indexing Status Snapshot") => z5.discriminatedUnion("strategy", [
   makeCrossChainIndexingStatusSnapshotOmnichainSchema(valueLabel)
 ]);
-var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => z4.strictObject({
+var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => z5.strictObject({
   projectedAt: makeUnixTimestampSchema(valueLabel),
   worstCaseDistance: makeDurationSchema(valueLabel),
   snapshot: makeCrossChainIndexingStatusSnapshotSchema(valueLabel)
@@ -1761,7 +1881,7 @@ function serializeConfigResponse(response) {
 import { prettifyError as prettifyError5 } from "zod/v4";
 
 // src/api/indexing-status/zod-schemas.ts
-import z5 from "zod/v4";
+import z6 from "zod/v4";
 
 // src/api/indexing-status/response.ts
 var IndexingStatusResponseCodes = {
@@ -1776,14 +1896,14 @@ var IndexingStatusResponseCodes = {
 };
 
 // src/api/indexing-status/zod-schemas.ts
-var makeIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => z5.strictObject({
-  responseCode: z5.literal(IndexingStatusResponseCodes.Ok),
+var makeIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => z6.strictObject({
+  responseCode: z6.literal(IndexingStatusResponseCodes.Ok),
   realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel)
 });
-var makeIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => z5.strictObject({
-  responseCode: z5.literal(IndexingStatusResponseCodes.Error)
+var makeIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => z6.strictObject({
+  responseCode: z6.literal(IndexingStatusResponseCodes.Error)
 });
-var makeIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => z5.discriminatedUnion("responseCode", [
+var makeIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => z6.discriminatedUnion("responseCode", [
   makeIndexingStatusResponseOkSchema(valueLabel),
   makeIndexingStatusResponseErrorSchema(valueLabel)
 ]);
@@ -1817,21 +1937,20 @@ import { prettifyError as prettifyError7 } from "zod/v4";
 
 // src/api/name-tokens/zod-schemas.ts
 import { namehash as namehash2 } from "viem";
-import z8 from "zod/v4";
+import z9 from "zod/v4";
 
 // src/tokenscope/assets.ts
-import { AssetId as CaipAssetId2 } from "caip";
-import { isAddressEqual as isAddressEqual3, zeroAddress as zeroAddress3 } from "viem";
+import { isAddressEqual as isAddressEqual5, zeroAddress as zeroAddress5 } 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";
+import { AssetId as CaipAssetId2 } from "caip";
+import { zeroAddress as zeroAddress4 } from "viem";
+import z7 from "zod/v4";
 
 // src/tokenscope/name-token.ts
-import { isAddressEqual as isAddressEqual2, zeroAddress } from "viem";
-import { DatasourceNames } from "@ensnode/datasources";
+import { isAddressEqual as isAddressEqual4, zeroAddress as zeroAddress3 } from "viem";
+import { DatasourceNames as DatasourceNames2 } from "@ensnode/datasources";
 var NameTokenOwnershipTypes = {
   /**
    * Name Token is owned by NameWrapper account.
@@ -1862,12 +1981,12 @@ function serializeNameToken(nameToken) {
 function getNameWrapperAccounts(namespaceId) {
   const ethnamesNameWrapperAccount = getDatasourceContract(
     namespaceId,
-    DatasourceNames.ENSRoot,
+    DatasourceNames2.ENSRoot,
     "NameWrapper"
   );
   const lineanamesNameWrapperAccount = maybeGetDatasourceContract(
     namespaceId,
-    DatasourceNames.Lineanames,
+    DatasourceNames2.Lineanames,
     "NameWrapper"
   );
   const nameWrapperAccounts = [
@@ -1890,7 +2009,7 @@ function getNameTokenOwnership(namespaceId, name, owner) {
       owner
     };
   }
-  if (isAddressEqual2(owner.address, zeroAddress)) {
+  if (isAddressEqual4(owner.address, zeroAddress3)) {
     return {
       ownershipType: NameTokenOwnershipTypes.Burned,
       owner
@@ -1910,14 +2029,28 @@ function getNameTokenOwnership(namespaceId, name, owner) {
 }
 
 // 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) => {
+var tokenIdSchemaSerializable = z7.string();
+var tokenIdSchemaNative = z7.preprocess(
+  (v) => typeof v === "string" ? BigInt(v) : v,
+  z7.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 z7.object({
+    assetNamespace: z7.enum(AssetNamespaces),
+    contract: makeAccountIdSchema(valueLabel),
+    tokenId: makeTokenIdSchema(valueLabel, serializable ?? false)
+  });
+};
+var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => z7.preprocess((v) => {
   if (typeof v === "string") {
-    const result = new CaipAssetId(v);
+    const result = new CaipAssetId2(v);
     return {
       assetNamespace: result.assetName.namespace,
       contract: {
@@ -1931,7 +2064,7 @@ var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => z6.prep
 }, makeAssetIdSchema(valueLabel));
 function invariant_nameTokenOwnershipHasNonZeroAddressOwner(ctx) {
   const ownership = ctx.value;
-  if (ctx.value.owner.address === zeroAddress2) {
+  if (ctx.value.owner.address === zeroAddress4) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
@@ -1939,25 +2072,25 @@ function invariant_nameTokenOwnershipHasNonZeroAddressOwner(ctx) {
     });
   }
 }
-var makeNameTokenOwnershipNameWrapperSchema = (valueLabel = "Name Token Ownership NameWrapper") => z6.object({
-  ownershipType: z6.literal(NameTokenOwnershipTypes.NameWrapper),
+var makeNameTokenOwnershipNameWrapperSchema = (valueLabel = "Name Token Ownership NameWrapper") => z7.object({
+  ownershipType: z7.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),
+var makeNameTokenOwnershipFullyOnchainSchema = (valueLabel = "Name Token Ownership Fully Onchain") => z7.object({
+  ownershipType: z7.literal(NameTokenOwnershipTypes.FullyOnchain),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
-var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => z6.object({
-  ownershipType: z6.literal(NameTokenOwnershipTypes.Burned),
+var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => z7.object({
+  ownershipType: z7.literal(NameTokenOwnershipTypes.Burned),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasZeroAddressOwner);
-var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => z6.object({
-  ownershipType: z6.literal(NameTokenOwnershipTypes.Unknown),
+var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => z7.object({
+  ownershipType: z7.literal(NameTokenOwnershipTypes.Unknown),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
 function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
   const ownership = ctx.value;
-  if (ctx.value.owner.address !== zeroAddress2) {
+  if (ctx.value.owner.address !== zeroAddress4) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
@@ -1965,23 +2098,19 @@ function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
     });
   }
 }
-var makeNameTokenOwnershipSchema = (valueLabel = "Name Token Ownership") => z6.discriminatedUnion("ownershipType", [
+var makeNameTokenOwnershipSchema = (valueLabel = "Name Token Ownership") => z7.discriminatedUnion("ownershipType", [
   makeNameTokenOwnershipNameWrapperSchema(valueLabel),
   makeNameTokenOwnershipFullyOnchainSchema(valueLabel),
   makeNameTokenOwnershipBurnedSchema(valueLabel),
   makeNameTokenOwnershipUnknownSchema(valueLabel)
 ]);
-var makeNameTokenSchema = (valueLabel = "Name Token Schema") => z6.object({
-  token: makeAssetIdSchema(`${valueLabel}.token`),
+var makeNameTokenSchema = (valueLabel = "Name Token Schema", serializable) => z7.object({
+  token: makeAssetIdSchema(`${valueLabel}.token`, serializable),
   ownership: makeNameTokenOwnershipSchema(`${valueLabel}.ownership`),
-  mintStatus: z6.enum(NFTMintStatuses)
+  mintStatus: z7.enum(NFTMintStatuses)
 });
 
 // src/tokenscope/assets.ts
-var AssetNamespaces = {
-  ERC721: "erc721",
-  ERC1155: "erc1155"
-};
 function serializeAssetId(assetId) {
   return {
     assetNamespace: assetId.assetNamespace,
@@ -1999,14 +2128,6 @@ ${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);
@@ -2035,13 +2156,13 @@ var NFTMintStatuses = {
   Burned: "burned"
 };
 var formatNFTTransferEventMetadata = (metadata) => {
-  const serializedAssetId = serializeAssetId(metadata.nft);
+  const assetIdString = formatAssetId(metadata.nft);
   return [
     `Event: ${metadata.eventHandlerName}`,
     `Chain ID: ${metadata.chainId}`,
     `Block Number: ${metadata.blockNumber}`,
     `Transaction Hash: ${metadata.transactionHash}`,
-    `NFT: ${serializedAssetId}`
+    `NFT: ${assetIdString}`
   ].map((line) => ` - ${line}`).join("\n");
 };
 var NFTTransferTypes = {
@@ -2147,11 +2268,11 @@ var NFTTransferTypes = {
 };
 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)) {
+  const isIndexedAsMinted = isIndexed && !isAddressEqual5(currentlyIndexedOwner, zeroAddress5);
+  const isMint = isAddressEqual5(from, zeroAddress5);
+  const isBurn = isAddressEqual5(to, zeroAddress5);
+  const isSelfTransfer = isAddressEqual5(from, to);
+  if (isIndexed && !isAddressEqual5(currentlyIndexedOwner, from)) {
     if (isMint && allowMintedRemint) {
     } else {
       throw new Error(
@@ -2234,10 +2355,10 @@ ${formatNFTTransferEventMetadata(metadata)}`
 };
 
 // src/api/shared/errors/zod-schemas.ts
-import z7 from "zod/v4";
-var ErrorResponseSchema = z7.object({
-  message: z7.string(),
-  details: z7.optional(z7.unknown())
+import z8 from "zod/v4";
+var ErrorResponseSchema = z8.object({
+  message: z8.string(),
+  details: z8.optional(z8.unknown())
 });
 
 // src/api/name-tokens/response.ts
@@ -2276,7 +2397,13 @@ var NameTokensResponseErrorCodes = {
 };
 
 // src/api/name-tokens/zod-schemas.ts
-function invariant_nameIsAssociatedWithDomainId(ctx) {
+var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", serializable) => z9.object({
+  domainId: makeNodeSchema(`${valueLabel}.domainId`),
+  name: makeReinterpretedNameSchema(valueLabel),
+  tokens: z9.array(makeNameTokenSchema(`${valueLabel}.tokens`, serializable)).nonempty(),
+  expiresAt: makeUnixTimestampSchema(`${valueLabel}.expiresAt`),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
+}).check(function invariant_nameIsAssociatedWithDomainId(ctx) {
   const { name, domainId } = ctx.value;
   if (namehash2(name) !== domainId) {
     ctx.issues.push({
@@ -2285,24 +2412,24 @@ function invariant_nameIsAssociatedWithDomainId(ctx) {
       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`
-    });
+}).check(
+  function invariant_nameTokensOwnershipTypeNameWrapperRequiresOwnershipTypeFullyOnchainOrUnknown(ctx) {
+    const { tokens } = ctx.value;
+    const containsOwnershipNameWrapper = tokens.some(
+      (t) => t.ownership.ownershipType === NameTokenOwnershipTypes.NameWrapper
+    );
+    const containsOwnershipFullyOnchainOrUnknown = tokens.some(
+      (t) => t.ownership.ownershipType === NameTokenOwnershipTypes.FullyOnchain || t.ownership.ownershipType === NameTokenOwnershipTypes.Unknown
+    );
+    if (containsOwnershipNameWrapper && !containsOwnershipFullyOnchainOrUnknown) {
+      ctx.issues.push({
+        code: "custom",
+        input: ctx.value,
+        message: `'tokens' must contain name token with ownership type 'fully-onchain' or 'unknown' when name token with ownership type 'namewrapper' in listed`
+      });
+    }
   }
-}
-function invariant_nameTokensContainAtMostOneWithOwnershipTypeEffective(ctx) {
+).check(function invariant_nameTokensContainAtMostOneWithOwnershipTypeEffective(ctx) {
   const { tokens } = ctx.value;
   const tokensCountWithOwnershipFullyOnchain = tokens.filter(
     (t) => t.ownership.ownershipType === NameTokenOwnershipTypes.FullyOnchain
@@ -2314,46 +2441,43 @@ function invariant_nameTokensContainAtMostOneWithOwnershipTypeEffective(ctx) {
       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),
+var makeNameTokensResponseOkSchema = (valueLabel = "Name Tokens Response OK", serializable) => z9.strictObject({
+  responseCode: z9.literal(NameTokensResponseCodes.Ok),
+  registeredNameTokens: makeRegisteredNameTokenSchema(`${valueLabel}.nameTokens`, serializable)
+});
+var makeNameTokensResponseErrorNameTokensNotIndexedSchema = (_valueLabel = "Name Tokens Response Error Name Not Indexed") => z9.strictObject({
+  responseCode: z9.literal(NameTokensResponseCodes.Error),
+  errorCode: z9.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),
+var makeNameTokensResponseErrorEnsIndexerConfigUnsupported = (_valueLabel = "Name Tokens Response Error ENSIndexer Config Unsupported") => z9.strictObject({
+  responseCode: z9.literal(NameTokensResponseCodes.Error),
+  errorCode: z9.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),
+var makeNameTokensResponseErrorNameIndexingStatusUnsupported = (_valueLabel = "Name Tokens Response Error Indexing Status Unsupported") => z9.strictObject({
+  responseCode: z9.literal(NameTokensResponseCodes.Error),
+  errorCode: z9.literal(NameTokensResponseErrorCodes.IndexingStatusUnsupported),
   error: ErrorResponseSchema
 });
-var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => z8.discriminatedUnion("errorCode", [
+var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => z9.discriminatedUnion("errorCode", [
   makeNameTokensResponseErrorNameTokensNotIndexedSchema(valueLabel),
   makeNameTokensResponseErrorEnsIndexerConfigUnsupported(valueLabel),
   makeNameTokensResponseErrorNameIndexingStatusUnsupported(valueLabel)
 ]);
-var makeNameTokensResponseSchema = (valueLabel = "Name Tokens Response") => z8.discriminatedUnion("responseCode", [
-  makeNameTokensResponseOkSchema(valueLabel),
-  makeNameTokensResponseErrorSchema(valueLabel)
-]);
+var makeNameTokensResponseSchema = (valueLabel = "Name Tokens Response", serializable) => {
+  return z9.discriminatedUnion("responseCode", [
+    makeNameTokensResponseOkSchema(valueLabel, serializable ?? false),
+    makeNameTokensResponseErrorSchema(valueLabel)
+  ]);
+};
 
 // src/api/name-tokens/deserialize.ts
 function deserializedNameTokensResponse(maybeResponse) {
-  const parsed = makeNameTokensResponseSchema().safeParse(maybeResponse);
+  const parsed = makeNameTokensResponseSchema("Name Tokens Response", false).safeParse(
+    maybeResponse
+  );
   if (parsed.error) {
     throw new Error(`Cannot deserialize NameTokensResponse:
 ${prettifyError7(parsed.error)}
@@ -2434,13 +2558,13 @@ 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";
+import z12 from "zod/v4";
 
 // ../ens-referrals/src/address.ts
-import { isAddress as isAddress3 } from "viem";
+import { isAddress as isAddress4 } from "viem";
 
 // ../ens-referrals/src/encoding.ts
-import { getAddress, pad, size as size2, slice, zeroAddress as zeroAddress4 } from "viem";
+import { getAddress, pad, size as size2, slice, zeroAddress as zeroAddress6 } from "viem";
 var ENCODED_REFERRER_BYTE_OFFSET = 12;
 var ENCODED_REFERRER_BYTE_LENGTH = 32;
 var EXPECTED_ENCODED_REFERRER_PADDING = pad("0x", {
@@ -2459,7 +2583,7 @@ function decodeEncodedReferrer(encodedReferrer) {
   }
   const padding = slice(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
   if (padding !== EXPECTED_ENCODED_REFERRER_PADDING) {
-    return zeroAddress4;
+    return zeroAddress6;
   }
   const decodedReferrer = slice(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
   try {
@@ -2488,7 +2612,7 @@ var ReferrerDetailTypeIds = {
 };
 
 // src/registrars/zod-schemas.ts
-import z9 from "zod/v4";
+import { z as z10 } from "zod/v4";
 
 // src/registrars/registrar-action.ts
 var RegistrarActionTypes = {
@@ -2529,11 +2653,11 @@ function serializeRegistrarAction(registrarAction) {
 }
 
 // src/registrars/zod-schemas.ts
-var makeSubregistrySchema = (valueLabel = "Subregistry") => z9.object({
+var makeSubregistrySchema = (valueLabel = "Subregistry") => z10.object({
   subregistryId: makeAccountIdSchema(`${valueLabel} Subregistry ID`),
   node: makeNodeSchema(`${valueLabel} Node`)
 });
-var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => z9.object({
+var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => z10.object({
   subregistry: makeSubregistrySchema(`${valueLabel} Subregistry`),
   node: makeNodeSchema(`${valueLabel} Node`),
   expiresAt: makeUnixTimestampSchema(`${valueLabel} Expires at`)
@@ -2549,18 +2673,18 @@ function invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium(ctx) {
     });
   }
 }
-var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => z9.union([
+var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => z10.union([
   // pricing available
-  z9.object({
+  z10.object({
     baseCost: makePriceEthSchema(`${valueLabel} Base Cost`),
     premium: makePriceEthSchema(`${valueLabel} Premium`),
     total: makePriceEthSchema(`${valueLabel} Total`)
   }).check(invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium).transform((v) => v),
   // pricing unknown
-  z9.object({
-    baseCost: z9.null(),
-    premium: z9.null(),
-    total: z9.null()
+  z10.object({
+    baseCost: z10.null(),
+    premium: z10.null(),
+    total: z10.null()
   }).transform((v) => v)
 ]);
 function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
@@ -2583,9 +2707,9 @@ function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
     });
   }
 }
-var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => z9.union([
+var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => z10.union([
   // referral available
-  z9.object({
+  z10.object({
     encodedReferrer: makeHexStringSchema(
       { bytesCount: ENCODED_REFERRER_BYTE_LENGTH },
       `${valueLabel} Encoded Referrer`
@@ -2593,9 +2717,9 @@ var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral
     decodedReferrer: makeLowercaseAddressSchema(`${valueLabel} Decoded Referrer`)
   }).check(invariant_registrarActionDecodedReferrerBasedOnRawReferrer),
   // referral not applicable
-  z9.object({
-    encodedReferrer: z9.null(),
-    decodedReferrer: z9.null()
+  z10.object({
+    encodedReferrer: z10.null(),
+    decodedReferrer: z10.null()
   })
 ]);
 function invariant_eventIdsInitialElementIsTheActionId(ctx) {
@@ -2608,9 +2732,9 @@ function invariant_eventIdsInitialElementIsTheActionId(ctx) {
     });
   }
 }
-var EventIdSchema = z9.string().nonempty();
-var EventIdsSchema = z9.array(EventIdSchema).min(1).transform((v) => v);
-var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => z9.object({
+var EventIdSchema = z10.string().nonempty();
+var EventIdsSchema = z10.array(EventIdSchema).min(1).transform((v) => v);
+var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => z10.object({
   id: EventIdSchema,
   incrementalDuration: makeDurationSchema(`${valueLabel} Incremental Duration`),
   registrant: makeLowercaseAddressSchema(`${valueLabel} Registrant`),
@@ -2624,38 +2748,38 @@ var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => z9
   eventIds: EventIdsSchema
 }).check(invariant_eventIdsInitialElementIsTheActionId);
 var makeRegistrarActionRegistrationSchema = (valueLabel = "Registration ") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: z9.literal(RegistrarActionTypes.Registration)
+  type: z10.literal(RegistrarActionTypes.Registration)
 });
 var makeRegistrarActionRenewalSchema = (valueLabel = "Renewal") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: z9.literal(RegistrarActionTypes.Renewal)
+  type: z10.literal(RegistrarActionTypes.Renewal)
 });
-var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => z9.discriminatedUnion("type", [
+var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => z10.discriminatedUnion("type", [
   makeRegistrarActionRegistrationSchema(`${valueLabel} Registration`),
   makeRegistrarActionRenewalSchema(`${valueLabel} Renewal`)
 ]);
 
 // src/api/shared/pagination/zod-schemas.ts
-import z10 from "zod/v4";
+import z11 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({
+var makeRequestPageParamsSchema = (valueLabel = "RequestPageParams") => z11.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()
+var makeResponsePageContextSchemaWithNoRecords = (valueLabel = "ResponsePageContextWithNoRecords") => z11.object({
+  totalRecords: z11.literal(0),
+  totalPages: z11.literal(1),
+  hasNext: z11.literal(false),
+  hasPrev: z11.literal(false),
+  startIndex: z11.undefined(),
+  endIndex: z11.undefined()
 }).extend(makeRequestPageParamsSchema(valueLabel).shape);
 function invariant_responsePageWithRecordsIsCorrect(ctx) {
   const { hasNext, hasPrev, recordsPerPage, page, totalRecords, startIndex, endIndex } = ctx.value;
@@ -2690,15 +2814,15 @@ function invariant_responsePageWithRecordsIsCorrect(ctx) {
     });
   }
 }
-var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => z10.object({
+var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => z11.object({
   totalRecords: makePositiveIntegerSchema(`${valueLabel}.totalRecords`),
   totalPages: makePositiveIntegerSchema(`${valueLabel}.totalPages`),
-  hasNext: z10.boolean(),
-  hasPrev: z10.boolean(),
+  hasNext: z11.boolean(),
+  hasPrev: z11.boolean(),
   startIndex: makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`),
   endIndex: makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`)
 }).extend(makeRequestPageParamsSchema(valueLabel).shape).check(invariant_responsePageWithRecordsIsCorrect);
-var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => z10.union([
+var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => z11.union([
   makeResponsePageContextSchemaWithNoRecords(valueLabel),
   makeResponsePageContextSchemaWithRecords(valueLabel)
 ]);
@@ -2728,20 +2852,21 @@ function invariant_registrationLifecycleNodeMatchesName(ctx) {
     });
   }
 }
-var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => z11.object({
+var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => z12.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 makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => z12.object({
+  responseCode: z12.literal(RegistrarActionsResponseCodes.Ok),
+  registrarActions: z12.array(makeNamedRegistrarActionSchema(valueLabel)),
+  pageContext: makeResponsePageContextSchema(`${valueLabel}.pageContext`),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`).optional()
 });
-var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => z11.strictObject({
-  responseCode: z11.literal(RegistrarActionsResponseCodes.Error),
+var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => z12.strictObject({
+  responseCode: z12.literal(RegistrarActionsResponseCodes.Error),
   error: ErrorResponseSchema
 });
-var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => z11.discriminatedUnion("responseCode", [
+var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => z12.discriminatedUnion("responseCode", [
   makeRegistrarActionsResponseOkSchema(valueLabel),
   makeRegistrarActionsResponseErrorSchema(valueLabel)
 ]);
@@ -2763,7 +2888,9 @@ ${prettifyError8(parsed.error)}
 var RegistrarActionsFilterTypes = {
   BySubregistryNode: "bySubregistryNode",
   WithEncodedReferral: "withEncodedReferral",
-  ByDecodedReferrer: "byDecodedReferrer"
+  ByDecodedReferrer: "byDecodedReferrer",
+  BeginTimestamp: "beginTimestamp",
+  EndTimestamp: "endTimestamp"
 };
 var RegistrarActionsOrders = {
   LatestRegistrarActions: "orderBy[timestamp]=desc"
@@ -2796,10 +2923,30 @@ function byDecodedReferrer(decodedReferrer) {
     value: decodedReferrer
   };
 }
+function beginTimestamp(timestamp) {
+  if (typeof timestamp === "undefined") {
+    return void 0;
+  }
+  return {
+    filterType: RegistrarActionsFilterTypes.BeginTimestamp,
+    value: timestamp
+  };
+}
+function endTimestamp(timestamp) {
+  if (typeof timestamp === "undefined") {
+    return void 0;
+  }
+  return {
+    filterType: RegistrarActionsFilterTypes.EndTimestamp,
+    value: timestamp
+  };
+}
 var registrarActionsFilter = {
   byParentNode,
   withReferral,
-  byDecodedReferrer
+  byDecodedReferrer,
+  beginTimestamp,
+  endTimestamp
 };
 
 // src/api/registrar-actions/prerequisites.ts
@@ -2854,14 +3001,14 @@ var registrarActionsPrerequisites = Object.freeze({
 
 // src/registrars/basenames-subregistry.ts
 import {
-  DatasourceNames as DatasourceNames2,
+  DatasourceNames as DatasourceNames3,
   ENSNamespaceIds as ENSNamespaceIds3,
   maybeGetDatasource as maybeGetDatasource2
 } from "@ensnode/datasources";
 function getBasenamesSubregistryId(namespace) {
-  const datasource = maybeGetDatasource2(namespace, DatasourceNames2.Basenames);
+  const datasource = maybeGetDatasource2(namespace, DatasourceNames3.Basenames);
   if (!datasource) {
-    throw new Error(`Datasource not found for ${namespace} ${DatasourceNames2.Basenames}`);
+    throw new Error(`Datasource not found for ${namespace} ${DatasourceNames3.Basenames}`);
   }
   const address = datasource.contracts.BaseRegistrar?.address;
   if (address === void 0 || Array.isArray(address)) {
@@ -2878,7 +3025,6 @@ function getBasenamesSubregistryManagedName(namespaceId) {
       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.`
@@ -2888,14 +3034,14 @@ function getBasenamesSubregistryManagedName(namespaceId) {
 
 // src/registrars/ethnames-subregistry.ts
 import {
-  DatasourceNames as DatasourceNames3,
+  DatasourceNames as DatasourceNames4,
   ENSNamespaceIds as ENSNamespaceIds4,
   maybeGetDatasource as maybeGetDatasource3
 } from "@ensnode/datasources";
 function getEthnamesSubregistryId(namespace) {
-  const datasource = maybeGetDatasource3(namespace, DatasourceNames3.ENSRoot);
+  const datasource = maybeGetDatasource3(namespace, DatasourceNames4.ENSRoot);
   if (!datasource) {
-    throw new Error(`Datasource not found for ${namespace} ${DatasourceNames3.ENSRoot}`);
+    throw new Error(`Datasource not found for ${namespace} ${DatasourceNames4.ENSRoot}`);
   }
   const address = datasource.contracts.BaseRegistrar?.address;
   if (address === void 0 || Array.isArray(address)) {
@@ -2910,7 +3056,6 @@ function getEthnamesSubregistryManagedName(namespaceId) {
   switch (namespaceId) {
     case ENSNamespaceIds4.Mainnet:
     case ENSNamespaceIds4.Sepolia:
-    case ENSNamespaceIds4.Holesky:
     case ENSNamespaceIds4.EnsTestEnv:
       return "eth";
   }
@@ -2918,14 +3063,14 @@ function getEthnamesSubregistryManagedName(namespaceId) {
 
 // src/registrars/lineanames-subregistry.ts
 import {
-  DatasourceNames as DatasourceNames4,
+  DatasourceNames as DatasourceNames5,
   ENSNamespaceIds as ENSNamespaceIds5,
   maybeGetDatasource as maybeGetDatasource4
 } from "@ensnode/datasources";
 function getLineanamesSubregistryId(namespace) {
-  const datasource = maybeGetDatasource4(namespace, DatasourceNames4.Lineanames);
+  const datasource = maybeGetDatasource4(namespace, DatasourceNames5.Lineanames);
   if (!datasource) {
-    throw new Error(`Datasource not found for ${namespace} ${DatasourceNames4.Lineanames}`);
+    throw new Error(`Datasource not found for ${namespace} ${DatasourceNames5.Lineanames}`);
   }
   const address = datasource.contracts.BaseRegistrar?.address;
   if (address === void 0 || Array.isArray(address)) {
@@ -2942,7 +3087,6 @@ function getLineanamesSubregistryManagedName(namespaceId) {
       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.`
@@ -2950,6 +3094,21 @@ function getLineanamesSubregistryManagedName(namespaceId) {
   }
 }
 
+// src/registrars/registration-expiration.ts
+function isRegistrationExpired(info, now) {
+  if (info.expiry == null) return false;
+  return info.expiry <= now;
+}
+function isRegistrationFullyExpired(info, now) {
+  if (info.expiry == null) return false;
+  return now >= info.expiry + (info.gracePeriod ?? 0n);
+}
+function isRegistrationInGracePeriod(info, now) {
+  if (info.expiry == null) return false;
+  if (info.gracePeriod == null) return false;
+  return info.expiry <= now && info.expiry + info.gracePeriod > now;
+}
+
 // src/api/registrar-actions/serialize.ts
 function serializeNamedRegistrarAction({
   action,
@@ -2966,7 +3125,8 @@ function serializeRegistrarActionsResponse(response) {
       return {
         responseCode: response.responseCode,
         registrarActions: response.registrarActions.map(serializeNamedRegistrarAction),
-        pageContext: response.pageContext
+        pageContext: response.pageContext,
+        accurateAsOf: response.accurateAsOf
       };
     case RegistrarActionsResponseCodes.Error:
       return response;
@@ -3037,7 +3197,7 @@ var ClientError = class _ClientError extends Error {
 import { prettifyError as prettifyError10 } from "zod/v4";
 
 // src/ensanalytics/zod-schemas.ts
-import z12 from "zod/v4";
+import z13 from "zod/v4";
 
 // src/ensanalytics/types.ts
 var ReferrerLeaderboardPageResponseCodes = {
@@ -3062,20 +3222,28 @@ var ReferrerDetailResponseCodes = {
 };
 
 // src/ensanalytics/zod-schemas.ts
-var makeReferralProgramRulesSchema = (valueLabel = "ReferralProgramRules") => z12.object({
+var makeRevenueContributionSchema = (valueLabel = "RevenueContribution") => z13.coerce.bigint({
+  error: `${valueLabel} must represent a bigint.`
+}).nonnegative({
+  error: `${valueLabel} must not be negative.`
+});
+var makeReferralProgramRulesSchema = (valueLabel = "ReferralProgramRules") => z13.object({
   totalAwardPoolValue: makeFiniteNonNegativeNumberSchema(`${valueLabel}.totalAwardPoolValue`),
   maxQualifiedReferrers: makeNonNegativeIntegerSchema(`${valueLabel}.maxQualifiedReferrers`),
   startTime: makeUnixTimestampSchema(`${valueLabel}.startTime`),
   endTime: makeUnixTimestampSchema(`${valueLabel}.endTime`),
   subregistryId: makeAccountIdSchema(`${valueLabel}.subregistryId`)
 });
-var makeAwardedReferrerMetricsSchema = (valueLabel = "AwardedReferrerMetrics") => z12.object({
+var makeAwardedReferrerMetricsSchema = (valueLabel = "AwardedReferrerMetrics") => z13.object({
   referrer: makeLowercaseAddressSchema(`${valueLabel}.referrer`),
   totalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.totalReferrals`),
   totalIncrementalDuration: makeDurationSchema(`${valueLabel}.totalIncrementalDuration`),
+  totalRevenueContribution: makeRevenueContributionSchema(
+    `${valueLabel}.totalRevenueContribution`
+  ),
   score: makeFiniteNonNegativeNumberSchema(`${valueLabel}.score`),
   rank: makePositiveIntegerSchema(`${valueLabel}.rank`),
-  isQualified: z12.boolean(),
+  isQualified: z13.boolean(),
   finalScoreBoost: makeFiniteNonNegativeNumberSchema(`${valueLabel}.finalScoreBoost`).max(
     1,
     `${valueLabel}.finalScoreBoost must be <= 1`
@@ -3087,13 +3255,16 @@ var makeAwardedReferrerMetricsSchema = (valueLabel = "AwardedReferrerMetrics") =
   ),
   awardPoolApproxValue: makeFiniteNonNegativeNumberSchema(`${valueLabel}.awardPoolApproxValue`)
 });
-var makeUnrankedReferrerMetricsSchema = (valueLabel = "UnrankedReferrerMetrics") => z12.object({
+var makeUnrankedReferrerMetricsSchema = (valueLabel = "UnrankedReferrerMetrics") => z13.object({
   referrer: makeLowercaseAddressSchema(`${valueLabel}.referrer`),
   totalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.totalReferrals`),
   totalIncrementalDuration: makeDurationSchema(`${valueLabel}.totalIncrementalDuration`),
+  totalRevenueContribution: makeRevenueContributionSchema(
+    `${valueLabel}.totalRevenueContribution`
+  ),
   score: makeFiniteNonNegativeNumberSchema(`${valueLabel}.score`),
-  rank: z12.null(),
-  isQualified: z12.literal(false),
+  rank: z13.null(),
+  isQualified: z13.literal(false),
   finalScoreBoost: makeFiniteNonNegativeNumberSchema(`${valueLabel}.finalScoreBoost`).max(
     1,
     `${valueLabel}.finalScoreBoost must be <= 1`
@@ -3105,11 +3276,14 @@ var makeUnrankedReferrerMetricsSchema = (valueLabel = "UnrankedReferrerMetrics")
   ),
   awardPoolApproxValue: makeFiniteNonNegativeNumberSchema(`${valueLabel}.awardPoolApproxValue`)
 });
-var makeAggregatedReferrerMetricsSchema = (valueLabel = "AggregatedReferrerMetrics") => z12.object({
+var makeAggregatedReferrerMetricsSchema = (valueLabel = "AggregatedReferrerMetrics") => z13.object({
   grandTotalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.grandTotalReferrals`),
   grandTotalIncrementalDuration: makeDurationSchema(
     `${valueLabel}.grandTotalIncrementalDuration`
   ),
+  grandTotalRevenueContribution: makeRevenueContributionSchema(
+    `${valueLabel}.grandTotalRevenueContribution`
+  ),
   grandTotalQualifiedReferrersFinalScore: makeFiniteNonNegativeNumberSchema(
     `${valueLabel}.grandTotalQualifiedReferrersFinalScore`
   ),
@@ -3117,7 +3291,7 @@ var makeAggregatedReferrerMetricsSchema = (valueLabel = "AggregatedReferrerMetri
     `${valueLabel}.minFinalScoreToQualify`
   )
 });
-var makeReferrerLeaderboardPageContextSchema = (valueLabel = "ReferrerLeaderboardPageContext") => z12.object({
+var makeReferrerLeaderboardPageContextSchema = (valueLabel = "ReferrerLeaderboardPageContext") => z13.object({
   page: makePositiveIntegerSchema(`${valueLabel}.page`),
   recordsPerPage: makePositiveIntegerSchema(`${valueLabel}.recordsPerPage`).max(
     REFERRERS_PER_LEADERBOARD_PAGE_MAX,
@@ -3125,66 +3299,153 @@ var makeReferrerLeaderboardPageContextSchema = (valueLabel = "ReferrerLeaderboar
   ),
   totalRecords: makeNonNegativeIntegerSchema(`${valueLabel}.totalRecords`),
   totalPages: makePositiveIntegerSchema(`${valueLabel}.totalPages`),
-  hasNext: z12.boolean(),
-  hasPrev: z12.boolean(),
-  startIndex: z12.optional(makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`)),
-  endIndex: z12.optional(makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`))
+  hasNext: z13.boolean(),
+  hasPrev: z13.boolean(),
+  startIndex: z13.optional(makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`)),
+  endIndex: z13.optional(makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`))
 });
-var makeReferrerLeaderboardPageSchema = (valueLabel = "ReferrerLeaderboardPage") => z12.object({
+var makeReferrerLeaderboardPageSchema = (valueLabel = "ReferrerLeaderboardPage") => z13.object({
   rules: makeReferralProgramRulesSchema(`${valueLabel}.rules`),
-  referrers: z12.array(makeAwardedReferrerMetricsSchema(`${valueLabel}.referrers[record]`)),
+  referrers: z13.array(makeAwardedReferrerMetricsSchema(`${valueLabel}.referrers[record]`)),
   aggregatedMetrics: makeAggregatedReferrerMetricsSchema(`${valueLabel}.aggregatedMetrics`),
   pageContext: makeReferrerLeaderboardPageContextSchema(`${valueLabel}.pageContext`),
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 });
-var makeReferrerLeaderboardPageResponseOkSchema = (valueLabel = "ReferrerLeaderboardPageResponseOk") => z12.object({
-  responseCode: z12.literal(ReferrerLeaderboardPageResponseCodes.Ok),
+var makeReferrerLeaderboardPageResponseOkSchema = (valueLabel = "ReferrerLeaderboardPageResponseOk") => z13.object({
+  responseCode: z13.literal(ReferrerLeaderboardPageResponseCodes.Ok),
   data: makeReferrerLeaderboardPageSchema(`${valueLabel}.data`)
 });
-var makeReferrerLeaderboardPageResponseErrorSchema = (_valueLabel = "ReferrerLeaderboardPageResponseError") => z12.object({
-  responseCode: z12.literal(ReferrerLeaderboardPageResponseCodes.Error),
-  error: z12.string(),
-  errorMessage: z12.string()
+var makeReferrerLeaderboardPageResponseErrorSchema = (_valueLabel = "ReferrerLeaderboardPageResponseError") => z13.object({
+  responseCode: z13.literal(ReferrerLeaderboardPageResponseCodes.Error),
+  error: z13.string(),
+  errorMessage: z13.string()
 });
-var makeReferrerLeaderboardPageResponseSchema = (valueLabel = "ReferrerLeaderboardPageResponse") => z12.union([
+var makeReferrerLeaderboardPageResponseSchema = (valueLabel = "ReferrerLeaderboardPageResponse") => z13.union([
   makeReferrerLeaderboardPageResponseOkSchema(valueLabel),
   makeReferrerLeaderboardPageResponseErrorSchema(valueLabel)
 ]);
-var makeReferrerDetailRankedSchema = (valueLabel = "ReferrerDetailRanked") => z12.object({
-  type: z12.literal(ReferrerDetailTypeIds.Ranked),
+var makeReferrerDetailRankedSchema = (valueLabel = "ReferrerDetailRanked") => z13.object({
+  type: z13.literal(ReferrerDetailTypeIds.Ranked),
   rules: makeReferralProgramRulesSchema(`${valueLabel}.rules`),
   referrer: makeAwardedReferrerMetricsSchema(`${valueLabel}.referrer`),
   aggregatedMetrics: makeAggregatedReferrerMetricsSchema(`${valueLabel}.aggregatedMetrics`),
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 });
-var makeReferrerDetailUnrankedSchema = (valueLabel = "ReferrerDetailUnranked") => z12.object({
-  type: z12.literal(ReferrerDetailTypeIds.Unranked),
+var makeReferrerDetailUnrankedSchema = (valueLabel = "ReferrerDetailUnranked") => z13.object({
+  type: z13.literal(ReferrerDetailTypeIds.Unranked),
   rules: makeReferralProgramRulesSchema(`${valueLabel}.rules`),
   referrer: makeUnrankedReferrerMetricsSchema(`${valueLabel}.referrer`),
   aggregatedMetrics: makeAggregatedReferrerMetricsSchema(`${valueLabel}.aggregatedMetrics`),
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 });
-var makeReferrerDetailResponseOkSchema = (valueLabel = "ReferrerDetailResponse") => z12.object({
-  responseCode: z12.literal(ReferrerDetailResponseCodes.Ok),
-  data: z12.union([
+var makeReferrerDetailResponseOkSchema = (valueLabel = "ReferrerDetailResponse") => z13.object({
+  responseCode: z13.literal(ReferrerDetailResponseCodes.Ok),
+  data: z13.union([
     makeReferrerDetailRankedSchema(`${valueLabel}.data`),
     makeReferrerDetailUnrankedSchema(`${valueLabel}.data`)
   ])
 });
-var makeReferrerDetailResponseErrorSchema = (_valueLabel = "ReferrerDetailResponse") => z12.object({
-  responseCode: z12.literal(ReferrerDetailResponseCodes.Error),
-  error: z12.string(),
-  errorMessage: z12.string()
+var makeReferrerDetailResponseErrorSchema = (_valueLabel = "ReferrerDetailResponse") => z13.object({
+  responseCode: z13.literal(ReferrerDetailResponseCodes.Error),
+  error: z13.string(),
+  errorMessage: z13.string()
 });
-var makeReferrerDetailResponseSchema = (valueLabel = "ReferrerDetailResponse") => z12.union([
+var makeReferrerDetailResponseSchema = (valueLabel = "ReferrerDetailResponse") => z13.union([
   makeReferrerDetailResponseOkSchema(valueLabel),
   makeReferrerDetailResponseErrorSchema(valueLabel)
 ]);
 
 // src/ensanalytics/deserialize.ts
+function deserializeRevenueContribution(value) {
+  return BigInt(value);
+}
+function deserializeReferralProgramRules(rules) {
+  return rules;
+}
+function deserializeAwardedReferrerMetrics(metrics) {
+  return {
+    referrer: metrics.referrer,
+    totalReferrals: metrics.totalReferrals,
+    totalIncrementalDuration: metrics.totalIncrementalDuration,
+    totalRevenueContribution: deserializeRevenueContribution(metrics.totalRevenueContribution),
+    score: metrics.score,
+    rank: metrics.rank,
+    isQualified: metrics.isQualified,
+    finalScoreBoost: metrics.finalScoreBoost,
+    finalScore: metrics.finalScore,
+    awardPoolShare: metrics.awardPoolShare,
+    awardPoolApproxValue: metrics.awardPoolApproxValue
+  };
+}
+function deserializeUnrankedReferrerMetrics(metrics) {
+  return {
+    referrer: metrics.referrer,
+    totalReferrals: metrics.totalReferrals,
+    totalIncrementalDuration: metrics.totalIncrementalDuration,
+    totalRevenueContribution: deserializeRevenueContribution(metrics.totalRevenueContribution),
+    score: metrics.score,
+    rank: metrics.rank,
+    isQualified: metrics.isQualified,
+    finalScoreBoost: metrics.finalScoreBoost,
+    finalScore: metrics.finalScore,
+    awardPoolShare: metrics.awardPoolShare,
+    awardPoolApproxValue: metrics.awardPoolApproxValue
+  };
+}
+function deserializeAggregatedReferrerMetrics(metrics) {
+  return {
+    grandTotalReferrals: metrics.grandTotalReferrals,
+    grandTotalIncrementalDuration: metrics.grandTotalIncrementalDuration,
+    grandTotalRevenueContribution: deserializeRevenueContribution(
+      metrics.grandTotalRevenueContribution
+    ),
+    grandTotalQualifiedReferrersFinalScore: metrics.grandTotalQualifiedReferrersFinalScore,
+    minFinalScoreToQualify: metrics.minFinalScoreToQualify
+  };
+}
+function deserializeReferrerLeaderboardPage(page) {
+  return {
+    rules: deserializeReferralProgramRules(page.rules),
+    referrers: page.referrers.map(deserializeAwardedReferrerMetrics),
+    aggregatedMetrics: deserializeAggregatedReferrerMetrics(page.aggregatedMetrics),
+    pageContext: page.pageContext,
+    accurateAsOf: page.accurateAsOf
+  };
+}
+function deserializeReferrerDetailRanked(detail) {
+  return {
+    type: detail.type,
+    rules: deserializeReferralProgramRules(detail.rules),
+    referrer: deserializeAwardedReferrerMetrics(detail.referrer),
+    aggregatedMetrics: deserializeAggregatedReferrerMetrics(detail.aggregatedMetrics),
+    accurateAsOf: detail.accurateAsOf
+  };
+}
+function deserializeReferrerDetailUnranked(detail) {
+  return {
+    type: detail.type,
+    rules: deserializeReferralProgramRules(detail.rules),
+    referrer: deserializeUnrankedReferrerMetrics(detail.referrer),
+    aggregatedMetrics: deserializeAggregatedReferrerMetrics(detail.aggregatedMetrics),
+    accurateAsOf: detail.accurateAsOf
+  };
+}
 function deserializeReferrerLeaderboardPageResponse(maybeResponse, valueLabel) {
+  let deserialized;
+  switch (maybeResponse.responseCode) {
+    case "ok": {
+      deserialized = {
+        responseCode: maybeResponse.responseCode,
+        data: deserializeReferrerLeaderboardPage(maybeResponse.data)
+      };
+      break;
+    }
+    case "error":
+      deserialized = maybeResponse;
+      break;
+  }
   const schema = makeReferrerLeaderboardPageResponseSchema(valueLabel);
-  const parsed = schema.safeParse(maybeResponse);
+  const parsed = schema.safeParse(deserialized);
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize SerializedReferrerLeaderboardPageResponse:
@@ -3195,8 +3456,31 @@ ${prettifyError10(parsed.error)}
   return parsed.data;
 }
 function deserializeReferrerDetailResponse(maybeResponse, valueLabel) {
+  let deserialized;
+  switch (maybeResponse.responseCode) {
+    case "ok": {
+      switch (maybeResponse.data.type) {
+        case "ranked":
+          deserialized = {
+            responseCode: maybeResponse.responseCode,
+            data: deserializeReferrerDetailRanked(maybeResponse.data)
+          };
+          break;
+        case "unranked":
+          deserialized = {
+            responseCode: maybeResponse.responseCode,
+            data: deserializeReferrerDetailUnranked(maybeResponse.data)
+          };
+          break;
+      }
+      break;
+    }
+    case "error":
+      deserialized = maybeResponse;
+      break;
+  }
   const schema = makeReferrerDetailResponseSchema(valueLabel);
-  const parsed = schema.safeParse(maybeResponse);
+  const parsed = schema.safeParse(deserialized);
   if (parsed.error) {
     throw new Error(`Cannot deserialize ReferrerDetailResponse:
 ${prettifyError10(parsed.error)}
@@ -3206,10 +3490,87 @@ ${prettifyError10(parsed.error)}
 }
 
 // src/ensanalytics/serialize.ts
+function serializeRevenueContribution(revenueContribution) {
+  return revenueContribution.toString();
+}
+function serializeReferralProgramRules(rules) {
+  return rules;
+}
+function serializeAwardedReferrerMetrics(metrics) {
+  return {
+    referrer: metrics.referrer,
+    totalReferrals: metrics.totalReferrals,
+    totalIncrementalDuration: metrics.totalIncrementalDuration,
+    totalRevenueContribution: serializeRevenueContribution(metrics.totalRevenueContribution),
+    score: metrics.score,
+    rank: metrics.rank,
+    isQualified: metrics.isQualified,
+    finalScoreBoost: metrics.finalScoreBoost,
+    finalScore: metrics.finalScore,
+    awardPoolShare: metrics.awardPoolShare,
+    awardPoolApproxValue: metrics.awardPoolApproxValue
+  };
+}
+function serializeUnrankedReferrerMetrics(metrics) {
+  return {
+    referrer: metrics.referrer,
+    totalReferrals: metrics.totalReferrals,
+    totalIncrementalDuration: metrics.totalIncrementalDuration,
+    totalRevenueContribution: serializeRevenueContribution(metrics.totalRevenueContribution),
+    score: metrics.score,
+    rank: metrics.rank,
+    isQualified: metrics.isQualified,
+    finalScoreBoost: metrics.finalScoreBoost,
+    finalScore: metrics.finalScore,
+    awardPoolShare: metrics.awardPoolShare,
+    awardPoolApproxValue: metrics.awardPoolApproxValue
+  };
+}
+function serializeAggregatedReferrerMetrics(metrics) {
+  return {
+    grandTotalReferrals: metrics.grandTotalReferrals,
+    grandTotalIncrementalDuration: metrics.grandTotalIncrementalDuration,
+    grandTotalRevenueContribution: serializeRevenueContribution(
+      metrics.grandTotalRevenueContribution
+    ),
+    grandTotalQualifiedReferrersFinalScore: metrics.grandTotalQualifiedReferrersFinalScore,
+    minFinalScoreToQualify: metrics.minFinalScoreToQualify
+  };
+}
+function serializeReferrerLeaderboardPage(page) {
+  return {
+    rules: serializeReferralProgramRules(page.rules),
+    referrers: page.referrers.map(serializeAwardedReferrerMetrics),
+    aggregatedMetrics: serializeAggregatedReferrerMetrics(page.aggregatedMetrics),
+    pageContext: page.pageContext,
+    accurateAsOf: page.accurateAsOf
+  };
+}
+function serializeReferrerDetailRanked(detail) {
+  return {
+    type: detail.type,
+    rules: serializeReferralProgramRules(detail.rules),
+    referrer: serializeAwardedReferrerMetrics(detail.referrer),
+    aggregatedMetrics: serializeAggregatedReferrerMetrics(detail.aggregatedMetrics),
+    accurateAsOf: detail.accurateAsOf
+  };
+}
+function serializeReferrerDetailUnranked(detail) {
+  return {
+    type: detail.type,
+    rules: serializeReferralProgramRules(detail.rules),
+    referrer: serializeUnrankedReferrerMetrics(detail.referrer),
+    aggregatedMetrics: serializeAggregatedReferrerMetrics(detail.aggregatedMetrics),
+    accurateAsOf: detail.accurateAsOf
+  };
+}
 function serializeReferrerLeaderboardPageResponse(response) {
   switch (response.responseCode) {
     case ReferrerLeaderboardPageResponseCodes.Ok:
-      return response;
+      return {
+        responseCode: response.responseCode,
+        data: serializeReferrerLeaderboardPage(response.data)
+      };
     case ReferrerLeaderboardPageResponseCodes.Error:
       return response;
   }
@@ -3217,7 +3578,19 @@ function serializeReferrerLeaderboardPageResponse(response) {
 function serializeReferrerDetailResponse(response) {
   switch (response.responseCode) {
     case ReferrerDetailResponseCodes.Ok:
-      return response;
+      switch (response.data.type) {
+        case "ranked":
+          return {
+            responseCode: response.responseCode,
+            data: serializeReferrerDetailRanked(response.data)
+          };
+        case "unranked":
+          return {
+            responseCode: response.responseCode,
+            data: serializeReferrerDetailUnranked(response.data)
+          };
+      }
+      break;
     case ReferrerDetailResponseCodes.Error:
       return response;
   }
@@ -3649,6 +4022,7 @@ var ENSNodeClient = class _ENSNodeClient {
    *   const { registrarActions, pageContext } = response;
    *   console.log(registrarActions);
    *   console.log(`Page ${pageContext.page} of ${pageContext.totalPages}`);
+   *   console.log(`Accurate as of: ${response.accurateAsOf}`);
    * }
    *
    * // Get second page with 25 records per page
@@ -3679,6 +4053,26 @@ var ENSNodeClient = class _ENSNodeClient {
    *   filters: [registrarActionsFilter.byParentNode(namehash('base.eth'))],
    *   recordsPerPage: 10
    * });
+   *
+   * // get registrar actions within a specific time range
+   * const beginTimestamp = 1764547200; // Dec 1, 2025, 00:00:00 UTC
+   * const endTimestamp = 1767225600; // Jan 1, 2026, 00:00:00 UTC
+   * await client.registrarActions({
+   *   filters: [
+   *     registrarActionsFilter.beginTimestamp(beginTimestamp),
+   *     registrarActionsFilter.endTimestamp(endTimestamp),
+   *   ],
+   * });
+   *
+   * // get registrar actions from a specific timestamp onwards
+   * await client.registrarActions({
+   *   filters: [registrarActionsFilter.beginTimestamp(1764547200)],
+   * });
+   *
+   * // get registrar actions up to a specific timestamp
+   * await client.registrarActions({
+   *   filters: [registrarActionsFilter.endTimestamp(1767225600)],
+   * });
    * ```
    */
   async registrarActions(request = {}) {
@@ -3700,6 +4094,18 @@ var ENSNodeClient = class _ENSNodeClient {
       );
       return decodedReferrerFilter ? { key: "decodedReferrer", value: decodedReferrerFilter.value } : null;
     };
+    const buildBeginTimestampArg = (filters) => {
+      const beginTimestampFilter = filters?.find(
+        (f) => f.filterType === RegistrarActionsFilterTypes.BeginTimestamp
+      );
+      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: {
@@ -3730,6 +4136,14 @@ var ENSNodeClient = class _ENSNodeClient {
     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 {
@@ -3783,7 +4197,7 @@ var ENSNodeClient = class _ENSNodeClient {
     const url = new URL(`/api/name-tokens`, this.options.url);
     if (request.name !== void 0) {
       url.searchParams.set("name", request.name);
-    } else {
+    } else if (request.domainId !== void 0) {
       url.searchParams.set("domainId", request.domainId);
     }
     const response = await fetch(url);
@@ -3808,6 +4222,30 @@ var ENSNodeClient = class _ENSNodeClient {
   }
 };
 
+// src/ensv2/ids-lib.ts
+import { hexToBigInt as hexToBigInt2 } from "viem";
+var makeRegistryId = (accountId) => formatAccountId(accountId);
+var makeENSv1DomainId = (node) => node;
+var makeENSv2DomainId = (registry, canonicalId) => formatAssetId({
+  assetNamespace: AssetNamespaces.ERC1155,
+  contract: registry,
+  tokenId: canonicalId
+});
+var maskLower32Bits = (num) => num ^ num & 0xffffffffn;
+var getCanonicalId = (input) => {
+  if (typeof input === "bigint") return maskLower32Bits(input);
+  return getCanonicalId(hexToBigInt2(input));
+};
+var makePermissionsId = (contract) => formatAccountId(contract);
+var makePermissionsResourceId = (contract, resource) => `${makePermissionsId(contract)}/${resource}`;
+var makePermissionsUserId = (contract, resource, user) => `${makePermissionsId(contract)}/${resource}/${user}`;
+var makeResolverId = (contract) => formatAccountId(contract);
+var makeResolverRecordsId = (resolver, node) => `${makeResolverId(resolver)}/${node}`;
+var makeLatestRegistrationId = (domainId) => `${domainId}/latest`;
+var makeRegistrationId = (domainId, index = 0) => `${domainId}/${index}`;
+var makeLatestRenewalId = (domainId, registrationIndex) => `${makeRegistrationId(domainId, registrationIndex)}/latest`;
+var makeRenewalId = (domainId, registrationIndex, index = 0) => `${makeRegistrationId(domainId, registrationIndex)}/${index}`;
+
 // src/identity/identity.ts
 import { getENSRootChainId as getENSRootChainId2 } from "@ensnode/datasources";
 
@@ -3912,6 +4350,7 @@ export {
   LruCache,
   NFTMintStatuses,
   NFTTransferTypes,
+  NODE_ANY,
   NameTokenOwnershipTypes,
   NameTokensResponseCodes,
   NameTokensResponseErrorCodes,
@@ -3921,6 +4360,7 @@ export {
   RECORDS_PER_PAGE_DEFAULT,
   RECORDS_PER_PAGE_MAX,
   ROOT_NODE,
+  ROOT_RESOURCE,
   ReferrerDetailResponseCodes,
   ReferrerLeaderboardPageResponseCodes,
   RegistrarActionTypes,
@@ -3984,15 +4424,20 @@ export {
   deserializedNameTokensResponse,
   durationBetween,
   encodeLabelHash,
+  encodedLabelToLabelhash,
   evmChainIdToCoinType,
   formatAccountId,
   formatAssetId,
   formatNFTTransferEventMetadata,
   getBasenamesSubregistryId,
   getBasenamesSubregistryManagedName,
+  getCanonicalId,
   getCurrencyInfo,
   getDatasourceContract,
   getENSRootChainId,
+  getENSv1Registry,
+  getENSv2RootRegistry,
+  getENSv2RootRegistryId,
   getEthnamesSubregistryId,
   getEthnamesSubregistryManagedName,
   getLatestIndexedBlockRef,
@@ -4009,16 +4454,33 @@ export {
   getTimestampForHighestOmnichainKnownBlock,
   getTimestampForLowestOmnichainStartBlock,
   hasNullByte,
+  interpretAddress,
+  interpretAddressRecordValue,
+  interpretNameRecordValue,
+  interpretTextRecordKey,
+  interpretTextRecordValue,
+  interpretTokenIdAsLabelHash,
+  interpretTokenIdAsNode,
   interpretedLabelsToInterpretedName,
+  interpretedNameToInterpretedLabels,
+  interpretedNameToLabelHashPath,
+  isENSv1Registry,
+  isENSv2RootRegistry,
   isEncodedLabelHash,
   isHttpProtocol,
+  isInterpetedLabel,
+  isInterpretedName,
   isLabelHash,
   isNormalizedLabel,
   isNormalizedName,
+  isPccFuseSet,
   isPriceCurrencyEqual,
   isPriceEqual,
   isRegistrarActionPricingAvailable,
   isRegistrarActionReferralAvailable,
+  isRegistrationExpired,
+  isRegistrationFullyExpired,
+  isRegistrationInGracePeriod,
   isResolvedIdentity,
   isSelectionEmpty,
   isSubgraphCompatible,
@@ -4028,7 +4490,20 @@ export {
   literalLabelToInterpretedLabel,
   literalLabelsToInterpretedName,
   literalLabelsToLiteralName,
+  makeContractMatcher,
   makeENSApiPublicConfigSchema,
+  makeENSv1DomainId,
+  makeENSv2DomainId,
+  makeLatestRegistrationId,
+  makeLatestRenewalId,
+  makePermissionsId,
+  makePermissionsResourceId,
+  makePermissionsUserId,
+  makeRegistrationId,
+  makeRegistryId,
+  makeRenewalId,
+  makeResolverId,
+  makeResolverRecordsId,
   makeSubdomainNode,
   maybeGetDatasourceContract,
   nameTokensPrerequisites,