@ensnode/ensnode-sdk 1.3.1 → 1.5.0

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,
@@ -219,13 +256,13 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/ensapi/config/deserialize.ts
-var import_v45 = require("zod/v4");
+var import_v46 = require("zod/v4");
 
 // src/ensapi/config/zod-schemas.ts
-var import_v44 = 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,30 +1261,39 @@ 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`),
   versionInfo: makeENSIndexerVersionInfoSchema(`${valueLabel}.versionInfo`)
 }).check(invariant_isSubgraphCompatibleRequirements);
 
-// src/ensapi/config/zod-schemas.ts
+// src/shared/config/thegraph.ts
+var import_v44 = require("zod/v4");
 var TheGraphCannotFallbackReasonSchema = import_v44.z.enum({
   NotSubgraphCompatible: "not-subgraph-compatible",
   NoApiKey: "no-api-key",
   NoSubgraphUrl: "no-subgraph-url"
 });
-var TheGraphFallbackSchema = import_v44.z.strictObject({
-  canFallback: import_v44.z.boolean(),
-  reason: TheGraphCannotFallbackReasonSchema.nullable()
-});
+var TheGraphFallbackSchema = import_v44.z.discriminatedUnion("canFallback", [
+  import_v44.z.strictObject({
+    canFallback: import_v44.z.literal(true),
+    url: import_v44.z.string()
+  }),
+  import_v44.z.strictObject({
+    canFallback: import_v44.z.literal(false),
+    reason: TheGraphCannotFallbackReasonSchema
+  })
+]);
+
+// src/ensapi/config/zod-schemas.ts
 function makeENSApiPublicConfigSchema(valueLabel) {
   const label = valueLabel ?? "ENSApiPublicConfig";
-  return import_v44.z.strictObject({
-    version: import_v44.z.string().min(1, `${label}.version must be a non-empty string`),
+  return import_v45.z.strictObject({
+    version: import_v45.z.string().min(1, `${label}.version must be a non-empty string`),
     theGraphFallback: TheGraphFallbackSchema,
     ensIndexerPublicConfig: makeENSIndexerPublicConfigSchema(`${label}.ensIndexerPublicConfig`)
   });
@@ -1150,9 +1305,9 @@ function deserializeENSApiPublicConfig(maybeConfig, valueLabel) {
   try {
     return schema.parse(maybeConfig);
   } catch (error) {
-    if (error instanceof import_v45.ZodError) {
+    if (error instanceof import_v46.ZodError) {
       throw new Error(`Cannot deserialize ENSApiPublicConfig:
-${(0, import_v45.prettifyError)(error)}
+${(0, import_v46.prettifyError)(error)}
 `);
     }
     throw error;
@@ -1160,20 +1315,20 @@ ${(0, import_v45.prettifyError)(error)}
 }
 
 // src/ensindexer/config/deserialize.ts
-var import_v46 = require("zod/v4");
+var import_v47 = require("zod/v4");
 function deserializeENSIndexerPublicConfig(maybeConfig, valueLabel) {
   const schema = makeENSIndexerPublicConfigSchema(valueLabel);
   const parsed = schema.safeParse(maybeConfig);
   if (parsed.error) {
     throw new Error(`Cannot deserialize ENSIndexerPublicConfig:
-${(0, import_v46.prettifyError)(parsed.error)}
+${(0, import_v47.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
 }
 
 // src/ensindexer/config/label-utils.ts
-var import_viem10 = require("viem");
+var import_viem13 = require("viem");
 function labelHashToBytes(labelHash) {
   try {
     if (labelHash.length !== 66) {
@@ -1185,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)`);
     }
@@ -1278,10 +1433,10 @@ function serializeENSIndexerPublicConfig(config) {
 }
 
 // src/ensindexer/indexing-status/deserialize.ts
-var import_v48 = require("zod/v4");
+var import_v49 = require("zod/v4");
 
 // src/ensindexer/indexing-status/zod-schemas.ts
-var import_v47 = __toESM(require("zod/v4"), 1);
+var import_v48 = require("zod/v4");
 
 // src/ensindexer/indexing-status/types.ts
 var ChainIndexingConfigTypeIds = {
@@ -1707,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})`
     });
   }
 }
@@ -1737,52 +1892,52 @@ function invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect(ct
 }
 
 // src/ensindexer/indexing-status/zod-schemas.ts
-var makeChainIndexingConfigSchema = (valueLabel = "Value") => import_v47.default.discriminatedUnion("configType", [
-  import_v47.default.strictObject({
-    configType: import_v47.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_v47.default.strictObject({
-    configType: import_v47.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_v47.default.strictObject({
-  chainStatus: import_v47.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_v47.default.strictObject({
-  chainStatus: import_v47.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_v47.default.strictObject({
-  chainStatus: import_v47.default.literal(ChainIndexingStatusIds.Completed),
-  config: import_v47.default.strictObject({
-    configType: import_v47.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_v47.default.strictObject({
-  chainStatus: import_v47.default.literal(ChainIndexingStatusIds.Following),
-  config: import_v47.default.strictObject({
-    configType: import_v47.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_v47.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_v47.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();
@@ -1791,29 +1946,29 @@ var makeChainIndexingStatusesSchema = (valueLabel = "Value") => import_v47.defau
   }
   return chainsIndexingStatus;
 });
-var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_v47.default.strictObject({
-  omnichainStatus: import_v47.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_v47.default.strictObject({
-  omnichainStatus: import_v47.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_v47.default.strictObject({
-  omnichainStatus: import_v47.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_v47.default.strictObject({
-  omnichainStatus: import_v47.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_v47.default.discriminatedUnion("omnichainStatus", [
+var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => import_v48.z.discriminatedUnion("omnichainStatus", [
   makeOmnichainIndexingStatusSnapshotUnstartedSchema(valueLabel),
   makeOmnichainIndexingStatusSnapshotBackfillSchema(valueLabel),
   makeOmnichainIndexingStatusSnapshotCompletedSchema(valueLabel),
@@ -1821,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_v47.default.strictObject({
-  strategy: import_v47.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_v47.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_v47.default.strictObject({
+var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => import_v48.z.strictObject({
   projectedAt: makeUnixTimestampSchema(valueLabel),
   worstCaseDistance: makeDurationSchema(valueLabel),
   snapshot: makeCrossChainIndexingStatusSnapshotSchema(valueLabel)
@@ -1843,7 +1998,7 @@ function deserializeChainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize into ChainIndexingStatusSnapshot:
-${(0, import_v48.prettifyError)(parsed.error)}
+${(0, import_v49.prettifyError)(parsed.error)}
 `
     );
   }
@@ -1855,7 +2010,7 @@ function deserializeOmnichainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize into OmnichainIndexingStatusSnapshot:
-${(0, import_v48.prettifyError)(parsed.error)}
+${(0, import_v49.prettifyError)(parsed.error)}
 `
     );
   }
@@ -1867,7 +2022,7 @@ function deserializeCrossChainIndexingStatusSnapshot(maybeSnapshot, valueLabel)
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize into CrossChainIndexingStatusSnapshot:
-${(0, import_v48.prettifyError)(parsed.error)}
+${(0, import_v49.prettifyError)(parsed.error)}
 `
     );
   }
@@ -1879,7 +2034,7 @@ function deserializeRealtimeIndexingStatusProjection(maybeProjection, valueLabel
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize into RealtimeIndexingStatusProjection:
-${(0, import_v48.prettifyError)(parsed.error)}
+${(0, import_v49.prettifyError)(parsed.error)}
 `
     );
   }
@@ -1975,10 +2130,10 @@ function serializeConfigResponse(response) {
 }
 
 // src/api/indexing-status/deserialize.ts
-var import_v410 = require("zod/v4");
+var import_v411 = require("zod/v4");
 
 // src/api/indexing-status/zod-schemas.ts
-var import_v49 = __toESM(require("zod/v4"), 1);
+var import_v410 = __toESM(require("zod/v4"), 1);
 
 // src/api/indexing-status/response.ts
 var IndexingStatusResponseCodes = {
@@ -1993,14 +2148,14 @@ var IndexingStatusResponseCodes = {
 };
 
 // src/api/indexing-status/zod-schemas.ts
-var makeIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v49.default.strictObject({
-  responseCode: import_v49.default.literal(IndexingStatusResponseCodes.Ok),
+var makeIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v410.default.strictObject({
+  responseCode: import_v410.default.literal(IndexingStatusResponseCodes.Ok),
   realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel)
 });
-var makeIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v49.default.strictObject({
-  responseCode: import_v49.default.literal(IndexingStatusResponseCodes.Error)
+var makeIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v410.default.strictObject({
+  responseCode: import_v410.default.literal(IndexingStatusResponseCodes.Error)
 });
-var makeIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v49.default.discriminatedUnion("responseCode", [
+var makeIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v410.default.discriminatedUnion("responseCode", [
   makeIndexingStatusResponseOkSchema(valueLabel),
   makeIndexingStatusResponseErrorSchema(valueLabel)
 ]);
@@ -2010,7 +2165,7 @@ function deserializeIndexingStatusResponse(maybeResponse) {
   const parsed = makeIndexingStatusResponseSchema().safeParse(maybeResponse);
   if (parsed.error) {
     throw new Error(`Cannot deserialize IndexingStatusResponse:
-${(0, import_v410.prettifyError)(parsed.error)}
+${(0, import_v411.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2030,25 +2185,24 @@ function serializeIndexingStatusResponse(response) {
 }
 
 // src/api/name-tokens/deserialize.ts
-var import_v415 = require("zod/v4");
+var import_v416 = require("zod/v4");
 
 // src/api/name-tokens/zod-schemas.ts
-var import_viem14 = require("viem");
-var import_v414 = __toESM(require("zod/v4"), 1);
+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_v412 = require("zod/v4");
+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_v411 = __toESM(require("zod/v4"), 1);
+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.
@@ -2079,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 = [
@@ -2107,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
@@ -2127,12 +2281,26 @@ function getNameTokenOwnership(namespaceId, name, owner) {
 }
 
 // src/tokenscope/zod-schemas.ts
-var makeAssetIdSchema = (valueLabel = "Asset ID Schema") => import_v411.default.object({
-  assetNamespace: import_v411.default.enum(AssetNamespaces),
-  contract: makeAccountIdSchema(valueLabel),
-  tokenId: import_v411.default.preprocess((v) => typeof v === "string" ? BigInt(v) : v, import_v411.default.bigint().positive())
-});
-var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => import_v411.default.preprocess((v) => {
+var tokenIdSchemaSerializable = import_v412.default.string();
+var tokenIdSchemaNative = import_v412.default.preprocess(
+  (v) => typeof v === "string" ? BigInt(v) : v,
+  import_v412.default.bigint().positive()
+);
+function makeTokenIdSchema(_valueLabel = "Token ID Schema", serializable = false) {
+  if (serializable) {
+    return tokenIdSchemaSerializable;
+  } else {
+    return tokenIdSchemaNative;
+  }
+}
+var makeAssetIdSchema = (valueLabel = "Asset ID Schema", serializable) => {
+  return import_v412.default.object({
+    assetNamespace: import_v412.default.enum(AssetNamespaces),
+    contract: makeAccountIdSchema(valueLabel),
+    tokenId: makeTokenIdSchema(valueLabel, serializable ?? false)
+  });
+};
+var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => import_v412.default.preprocess((v) => {
   if (typeof v === "string") {
     const result = new import_caip3.AssetId(v);
     return {
@@ -2148,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,
@@ -2156,25 +2324,25 @@ function invariant_nameTokenOwnershipHasNonZeroAddressOwner(ctx) {
     });
   }
 }
-var makeNameTokenOwnershipNameWrapperSchema = (valueLabel = "Name Token Ownership NameWrapper") => import_v411.default.object({
-  ownershipType: import_v411.default.literal(NameTokenOwnershipTypes.NameWrapper),
+var makeNameTokenOwnershipNameWrapperSchema = (valueLabel = "Name Token Ownership NameWrapper") => import_v412.default.object({
+  ownershipType: import_v412.default.literal(NameTokenOwnershipTypes.NameWrapper),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
-var makeNameTokenOwnershipFullyOnchainSchema = (valueLabel = "Name Token Ownership Fully Onchain") => import_v411.default.object({
-  ownershipType: import_v411.default.literal(NameTokenOwnershipTypes.FullyOnchain),
+var makeNameTokenOwnershipFullyOnchainSchema = (valueLabel = "Name Token Ownership Fully Onchain") => import_v412.default.object({
+  ownershipType: import_v412.default.literal(NameTokenOwnershipTypes.FullyOnchain),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
-var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => import_v411.default.object({
-  ownershipType: import_v411.default.literal(NameTokenOwnershipTypes.Burned),
+var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => import_v412.default.object({
+  ownershipType: import_v412.default.literal(NameTokenOwnershipTypes.Burned),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasZeroAddressOwner);
-var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => import_v411.default.object({
-  ownershipType: import_v411.default.literal(NameTokenOwnershipTypes.Unknown),
+var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => import_v412.default.object({
+  ownershipType: import_v412.default.literal(NameTokenOwnershipTypes.Unknown),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).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,
@@ -2182,23 +2350,19 @@ function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
     });
   }
 }
-var makeNameTokenOwnershipSchema = (valueLabel = "Name Token Ownership") => import_v411.default.discriminatedUnion("ownershipType", [
+var makeNameTokenOwnershipSchema = (valueLabel = "Name Token Ownership") => import_v412.default.discriminatedUnion("ownershipType", [
   makeNameTokenOwnershipNameWrapperSchema(valueLabel),
   makeNameTokenOwnershipFullyOnchainSchema(valueLabel),
   makeNameTokenOwnershipBurnedSchema(valueLabel),
   makeNameTokenOwnershipUnknownSchema(valueLabel)
 ]);
-var makeNameTokenSchema = (valueLabel = "Name Token Schema") => import_v411.default.object({
-  token: makeAssetIdSchema(`${valueLabel}.token`),
+var makeNameTokenSchema = (valueLabel = "Name Token Schema", serializable) => import_v412.default.object({
+  token: makeAssetIdSchema(`${valueLabel}.token`, serializable),
   ownership: makeNameTokenOwnershipSchema(`${valueLabel}.ownership`),
-  mintStatus: import_v411.default.enum(NFTMintStatuses)
+  mintStatus: import_v412.default.enum(NFTMintStatuses)
 });
 
 // src/tokenscope/assets.ts
-var AssetNamespaces = {
-  ERC721: "erc721",
-  ERC1155: "erc1155"
-};
 function serializeAssetId(assetId) {
   return {
     assetNamespace: assetId.assetNamespace,
@@ -2211,25 +2375,17 @@ function deserializeAssetId(maybeAssetId, valueLabel) {
   const parsed = schema.safeParse(maybeAssetId);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize AssetId:
-${(0, import_v412.prettifyError)(parsed.error)}
+${(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);
   if (parsed.error) {
     throw new RangeError(`Cannot parse AssetId:
-${(0, import_v412.prettifyError)(parsed.error)}
+${(0, import_v413.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2252,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 = {
@@ -2364,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(
@@ -2451,10 +2607,10 @@ ${formatNFTTransferEventMetadata(metadata)}`
 };
 
 // src/api/shared/errors/zod-schemas.ts
-var import_v413 = __toESM(require("zod/v4"), 1);
-var ErrorResponseSchema = import_v413.default.object({
-  message: import_v413.default.string(),
-  details: import_v413.default.optional(import_v413.default.unknown())
+var import_v414 = __toESM(require("zod/v4"), 1);
+var ErrorResponseSchema = import_v414.default.object({
+  message: import_v414.default.string(),
+  details: import_v414.default.optional(import_v414.default.unknown())
 });
 
 // src/api/name-tokens/response.ts
@@ -2493,33 +2649,39 @@ var NameTokensResponseErrorCodes = {
 };
 
 // src/api/name-tokens/zod-schemas.ts
-function invariant_nameIsAssociatedWithDomainId(ctx) {
+var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", serializable) => import_v415.default.object({
+  domainId: makeNodeSchema(`${valueLabel}.domainId`),
+  name: makeReinterpretedNameSchema(valueLabel),
+  tokens: import_v415.default.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 ((0, import_viem14.namehash)(name) !== domainId) {
+  if ((0, import_viem17.namehash)(name) !== domainId) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
       message: `'name' must be associated with 'domainId': ${domainId}`
     });
   }
-}
-function invariant_nameTokensOwnershipTypeNameWrapperRequiresOwnershipTypeFullyOnchainOrUnknown(ctx) {
-  const { tokens } = ctx.value;
-  const containsOwnershipNameWrapper = tokens.some(
-    (t) => t.ownership.ownershipType === NameTokenOwnershipTypes.NameWrapper
-  );
-  const containsOwnershipFullyOnchainOrUnknown = tokens.some(
-    (t) => t.ownership.ownershipType === NameTokenOwnershipTypes.FullyOnchain || t.ownership.ownershipType === NameTokenOwnershipTypes.Unknown
-  );
-  if (containsOwnershipNameWrapper && !containsOwnershipFullyOnchainOrUnknown) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: `'tokens' must contain name token with ownership type 'fully-onchain' or 'unknown' when name token with ownership type 'namewrapper' in listed`
-    });
+}).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
@@ -2531,49 +2693,46 @@ 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") => import_v414.default.object({
-  domainId: makeNodeSchema(`${valueLabel}.domainId`),
-  name: makeReinterpretedNameSchema(valueLabel),
-  tokens: import_v414.default.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") => import_v414.default.strictObject({
-  responseCode: import_v414.default.literal(NameTokensResponseCodes.Ok),
-  registeredNameTokens: makeRegisteredNameTokenSchema(`${valueLabel}.nameTokens`)
 });
-var makeNameTokensResponseErrorNameTokensNotIndexedSchema = (_valueLabel = "Name Tokens Response Error Name Not Indexed") => import_v414.default.strictObject({
-  responseCode: import_v414.default.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v414.default.literal(NameTokensResponseErrorCodes.NameTokensNotIndexed),
+var makeNameTokensResponseOkSchema = (valueLabel = "Name Tokens Response OK", serializable) => import_v415.default.strictObject({
+  responseCode: import_v415.default.literal(NameTokensResponseCodes.Ok),
+  registeredNameTokens: makeRegisteredNameTokenSchema(`${valueLabel}.nameTokens`, serializable)
+});
+var makeNameTokensResponseErrorNameTokensNotIndexedSchema = (_valueLabel = "Name Tokens Response Error Name Not Indexed") => import_v415.default.strictObject({
+  responseCode: import_v415.default.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v415.default.literal(NameTokensResponseErrorCodes.NameTokensNotIndexed),
   error: ErrorResponseSchema
 });
-var makeNameTokensResponseErrorEnsIndexerConfigUnsupported = (_valueLabel = "Name Tokens Response Error ENSIndexer Config Unsupported") => import_v414.default.strictObject({
-  responseCode: import_v414.default.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v414.default.literal(NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported),
+var makeNameTokensResponseErrorEnsIndexerConfigUnsupported = (_valueLabel = "Name Tokens Response Error ENSIndexer Config Unsupported") => import_v415.default.strictObject({
+  responseCode: import_v415.default.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v415.default.literal(NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported),
   error: ErrorResponseSchema
 });
-var makeNameTokensResponseErrorNameIndexingStatusUnsupported = (_valueLabel = "Name Tokens Response Error Indexing Status Unsupported") => import_v414.default.strictObject({
-  responseCode: import_v414.default.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v414.default.literal(NameTokensResponseErrorCodes.IndexingStatusUnsupported),
+var makeNameTokensResponseErrorNameIndexingStatusUnsupported = (_valueLabel = "Name Tokens Response Error Indexing Status Unsupported") => import_v415.default.strictObject({
+  responseCode: import_v415.default.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v415.default.literal(NameTokensResponseErrorCodes.IndexingStatusUnsupported),
   error: ErrorResponseSchema
 });
-var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => import_v414.default.discriminatedUnion("errorCode", [
+var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => import_v415.default.discriminatedUnion("errorCode", [
   makeNameTokensResponseErrorNameTokensNotIndexedSchema(valueLabel),
   makeNameTokensResponseErrorEnsIndexerConfigUnsupported(valueLabel),
   makeNameTokensResponseErrorNameIndexingStatusUnsupported(valueLabel)
 ]);
-var makeNameTokensResponseSchema = (valueLabel = "Name Tokens Response") => import_v414.default.discriminatedUnion("responseCode", [
-  makeNameTokensResponseOkSchema(valueLabel),
-  makeNameTokensResponseErrorSchema(valueLabel)
-]);
+var makeNameTokensResponseSchema = (valueLabel = "Name Tokens Response", serializable) => {
+  return import_v415.default.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:
-${(0, import_v415.prettifyError)(parsed.error)}
+${(0, import_v416.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2647,40 +2806,40 @@ function serializeNameTokensResponse(response) {
 }
 
 // src/api/registrar-actions/deserialize.ts
-var import_v419 = require("zod/v4");
+var import_v420 = require("zod/v4");
 
 // src/api/registrar-actions/zod-schemas.ts
-var import_ens7 = require("viem/ens");
-var import_v418 = __toESM(require("zod/v4"), 1);
+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.`);
   }
@@ -2690,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 = {
@@ -2705,7 +2864,7 @@ var ReferrerDetailTypeIds = {
 };
 
 // src/registrars/zod-schemas.ts
-var import_v416 = __toESM(require("zod/v4"), 1);
+var import_v417 = require("zod/v4");
 
 // src/registrars/registrar-action.ts
 var RegistrarActionTypes = {
@@ -2746,11 +2905,11 @@ function serializeRegistrarAction(registrarAction) {
 }
 
 // src/registrars/zod-schemas.ts
-var makeSubregistrySchema = (valueLabel = "Subregistry") => import_v416.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_v416.default.object({
+var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => import_v417.z.object({
   subregistry: makeSubregistrySchema(`${valueLabel} Subregistry`),
   node: makeNodeSchema(`${valueLabel} Node`),
   expiresAt: makeUnixTimestampSchema(`${valueLabel} Expires at`)
@@ -2766,18 +2925,18 @@ function invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium(ctx) {
     });
   }
 }
-var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => import_v416.default.union([
+var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => import_v417.z.union([
   // pricing available
-  import_v416.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_v416.default.object({
-    baseCost: import_v416.default.null(),
-    premium: import_v416.default.null(),
-    total: import_v416.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) {
@@ -2800,9 +2959,9 @@ function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
     });
   }
 }
-var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => import_v416.default.union([
+var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => import_v417.z.union([
   // referral available
-  import_v416.default.object({
+  import_v417.z.object({
     encodedReferrer: makeHexStringSchema(
       { bytesCount: ENCODED_REFERRER_BYTE_LENGTH },
       `${valueLabel} Encoded Referrer`
@@ -2810,9 +2969,9 @@ var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral
     decodedReferrer: makeLowercaseAddressSchema(`${valueLabel} Decoded Referrer`)
   }).check(invariant_registrarActionDecodedReferrerBasedOnRawReferrer),
   // referral not applicable
-  import_v416.default.object({
-    encodedReferrer: import_v416.default.null(),
-    decodedReferrer: import_v416.default.null()
+  import_v417.z.object({
+    encodedReferrer: import_v417.z.null(),
+    decodedReferrer: import_v417.z.null()
   })
 ]);
 function invariant_eventIdsInitialElementIsTheActionId(ctx) {
@@ -2825,9 +2984,9 @@ function invariant_eventIdsInitialElementIsTheActionId(ctx) {
     });
   }
 }
-var EventIdSchema = import_v416.default.string().nonempty();
-var EventIdsSchema = import_v416.default.array(EventIdSchema).min(1).transform((v) => v);
-var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => import_v416.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`),
@@ -2841,38 +3000,38 @@ var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => im
   eventIds: EventIdsSchema
 }).check(invariant_eventIdsInitialElementIsTheActionId);
 var makeRegistrarActionRegistrationSchema = (valueLabel = "Registration ") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: import_v416.default.literal(RegistrarActionTypes.Registration)
+  type: import_v417.z.literal(RegistrarActionTypes.Registration)
 });
 var makeRegistrarActionRenewalSchema = (valueLabel = "Renewal") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: import_v416.default.literal(RegistrarActionTypes.Renewal)
+  type: import_v417.z.literal(RegistrarActionTypes.Renewal)
 });
-var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => import_v416.default.discriminatedUnion("type", [
+var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => import_v417.z.discriminatedUnion("type", [
   makeRegistrarActionRegistrationSchema(`${valueLabel} Registration`),
   makeRegistrarActionRenewalSchema(`${valueLabel} Renewal`)
 ]);
 
 // src/api/shared/pagination/zod-schemas.ts
-var import_v417 = __toESM(require("zod/v4"), 1);
+var import_v418 = __toESM(require("zod/v4"), 1);
 
 // 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") => import_v417.default.object({
+var makeRequestPageParamsSchema = (valueLabel = "RequestPageParams") => import_v418.default.object({
   page: makePositiveIntegerSchema(`${valueLabel}.page`),
   recordsPerPage: makePositiveIntegerSchema(`${valueLabel}.recordsPerPage`).max(
     RECORDS_PER_PAGE_MAX,
     `${valueLabel}.recordsPerPage must not exceed ${RECORDS_PER_PAGE_MAX}`
   )
 });
-var makeResponsePageContextSchemaWithNoRecords = (valueLabel = "ResponsePageContextWithNoRecords") => import_v417.default.object({
-  totalRecords: import_v417.default.literal(0),
-  totalPages: import_v417.default.literal(1),
-  hasNext: import_v417.default.literal(false),
-  hasPrev: import_v417.default.literal(false),
-  startIndex: import_v417.default.undefined(),
-  endIndex: import_v417.default.undefined()
+var makeResponsePageContextSchemaWithNoRecords = (valueLabel = "ResponsePageContextWithNoRecords") => import_v418.default.object({
+  totalRecords: import_v418.default.literal(0),
+  totalPages: import_v418.default.literal(1),
+  hasNext: import_v418.default.literal(false),
+  hasPrev: import_v418.default.literal(false),
+  startIndex: import_v418.default.undefined(),
+  endIndex: import_v418.default.undefined()
 }).extend(makeRequestPageParamsSchema(valueLabel).shape);
 function invariant_responsePageWithRecordsIsCorrect(ctx) {
   const { hasNext, hasPrev, recordsPerPage, page, totalRecords, startIndex, endIndex } = ctx.value;
@@ -2907,15 +3066,15 @@ function invariant_responsePageWithRecordsIsCorrect(ctx) {
     });
   }
 }
-var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => import_v417.default.object({
+var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => import_v418.default.object({
   totalRecords: makePositiveIntegerSchema(`${valueLabel}.totalRecords`),
   totalPages: makePositiveIntegerSchema(`${valueLabel}.totalPages`),
-  hasNext: import_v417.default.boolean(),
-  hasPrev: import_v417.default.boolean(),
+  hasNext: import_v418.default.boolean(),
+  hasPrev: import_v418.default.boolean(),
   startIndex: makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`),
   endIndex: makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`)
 }).extend(makeRequestPageParamsSchema(valueLabel).shape).check(invariant_responsePageWithRecordsIsCorrect);
-var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => import_v417.default.union([
+var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => import_v418.default.union([
   makeResponsePageContextSchemaWithNoRecords(valueLabel),
   makeResponsePageContextSchemaWithRecords(valueLabel)
 ]);
@@ -2936,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",
@@ -2945,20 +3104,21 @@ function invariant_registrationLifecycleNodeMatchesName(ctx) {
     });
   }
 }
-var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => import_v418.default.object({
+var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => import_v419.default.object({
   action: makeRegistrarActionSchema(valueLabel),
   name: makeReinterpretedNameSchema(valueLabel)
 }).check(invariant_registrationLifecycleNodeMatchesName);
-var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => import_v418.default.strictObject({
-  responseCode: import_v418.default.literal(RegistrarActionsResponseCodes.Ok),
-  registrarActions: import_v418.default.array(makeNamedRegistrarActionSchema(valueLabel)),
-  pageContext: makeResponsePageContextSchema(`${valueLabel}.pageContext`)
+var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => import_v419.default.object({
+  responseCode: import_v419.default.literal(RegistrarActionsResponseCodes.Ok),
+  registrarActions: import_v419.default.array(makeNamedRegistrarActionSchema(valueLabel)),
+  pageContext: makeResponsePageContextSchema(`${valueLabel}.pageContext`),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`).optional()
 });
-var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => import_v418.default.strictObject({
-  responseCode: import_v418.default.literal(RegistrarActionsResponseCodes.Error),
+var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => import_v419.default.strictObject({
+  responseCode: import_v419.default.literal(RegistrarActionsResponseCodes.Error),
   error: ErrorResponseSchema
 });
-var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => import_v418.default.discriminatedUnion("responseCode", [
+var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => import_v419.default.discriminatedUnion("responseCode", [
   makeRegistrarActionsResponseOkSchema(valueLabel),
   makeRegistrarActionsResponseErrorSchema(valueLabel)
 ]);
@@ -2969,7 +3129,7 @@ function deserializeRegistrarActionsResponse(maybeResponse) {
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize RegistrarActionsResponse:
-${(0, import_v419.prettifyError)(parsed.error)}
+${(0, import_v420.prettifyError)(parsed.error)}
 `
     );
   }
@@ -2980,7 +3140,9 @@ ${(0, import_v419.prettifyError)(parsed.error)}
 var RegistrarActionsFilterTypes = {
   BySubregistryNode: "bySubregistryNode",
   WithEncodedReferral: "withEncodedReferral",
-  ByDecodedReferrer: "byDecodedReferrer"
+  ByDecodedReferrer: "byDecodedReferrer",
+  BeginTimestamp: "beginTimestamp",
+  EndTimestamp: "endTimestamp"
 };
 var RegistrarActionsOrders = {
   LatestRegistrarActions: "orderBy[timestamp]=desc"
@@ -3013,10 +3175,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
@@ -3070,11 +3252,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)) {
@@ -3087,12 +3269,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.`
       );
@@ -3100,11 +3281,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)) {
@@ -3117,20 +3298,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)) {
@@ -3143,18 +3323,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,
@@ -3171,7 +3365,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;
@@ -3179,12 +3374,12 @@ function serializeRegistrarActionsResponse(response) {
 }
 
 // src/api/shared/errors/deserialize.ts
-var import_v420 = require("zod/v4");
+var import_v421 = require("zod/v4");
 function deserializeErrorResponse(maybeErrorResponse) {
   const parsed = ErrorResponseSchema.safeParse(maybeErrorResponse);
   if (parsed.error) {
     throw new Error(`Cannot deserialize ErrorResponse:
-${(0, import_v420.prettifyError)(parsed.error)}
+${(0, import_v421.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -3239,10 +3434,10 @@ var ClientError = class _ClientError extends Error {
 };
 
 // src/ensanalytics/deserialize.ts
-var import_v422 = require("zod/v4");
+var import_v423 = require("zod/v4");
 
 // src/ensanalytics/zod-schemas.ts
-var import_v421 = __toESM(require("zod/v4"), 1);
+var import_v422 = __toESM(require("zod/v4"), 1);
 
 // src/ensanalytics/types.ts
 var ReferrerLeaderboardPageResponseCodes = {
@@ -3267,20 +3462,28 @@ var ReferrerDetailResponseCodes = {
 };
 
 // src/ensanalytics/zod-schemas.ts
-var makeReferralProgramRulesSchema = (valueLabel = "ReferralProgramRules") => import_v421.default.object({
+var makeRevenueContributionSchema = (valueLabel = "RevenueContribution") => import_v422.default.coerce.bigint({
+  error: `${valueLabel} must represent a bigint.`
+}).nonnegative({
+  error: `${valueLabel} must not be negative.`
+});
+var makeReferralProgramRulesSchema = (valueLabel = "ReferralProgramRules") => import_v422.default.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") => import_v421.default.object({
+var makeAwardedReferrerMetricsSchema = (valueLabel = "AwardedReferrerMetrics") => import_v422.default.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: import_v421.default.boolean(),
+  isQualified: import_v422.default.boolean(),
   finalScoreBoost: makeFiniteNonNegativeNumberSchema(`${valueLabel}.finalScoreBoost`).max(
     1,
     `${valueLabel}.finalScoreBoost must be <= 1`
@@ -3292,13 +3495,16 @@ var makeAwardedReferrerMetricsSchema = (valueLabel = "AwardedReferrerMetrics") =
   ),
   awardPoolApproxValue: makeFiniteNonNegativeNumberSchema(`${valueLabel}.awardPoolApproxValue`)
 });
-var makeUnrankedReferrerMetricsSchema = (valueLabel = "UnrankedReferrerMetrics") => import_v421.default.object({
+var makeUnrankedReferrerMetricsSchema = (valueLabel = "UnrankedReferrerMetrics") => import_v422.default.object({
   referrer: makeLowercaseAddressSchema(`${valueLabel}.referrer`),
   totalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.totalReferrals`),
   totalIncrementalDuration: makeDurationSchema(`${valueLabel}.totalIncrementalDuration`),
+  totalRevenueContribution: makeRevenueContributionSchema(
+    `${valueLabel}.totalRevenueContribution`
+  ),
   score: makeFiniteNonNegativeNumberSchema(`${valueLabel}.score`),
-  rank: import_v421.default.null(),
-  isQualified: import_v421.default.literal(false),
+  rank: import_v422.default.null(),
+  isQualified: import_v422.default.literal(false),
   finalScoreBoost: makeFiniteNonNegativeNumberSchema(`${valueLabel}.finalScoreBoost`).max(
     1,
     `${valueLabel}.finalScoreBoost must be <= 1`
@@ -3310,11 +3516,14 @@ var makeUnrankedReferrerMetricsSchema = (valueLabel = "UnrankedReferrerMetrics")
   ),
   awardPoolApproxValue: makeFiniteNonNegativeNumberSchema(`${valueLabel}.awardPoolApproxValue`)
 });
-var makeAggregatedReferrerMetricsSchema = (valueLabel = "AggregatedReferrerMetrics") => import_v421.default.object({
+var makeAggregatedReferrerMetricsSchema = (valueLabel = "AggregatedReferrerMetrics") => import_v422.default.object({
   grandTotalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.grandTotalReferrals`),
   grandTotalIncrementalDuration: makeDurationSchema(
     `${valueLabel}.grandTotalIncrementalDuration`
   ),
+  grandTotalRevenueContribution: makeRevenueContributionSchema(
+    `${valueLabel}.grandTotalRevenueContribution`
+  ),
   grandTotalQualifiedReferrersFinalScore: makeFiniteNonNegativeNumberSchema(
     `${valueLabel}.grandTotalQualifiedReferrersFinalScore`
   ),
@@ -3322,7 +3531,7 @@ var makeAggregatedReferrerMetricsSchema = (valueLabel = "AggregatedReferrerMetri
     `${valueLabel}.minFinalScoreToQualify`
   )
 });
-var makeReferrerLeaderboardPageContextSchema = (valueLabel = "ReferrerLeaderboardPageContext") => import_v421.default.object({
+var makeReferrerLeaderboardPageContextSchema = (valueLabel = "ReferrerLeaderboardPageContext") => import_v422.default.object({
   page: makePositiveIntegerSchema(`${valueLabel}.page`),
   recordsPerPage: makePositiveIntegerSchema(`${valueLabel}.recordsPerPage`).max(
     REFERRERS_PER_LEADERBOARD_PAGE_MAX,
@@ -3330,91 +3539,278 @@ var makeReferrerLeaderboardPageContextSchema = (valueLabel = "ReferrerLeaderboar
   ),
   totalRecords: makeNonNegativeIntegerSchema(`${valueLabel}.totalRecords`),
   totalPages: makePositiveIntegerSchema(`${valueLabel}.totalPages`),
-  hasNext: import_v421.default.boolean(),
-  hasPrev: import_v421.default.boolean(),
-  startIndex: import_v421.default.optional(makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`)),
-  endIndex: import_v421.default.optional(makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`))
+  hasNext: import_v422.default.boolean(),
+  hasPrev: import_v422.default.boolean(),
+  startIndex: import_v422.default.optional(makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`)),
+  endIndex: import_v422.default.optional(makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`))
 });
-var makeReferrerLeaderboardPageSchema = (valueLabel = "ReferrerLeaderboardPage") => import_v421.default.object({
+var makeReferrerLeaderboardPageSchema = (valueLabel = "ReferrerLeaderboardPage") => import_v422.default.object({
   rules: makeReferralProgramRulesSchema(`${valueLabel}.rules`),
-  referrers: import_v421.default.array(makeAwardedReferrerMetricsSchema(`${valueLabel}.referrers[record]`)),
+  referrers: import_v422.default.array(makeAwardedReferrerMetricsSchema(`${valueLabel}.referrers[record]`)),
   aggregatedMetrics: makeAggregatedReferrerMetricsSchema(`${valueLabel}.aggregatedMetrics`),
   pageContext: makeReferrerLeaderboardPageContextSchema(`${valueLabel}.pageContext`),
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 });
-var makeReferrerLeaderboardPageResponseOkSchema = (valueLabel = "ReferrerLeaderboardPageResponseOk") => import_v421.default.object({
-  responseCode: import_v421.default.literal(ReferrerLeaderboardPageResponseCodes.Ok),
+var makeReferrerLeaderboardPageResponseOkSchema = (valueLabel = "ReferrerLeaderboardPageResponseOk") => import_v422.default.object({
+  responseCode: import_v422.default.literal(ReferrerLeaderboardPageResponseCodes.Ok),
   data: makeReferrerLeaderboardPageSchema(`${valueLabel}.data`)
 });
-var makeReferrerLeaderboardPageResponseErrorSchema = (_valueLabel = "ReferrerLeaderboardPageResponseError") => import_v421.default.object({
-  responseCode: import_v421.default.literal(ReferrerLeaderboardPageResponseCodes.Error),
-  error: import_v421.default.string(),
-  errorMessage: import_v421.default.string()
+var makeReferrerLeaderboardPageResponseErrorSchema = (_valueLabel = "ReferrerLeaderboardPageResponseError") => import_v422.default.object({
+  responseCode: import_v422.default.literal(ReferrerLeaderboardPageResponseCodes.Error),
+  error: import_v422.default.string(),
+  errorMessage: import_v422.default.string()
 });
-var makeReferrerLeaderboardPageResponseSchema = (valueLabel = "ReferrerLeaderboardPageResponse") => import_v421.default.union([
+var makeReferrerLeaderboardPageResponseSchema = (valueLabel = "ReferrerLeaderboardPageResponse") => import_v422.default.union([
   makeReferrerLeaderboardPageResponseOkSchema(valueLabel),
   makeReferrerLeaderboardPageResponseErrorSchema(valueLabel)
 ]);
-var makeReferrerDetailRankedSchema = (valueLabel = "ReferrerDetailRanked") => import_v421.default.object({
-  type: import_v421.default.literal(ReferrerDetailTypeIds.Ranked),
+var makeReferrerDetailRankedSchema = (valueLabel = "ReferrerDetailRanked") => import_v422.default.object({
+  type: import_v422.default.literal(ReferrerDetailTypeIds.Ranked),
   rules: makeReferralProgramRulesSchema(`${valueLabel}.rules`),
   referrer: makeAwardedReferrerMetricsSchema(`${valueLabel}.referrer`),
   aggregatedMetrics: makeAggregatedReferrerMetricsSchema(`${valueLabel}.aggregatedMetrics`),
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 });
-var makeReferrerDetailUnrankedSchema = (valueLabel = "ReferrerDetailUnranked") => import_v421.default.object({
-  type: import_v421.default.literal(ReferrerDetailTypeIds.Unranked),
+var makeReferrerDetailUnrankedSchema = (valueLabel = "ReferrerDetailUnranked") => import_v422.default.object({
+  type: import_v422.default.literal(ReferrerDetailTypeIds.Unranked),
   rules: makeReferralProgramRulesSchema(`${valueLabel}.rules`),
   referrer: makeUnrankedReferrerMetricsSchema(`${valueLabel}.referrer`),
   aggregatedMetrics: makeAggregatedReferrerMetricsSchema(`${valueLabel}.aggregatedMetrics`),
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 });
-var makeReferrerDetailResponseOkSchema = (valueLabel = "ReferrerDetailResponse") => import_v421.default.object({
-  responseCode: import_v421.default.literal(ReferrerDetailResponseCodes.Ok),
-  data: import_v421.default.union([
+var makeReferrerDetailResponseOkSchema = (valueLabel = "ReferrerDetailResponse") => import_v422.default.object({
+  responseCode: import_v422.default.literal(ReferrerDetailResponseCodes.Ok),
+  data: import_v422.default.union([
     makeReferrerDetailRankedSchema(`${valueLabel}.data`),
     makeReferrerDetailUnrankedSchema(`${valueLabel}.data`)
   ])
 });
-var makeReferrerDetailResponseErrorSchema = (_valueLabel = "ReferrerDetailResponse") => import_v421.default.object({
-  responseCode: import_v421.default.literal(ReferrerDetailResponseCodes.Error),
-  error: import_v421.default.string(),
-  errorMessage: import_v421.default.string()
+var makeReferrerDetailResponseErrorSchema = (_valueLabel = "ReferrerDetailResponse") => import_v422.default.object({
+  responseCode: import_v422.default.literal(ReferrerDetailResponseCodes.Error),
+  error: import_v422.default.string(),
+  errorMessage: import_v422.default.string()
 });
-var makeReferrerDetailResponseSchema = (valueLabel = "ReferrerDetailResponse") => import_v421.default.union([
+var makeReferrerDetailResponseSchema = (valueLabel = "ReferrerDetailResponse") => import_v422.default.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:
-${(0, import_v422.prettifyError)(parsed.error)}
+${(0, import_v423.prettifyError)(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:
-${(0, import_v422.prettifyError)(parsed.error)}
+${(0, import_v423.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
 }
 
 // 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;
   }
@@ -3422,7 +3818,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;
   }
@@ -3854,6 +4262,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
@@ -3884,6 +4293,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 = {}) {
@@ -3905,6 +4334,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: {
@@ -3935,6 +4376,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 {
@@ -3988,7 +4437,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);
@@ -4013,8 +4462,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 = {
@@ -4041,7 +4514,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
   };
 }
@@ -4051,13 +4524,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