@ensnode/ensnode-sdk 0.32.0 → 0.34.0

package/dist/index.js

@@ -1,6 +1,9 @@
 // src/ens/constants.ts
 import { namehash } from "viem";
 var ROOT_NODE = namehash("");
+var ETH_NODE = namehash("eth");
+var BASENAMES_NODE = namehash("base.eth");
+var LINEANAMES_NODE = namehash("linea.eth");
 var REVERSE_ROOT_NODES = /* @__PURE__ */ new Set([namehash("addr.reverse")]);
 
 // src/ens/subname-helpers.ts
@@ -329,6 +332,12 @@ function isNormalized(name) {
   }
 }
 
+// src/shared/account-id.ts
+import { isAddressEqual } from "viem";
+var accountIdEqual = (a, b) => {
+  return a.chainId === b.chainId && isAddressEqual(a.address, b.address);
+};
+
 // src/ensindexer/config/types.ts
 var PluginName = /* @__PURE__ */ ((PluginName2) => {
   PluginName2["Subgraph"] = "subgraph";
@@ -337,6 +346,7 @@ var PluginName = /* @__PURE__ */ ((PluginName2) => {
   PluginName2["ThreeDNS"] = "threedns";
   PluginName2["ReverseResolvers"] = "reverse-resolvers";
   PluginName2["Referrals"] = "referrals";
+  PluginName2["TokenScope"] = "tokenscope";
   return PluginName2;
 })(PluginName || {});
 
@@ -344,7 +354,8 @@ var PluginName = /* @__PURE__ */ ((PluginName2) => {
 function isSubgraphCompatible(config) {
   const onlySubgraphPluginActivated = config.plugins.length === 1 && config.plugins[0] === "subgraph" /* Subgraph */;
   const indexingBehaviorIsSubgraphCompatible = !config.healReverseAddresses && !config.indexAdditionalResolverRecords;
-  return onlySubgraphPluginActivated && indexingBehaviorIsSubgraphCompatible;
+  const labelSetIsSubgraphCompatible = config.labelSet.labelSetId === "subgraph" && config.labelSet.labelSetVersion === 0;
+  return onlySubgraphPluginActivated && indexingBehaviorIsSubgraphCompatible && labelSetIsSubgraphCompatible;
 }
 
 // src/ensindexer/config/zod-schemas.ts
@@ -367,6 +378,29 @@ var makePluginsListSchema = (valueLabel = "Plugins") => z2.array(
 var makeDatabaseSchemaNameSchema = (valueLabel = "Database schema name") => z2.string({ error: `${valueLabel} must be a string` }).trim().nonempty({
   error: `${valueLabel} is required and must be a non-empty string.`
 });
+var makeLabelSetIdSchema = (valueLabel) => {
+  return z2.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 z2.coerce.number({ error: `${valueLabel} must be an integer.` }).pipe(makeNonNegativeIntegerSchema(valueLabel));
+};
+var makeFullyPinnedLabelSetSchema = (valueLabel = "Label set") => {
+  let valueLabelLabelSetId = valueLabel;
+  let valueLabelLabelSetVersion = valueLabel;
+  if (valueLabel == "LABEL_SET") {
+    valueLabelLabelSetId = "LABEL_SET_ID";
+    valueLabelLabelSetVersion = "LABEL_SET_VERSION";
+  } else {
+    valueLabelLabelSetId = valueLabel + ".labelSetId";
+    valueLabelLabelSetVersion = valueLabel + ".labelSetVersion";
+  }
+  return z2.object({
+    labelSetId: makeLabelSetIdSchema(valueLabelLabelSetId),
+    labelSetVersion: makeLabelSetVersionSchema(valueLabelLabelSetVersion)
+  });
+};
 var makeNonEmptyStringSchema = (valueLabel = "Value") => z2.string().nonempty({ error: `${valueLabel} must be a non-empty string.` });
 var makeDependencyInfoSchema = (valueLabel = "Value") => z2.strictObject(
   {
@@ -390,21 +424,10 @@ function invariant_reverseResolversPluginNeedsResolverRecords(ctx) {
     });
   }
 }
-function invariant_experimentalResolutionNeedsReverseResolversPlugin(ctx) {
-  const { value: config } = ctx;
-  const reverseResolversPluginActive = config.plugins.includes("reverse-resolvers" /* ReverseResolvers */);
-  if (config.experimentalResolution && !reverseResolversPluginActive) {
-    ctx.issues.push({
-      code: "custom",
-      input: config,
-      message: `'reverseResolversPluginActive' requires the ${"reverse-resolvers" /* ReverseResolvers */} plugin to be active.`
-    });
-  }
-}
 function invariant_isSubgraphCompatibleRequirements(ctx) {
   const { value: config } = ctx;
   if (config.isSubgraphCompatible !== isSubgraphCompatible(config)) {
-    const message = config.isSubgraphCompatible ? `'isSubgraphCompatible' requires only the '${"subgraph" /* Subgraph */}' plugin to be active. Also, both 'indexAdditionalResolverRecords' and 'healReverseAddresses' must be set to 'false'` : `Both 'indexAdditionalResolverRecords' and 'healReverseAddresses' were set to 'false', and the only active plugin was the '${"subgraph" /* Subgraph */}' plugin. The 'isSubgraphCompatible' must be set to 'true'`;
+    const message = config.isSubgraphCompatible ? `'isSubgraphCompatible' requires only the '${"subgraph" /* Subgraph */}' plugin to be active, both 'indexAdditionalResolverRecords' and 'healReverseAddresses' must be set to 'false', and labelSet must be {labelSetId: "subgraph", labelSetVersion: 0}` : `Both 'indexAdditionalResolverRecords' and 'healReverseAddresses' were set to 'false', the only active plugin was the '${"subgraph" /* Subgraph */}' plugin, and labelSet was {labelSetId: "subgraph", labelSetVersion: 0}. The 'isSubgraphCompatible' must be set to 'true'`;
     ctx.issues.push({
       code: "custom",
       input: config,
@@ -415,7 +438,7 @@ function invariant_isSubgraphCompatibleRequirements(ctx) {
 var makeENSIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") => z2.object({
   ensAdminUrl: makeUrlSchema(`${valueLabel}.ensAdminUrl`),
   ensNodePublicUrl: makeUrlSchema(`${valueLabel}.ensNodePublicUrl`),
-  experimentalResolution: z2.boolean({ error: `${valueLabel}.experimentalResolution` }),
+  labelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.labelSet`),
   healReverseAddresses: z2.boolean({ error: `${valueLabel}.healReverseAddresses` }),
   indexAdditionalResolverRecords: z2.boolean({
     error: `${valueLabel}.indexAdditionalResolverRecords`
@@ -426,7 +449,7 @@ var makeENSIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") =
   plugins: makePluginsListSchema(`${valueLabel}.plugins`),
   databaseSchemaName: makeDatabaseSchemaNameSchema(`${valueLabel}.databaseSchemaName`),
   dependencyInfo: makeDependencyInfoSchema(`${valueLabel}.dependencyInfo`)
-}).check(invariant_reverseResolversPluginNeedsResolverRecords).check(invariant_experimentalResolutionNeedsReverseResolversPlugin).check(invariant_isSubgraphCompatibleRequirements);
+}).check(invariant_reverseResolversPluginNeedsResolverRecords).check(invariant_isSubgraphCompatibleRequirements);
 
 // src/ensindexer/config/deserialize.ts
 function deserializeENSIndexerPublicConfig(maybeConfig, valueLabel) {
@@ -448,9 +471,9 @@ function serializeENSIndexerPublicConfig(config) {
   const {
     ensAdminUrl,
     ensNodePublicUrl,
+    labelSet,
     indexedChainIds,
     databaseSchemaName,
-    experimentalResolution,
     healReverseAddresses,
     indexAdditionalResolverRecords,
     isSubgraphCompatible: isSubgraphCompatible2,
@@ -461,9 +484,9 @@ function serializeENSIndexerPublicConfig(config) {
   return {
     ensAdminUrl: serializeUrl(ensAdminUrl),
     ensNodePublicUrl: serializeUrl(ensNodePublicUrl),
+    labelSet,
     indexedChainIds: serializeIndexedChainIds(indexedChainIds),
     databaseSchemaName,
-    experimentalResolution,
     healReverseAddresses,
     indexAdditionalResolverRecords,
     isSubgraphCompatible: isSubgraphCompatible2,
@@ -473,6 +496,86 @@ function serializeENSIndexerPublicConfig(config) {
   };
 }
 
+// src/ensindexer/config/labelset-utils.ts
+function buildLabelSetId(maybeLabelSetId) {
+  return makeLabelSetIdSchema("LabelSetId").parse(maybeLabelSetId);
+}
+function buildLabelSetVersion(maybeLabelSetVersion) {
+  return makeLabelSetVersionSchema("LabelSetVersion").parse(maybeLabelSetVersion);
+}
+function buildEnsRainbowClientLabelSet(labelSetId, labelSetVersion) {
+  if (labelSetVersion !== void 0 && labelSetId === void 0) {
+    throw new Error("When a labelSetVersion is defined, labelSetId must also be defined.");
+  }
+  return { labelSetId, labelSetVersion };
+}
+function validateSupportedLabelSetAndVersion(serverSet, clientSet) {
+  if (clientSet.labelSetId === void 0) {
+    return;
+  }
+  if (serverSet.labelSetId !== clientSet.labelSetId) {
+    throw new Error(
+      `Server label set ID "${serverSet.labelSetId}" does not match client's requested label set ID "${clientSet.labelSetId}".`
+    );
+  }
+  if (clientSet.labelSetVersion !== void 0 && serverSet.highestLabelSetVersion < clientSet.labelSetVersion) {
+    throw new Error(
+      `Server highest label set version ${serverSet.highestLabelSetVersion} is less than client's requested version ${clientSet.labelSetVersion} for label set ID "${clientSet.labelSetId}".`
+    );
+  }
+}
+
+// src/ensindexer/config/label-utils.ts
+import { hexToBytes } from "viem";
+function labelHashToBytes(labelHash) {
+  try {
+    if (labelHash.length !== 66) {
+      throw new Error(`Invalid labelHash length ${labelHash.length} characters (expected 66)`);
+    }
+    if (labelHash !== labelHash.toLowerCase()) {
+      throw new Error("Labelhash must be in lowercase");
+    }
+    if (!labelHash.startsWith("0x")) {
+      throw new Error("Labelhash must be 0x-prefixed");
+    }
+    const bytes = hexToBytes(labelHash);
+    if (bytes.length !== 32) {
+      throw new Error(`Invalid labelHash length ${bytes.length} bytes (expected 32)`);
+    }
+    return bytes;
+  } catch (e) {
+    if (e instanceof Error) {
+      throw e;
+    }
+    throw new Error("Invalid hex format");
+  }
+}
+
+// src/ensindexer/config/parsing.ts
+function parseNonNegativeInteger(maybeNumber) {
+  const trimmed = maybeNumber.trim();
+  if (!trimmed) {
+    throw new Error("Input cannot be empty");
+  }
+  if (trimmed === "-0") {
+    throw new Error("Negative zero is not a valid non-negative integer");
+  }
+  const num = Number(maybeNumber);
+  if (Number.isNaN(num)) {
+    throw new Error(`"${maybeNumber}" is not a valid number`);
+  }
+  if (!Number.isFinite(num)) {
+    throw new Error(`"${maybeNumber}" is not a finite number`);
+  }
+  if (!Number.isInteger(num)) {
+    throw new Error(`"${maybeNumber}" is not an integer`);
+  }
+  if (num < 0) {
+    throw new Error(`"${maybeNumber}" is not a non-negative integer`);
+  }
+  return num;
+}
+
 // src/ensindexer/indexing-status/deserialize.ts
 import { prettifyError as prettifyError3 } from "zod/v4";
 
@@ -534,6 +637,34 @@ function getOverallApproxRealtimeDistance(chains) {
   const approxRealtimeDistance = Math.max(...chainApproxRealtimeDistances);
   return approxRealtimeDistance;
 }
+function getTimestampForLowestOmnichainStartBlock(chains) {
+  const earliestKnownBlockTimestamps = chains.map(
+    (chain) => chain.config.startBlock.timestamp
+  );
+  return Math.min(...earliestKnownBlockTimestamps);
+}
+function getTimestampForHighestOmnichainKnownBlock(chains) {
+  const latestKnownBlockTimestamps = [];
+  for (const chain of chains) {
+    switch (chain.status) {
+      case ChainIndexingStatusIds.Unstarted:
+        if (chain.config.endBlock) {
+          latestKnownBlockTimestamps.push(chain.config.endBlock.timestamp);
+        }
+        break;
+      case ChainIndexingStatusIds.Backfill:
+        latestKnownBlockTimestamps.push(chain.backfillEndBlock.timestamp);
+        break;
+      case ChainIndexingStatusIds.Completed:
+        latestKnownBlockTimestamps.push(chain.latestIndexedBlock.timestamp);
+        break;
+      case ChainIndexingStatusIds.Following:
+        latestKnownBlockTimestamps.push(chain.latestKnownBlock.timestamp);
+        break;
+    }
+  }
+  return Math.max(...latestKnownBlockTimestamps);
+}
 function getOmnichainIndexingCursor(chains) {
   return Math.min(...chains.map((chain) => chain.latestIndexedBlock.timestamp));
 }
@@ -585,6 +716,12 @@ function checkChainIndexingStatusesForFollowingOverallStatus(chains) {
   );
   return allChainsHaveValidStatuses;
 }
+function sortAscChainStatusesByStartBlock(chains) {
+  chains.sort(
+    ([, chainA], [, chainB]) => chainA.config.startBlock.timestamp - chainB.config.startBlock.timestamp
+  );
+  return chains;
+}
 
 // src/ensindexer/indexing-status/zod-schemas.ts
 var makeChainIndexingConfigSchema = (valueLabel = "Value") => z3.discriminatedUnion("strategy", [
@@ -612,6 +749,7 @@ var makeChainIndexingBackfillStatusSchema = (valueLabel = "Value") => z3.strictO
   status: z3.literal(ChainIndexingStatusIds.Backfill),
   config: makeChainIndexingConfigSchema(valueLabel),
   latestIndexedBlock: makeBlockRefSchema(valueLabel),
+  latestSyncedBlock: makeBlockRefSchema(valueLabel),
   backfillEndBlock: makeBlockRefSchema(valueLabel)
 }).refine(
   ({ config, latestIndexedBlock }) => isBeforeOrEqualTo(config.startBlock, latestIndexedBlock),
@@ -619,9 +757,14 @@ var makeChainIndexingBackfillStatusSchema = (valueLabel = "Value") => z3.strictO
     error: `config.startBlock must be before or same as latestIndexedBlock.`
   }
 ).refine(
-  ({ latestIndexedBlock, backfillEndBlock }) => isBeforeOrEqualTo(latestIndexedBlock, backfillEndBlock),
+  ({ latestIndexedBlock, latestSyncedBlock }) => isBeforeOrEqualTo(latestIndexedBlock, latestSyncedBlock),
   {
-    error: `latestIndexedBlock must be before or same as backfillEndBlock.`
+    error: `latestIndexedBlock must be before or same as latestSyncedBlock.`
+  }
+).refine(
+  ({ latestSyncedBlock, backfillEndBlock }) => isBeforeOrEqualTo(latestSyncedBlock, backfillEndBlock),
+  {
+    error: `latestSyncedBlock must be before or same as backfillEndBlock.`
   }
 ).refine(
   ({ config, backfillEndBlock }) => config.endBlock === null || isEqualTo(backfillEndBlock, config.endBlock),
@@ -663,9 +806,9 @@ var makeChainIndexingCompletedStatusSchema = (valueLabel = "Value") => z3.strict
     error: `config.startBlock must be before or same as latestIndexedBlock.`
   }
 ).refine(
-  ({ config, latestIndexedBlock }) => isEqualTo(latestIndexedBlock, config.endBlock),
+  ({ config, latestIndexedBlock }) => isBeforeOrEqualTo(latestIndexedBlock, config.endBlock),
   {
-    error: `latestIndexedBlock must be the same as config.endBlock.`
+    error: `latestIndexedBlock must be before or same as config.endBlock.`
   }
 );
 var makeChainIndexingStatusSchema = (valueLabel = "Value") => z3.discriminatedUnion("status", [
@@ -853,7 +996,7 @@ var TraceableENSProtocol = /* @__PURE__ */ ((TraceableENSProtocol2) => {
   return TraceableENSProtocol2;
 })(TraceableENSProtocol || {});
 var ForwardResolutionProtocolStep = /* @__PURE__ */ ((ForwardResolutionProtocolStep2) => {
-  ForwardResolutionProtocolStep2["Operation"] = "operation";
+  ForwardResolutionProtocolStep2["Operation"] = "forward-resolution";
   ForwardResolutionProtocolStep2["FindResolver"] = "find-resolver";
   ForwardResolutionProtocolStep2["ActiveResolverExists"] = "active-resolver-exists";
   ForwardResolutionProtocolStep2["AccelerateENSIP19ReverseResolver"] = "accelerate-ensip-19-reverse-resolver";
@@ -864,7 +1007,7 @@ var ForwardResolutionProtocolStep = /* @__PURE__ */ ((ForwardResolutionProtocolS
   return ForwardResolutionProtocolStep2;
 })(ForwardResolutionProtocolStep || {});
 var ReverseResolutionProtocolStep = /* @__PURE__ */ ((ReverseResolutionProtocolStep2) => {
-  ReverseResolutionProtocolStep2["Operation"] = "operation";
+  ReverseResolutionProtocolStep2["Operation"] = "reverse-resolution";
   ReverseResolutionProtocolStep2["ResolveReverseName"] = "resolve-reverse-name";
   ReverseResolutionProtocolStep2["NameRecordExists"] = "name-record-exists-check";
   ReverseResolutionProtocolStep2["ForwardResolveAddressRecord"] = "forward-resolve-address-record";
@@ -875,26 +1018,47 @@ var PROTOCOL_ATTRIBUTE_PREFIX = "ens";
 var ATTR_PROTOCOL_NAME = `${PROTOCOL_ATTRIBUTE_PREFIX}.protocol`;
 var ATTR_PROTOCOL_STEP = `${PROTOCOL_ATTRIBUTE_PREFIX}.protocol.step`;
 var ATTR_PROTOCOL_STEP_RESULT = `${PROTOCOL_ATTRIBUTE_PREFIX}.protocol.step.result`;
-function hrTimeToMicroseconds(time) {
-  return time[0] * 1e6 + time[1] / 1e3;
-}
-var readableSpanToProtocolSpan = (span) => ({
-  id: span.spanContext().spanId,
-  traceId: span.spanContext().traceId,
-  parentSpanContext: span.parentSpanContext,
-  name: span.name,
-  timestamp: hrTimeToMicroseconds(span.startTime),
-  duration: hrTimeToMicroseconds(span.duration),
-  // only export `ens.*` attributes to avoid leaking internal details
-  attributes: Object.fromEntries(
-    Object.entries(span.attributes).filter(
-      ([key]) => key.startsWith(`${PROTOCOL_ATTRIBUTE_PREFIX}.`)
-    )
-  ),
-  status: span.status,
-  events: span.events
+
+// src/api/helpers.ts
+import { prettifyError as prettifyError4 } from "zod/v4";
+
+// src/api/zod-schemas.ts
+import z4 from "zod/v4";
+var ErrorResponseSchema = z4.object({
+  message: z4.string(),
+  details: z4.optional(z4.unknown())
 });
 
+// src/api/helpers.ts
+function deserializeErrorResponse(maybeErrorResponse) {
+  const parsed = ErrorResponseSchema.safeParse(maybeErrorResponse);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize ErrorResponse:
+${prettifyError4(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+
+// src/api/types.ts
+var IndexingStatusResponseCodes = {
+  IndexerError: 512,
+  RequestedDistanceNotAchievedError: 513
+};
+
+// src/client-error.ts
+var ClientError = class _ClientError extends Error {
+  details;
+  constructor(message, details) {
+    super(message);
+    this.name = "ClientError";
+    this.details = details;
+  }
+  static fromErrorResponse({ message, details }) {
+    return new _ClientError(message, details);
+  }
+};
+
 // src/client.ts
 var DEFAULT_ENSNODE_API_URL = "https://api.alpha.ensnode.io";
 var ENSNodeClient = class _ENSNodeClient {
@@ -921,7 +1085,7 @@ var ENSNodeClient = class _ENSNodeClient {
    * @param name The ENS Name whose records to resolve
    * @param selection selection of Resolver records
    * @param options additional options
-   * @param options.accelerate whether to attempt Protocol Acceleration (default true)
+   * @param options.accelerate whether to attempt Protocol Acceleration (default false)
    * @param options.trace whether to include a trace in the response (default false)
    * @returns ResolveRecordsResponse<SELECTION>
    * @throws If the request fails or the ENSNode API returns an error response
@@ -957,11 +1121,11 @@ var ENSNodeClient = class _ENSNodeClient {
       url.searchParams.set("texts", selection.texts.join(","));
     }
     if (options?.trace) url.searchParams.set("trace", "true");
-    if (options?.accelerate === false) url.searchParams.set("accelerate", "false");
+    if (options?.accelerate) url.searchParams.set("accelerate", "true");
     const response = await fetch(url);
     if (!response.ok) {
       const error = await response.json();
-      throw new Error(`Records Resolution Failed: ${error.message}`);
+      throw ClientError.fromErrorResponse(error);
     }
     const data = await response.json();
     return data;
@@ -976,7 +1140,7 @@ var ENSNodeClient = class _ENSNodeClient {
    * @param address The Address whose Primary Name to resolve
    * @param chainId The chain id within which to query the address' ENSIP-19 Multichain Primary Name
    * @param options additional options
-   * @param options.accelerate whether to attempt Protocol Acceleration (default true)
+   * @param options.accelerate whether to attempt Protocol Acceleration (default false)
    * @param options.trace whether to include a trace in the response (default false)
    * @returns ResolvePrimaryNameResponse
    * @throws If the request fails or the ENSNode API returns an error response
@@ -999,11 +1163,11 @@ var ENSNodeClient = class _ENSNodeClient {
   async resolvePrimaryName(address, chainId, options) {
     const url = new URL(`/api/resolve/primary-name/${address}/${chainId}`, this.options.url);
     if (options?.trace) url.searchParams.set("trace", "true");
-    if (options?.accelerate === false) url.searchParams.set("accelerate", "false");
+    if (options?.accelerate) url.searchParams.set("accelerate", "true");
     const response = await fetch(url);
     if (!response.ok) {
       const error = await response.json();
-      throw new Error(`Primary Name Resolution Failed: ${error.message}`);
+      throw ClientError.fromErrorResponse(error);
     }
     const data = await response.json();
     return data;
@@ -1054,55 +1218,180 @@ var ENSNodeClient = class _ENSNodeClient {
     const url = new URL(`/api/resolve/primary-names/${address}`, this.options.url);
     if (options?.chainIds) url.searchParams.set("chainIds", options.chainIds.join(","));
     if (options?.trace) url.searchParams.set("trace", "true");
-    if (options?.accelerate === false) url.searchParams.set("accelerate", "false");
+    if (options?.accelerate) url.searchParams.set("accelerate", "true");
     const response = await fetch(url);
     if (!response.ok) {
       const error = await response.json();
-      throw new Error(`Primary Names Resolution Failed: ${error.message}`);
+      throw ClientError.fromErrorResponse(error);
     }
     const data = await response.json();
     return data;
   }
+  /**
+   * Fetch ENSNode Config
+   *
+   * Fetch the ENSNode's configuration.
+   *
+   * @returns {ConfigResponse}
+   *
+   * @throws if the ENSNode request fails
+   * @throws if the ENSNode API returns an error response
+   * @throws if the ENSNode response breaks required invariants
+   */
+  async config() {
+    const url = new URL(`/api/config`, this.options.url);
+    const response = await fetch(url);
+    let responseData;
+    try {
+      responseData = await response.json();
+    } catch {
+      throw new Error("Malformed response data: invalid JSON");
+    }
+    if (!response.ok) {
+      const errorResponse = deserializeErrorResponse(responseData);
+      throw new Error(`Fetching ENSNode Config Failed: ${errorResponse.message}`);
+    }
+    return deserializeENSIndexerPublicConfig(responseData);
+  }
+  /**
+   * Fetch ENSNode Indexing Status
+   *
+   * Fetch the ENSNode's multichain indexing status.
+   *
+   * @param options additional options
+   * @param options.maxRealtimeDistance the max allowed distance between the
+   *  latest indexed block of each chain and the "tip" of all indexed chains.
+   *  Setting this parameter influences the HTTP response code as follows:
+   *  - Success (200 OK): The latest indexed block of each chain is within the
+   *    requested distance from realtime.
+   *  - Service Unavailable (503): The latest indexed block of each chain is NOT
+   *    within the requested distance from realtime.
+   *
+   * @returns {IndexingStatusResponse}
+   *
+   * @throws if the ENSNode request fails
+   * @throws if the ENSNode API returns an error response
+   * @throws if the ENSNode response breaks required invariants
+   */
+  async indexingStatus(options) {
+    const url = new URL(`/api/indexing-status`, this.options.url);
+    if (typeof options?.maxRealtimeDistance !== "undefined") {
+      url.searchParams.set("maxRealtimeDistance", `${options.maxRealtimeDistance}`);
+    }
+    const response = await fetch(url);
+    let responseData;
+    try {
+      responseData = await response.json();
+    } catch {
+      throw new Error("Malformed response data: invalid JSON");
+    }
+    if (!response.ok) {
+      switch (response.status) {
+        case IndexingStatusResponseCodes.IndexerError: {
+          console.error("Indexing Status API: indexer error");
+          return deserializeENSIndexerIndexingStatus(
+            responseData
+          );
+        }
+        case IndexingStatusResponseCodes.RequestedDistanceNotAchievedError: {
+          console.error(
+            "Indexing Status API: Requested realtime indexing distance not achieved error"
+          );
+          return deserializeENSIndexerIndexingStatus(
+            responseData
+          );
+        }
+        default: {
+          const errorResponse = deserializeErrorResponse(responseData);
+          throw new Error(`Fetching ENSNode Indexing Status Failed: ${errorResponse.message}`);
+        }
+      }
+    }
+    return deserializeENSIndexerIndexingStatus(
+      responseData
+    );
+  }
 };
 
 // src/resolution/resolver-records-selection.ts
-var DEFAULT_RECORDS_SELECTION = {
-  addresses: [ETH_COIN_TYPE],
-  texts: [
-    "url",
-    "avatar",
-    "header",
-    "description",
-    "email",
-    "com.twitter",
-    "com.farcaster",
-    "com.github"
-  ]
-};
 var isSelectionEmpty = (selection) => !selection.name && !selection.addresses?.length && !selection.texts?.length;
+
+// src/resolution/default-records-selection.ts
+import {
+  DatasourceNames,
+  ENSNamespaceIds as ENSNamespaceIds2,
+  maybeGetDatasource
+} from "@ensnode/datasources";
+var getENSIP19SupportedCoinTypes = (namespace) => uniq(
+  [
+    maybeGetDatasource(namespace, DatasourceNames.ReverseResolverBase),
+    maybeGetDatasource(namespace, DatasourceNames.ReverseResolverLinea),
+    maybeGetDatasource(namespace, DatasourceNames.ReverseResolverOptimism),
+    maybeGetDatasource(namespace, DatasourceNames.ReverseResolverArbitrum),
+    maybeGetDatasource(namespace, DatasourceNames.ReverseResolverScroll)
+  ].filter((ds) => ds !== void 0).map((ds) => ds.chain.id)
+).map(evmChainIdToCoinType);
+var TEXTS = [
+  "url",
+  "avatar",
+  "header",
+  "description",
+  "email",
+  "com.twitter",
+  "com.farcaster",
+  "com.github"
+];
+var DefaultRecordsSelection = {
+  [ENSNamespaceIds2.Mainnet]: {
+    addresses: [ETH_COIN_TYPE, ...getENSIP19SupportedCoinTypes(ENSNamespaceIds2.Mainnet)],
+    texts: TEXTS
+  },
+  [ENSNamespaceIds2.Sepolia]: {
+    addresses: [ETH_COIN_TYPE, ...getENSIP19SupportedCoinTypes(ENSNamespaceIds2.Sepolia)],
+    texts: TEXTS
+  },
+  [ENSNamespaceIds2.Holesky]: {
+    addresses: [ETH_COIN_TYPE, ...getENSIP19SupportedCoinTypes(ENSNamespaceIds2.Holesky)],
+    texts: TEXTS
+  },
+  [ENSNamespaceIds2.EnsTestEnv]: {
+    addresses: [ETH_COIN_TYPE, ...getENSIP19SupportedCoinTypes(ENSNamespaceIds2.EnsTestEnv)],
+    texts: TEXTS
+  }
+};
 export {
   ATTR_PROTOCOL_NAME,
   ATTR_PROTOCOL_STEP,
   ATTR_PROTOCOL_STEP_RESULT,
+  BASENAMES_NODE,
   ChainIndexingStatusIds,
   ChainIndexingStrategyIds,
+  ClientError,
   DEFAULT_ENSNODE_API_URL,
   DEFAULT_EVM_CHAIN_ID,
   DEFAULT_EVM_COIN_TYPE,
-  DEFAULT_RECORDS_SELECTION,
+  DefaultRecordsSelection,
   ENSNamespaceIds,
   ENSNodeClient,
   ETH_COIN_TYPE,
+  ETH_NODE,
   ForwardResolutionProtocolStep,
+  IndexingStatusResponseCodes,
+  LINEANAMES_NODE,
   LruCache,
   OverallIndexingStatusIds,
+  PROTOCOL_ATTRIBUTE_PREFIX,
   PluginName,
   REVERSE_ROOT_NODES,
   ROOT_NODE,
   ReverseResolutionProtocolStep,
   TraceableENSProtocol,
+  accountIdEqual,
   addrReverseLabel,
   bigintToCoinType,
+  buildEnsRainbowClientLabelSet,
+  buildLabelSetId,
+  buildLabelSetVersion,
   checkChainIndexingStatusesForBackfillOverallStatus,
   checkChainIndexingStatusesForCompletedOverallStatus,
   checkChainIndexingStatusesForFollowingOverallStatus,
@@ -1118,6 +1407,7 @@ export {
   deserializeDuration,
   deserializeENSIndexerIndexingStatus,
   deserializeENSIndexerPublicConfig,
+  deserializeErrorResponse,
   deserializeUrl,
   evmChainIdToCoinType,
   getActiveChains,
@@ -1126,15 +1416,27 @@ export {
   getOverallApproxRealtimeDistance,
   getOverallIndexingStatus,
   getStandbyChains,
-  hrTimeToMicroseconds,
+  getTimestampForHighestOmnichainKnownBlock,
+  getTimestampForLowestOmnichainStartBlock,
+  invariant_isSubgraphCompatibleRequirements,
+  invariant_reverseResolversPluginNeedsResolverRecords,
   isLabelIndexable,
   isNormalized,
   isSelectionEmpty,
   isSubgraphCompatible,
+  labelHashToBytes,
+  makeDatabaseSchemaNameSchema,
+  makeDependencyInfoSchema,
+  makeENSIndexerPublicConfigSchema,
+  makeFullyPinnedLabelSetSchema,
+  makeIndexedChainIdsSchema,
+  makeLabelSetIdSchema,
+  makeLabelSetVersionSchema,
+  makePluginsListSchema,
   makeSubdomainNode,
   maybeHealLabelByReverseAddress,
+  parseNonNegativeInteger,
   parseReverseName,
-  readableSpanToProtocolSpan,
   reverseName,
   serializeChainId,
   serializeChainIndexingStatuses,
@@ -1143,7 +1445,9 @@ export {
   serializeENSIndexerPublicConfig,
   serializeIndexedChainIds,
   serializeUrl,
+  sortAscChainStatusesByStartBlock,
   uint256ToHex32,
-  uniq
+  uniq,
+  validateSupportedLabelSetAndVersion
 };
 //# sourceMappingURL=index.js.map