@ensnode/ensnode-sdk 0.0.0-next-20260106001025 → 0.0.0-next-20260108092445

package/dist/index.js

@@ -5,7 +5,7 @@ import { prettifyError as prettifyError2, ZodError } 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 || {});
 
@@ -1073,7 +1184,7 @@ function serializeENSIndexerPublicConfig(config) {
 import { prettifyError as prettifyError4 } from "zod/v4";
 
 // src/ensindexer/indexing-status/zod-schemas.ts
-import z5 from "zod/v4";
+import { z as z5 } from "zod/v4";
 
 // src/ensindexer/indexing-status/types.ts
 var ChainIndexingConfigTypeIds = {
@@ -1499,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})`
     });
   }
 }
@@ -1829,18 +1940,17 @@ import { namehash as namehash2 } from "viem";
 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 { 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.
@@ -1871,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 = [
@@ -1899,7 +2009,7 @@ function getNameTokenOwnership(namespaceId, name, owner) {
       owner
     };
   }
-  if (isAddressEqual2(owner.address, zeroAddress)) {
+  if (isAddressEqual4(owner.address, zeroAddress3)) {
     return {
       ownershipType: NameTokenOwnershipTypes.Burned,
       owner
@@ -1940,7 +2050,7 @@ var makeAssetIdSchema = (valueLabel = "Asset ID Schema", serializable) => {
 };
 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: {
@@ -1954,7 +2064,7 @@ var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => z7.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,
@@ -1980,7 +2090,7 @@ var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Un
 }).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,
@@ -2001,10 +2111,6 @@ var makeNameTokenSchema = (valueLabel = "Name Token Schema", serializable) => z7
 });
 
 // src/tokenscope/assets.ts
-var AssetNamespaces = {
-  ERC721: "erc721",
-  ERC1155: "erc1155"
-};
 function serializeAssetId(assetId) {
   return {
     assetNamespace: assetId.assetNamespace,
@@ -2022,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);
@@ -2058,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 = {
@@ -2170,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(
@@ -2463,10 +2561,10 @@ import { namehash as namehash3 } from "viem/ens";
 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", {
@@ -2485,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 {
@@ -2514,7 +2612,7 @@ var ReferrerDetailTypeIds = {
 };
 
 // src/registrars/zod-schemas.ts
-import z10 from "zod/v4";
+import { z as z10 } from "zod/v4";
 
 // src/registrars/registrar-action.ts
 var RegistrarActionTypes = {
@@ -2902,14 +3000,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)) {
@@ -2926,7 +3024,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.`
@@ -2936,14 +3033,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)) {
@@ -2958,7 +3055,6 @@ function getEthnamesSubregistryManagedName(namespaceId) {
   switch (namespaceId) {
     case ENSNamespaceIds4.Mainnet:
     case ENSNamespaceIds4.Sepolia:
-    case ENSNamespaceIds4.Holesky:
     case ENSNamespaceIds4.EnsTestEnv:
       return "eth";
   }
@@ -2966,14 +3062,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)) {
@@ -2990,7 +3086,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.`
@@ -2998,6 +3093,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,
@@ -4109,6 +4219,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";
 
@@ -4213,6 +4347,7 @@ export {
   LruCache,
   NFTMintStatuses,
   NFTTransferTypes,
+  NODE_ANY,
   NameTokenOwnershipTypes,
   NameTokensResponseCodes,
   NameTokensResponseErrorCodes,
@@ -4222,6 +4357,7 @@ export {
   RECORDS_PER_PAGE_DEFAULT,
   RECORDS_PER_PAGE_MAX,
   ROOT_NODE,
+  ROOT_RESOURCE,
   ReferrerDetailResponseCodes,
   ReferrerLeaderboardPageResponseCodes,
   RegistrarActionTypes,
@@ -4285,15 +4421,20 @@ export {
   deserializedNameTokensResponse,
   durationBetween,
   encodeLabelHash,
+  encodedLabelToLabelhash,
   evmChainIdToCoinType,
   formatAccountId,
   formatAssetId,
   formatNFTTransferEventMetadata,
   getBasenamesSubregistryId,
   getBasenamesSubregistryManagedName,
+  getCanonicalId,
   getCurrencyInfo,
   getDatasourceContract,
   getENSRootChainId,
+  getENSv1Registry,
+  getENSv2RootRegistry,
+  getENSv2RootRegistryId,
   getEthnamesSubregistryId,
   getEthnamesSubregistryManagedName,
   getLatestIndexedBlockRef,
@@ -4310,16 +4451,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,
@@ -4329,7 +4487,20 @@ export {
   literalLabelToInterpretedLabel,
   literalLabelsToInterpretedName,
   literalLabelsToLiteralName,
+  makeContractMatcher,
   makeENSApiPublicConfigSchema,
+  makeENSv1DomainId,
+  makeENSv2DomainId,
+  makeLatestRegistrationId,
+  makeLatestRenewalId,
+  makePermissionsId,
+  makePermissionsResourceId,
+  makePermissionsUserId,
+  makeRegistrationId,
+  makeRegistryId,
+  makeRenewalId,
+  makeResolverId,
+  makeResolverRecordsId,
   makeSubdomainNode,
   maybeGetDatasourceContract,
   nameTokensPrerequisites,