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

package/dist/index.cjs

@@ -54,6 +54,7 @@ __export(index_exports, {
   LruCache: () => LruCache,
   NFTMintStatuses: () => NFTMintStatuses,
   NFTTransferTypes: () => NFTTransferTypes,
+  NODE_ANY: () => NODE_ANY,
   NameTokenOwnershipTypes: () => NameTokenOwnershipTypes,
   NameTokensResponseCodes: () => NameTokensResponseCodes,
   NameTokensResponseErrorCodes: () => NameTokensResponseErrorCodes,
@@ -63,6 +64,7 @@ __export(index_exports, {
   RECORDS_PER_PAGE_DEFAULT: () => RECORDS_PER_PAGE_DEFAULT,
   RECORDS_PER_PAGE_MAX: () => RECORDS_PER_PAGE_MAX,
   ROOT_NODE: () => ROOT_NODE,
+  ROOT_RESOURCE: () => ROOT_RESOURCE,
   ReferrerDetailResponseCodes: () => ReferrerDetailResponseCodes,
   ReferrerLeaderboardPageResponseCodes: () => ReferrerLeaderboardPageResponseCodes,
   RegistrarActionTypes: () => RegistrarActionTypes,
@@ -126,15 +128,20 @@ __export(index_exports, {
   deserializedNameTokensResponse: () => deserializedNameTokensResponse,
   durationBetween: () => durationBetween,
   encodeLabelHash: () => encodeLabelHash,
+  encodedLabelToLabelhash: () => encodedLabelToLabelhash,
   evmChainIdToCoinType: () => evmChainIdToCoinType,
   formatAccountId: () => formatAccountId,
   formatAssetId: () => formatAssetId,
   formatNFTTransferEventMetadata: () => formatNFTTransferEventMetadata,
   getBasenamesSubregistryId: () => getBasenamesSubregistryId,
   getBasenamesSubregistryManagedName: () => getBasenamesSubregistryManagedName,
+  getCanonicalId: () => getCanonicalId,
   getCurrencyInfo: () => getCurrencyInfo,
   getDatasourceContract: () => getDatasourceContract,
   getENSRootChainId: () => import_datasources2.getENSRootChainId,
+  getENSv1Registry: () => getENSv1Registry,
+  getENSv2RootRegistry: () => getENSv2RootRegistry,
+  getENSv2RootRegistryId: () => getENSv2RootRegistryId,
   getEthnamesSubregistryId: () => getEthnamesSubregistryId,
   getEthnamesSubregistryManagedName: () => getEthnamesSubregistryManagedName,
   getLatestIndexedBlockRef: () => getLatestIndexedBlockRef,
@@ -151,16 +158,33 @@ __export(index_exports, {
   getTimestampForHighestOmnichainKnownBlock: () => getTimestampForHighestOmnichainKnownBlock,
   getTimestampForLowestOmnichainStartBlock: () => getTimestampForLowestOmnichainStartBlock,
   hasNullByte: () => hasNullByte,
+  interpretAddress: () => interpretAddress,
+  interpretAddressRecordValue: () => interpretAddressRecordValue,
+  interpretNameRecordValue: () => interpretNameRecordValue,
+  interpretTextRecordKey: () => interpretTextRecordKey,
+  interpretTextRecordValue: () => interpretTextRecordValue,
+  interpretTokenIdAsLabelHash: () => interpretTokenIdAsLabelHash,
+  interpretTokenIdAsNode: () => interpretTokenIdAsNode,
   interpretedLabelsToInterpretedName: () => interpretedLabelsToInterpretedName,
+  interpretedNameToInterpretedLabels: () => interpretedNameToInterpretedLabels,
+  interpretedNameToLabelHashPath: () => interpretedNameToLabelHashPath,
+  isENSv1Registry: () => isENSv1Registry,
+  isENSv2RootRegistry: () => isENSv2RootRegistry,
   isEncodedLabelHash: () => isEncodedLabelHash,
   isHttpProtocol: () => isHttpProtocol,
+  isInterpetedLabel: () => isInterpetedLabel,
+  isInterpretedName: () => isInterpretedName,
   isLabelHash: () => isLabelHash,
   isNormalizedLabel: () => isNormalizedLabel,
   isNormalizedName: () => isNormalizedName,
+  isPccFuseSet: () => isPccFuseSet,
   isPriceCurrencyEqual: () => isPriceCurrencyEqual,
   isPriceEqual: () => isPriceEqual,
   isRegistrarActionPricingAvailable: () => isRegistrarActionPricingAvailable,
   isRegistrarActionReferralAvailable: () => isRegistrarActionReferralAvailable,
+  isRegistrationExpired: () => isRegistrationExpired,
+  isRegistrationFullyExpired: () => isRegistrationFullyExpired,
+  isRegistrationInGracePeriod: () => isRegistrationInGracePeriod,
   isResolvedIdentity: () => isResolvedIdentity,
   isSelectionEmpty: () => isSelectionEmpty,
   isSubgraphCompatible: () => isSubgraphCompatible,
@@ -170,7 +194,20 @@ __export(index_exports, {
   literalLabelToInterpretedLabel: () => literalLabelToInterpretedLabel,
   literalLabelsToInterpretedName: () => literalLabelsToInterpretedName,
   literalLabelsToLiteralName: () => literalLabelsToLiteralName,
+  makeContractMatcher: () => makeContractMatcher,
   makeENSApiPublicConfigSchema: () => makeENSApiPublicConfigSchema,
+  makeENSv1DomainId: () => makeENSv1DomainId,
+  makeENSv2DomainId: () => makeENSv2DomainId,
+  makeLatestRegistrationId: () => makeLatestRegistrationId,
+  makeLatestRenewalId: () => makeLatestRenewalId,
+  makePermissionsId: () => makePermissionsId,
+  makePermissionsResourceId: () => makePermissionsResourceId,
+  makePermissionsUserId: () => makePermissionsUserId,
+  makeRegistrationId: () => makeRegistrationId,
+  makeRegistryId: () => makeRegistryId,
+  makeRenewalId: () => makeRenewalId,
+  makeResolverId: () => makeResolverId,
+  makeResolverRecordsId: () => makeResolverRecordsId,
   makeSubdomainNode: () => makeSubdomainNode,
   maybeGetDatasourceContract: () => maybeGetDatasourceContract,
   nameTokensPrerequisites: () => nameTokensPrerequisites,
@@ -225,7 +262,7 @@ var import_v46 = require("zod/v4");
 var import_v45 = require("zod/v4");
 
 // src/ensindexer/config/zod-schemas.ts
-var import_v43 = __toESM(require("zod/v4"), 1);
+var import_v43 = require("zod/v4");
 
 // src/shared/account-id.ts
 var import_viem = require("viem");
@@ -297,7 +334,7 @@ var import_v42 = require("zod/v4");
 // src/shared/zod-schemas.ts
 var import_caip = require("caip");
 var import_viem8 = require("viem");
-var import_v4 = __toESM(require("zod/v4"), 1);
+var import_v4 = require("zod/v4");
 
 // src/ens/index.ts
 var import_datasources2 = require("@ensnode/datasources");
@@ -329,6 +366,8 @@ var ETH_NODE = (0, import_viem2.namehash)("eth");
 var BASENAMES_NODE = (0, import_viem2.namehash)("base.eth");
 var LINEANAMES_NODE = (0, import_viem2.namehash)("linea.eth");
 var ADDR_REVERSE_NODE = (0, import_viem2.namehash)("addr.reverse");
+var NODE_ANY = import_viem2.zeroHash;
+var ROOT_RESOURCE = 0n;
 
 // src/ens/dns-encoded-name.ts
 var import_viem3 = require("viem");
@@ -377,6 +416,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
 var import_ens = require("viem/ens");
 function isNormalizedName(name) {
@@ -547,7 +590,7 @@ function addPrices(...prices) {
   );
 }
 
-// src/shared/reinterpretation.ts
+// src/shared/interpretation/reinterpretation.ts
 var import_viem7 = require("viem");
 function reinterpretLabel(label) {
   if (label === "") {
@@ -568,14 +611,14 @@ function reinterpretName(name) {
 }
 
 // src/shared/zod-schemas.ts
-var makeFiniteNonNegativeNumberSchema = (valueLabel = "Value") => import_v4.default.number({
+var makeFiniteNonNegativeNumberSchema = (valueLabel = "Value") => import_v4.z.number({
   // NOTE: Zod's implementation of `number` automatically rejects NaN and Infinity values.
   // and therefore the finite check is implicit.
   error: `${valueLabel} must be a finite number.`
 }).nonnegative({
   error: `${valueLabel} must be a non-negative number (>=0).`
 });
-var makeIntegerSchema = (valueLabel = "Value") => import_v4.default.int({
+var makeIntegerSchema = (valueLabel = "Value") => import_v4.z.int({
   error: `${valueLabel} must be an integer.`
 });
 var makePositiveIntegerSchema = (valueLabel = "Value") => makeIntegerSchema(valueLabel).positive({
@@ -584,12 +627,12 @@ var makePositiveIntegerSchema = (valueLabel = "Value") => makeIntegerSchema(valu
 var makeNonNegativeIntegerSchema = (valueLabel = "Value") => makeIntegerSchema(valueLabel).nonnegative({
   error: `${valueLabel} must be a non-negative integer (>=0).`
 });
-var makeDurationSchema = (valueLabel = "Value") => import_v4.default.coerce.number({
+var makeDurationSchema = (valueLabel = "Value") => import_v4.z.coerce.number({
   error: `${valueLabel} must be a number.`
 }).pipe(makeNonNegativeIntegerSchema(valueLabel));
 var makeChainIdSchema = (valueLabel = "Chain ID") => makePositiveIntegerSchema(valueLabel).transform((val) => val);
-var makeChainIdStringSchema = (valueLabel = "Chain ID String") => import_v4.default.string({ error: `${valueLabel} must be a string representing a chain ID.` }).pipe(import_v4.default.coerce.number({ error: `${valueLabel} must represent a positive integer (>0).` })).pipe(makeChainIdSchema(`The numeric value represented by ${valueLabel}`));
-var makeLowercaseAddressSchema = (valueLabel = "EVM address") => import_v4.default.string().check((ctx) => {
+var makeChainIdStringSchema = (valueLabel = "Chain ID String") => import_v4.z.string({ error: `${valueLabel} must be a string representing a chain ID.` }).pipe(import_v4.z.coerce.number({ error: `${valueLabel} must represent a positive integer (>0).` })).pipe(makeChainIdSchema(`The numeric value represented by ${valueLabel}`));
+var makeLowercaseAddressSchema = (valueLabel = "EVM address") => import_v4.z.string().check((ctx) => {
   if (!(0, import_viem8.isAddress)(ctx.value)) {
     ctx.issues.push({
       code: "custom",
@@ -598,14 +641,14 @@ var makeLowercaseAddressSchema = (valueLabel = "EVM address") => import_v4.defau
     });
   }
 }).transform((val) => asLowerCaseAddress(val));
-var makeDatetimeSchema = (valueLabel = "Datetime string") => import_v4.default.iso.datetime({ error: `${valueLabel} must be a string in ISO 8601 format.` }).transform((v) => new Date(v));
+var makeDatetimeSchema = (valueLabel = "Datetime string") => import_v4.z.iso.datetime({ error: `${valueLabel} must be a string in ISO 8601 format.` }).transform((v) => new Date(v));
 var makeUnixTimestampSchema = (valueLabel = "Timestamp") => makeIntegerSchema(valueLabel);
-var makeUrlSchema = (valueLabel = "Value") => import_v4.default.url({
+var makeUrlSchema = (valueLabel = "Value") => import_v4.z.url({
   error: `${valueLabel} must be a valid URL string (e.g., http://localhost:8080 or https://example.com).`,
   abort: true
 }).transform((v) => new URL(v));
 var makeBlockNumberSchema = (valueLabel = "Block number") => makeNonNegativeIntegerSchema(valueLabel);
-var makeBlockrangeSchema = (valueLabel = "Value") => import_v4.default.strictObject(
+var makeBlockrangeSchema = (valueLabel = "Value") => import_v4.z.strictObject(
   {
     startBlock: makeBlockNumberSchema(`${valueLabel}.startBlock`).optional(),
     endBlock: makeBlockNumberSchema(`${valueLabel}.endBlock`).optional()
@@ -622,7 +665,7 @@ var makeBlockrangeSchema = (valueLabel = "Value") => import_v4.default.strictObj
   },
   { error: `${valueLabel}: startBlock must be before or equal to endBlock` }
 );
-var makeBlockRefSchema = (valueLabel = "Value") => import_v4.default.strictObject(
+var makeBlockRefSchema = (valueLabel = "Value") => import_v4.z.strictObject(
   {
     timestamp: makeUnixTimestampSchema(`${valueLabel}.timestamp`),
     number: makeBlockNumberSchema(`${valueLabel}.number`)
@@ -631,35 +674,35 @@ var makeBlockRefSchema = (valueLabel = "Value") => import_v4.default.strictObjec
     error: `${valueLabel} must be a valid BlockRef object.`
   }
 );
-var makeENSNamespaceIdSchema = (valueLabel = "ENSNamespaceId") => import_v4.default.enum(import_datasources.ENSNamespaceIds, {
+var makeENSNamespaceIdSchema = (valueLabel = "ENSNamespaceId") => import_v4.z.enum(import_datasources.ENSNamespaceIds, {
   error() {
     return `Invalid ${valueLabel}. Supported ENS namespace IDs are: ${Object.keys(import_datasources.ENSNamespaceIds).join(", ")}`;
   }
 });
-var makePriceAmountSchema = (valueLabel = "Amount") => import_v4.default.coerce.bigint({
+var makePriceAmountSchema = (valueLabel = "Amount") => import_v4.z.coerce.bigint({
   error: `${valueLabel} must represent a bigint.`
 }).nonnegative({
   error: `${valueLabel} must not be negative.`
 });
-var makePriceCurrencySchema = (currency, valueLabel = "Price Currency") => import_v4.default.strictObject({
+var makePriceCurrencySchema = (currency, valueLabel = "Price Currency") => import_v4.z.strictObject({
   amount: makePriceAmountSchema(`${valueLabel} amount`),
-  currency: import_v4.default.literal(currency, {
+  currency: import_v4.z.literal(currency, {
     error: `${valueLabel} currency must be set to '${currency}'.`
   })
 });
 var makePriceEthSchema = (valueLabel = "Price ETH") => makePriceCurrencySchema(CurrencyIds.ETH, valueLabel).transform((v) => v);
-var makeAccountIdSchema = (valueLabel = "AccountId") => import_v4.default.strictObject({
+var makeAccountIdSchema = (valueLabel = "AccountId") => import_v4.z.strictObject({
   chainId: makeChainIdSchema(`${valueLabel} chain ID`),
   address: makeLowercaseAddressSchema(`${valueLabel} address`)
 });
-var makeAccountIdStringSchema = (valueLabel = "Account ID String") => import_v4.default.coerce.string().transform((v) => {
+var makeAccountIdStringSchema = (valueLabel = "Account ID String") => import_v4.z.coerce.string().transform((v) => {
   const result = new import_caip.AccountId(v);
   return {
     chainId: Number(result.chainId.reference),
     address: result.address
   };
 }).pipe(makeAccountIdSchema(valueLabel));
-var makeHexStringSchema = (options, valueLabel = "String representation of bytes array") => import_v4.default.string().check(function invariant_isHexEncoded(ctx) {
+var makeHexStringSchema = (options, valueLabel = "String representation of bytes array") => import_v4.z.string().check(function invariant_isHexEncoded(ctx) {
   if (!(0, import_viem8.isHex)(ctx.value)) {
     ctx.issues.push({
       code: "custom",
@@ -680,7 +723,7 @@ var makeHexStringSchema = (options, valueLabel = "String representation of bytes
 });
 var makeNodeSchema = (valueLabel = "Node") => makeHexStringSchema({ bytesCount: 32 }, valueLabel);
 var makeTransactionHashSchema = (valueLabel = "Transaction hash") => makeHexStringSchema({ bytesCount: 32 }, valueLabel);
-var makeReinterpretedNameSchema = (valueLabel = "Reinterpreted Name") => import_v4.default.string().transform((v) => v).check((ctx) => {
+var makeReinterpretedNameSchema = (valueLabel = "Reinterpreted Name") => import_v4.z.string().transform((v) => v).check((ctx) => {
   try {
     reinterpretName(ctx.value);
   } catch (error) {
@@ -943,12 +986,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/labelhash.ts
+// src/shared/interpretation/interpret-address.ts
 var import_viem9 = require("viem");
-var labelhashLiteralLabel = (label) => (0, import_viem9.keccak256)((0, import_viem9.stringToBytes)(label));
+var interpretAddress = (owner) => (0, import_viem9.isAddressEqual)(import_viem9.zeroAddress, owner) ? null : owner;
+
+// src/shared/interpretation/interpret-record-values.ts
+var import_viem10 = require("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 (!(0, import_viem10.isAddress)(value)) return value;
+  if ((0, import_viem10.isAddressEqual)(value, import_viem10.zeroAddress)) 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.ts
+// src/shared/interpretation/interpreted-names-and-labels.ts
+var import_viem12 = require("viem");
+var import_ens5 = require("viem/ens");
+
+// src/shared/labelhash.ts
+var import_viem11 = require("viem");
+var labelhashLiteralLabel = (label) => (0, import_viem11.keccak256)((0, import_viem11.stringToBytes)(label));
+
+// src/shared/interpretation/interpreted-names-and-labels.ts
 function literalLabelToInterpretedLabel(label) {
   if (isNormalizedLabel(label)) return label;
   return encodeLabelHash(labelhashLiteralLabel(label));
@@ -962,10 +1053,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 (!(0, import_viem12.isHex)(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 (0, import_ens5.labelhash)(label);
+  }).toReversed();
+}
 
 // src/shared/numbers.ts
 function bigIntToNumber(n) {
@@ -982,6 +1102,14 @@ function bigIntToNumber(n) {
   return Number(n);
 }
 
+// src/shared/root-registry.ts
+var import_datasources4 = require("@ensnode/datasources");
+var getENSv1Registry = (namespace) => getDatasourceContract(namespace, import_datasources4.DatasourceNames.ENSRoot, "ENSv1Registry");
+var isENSv1Registry = (namespace, contract) => accountIdEqual(getENSv1Registry(namespace), contract);
+var getENSv2RootRegistry = (namespace) => getDatasourceContract(namespace, import_datasources4.DatasourceNames.ENSRoot, "RootRegistry");
+var getENSv2RootRegistryId = (namespace) => makeRegistryId(getENSv2RootRegistry(namespace));
+var isENSv2RootRegistry = (namespace, contract) => accountIdEqual(getENSv2RootRegistry(namespace), contract);
+
 // src/shared/serialize.ts
 var import_caip2 = require("caip");
 function serializeChainId(chainId) {
@@ -1008,6 +1136,23 @@ function formatAccountId(accountId) {
     address: accountId.address
   }).toLowerCase();
 }
+function formatAssetId({
+  assetNamespace,
+  contract: { chainId, address },
+  tokenId
+}) {
+  return import_caip2.AssetId.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) {
@@ -1018,7 +1163,7 @@ function isWebSocketProtocol(url) {
 }
 
 // src/ensindexer/config/is-subgraph-compatible.ts
-var import_datasources4 = require("@ensnode/datasources");
+var import_datasources5 = require("@ensnode/datasources");
 
 // src/ensindexer/config/types.ts
 var PluginName = /* @__PURE__ */ ((PluginName2) => {
@@ -1029,6 +1174,7 @@ var PluginName = /* @__PURE__ */ ((PluginName2) => {
   PluginName2["ProtocolAcceleration"] = "protocol-acceleration";
   PluginName2["Registrars"] = "registrars";
   PluginName2["TokenScope"] = "tokenscope";
+  PluginName2["ENSv2"] = "ensv2";
   return PluginName2;
 })(PluginName || {});
 
@@ -1037,7 +1183,7 @@ function isSubgraphCompatible(config) {
   const onlySubgraphPluginActivated = config.plugins.length === 1 && config.plugins[0] === "subgraph" /* Subgraph */;
   const isSubgraphLabelSet = config.labelSet.labelSetId === "subgraph" && config.labelSet.labelSetVersion === 0;
   const isEnsTestEnvLabelSet = config.labelSet.labelSetId === "ens-test-env" && config.labelSet.labelSetVersion === 0;
-  const labelSetIsSubgraphCompatible = isSubgraphLabelSet || config.namespace === import_datasources4.ENSNamespaceIds.EnsTestEnv && isEnsTestEnvLabelSet;
+  const labelSetIsSubgraphCompatible = isSubgraphLabelSet || config.namespace === import_datasources5.ENSNamespaceIds.EnsTestEnv && isEnsTestEnvLabelSet;
   return onlySubgraphPluginActivated && labelSetIsSubgraphCompatible;
 }
 
@@ -1054,26 +1200,26 @@ function invariant_ensDbVersionIsSameAsEnsIndexerVersion(ctx) {
 }
 
 // src/ensindexer/config/zod-schemas.ts
-var makeIndexedChainIdsSchema = (valueLabel = "Indexed Chain IDs") => import_v43.default.array(makeChainIdSchema(valueLabel), {
+var makeIndexedChainIdsSchema = (valueLabel = "Indexed Chain IDs") => import_v43.z.array(makeChainIdSchema(valueLabel), {
   error: `${valueLabel} must be an array.`
 }).min(1, { error: `${valueLabel} list must include at least one element.` }).transform((v) => new Set(v));
-var makePluginsListSchema = (valueLabel = "Plugins") => import_v43.default.array(import_v43.default.string(), {
+var makePluginsListSchema = (valueLabel = "Plugins") => import_v43.z.array(import_v43.z.string(), {
   error: `${valueLabel} must be a list of strings.`
 }).min(1, {
   error: `${valueLabel} must be a list of strings with at least one string value`
 }).refine((arr) => arr.length === uniq(arr).length, {
   error: `${valueLabel} cannot contain duplicate values.`
 });
-var makeDatabaseSchemaNameSchema = (valueLabel = "Database schema name") => import_v43.default.string({ error: `${valueLabel} must be a string` }).trim().nonempty({
+var makeDatabaseSchemaNameSchema = (valueLabel = "Database schema name") => import_v43.z.string({ error: `${valueLabel} must be a string` }).trim().nonempty({
   error: `${valueLabel} is required and must be a non-empty string.`
 });
 var makeLabelSetIdSchema = (valueLabel) => {
-  return import_v43.default.string({ error: `${valueLabel} must be a string` }).min(1, { error: `${valueLabel} must be 1-50 characters long` }).max(50, { error: `${valueLabel} must be 1-50 characters long` }).regex(/^[a-z-]+$/, {
+  return import_v43.z.string({ error: `${valueLabel} must be a string` }).min(1, { error: `${valueLabel} must be 1-50 characters long` }).max(50, { error: `${valueLabel} must be 1-50 characters long` }).regex(/^[a-z-]+$/, {
     error: `${valueLabel} can only contain lowercase letters (a-z) and hyphens (-)`
   });
 };
 var makeLabelSetVersionSchema = (valueLabel) => {
-  return import_v43.default.coerce.number({ error: `${valueLabel} must be an integer.` }).pipe(makeNonNegativeIntegerSchema(valueLabel));
+  return import_v43.z.coerce.number({ error: `${valueLabel} must be an integer.` }).pipe(makeNonNegativeIntegerSchema(valueLabel));
 };
 var makeFullyPinnedLabelSetSchema = (valueLabel = "Label set") => {
   let valueLabelLabelSetId = valueLabel;
@@ -1085,13 +1231,13 @@ var makeFullyPinnedLabelSetSchema = (valueLabel = "Label set") => {
     valueLabelLabelSetId = `${valueLabel}.labelSetId`;
     valueLabelLabelSetVersion = `${valueLabel}.labelSetVersion`;
   }
-  return import_v43.default.object({
+  return import_v43.z.object({
     labelSetId: makeLabelSetIdSchema(valueLabelLabelSetId),
     labelSetVersion: makeLabelSetVersionSchema(valueLabelLabelSetVersion)
   });
 };
-var makeNonEmptyStringSchema = (valueLabel = "Value") => import_v43.default.string().nonempty({ error: `${valueLabel} must be a non-empty string.` });
-var makeENSIndexerVersionInfoSchema = (valueLabel = "Value") => import_v43.default.strictObject(
+var makeNonEmptyStringSchema = (valueLabel = "Value") => import_v43.z.string().nonempty({ error: `${valueLabel} must be a non-empty string.` });
+var makeENSIndexerVersionInfoSchema = (valueLabel = "Value") => import_v43.z.strictObject(
   {
     nodejs: makeNonEmptyStringSchema(),
     ponder: makeNonEmptyStringSchema(),
@@ -1115,10 +1261,10 @@ function invariant_isSubgraphCompatibleRequirements(ctx) {
     });
   }
 }
-var makeENSIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") => import_v43.default.object({
+var makeENSIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") => import_v43.z.object({
   labelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.labelSet`),
   indexedChainIds: makeIndexedChainIdsSchema(`${valueLabel}.indexedChainIds`),
-  isSubgraphCompatible: import_v43.default.boolean({ error: `${valueLabel}.isSubgraphCompatible` }),
+  isSubgraphCompatible: import_v43.z.boolean({ error: `${valueLabel}.isSubgraphCompatible` }),
   namespace: makeENSNamespaceIdSchema(`${valueLabel}.namespace`),
   plugins: makePluginsListSchema(`${valueLabel}.plugins`),
   databaseSchemaName: makeDatabaseSchemaNameSchema(`${valueLabel}.databaseSchemaName`),
@@ -1182,7 +1328,7 @@ ${(0, import_v47.prettifyError)(parsed.error)}
 }
 
 // src/ensindexer/config/label-utils.ts
-var import_viem10 = require("viem");
+var import_viem13 = require("viem");
 function labelHashToBytes(labelHash) {
   try {
     if (labelHash.length !== 66) {
@@ -1194,7 +1340,7 @@ function labelHashToBytes(labelHash) {
     if (!labelHash.startsWith("0x")) {
       throw new Error("Labelhash must be 0x-prefixed");
     }
-    const bytes = (0, import_viem10.hexToBytes)(labelHash);
+    const bytes = (0, import_viem13.hexToBytes)(labelHash);
     if (bytes.length !== 32) {
       throw new Error(`Invalid labelHash length ${bytes.length} bytes (expected 32)`);
     }
@@ -1290,7 +1436,7 @@ function serializeENSIndexerPublicConfig(config) {
 var import_v49 = require("zod/v4");
 
 // src/ensindexer/indexing-status/zod-schemas.ts
-var import_v48 = __toESM(require("zod/v4"), 1);
+var import_v48 = require("zod/v4");
 
 // src/ensindexer/indexing-status/types.ts
 var ChainIndexingConfigTypeIds = {
@@ -1716,7 +1862,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})`
     });
   }
 }
@@ -1746,52 +1892,52 @@ function invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect(ct
 }
 
 // src/ensindexer/indexing-status/zod-schemas.ts
-var makeChainIndexingConfigSchema = (valueLabel = "Value") => import_v48.default.discriminatedUnion("configType", [
-  import_v48.default.strictObject({
-    configType: import_v48.default.literal(ChainIndexingConfigTypeIds.Indefinite),
+var makeChainIndexingConfigSchema = (valueLabel = "Value") => import_v48.z.discriminatedUnion("configType", [
+  import_v48.z.strictObject({
+    configType: import_v48.z.literal(ChainIndexingConfigTypeIds.Indefinite),
     startBlock: makeBlockRefSchema(valueLabel)
   }),
-  import_v48.default.strictObject({
-    configType: import_v48.default.literal(ChainIndexingConfigTypeIds.Definite),
+  import_v48.z.strictObject({
+    configType: import_v48.z.literal(ChainIndexingConfigTypeIds.Definite),
     startBlock: makeBlockRefSchema(valueLabel),
     endBlock: makeBlockRefSchema(valueLabel)
   })
 ]);
-var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => import_v48.default.strictObject({
-  chainStatus: import_v48.default.literal(ChainIndexingStatusIds.Queued),
+var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => import_v48.z.strictObject({
+  chainStatus: import_v48.z.literal(ChainIndexingStatusIds.Queued),
   config: makeChainIndexingConfigSchema(valueLabel)
 }).check(invariant_chainSnapshotQueuedBlocks);
-var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => import_v48.default.strictObject({
-  chainStatus: import_v48.default.literal(ChainIndexingStatusIds.Backfill),
+var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => import_v48.z.strictObject({
+  chainStatus: import_v48.z.literal(ChainIndexingStatusIds.Backfill),
   config: makeChainIndexingConfigSchema(valueLabel),
   latestIndexedBlock: makeBlockRefSchema(valueLabel),
   backfillEndBlock: makeBlockRefSchema(valueLabel)
 }).check(invariant_chainSnapshotBackfillBlocks);
-var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => import_v48.default.strictObject({
-  chainStatus: import_v48.default.literal(ChainIndexingStatusIds.Completed),
-  config: import_v48.default.strictObject({
-    configType: import_v48.default.literal(ChainIndexingConfigTypeIds.Definite),
+var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => import_v48.z.strictObject({
+  chainStatus: import_v48.z.literal(ChainIndexingStatusIds.Completed),
+  config: import_v48.z.strictObject({
+    configType: import_v48.z.literal(ChainIndexingConfigTypeIds.Definite),
     startBlock: makeBlockRefSchema(valueLabel),
     endBlock: makeBlockRefSchema(valueLabel)
   }),
   latestIndexedBlock: makeBlockRefSchema(valueLabel)
 }).check(invariant_chainSnapshotCompletedBlocks);
-var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => import_v48.default.strictObject({
-  chainStatus: import_v48.default.literal(ChainIndexingStatusIds.Following),
-  config: import_v48.default.strictObject({
-    configType: import_v48.default.literal(ChainIndexingConfigTypeIds.Indefinite),
+var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => import_v48.z.strictObject({
+  chainStatus: import_v48.z.literal(ChainIndexingStatusIds.Following),
+  config: import_v48.z.strictObject({
+    configType: import_v48.z.literal(ChainIndexingConfigTypeIds.Indefinite),
     startBlock: makeBlockRefSchema(valueLabel)
   }),
   latestIndexedBlock: makeBlockRefSchema(valueLabel),
   latestKnownBlock: makeBlockRefSchema(valueLabel)
 }).check(invariant_chainSnapshotFollowingBlocks);
-var makeChainIndexingStatusSnapshotSchema = (valueLabel = "Value") => import_v48.default.discriminatedUnion("chainStatus", [
+var makeChainIndexingStatusSnapshotSchema = (valueLabel = "Value") => import_v48.z.discriminatedUnion("chainStatus", [
   makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
   makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
   makeChainIndexingStatusSnapshotCompletedSchema(valueLabel),
   makeChainIndexingStatusSnapshotFollowingSchema(valueLabel)
 ]);
-var makeChainIndexingStatusesSchema = (valueLabel = "Value") => import_v48.default.record(makeChainIdStringSchema(), makeChainIndexingStatusSnapshotSchema(valueLabel), {
+var makeChainIndexingStatusesSchema = (valueLabel = "Value") => import_v48.z.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();
@@ -1800,29 +1946,29 @@ var makeChainIndexingStatusesSchema = (valueLabel = "Value") => import_v48.defau
   }
   return chainsIndexingStatus;
 });
-var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_v48.default.strictObject({
-  omnichainStatus: import_v48.default.literal(OmnichainIndexingStatusIds.Unstarted),
+var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_v48.z.strictObject({
+  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Unstarted),
   chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainSnapshotUnstartedHasValidChains).transform((chains) => chains),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => import_v48.default.strictObject({
-  omnichainStatus: import_v48.default.literal(OmnichainIndexingStatusIds.Backfill),
+var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => import_v48.z.strictObject({
+  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Backfill),
   chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotBackfillHasValidChains).transform(
     (chains) => chains
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => import_v48.default.strictObject({
-  omnichainStatus: import_v48.default.literal(OmnichainIndexingStatusIds.Completed),
+var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => import_v48.z.strictObject({
+  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Completed),
   chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotCompletedHasValidChains).transform((chains) => chains),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => import_v48.default.strictObject({
-  omnichainStatus: import_v48.default.literal(OmnichainIndexingStatusIds.Following),
+var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => import_v48.z.strictObject({
+  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Following),
   chains: makeChainIndexingStatusesSchema(valueLabel),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => import_v48.default.discriminatedUnion("omnichainStatus", [
+var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => import_v48.z.discriminatedUnion("omnichainStatus", [
   makeOmnichainIndexingStatusSnapshotUnstartedSchema(valueLabel),
   makeOmnichainIndexingStatusSnapshotBackfillSchema(valueLabel),
   makeOmnichainIndexingStatusSnapshotCompletedSchema(valueLabel),
@@ -1830,16 +1976,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") => import_v48.default.strictObject({
-  strategy: import_v48.default.literal(CrossChainIndexingStrategyIds.Omnichain),
+var makeCrossChainIndexingStatusSnapshotOmnichainSchema = (valueLabel = "Cross-chain Indexing Status Snapshot Omnichain") => import_v48.z.strictObject({
+  strategy: import_v48.z.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") => import_v48.default.discriminatedUnion("strategy", [
+var makeCrossChainIndexingStatusSnapshotSchema = (valueLabel = "Cross-chain Indexing Status Snapshot") => import_v48.z.discriminatedUnion("strategy", [
   makeCrossChainIndexingStatusSnapshotOmnichainSchema(valueLabel)
 ]);
-var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => import_v48.default.strictObject({
+var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => import_v48.z.strictObject({
   projectedAt: makeUnixTimestampSchema(valueLabel),
   worstCaseDistance: makeDurationSchema(valueLabel),
   snapshot: makeCrossChainIndexingStatusSnapshotSchema(valueLabel)
@@ -2042,22 +2188,21 @@ function serializeIndexingStatusResponse(response) {
 var import_v416 = require("zod/v4");
 
 // src/api/name-tokens/zod-schemas.ts
-var import_viem14 = require("viem");
+var import_viem17 = require("viem");
 var import_v415 = __toESM(require("zod/v4"), 1);
 
 // src/tokenscope/assets.ts
-var import_caip4 = require("caip");
-var import_viem13 = require("viem");
+var import_viem16 = require("viem");
 var import_v413 = require("zod/v4");
 
 // src/tokenscope/zod-schemas.ts
 var import_caip3 = require("caip");
-var import_viem12 = require("viem");
+var import_viem15 = require("viem");
 var import_v412 = __toESM(require("zod/v4"), 1);
 
 // src/tokenscope/name-token.ts
-var import_viem11 = require("viem");
-var import_datasources5 = require("@ensnode/datasources");
+var import_viem14 = require("viem");
+var import_datasources6 = require("@ensnode/datasources");
 var NameTokenOwnershipTypes = {
   /**
    * Name Token is owned by NameWrapper account.
@@ -2088,12 +2233,12 @@ function serializeNameToken(nameToken) {
 function getNameWrapperAccounts(namespaceId) {
   const ethnamesNameWrapperAccount = getDatasourceContract(
     namespaceId,
-    import_datasources5.DatasourceNames.ENSRoot,
+    import_datasources6.DatasourceNames.ENSRoot,
     "NameWrapper"
   );
   const lineanamesNameWrapperAccount = maybeGetDatasourceContract(
     namespaceId,
-    import_datasources5.DatasourceNames.Lineanames,
+    import_datasources6.DatasourceNames.Lineanames,
     "NameWrapper"
   );
   const nameWrapperAccounts = [
@@ -2116,7 +2261,7 @@ function getNameTokenOwnership(namespaceId, name, owner) {
       owner
     };
   }
-  if ((0, import_viem11.isAddressEqual)(owner.address, import_viem11.zeroAddress)) {
+  if ((0, import_viem14.isAddressEqual)(owner.address, import_viem14.zeroAddress)) {
     return {
       ownershipType: NameTokenOwnershipTypes.Burned,
       owner
@@ -2171,7 +2316,7 @@ var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => import_
 }, makeAssetIdSchema(valueLabel));
 function invariant_nameTokenOwnershipHasNonZeroAddressOwner(ctx) {
   const ownership = ctx.value;
-  if (ctx.value.owner.address === import_viem12.zeroAddress) {
+  if (ctx.value.owner.address === import_viem15.zeroAddress) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
@@ -2197,7 +2342,7 @@ var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Un
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
 function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
   const ownership = ctx.value;
-  if (ctx.value.owner.address !== import_viem12.zeroAddress) {
+  if (ctx.value.owner.address !== import_viem15.zeroAddress) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
@@ -2218,10 +2363,6 @@ var makeNameTokenSchema = (valueLabel = "Name Token Schema", serializable) => im
 });
 
 // src/tokenscope/assets.ts
-var AssetNamespaces = {
-  ERC721: "erc721",
-  ERC1155: "erc1155"
-};
 function serializeAssetId(assetId) {
   return {
     assetNamespace: assetId.assetNamespace,
@@ -2239,14 +2380,6 @@ ${(0, import_v413.prettifyError)(parsed.error)}
   }
   return parsed.data;
 }
-function formatAssetId(assetId) {
-  const { assetNamespace, contract, tokenId } = serializeAssetId(assetId);
-  return import_caip4.AssetId.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);
@@ -2275,13 +2408,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 = {
@@ -2387,11 +2520,11 @@ var NFTTransferTypes = {
 };
 var getNFTTransferType = (from, to, allowMintedRemint, metadata, currentlyIndexedOwner) => {
   const isIndexed = currentlyIndexedOwner !== void 0;
-  const isIndexedAsMinted = isIndexed && !(0, import_viem13.isAddressEqual)(currentlyIndexedOwner, import_viem13.zeroAddress);
-  const isMint = (0, import_viem13.isAddressEqual)(from, import_viem13.zeroAddress);
-  const isBurn = (0, import_viem13.isAddressEqual)(to, import_viem13.zeroAddress);
-  const isSelfTransfer = (0, import_viem13.isAddressEqual)(from, to);
-  if (isIndexed && !(0, import_viem13.isAddressEqual)(currentlyIndexedOwner, from)) {
+  const isIndexedAsMinted = isIndexed && !(0, import_viem16.isAddressEqual)(currentlyIndexedOwner, import_viem16.zeroAddress);
+  const isMint = (0, import_viem16.isAddressEqual)(from, import_viem16.zeroAddress);
+  const isBurn = (0, import_viem16.isAddressEqual)(to, import_viem16.zeroAddress);
+  const isSelfTransfer = (0, import_viem16.isAddressEqual)(from, to);
+  if (isIndexed && !(0, import_viem16.isAddressEqual)(currentlyIndexedOwner, from)) {
     if (isMint && allowMintedRemint) {
     } else {
       throw new Error(
@@ -2524,7 +2657,7 @@ var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", seria
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 }).check(function invariant_nameIsAssociatedWithDomainId(ctx) {
   const { name, domainId } = ctx.value;
-  if ((0, import_viem14.namehash)(name) !== domainId) {
+  if ((0, import_viem17.namehash)(name) !== domainId) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
@@ -2676,37 +2809,37 @@ function serializeNameTokensResponse(response) {
 var import_v420 = require("zod/v4");
 
 // src/api/registrar-actions/zod-schemas.ts
-var import_ens7 = require("viem/ens");
+var import_ens10 = require("viem/ens");
 var import_v419 = __toESM(require("zod/v4"), 1);
 
 // ../ens-referrals/src/address.ts
-var import_viem15 = require("viem");
+var import_viem18 = require("viem");
 
 // ../ens-referrals/src/encoding.ts
-var import_viem16 = require("viem");
+var import_viem19 = require("viem");
 var ENCODED_REFERRER_BYTE_OFFSET = 12;
 var ENCODED_REFERRER_BYTE_LENGTH = 32;
-var EXPECTED_ENCODED_REFERRER_PADDING = (0, import_viem16.pad)("0x", {
+var EXPECTED_ENCODED_REFERRER_PADDING = (0, import_viem19.pad)("0x", {
   size: ENCODED_REFERRER_BYTE_OFFSET,
   dir: "left"
 });
-var ZERO_ENCODED_REFERRER = (0, import_viem16.pad)("0x", {
+var ZERO_ENCODED_REFERRER = (0, import_viem19.pad)("0x", {
   size: ENCODED_REFERRER_BYTE_LENGTH,
   dir: "left"
 });
 function decodeEncodedReferrer(encodedReferrer) {
-  if ((0, import_viem16.size)(encodedReferrer) !== ENCODED_REFERRER_BYTE_LENGTH) {
+  if ((0, import_viem19.size)(encodedReferrer) !== ENCODED_REFERRER_BYTE_LENGTH) {
     throw new Error(
       `Encoded referrer value must be represented by ${ENCODED_REFERRER_BYTE_LENGTH} bytes.`
     );
   }
-  const padding = (0, import_viem16.slice)(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
+  const padding = (0, import_viem19.slice)(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
   if (padding !== EXPECTED_ENCODED_REFERRER_PADDING) {
-    return import_viem16.zeroAddress;
+    return import_viem19.zeroAddress;
   }
-  const decodedReferrer = (0, import_viem16.slice)(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
+  const decodedReferrer = (0, import_viem19.slice)(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
   try {
-    return (0, import_viem16.getAddress)(decodedReferrer);
+    return (0, import_viem19.getAddress)(decodedReferrer);
   } catch {
     throw new Error(`Decoded referrer value must be a valid EVM address.`);
   }
@@ -2716,7 +2849,7 @@ function decodeEncodedReferrer(encodedReferrer) {
 var REFERRERS_PER_LEADERBOARD_PAGE_MAX = 100;
 
 // ../ens-referrals/src/link.ts
-var import_viem17 = require("viem");
+var import_viem20 = require("viem");
 
 // ../ens-referrals/src/referrer-detail.ts
 var ReferrerDetailTypeIds = {
@@ -2731,7 +2864,7 @@ var ReferrerDetailTypeIds = {
 };
 
 // src/registrars/zod-schemas.ts
-var import_v417 = __toESM(require("zod/v4"), 1);
+var import_v417 = require("zod/v4");
 
 // src/registrars/registrar-action.ts
 var RegistrarActionTypes = {
@@ -2772,11 +2905,11 @@ function serializeRegistrarAction(registrarAction) {
 }
 
 // src/registrars/zod-schemas.ts
-var makeSubregistrySchema = (valueLabel = "Subregistry") => import_v417.default.object({
+var makeSubregistrySchema = (valueLabel = "Subregistry") => import_v417.z.object({
   subregistryId: makeAccountIdSchema(`${valueLabel} Subregistry ID`),
   node: makeNodeSchema(`${valueLabel} Node`)
 });
-var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => import_v417.default.object({
+var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => import_v417.z.object({
   subregistry: makeSubregistrySchema(`${valueLabel} Subregistry`),
   node: makeNodeSchema(`${valueLabel} Node`),
   expiresAt: makeUnixTimestampSchema(`${valueLabel} Expires at`)
@@ -2792,18 +2925,18 @@ function invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium(ctx) {
     });
   }
 }
-var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => import_v417.default.union([
+var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => import_v417.z.union([
   // pricing available
-  import_v417.default.object({
+  import_v417.z.object({
     baseCost: makePriceEthSchema(`${valueLabel} Base Cost`),
     premium: makePriceEthSchema(`${valueLabel} Premium`),
     total: makePriceEthSchema(`${valueLabel} Total`)
   }).check(invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium).transform((v) => v),
   // pricing unknown
-  import_v417.default.object({
-    baseCost: import_v417.default.null(),
-    premium: import_v417.default.null(),
-    total: import_v417.default.null()
+  import_v417.z.object({
+    baseCost: import_v417.z.null(),
+    premium: import_v417.z.null(),
+    total: import_v417.z.null()
   }).transform((v) => v)
 ]);
 function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
@@ -2826,9 +2959,9 @@ function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
     });
   }
 }
-var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => import_v417.default.union([
+var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => import_v417.z.union([
   // referral available
-  import_v417.default.object({
+  import_v417.z.object({
     encodedReferrer: makeHexStringSchema(
       { bytesCount: ENCODED_REFERRER_BYTE_LENGTH },
       `${valueLabel} Encoded Referrer`
@@ -2836,9 +2969,9 @@ var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral
     decodedReferrer: makeLowercaseAddressSchema(`${valueLabel} Decoded Referrer`)
   }).check(invariant_registrarActionDecodedReferrerBasedOnRawReferrer),
   // referral not applicable
-  import_v417.default.object({
-    encodedReferrer: import_v417.default.null(),
-    decodedReferrer: import_v417.default.null()
+  import_v417.z.object({
+    encodedReferrer: import_v417.z.null(),
+    decodedReferrer: import_v417.z.null()
   })
 ]);
 function invariant_eventIdsInitialElementIsTheActionId(ctx) {
@@ -2851,9 +2984,9 @@ function invariant_eventIdsInitialElementIsTheActionId(ctx) {
     });
   }
 }
-var EventIdSchema = import_v417.default.string().nonempty();
-var EventIdsSchema = import_v417.default.array(EventIdSchema).min(1).transform((v) => v);
-var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => import_v417.default.object({
+var EventIdSchema = import_v417.z.string().nonempty();
+var EventIdsSchema = import_v417.z.array(EventIdSchema).min(1).transform((v) => v);
+var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => import_v417.z.object({
   id: EventIdSchema,
   incrementalDuration: makeDurationSchema(`${valueLabel} Incremental Duration`),
   registrant: makeLowercaseAddressSchema(`${valueLabel} Registrant`),
@@ -2867,12 +3000,12 @@ var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => im
   eventIds: EventIdsSchema
 }).check(invariant_eventIdsInitialElementIsTheActionId);
 var makeRegistrarActionRegistrationSchema = (valueLabel = "Registration ") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: import_v417.default.literal(RegistrarActionTypes.Registration)
+  type: import_v417.z.literal(RegistrarActionTypes.Registration)
 });
 var makeRegistrarActionRenewalSchema = (valueLabel = "Renewal") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: import_v417.default.literal(RegistrarActionTypes.Renewal)
+  type: import_v417.z.literal(RegistrarActionTypes.Renewal)
 });
-var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => import_v417.default.discriminatedUnion("type", [
+var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => import_v417.z.discriminatedUnion("type", [
   makeRegistrarActionRegistrationSchema(`${valueLabel} Registration`),
   makeRegistrarActionRenewalSchema(`${valueLabel} Renewal`)
 ]);
@@ -2962,7 +3095,7 @@ var RegistrarActionsResponseCodes = {
 function invariant_registrationLifecycleNodeMatchesName(ctx) {
   const { name, action } = ctx.value;
   const expectedNode = action.registrationLifecycle.node;
-  const actualNode = (0, import_ens7.namehash)(name);
+  const actualNode = (0, import_ens10.namehash)(name);
   if (actualNode !== expectedNode) {
     ctx.issues.push({
       code: "custom",
@@ -3118,11 +3251,11 @@ var registrarActionsPrerequisites = Object.freeze({
 });
 
 // src/registrars/basenames-subregistry.ts
-var import_datasources6 = require("@ensnode/datasources");
+var import_datasources7 = require("@ensnode/datasources");
 function getBasenamesSubregistryId(namespace) {
-  const datasource = (0, import_datasources6.maybeGetDatasource)(namespace, import_datasources6.DatasourceNames.Basenames);
+  const datasource = (0, import_datasources7.maybeGetDatasource)(namespace, import_datasources7.DatasourceNames.Basenames);
   if (!datasource) {
-    throw new Error(`Datasource not found for ${namespace} ${import_datasources6.DatasourceNames.Basenames}`);
+    throw new Error(`Datasource not found for ${namespace} ${import_datasources7.DatasourceNames.Basenames}`);
   }
   const address = datasource.contracts.BaseRegistrar?.address;
   if (address === void 0 || Array.isArray(address)) {
@@ -3135,12 +3268,11 @@ function getBasenamesSubregistryId(namespace) {
 }
 function getBasenamesSubregistryManagedName(namespaceId) {
   switch (namespaceId) {
-    case import_datasources6.ENSNamespaceIds.Mainnet:
+    case import_datasources7.ENSNamespaceIds.Mainnet:
       return "base.eth";
-    case import_datasources6.ENSNamespaceIds.Sepolia:
+    case import_datasources7.ENSNamespaceIds.Sepolia:
       return "basetest.eth";
-    case import_datasources6.ENSNamespaceIds.Holesky:
-    case import_datasources6.ENSNamespaceIds.EnsTestEnv:
+    case import_datasources7.ENSNamespaceIds.EnsTestEnv:
       throw new Error(
         `No registrar managed name is known for the 'basenames' subregistry within the "${namespaceId}" namespace.`
       );
@@ -3148,11 +3280,11 @@ function getBasenamesSubregistryManagedName(namespaceId) {
 }
 
 // src/registrars/ethnames-subregistry.ts
-var import_datasources7 = require("@ensnode/datasources");
+var import_datasources8 = require("@ensnode/datasources");
 function getEthnamesSubregistryId(namespace) {
-  const datasource = (0, import_datasources7.maybeGetDatasource)(namespace, import_datasources7.DatasourceNames.ENSRoot);
+  const datasource = (0, import_datasources8.maybeGetDatasource)(namespace, import_datasources8.DatasourceNames.ENSRoot);
   if (!datasource) {
-    throw new Error(`Datasource not found for ${namespace} ${import_datasources7.DatasourceNames.ENSRoot}`);
+    throw new Error(`Datasource not found for ${namespace} ${import_datasources8.DatasourceNames.ENSRoot}`);
   }
   const address = datasource.contracts.BaseRegistrar?.address;
   if (address === void 0 || Array.isArray(address)) {
@@ -3165,20 +3297,19 @@ function getEthnamesSubregistryId(namespace) {
 }
 function getEthnamesSubregistryManagedName(namespaceId) {
   switch (namespaceId) {
-    case import_datasources7.ENSNamespaceIds.Mainnet:
-    case import_datasources7.ENSNamespaceIds.Sepolia:
-    case import_datasources7.ENSNamespaceIds.Holesky:
-    case import_datasources7.ENSNamespaceIds.EnsTestEnv:
+    case import_datasources8.ENSNamespaceIds.Mainnet:
+    case import_datasources8.ENSNamespaceIds.Sepolia:
+    case import_datasources8.ENSNamespaceIds.EnsTestEnv:
       return "eth";
   }
 }
 
 // src/registrars/lineanames-subregistry.ts
-var import_datasources8 = require("@ensnode/datasources");
+var import_datasources9 = require("@ensnode/datasources");
 function getLineanamesSubregistryId(namespace) {
-  const datasource = (0, import_datasources8.maybeGetDatasource)(namespace, import_datasources8.DatasourceNames.Lineanames);
+  const datasource = (0, import_datasources9.maybeGetDatasource)(namespace, import_datasources9.DatasourceNames.Lineanames);
   if (!datasource) {
-    throw new Error(`Datasource not found for ${namespace} ${import_datasources8.DatasourceNames.Lineanames}`);
+    throw new Error(`Datasource not found for ${namespace} ${import_datasources9.DatasourceNames.Lineanames}`);
   }
   const address = datasource.contracts.BaseRegistrar?.address;
   if (address === void 0 || Array.isArray(address)) {
@@ -3191,18 +3322,32 @@ function getLineanamesSubregistryId(namespace) {
 }
 function getLineanamesSubregistryManagedName(namespaceId) {
   switch (namespaceId) {
-    case import_datasources8.ENSNamespaceIds.Mainnet:
+    case import_datasources9.ENSNamespaceIds.Mainnet:
       return "linea.eth";
-    case import_datasources8.ENSNamespaceIds.Sepolia:
+    case import_datasources9.ENSNamespaceIds.Sepolia:
       return "linea-sepolia.eth";
-    case import_datasources8.ENSNamespaceIds.Holesky:
-    case import_datasources8.ENSNamespaceIds.EnsTestEnv:
+    case import_datasources9.ENSNamespaceIds.EnsTestEnv:
       throw new Error(
         `No registrar managed name is known for the 'Lineanames' subregistry within the "${namespaceId}" namespace.`
       );
   }
 }
 
+// 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,
@@ -4314,8 +4459,32 @@ var ENSNodeClient = class _ENSNodeClient {
   }
 };
 
+// src/ensv2/ids-lib.ts
+var import_viem21 = require("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((0, import_viem21.hexToBigInt)(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
-var import_datasources9 = require("@ensnode/datasources");
+var import_datasources10 = require("@ensnode/datasources");
 
 // src/identity/types.ts
 var ResolutionStatusIds = {
@@ -4342,7 +4511,7 @@ var ResolutionStatusIds = {
 function buildUnresolvedIdentity(address, namespaceId, chainId) {
   return {
     resolutionStatus: ResolutionStatusIds.Unresolved,
-    chainId: chainId ?? (0, import_datasources9.getENSRootChainId)(namespaceId),
+    chainId: chainId ?? (0, import_datasources10.getENSRootChainId)(namespaceId),
     address
   };
 }
@@ -4352,13 +4521,13 @@ function isResolvedIdentity(identity) {
 
 // src/resolution/ensip19-chainid.ts
 var import_chains = require("viem/chains");
-var import_datasources10 = require("@ensnode/datasources");
+var import_datasources11 = require("@ensnode/datasources");
 var getResolvePrimaryNameChainIdParam = (chainId, namespaceId) => {
-  const ensRootChainId = (0, import_datasources10.getENSRootChainId)(namespaceId);
+  const ensRootChainId = (0, import_datasources11.getENSRootChainId)(namespaceId);
   return chainId === ensRootChainId ? import_chains.mainnet.id : chainId;
 };
 var translateDefaultableChainIdToChainId = (chainId, namespaceId) => {
-  return chainId === DEFAULT_EVM_CHAIN_ID ? (0, import_datasources10.getENSRootChainId)(namespaceId) : chainId;
+  return chainId === DEFAULT_EVM_CHAIN_ID ? (0, import_datasources11.getENSRootChainId)(namespaceId) : chainId;
 };
 
 // src/resolution/resolver-records-selection.ts