@ensnode/ensnode-sdk 0.31.0 → 0.32.0

package/dist/index.js

@@ -1,19 +1,133 @@
-// src/utils/constants.ts
+// src/ens/constants.ts
 import { namehash } from "viem";
 var ROOT_NODE = namehash("");
 var REVERSE_ROOT_NODES = /* @__PURE__ */ new Set([namehash("addr.reverse")]);
-var ETH_COIN_TYPE = 60n;
 
-// src/utils/types.ts
-var PluginName = /* @__PURE__ */ ((PluginName2) => {
-  PluginName2["Subgraph"] = "subgraph";
-  PluginName2["Basenames"] = "basenames";
-  PluginName2["Lineanames"] = "lineanames";
-  PluginName2["ThreeDNS"] = "threedns";
-  return PluginName2;
-})(PluginName || {});
+// src/ens/subname-helpers.ts
+import { concat, isAddress, isHash, keccak256, toHex } from "viem";
+import { labelhash } from "viem/ens";
+
+// src/ens/coin-type.ts
+import {
+  coinTypeToEvmChainId as _coinTypeToEvmChainId,
+  evmChainIdToCoinType as _evmChainIdToCoinType
+} from "@ensdomains/address-encoder/utils";
+var ETH_COIN_TYPE = 60;
+var DEFAULT_EVM_CHAIN_ID = 0;
+var DEFAULT_EVM_COIN_TYPE = 2147483648;
+var coinTypeToEvmChainId = (coinType) => {
+  if (coinType === ETH_COIN_TYPE) return 1;
+  return _coinTypeToEvmChainId(coinType);
+};
+var evmChainIdToCoinType = (chainId) => {
+  if (chainId === 1) return ETH_COIN_TYPE;
+  return _evmChainIdToCoinType(chainId);
+};
+var bigintToCoinType = (value) => {
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error(`'${value}' cannot represent as CoinType, it is too large.`);
+  }
+  return Number(value);
+};
 
-// src/utils/cache.ts
+// src/ens/reverse-name.ts
+var addrReverseLabel = (address) => address.slice(2).toLowerCase();
+var coinTypeReverseLabel = (coinType) => coinType.toString(16);
+function reverseName(address, coinType) {
+  const label = addrReverseLabel(address);
+  const middle = (() => {
+    switch (coinType) {
+      case ETH_COIN_TYPE:
+        return "addr";
+      case DEFAULT_EVM_COIN_TYPE:
+        return "default";
+      default:
+        return coinTypeReverseLabel(coinType);
+    }
+  })();
+  return `${label}.${middle}.reverse`;
+}
+
+// src/ens/subname-helpers.ts
+var makeSubdomainNode = (labelHash, node) => keccak256(concat([node, labelHash]));
+var maybeHealLabelByReverseAddress = ({
+  maybeReverseAddress,
+  labelHash
+}) => {
+  if (!isAddress(maybeReverseAddress)) {
+    throw new Error(
+      `Invalid reverse address: '${maybeReverseAddress}'. Must be a valid EVM Address.`
+    );
+  }
+  if (!isHash(labelHash)) {
+    throw new Error(
+      `Invalid labelHash: '${labelHash}'. Must start with '0x' and represent 32 bytes.`
+    );
+  }
+  const assumedLabel = addrReverseLabel(maybeReverseAddress);
+  if (labelhash(assumedLabel) === labelHash) return assumedLabel;
+  return null;
+};
+var uint256ToHex32 = (num) => toHex(num, { size: 32 });
+var UNINDEXABLE_LABEL_CHARACTERS = [
+  "\0",
+  // null byte: PostgreSQL does not allow storing this character in text fields.
+  ".",
+  // conflicts with ENS label separator logic.
+  "[",
+  // conflicts with "unknown label" representations.
+  "]"
+  // conflicts with "unknown label" representations.
+];
+var UNINDEXABLE_LABEL_CHARACTER_CODES = new Set(
+  UNINDEXABLE_LABEL_CHARACTERS.map((char) => char.charCodeAt(0))
+);
+var isLabelIndexable = (label) => {
+  if (!label) return false;
+  for (let i = 0; i < label.length; i++) {
+    if (UNINDEXABLE_LABEL_CHARACTER_CODES.has(label.charCodeAt(i))) return false;
+  }
+  return true;
+};
+
+// src/ens/names.ts
+var getNameHierarchy = (name) => name.split(".").map((_, i, labels) => labels.slice(i).join("."));
+
+// src/ens/types.ts
+import { ENSNamespaceIds } from "@ensnode/datasources";
+
+// src/ens/parse-reverse-name.ts
+import { getAddress, hexToBigInt } from "viem";
+var REVERSE_NAME_REGEX = /^([0-9a-fA-F]+)\.([0-9a-f]{1,64}|addr|default)\.reverse$/;
+var parseAddressLabel = (addressLabel) => getAddress(`0x${addressLabel}`);
+var parseCoinTypeLabel = (coinTypeLabel) => {
+  if (coinTypeLabel === "default") return DEFAULT_EVM_COIN_TYPE;
+  if (coinTypeLabel === "addr") return ETH_COIN_TYPE;
+  return bigintToCoinType(hexToBigInt(`0x${coinTypeLabel}`));
+};
+function parseReverseName(name) {
+  const match = name.match(REVERSE_NAME_REGEX);
+  if (!match) return null;
+  try {
+    const [, addressLabel, coinTypeLabel] = match;
+    if (!addressLabel) return null;
+    if (!coinTypeLabel) return null;
+    return {
+      address: parseAddressLabel(addressLabel),
+      coinType: parseCoinTypeLabel(coinTypeLabel)
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/ensindexer/config/deserialize.ts
+import { prettifyError as prettifyError2 } from "zod/v4";
+
+// src/ensindexer/config/zod-schemas.ts
+import z2 from "zod/v4";
+
+// src/shared/cache.ts
 var LruCache = class {
   _cache = /* @__PURE__ */ new Map();
   _capacity;
@@ -62,59 +176,974 @@ var LruCache = class {
   }
 };
 
-// src/utils/subname-helpers.ts
-import { concat, isAddress, isHash, keccak256, toHex } from "viem";
-import { labelhash } from "viem/ens";
-var makeSubdomainNode = (labelHash, node) => keccak256(concat([node, labelHash]));
-var addrReverseLabel = (address) => address.slice(2).toLowerCase();
-var maybeHealLabelByReverseAddress = ({
-  maybeReverseAddress,
-  labelHash
-}) => {
-  if (!isAddress(maybeReverseAddress)) {
+// src/shared/collections.ts
+var uniq = (arr) => [...new Set(arr)];
+
+// src/shared/serialize.ts
+function serializeChainId(chainId) {
+  return chainId.toString();
+}
+function serializeDatetime(datetime) {
+  return datetime.toISOString();
+}
+function serializeUrl(url) {
+  return url.toString();
+}
+
+// src/shared/deserialize.ts
+import { prettifyError } from "zod/v4";
+
+// src/shared/zod-schemas.ts
+import z from "zod/v4";
+var makeIntegerSchema = (valueLabel = "Value") => z.int({
+  error: `${valueLabel} must be an integer.`
+});
+var makePositiveIntegerSchema = (valueLabel = "Value") => makeIntegerSchema(valueLabel).positive({
+  error: `${valueLabel} must be a positive integer (>0).`
+});
+var makeNonNegativeIntegerSchema = (valueLabel = "Value") => makeIntegerSchema(valueLabel).nonnegative({
+  error: `${valueLabel} must be a non-negative integer (>=0).`
+});
+var makeDurationSchema = (valueLabel = "Value") => z.coerce.number({
+  error: `${valueLabel} must be a number.`
+}).pipe(makeNonNegativeIntegerSchema(valueLabel));
+var makeChainIdSchema = (valueLabel = "Chain ID") => makePositiveIntegerSchema(valueLabel);
+var makeChainIdStringSchema = (valueLabel = "Chain ID String") => z.string({ error: `${valueLabel} must be a string representing a chain ID.` }).pipe(z.coerce.number({ error: `${valueLabel} must represent a positive integer (>0).` })).pipe(makeChainIdSchema(`The numeric value represented by ${valueLabel}`));
+var makeDatetimeSchema = (valueLabel = "Datetime string") => 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") => z.url({
+  error: `${valueLabel} must be a valid URL string (e.g., http://localhost:8080 or https://example.com).`
+}).transform((v) => new URL(v));
+var makeBlockNumberSchema = (valueLabel = "Block number") => makeNonNegativeIntegerSchema(valueLabel);
+var makeBlockrangeSchema = (valueLabel = "Value") => z.strictObject(
+  {
+    startBlock: makeBlockNumberSchema(`${valueLabel}.startBlock`).optional(),
+    endBlock: makeBlockNumberSchema(`${valueLabel}.endBlock`).optional()
+  },
+  {
+    error: `${valueLabel} must be a valid Blockrange object.`
+  }
+).refine(
+  (v) => {
+    if (v.startBlock && v.endBlock) {
+      return v.startBlock <= v.endBlock;
+    }
+    return true;
+  },
+  { error: `${valueLabel}: startBlock must be before or equal to endBlock` }
+);
+var makeBlockRefSchema = (valueLabel = "Value") => z.strictObject(
+  {
+    timestamp: makeUnixTimestampSchema(`${valueLabel}.timestamp`),
+    number: makeBlockNumberSchema(`${valueLabel}.number`)
+  },
+  {
+    error: `${valueLabel} must be a valid BlockRef object.`
+  }
+);
+var makeENSNamespaceIdSchema = (valueLabel = "ENSNamespaceId") => z.enum(ENSNamespaceIds, {
+  error() {
+    return `Invalid ${valueLabel}. Supported ENS namespace IDs are: ${Object.keys(ENSNamespaceIds).join(", ")}`;
+  }
+});
+
+// src/shared/deserialize.ts
+function deserializeChainId(maybeChainId, valueLabel) {
+  const schema = makeChainIdStringSchema(valueLabel);
+  const parsed = schema.safeParse(maybeChainId);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize ChainId:
+${prettifyError(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+function deserializeDatetime(maybeDatetime, valueLabel) {
+  const schema = makeDatetimeSchema(valueLabel);
+  const parsed = schema.safeParse(maybeDatetime);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize Datetime:
+${prettifyError(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+function deserializeUrl(maybeUrl, valueLabel) {
+  const schema = makeUrlSchema(valueLabel);
+  const parsed = schema.safeParse(maybeUrl);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize URL:
+${prettifyError(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+function deserializeBlockNumber(maybeBlockNumber, valueLabel) {
+  const schema = makeBlockNumberSchema(valueLabel);
+  const parsed = schema.safeParse(maybeBlockNumber);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize BlockNumber:
+${prettifyError(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+function deserializeBlockrange(maybeBlockrange, valueLabel) {
+  const schema = makeBlockrangeSchema(valueLabel);
+  const parsed = schema.safeParse(maybeBlockrange);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize Blockrange:
+${prettifyError(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+function deserializeBlockRef(maybeBlockRef, valueLabel) {
+  const schema = makeBlockRefSchema(valueLabel);
+  const parsed = schema.safeParse(maybeBlockRef);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize BlockRef:
+${prettifyError(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+function deserializeDuration(maybeDuration, valueLabel) {
+  const schema = makeDurationSchema(valueLabel);
+  const parsed = schema.safeParse(maybeDuration);
+  if (parsed.error) {
+    throw new RangeError(`Cannot deserialize Duration:
+${prettifyError(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+
+// src/shared/is-normalized.ts
+import { normalize } from "viem/ens";
+function isNormalized(name) {
+  try {
+    return name === normalize(name);
+  } catch {
+    return false;
+  }
+}
+
+// src/ensindexer/config/types.ts
+var PluginName = /* @__PURE__ */ ((PluginName2) => {
+  PluginName2["Subgraph"] = "subgraph";
+  PluginName2["Basenames"] = "basenames";
+  PluginName2["Lineanames"] = "lineanames";
+  PluginName2["ThreeDNS"] = "threedns";
+  PluginName2["ReverseResolvers"] = "reverse-resolvers";
+  PluginName2["Referrals"] = "referrals";
+  return PluginName2;
+})(PluginName || {});
+
+// src/ensindexer/config/helpers.ts
+function isSubgraphCompatible(config) {
+  const onlySubgraphPluginActivated = config.plugins.length === 1 && config.plugins[0] === "subgraph" /* Subgraph */;
+  const indexingBehaviorIsSubgraphCompatible = !config.healReverseAddresses && !config.indexAdditionalResolverRecords;
+  return onlySubgraphPluginActivated && indexingBehaviorIsSubgraphCompatible;
+}
+
+// src/ensindexer/config/zod-schemas.ts
+var makeIndexedChainIdsSchema = (valueLabel = "Indexed Chain IDs") => z2.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") => z2.array(
+  z2.enum(PluginName, {
+    error: `${valueLabel} must be a list with at least one valid plugin name. Valid plugins are: ${Object.values(
+      PluginName
+    ).join(", ")}`
+  })
+).min(1, {
+  error: `${valueLabel} must be a list with at least one valid plugin name. Valid plugins are: ${Object.values(
+    PluginName
+  ).join(", ")}`
+}).refine((arr) => arr.length === uniq(arr).length, {
+  error: `${valueLabel} cannot contain duplicate values.`
+});
+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 makeNonEmptyStringSchema = (valueLabel = "Value") => z2.string().nonempty({ error: `${valueLabel} must be a non-empty string.` });
+var makeDependencyInfoSchema = (valueLabel = "Value") => z2.strictObject(
+  {
+    nodejs: makeNonEmptyStringSchema(),
+    ponder: makeNonEmptyStringSchema(),
+    ensRainbow: makeNonEmptyStringSchema(),
+    ensRainbowSchema: makePositiveIntegerSchema()
+  },
+  {
+    error: `${valueLabel} must be a valid DependencyInfo object.`
+  }
+);
+function invariant_reverseResolversPluginNeedsResolverRecords(ctx) {
+  const { value: config } = ctx;
+  const reverseResolversPluginActive = config.plugins.includes("reverse-resolvers" /* ReverseResolvers */);
+  if (reverseResolversPluginActive && !config.indexAdditionalResolverRecords) {
+    ctx.issues.push({
+      code: "custom",
+      input: config,
+      message: `The '${"reverse-resolvers" /* ReverseResolvers */}' plugin requires 'indexAdditionalResolverRecords' to be 'true'.`
+    });
+  }
+}
+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'`;
+    ctx.issues.push({
+      code: "custom",
+      input: config,
+      message
+    });
+  }
+}
+var makeENSIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") => z2.object({
+  ensAdminUrl: makeUrlSchema(`${valueLabel}.ensAdminUrl`),
+  ensNodePublicUrl: makeUrlSchema(`${valueLabel}.ensNodePublicUrl`),
+  experimentalResolution: z2.boolean({ error: `${valueLabel}.experimentalResolution` }),
+  healReverseAddresses: z2.boolean({ error: `${valueLabel}.healReverseAddresses` }),
+  indexAdditionalResolverRecords: z2.boolean({
+    error: `${valueLabel}.indexAdditionalResolverRecords`
+  }),
+  indexedChainIds: makeIndexedChainIdsSchema(`${valueLabel}.indexedChainIds`),
+  isSubgraphCompatible: z2.boolean({ error: `${valueLabel}.isSubgraphCompatible` }),
+  namespace: makeENSNamespaceIdSchema(`${valueLabel}.namespace`),
+  plugins: makePluginsListSchema(`${valueLabel}.plugins`),
+  databaseSchemaName: makeDatabaseSchemaNameSchema(`${valueLabel}.databaseSchemaName`),
+  dependencyInfo: makeDependencyInfoSchema(`${valueLabel}.dependencyInfo`)
+}).check(invariant_reverseResolversPluginNeedsResolverRecords).check(invariant_experimentalResolutionNeedsReverseResolversPlugin).check(invariant_isSubgraphCompatibleRequirements);
+
+// src/ensindexer/config/deserialize.ts
+function deserializeENSIndexerPublicConfig(maybeConfig, valueLabel) {
+  const schema = makeENSIndexerPublicConfigSchema(valueLabel);
+  const parsed = schema.safeParse(maybeConfig);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize ENSIndexerPublicConfig:
+${prettifyError2(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+
+// src/ensindexer/config/serialize.ts
+function serializeIndexedChainIds(indexedChainIds) {
+  return Array.from(indexedChainIds);
+}
+function serializeENSIndexerPublicConfig(config) {
+  const {
+    ensAdminUrl,
+    ensNodePublicUrl,
+    indexedChainIds,
+    databaseSchemaName,
+    experimentalResolution,
+    healReverseAddresses,
+    indexAdditionalResolverRecords,
+    isSubgraphCompatible: isSubgraphCompatible2,
+    namespace,
+    plugins,
+    dependencyInfo
+  } = config;
+  return {
+    ensAdminUrl: serializeUrl(ensAdminUrl),
+    ensNodePublicUrl: serializeUrl(ensNodePublicUrl),
+    indexedChainIds: serializeIndexedChainIds(indexedChainIds),
+    databaseSchemaName,
+    experimentalResolution,
+    healReverseAddresses,
+    indexAdditionalResolverRecords,
+    isSubgraphCompatible: isSubgraphCompatible2,
+    namespace,
+    plugins,
+    dependencyInfo
+  };
+}
+
+// src/ensindexer/indexing-status/deserialize.ts
+import { prettifyError as prettifyError3 } from "zod/v4";
+
+// src/ensindexer/indexing-status/zod-schemas.ts
+import z3 from "zod/v4";
+
+// src/shared/block-ref.ts
+function isBefore(blockA, blockB) {
+  return blockA.number < blockB.number && blockA.timestamp < blockB.timestamp;
+}
+function isEqualTo(blockA, blockB) {
+  return blockA.number === blockB.number && blockA.timestamp === blockB.timestamp;
+}
+function isBeforeOrEqualTo(blockA, blockB) {
+  return isBefore(blockA, blockB) || isEqualTo(blockA, blockB);
+}
+
+// src/ensindexer/indexing-status/types.ts
+var ChainIndexingStatusIds = {
+  Unstarted: "unstarted",
+  Backfill: "backfill",
+  Following: "following",
+  Completed: "completed"
+};
+var OverallIndexingStatusIds = {
+  Unstarted: "unstarted",
+  Backfill: "backfill",
+  Following: "following",
+  Completed: "completed",
+  IndexerError: "indexer-error"
+};
+var ChainIndexingStrategyIds = {
+  Indefinite: "indefinite",
+  Definite: "definite"
+};
+
+// src/ensindexer/indexing-status/helpers.ts
+function getOverallIndexingStatus(chains) {
+  const chainStatuses = chains.map((chain) => chain.status);
+  let overallStatus;
+  if (chainStatuses.some((chainStatus) => chainStatus === ChainIndexingStatusIds.Following)) {
+    overallStatus = OverallIndexingStatusIds.Following;
+  } else if (chainStatuses.some((chainStatus) => chainStatus === ChainIndexingStatusIds.Backfill)) {
+    overallStatus = OverallIndexingStatusIds.Backfill;
+  } else if (chainStatuses.some((chainStatus) => chainStatus === ChainIndexingStatusIds.Unstarted)) {
+    overallStatus = OverallIndexingStatusIds.Unstarted;
+  } else {
+    overallStatus = OverallIndexingStatusIds.Completed;
+  }
+  return overallStatus;
+}
+function getOverallApproxRealtimeDistance(chains) {
+  const chainApproxRealtimeDistances = chains.filter((chain) => chain.status === ChainIndexingStatusIds.Following).map((chain) => chain.approxRealtimeDistance);
+  if (chainApproxRealtimeDistances.length === 0) {
     throw new Error(
-      `Invalid reverse address: '${maybeReverseAddress}'. Must be a valid EVM Address.`
+      `The overall approximate realtime distance value is undefined if no indexed chain is in the '${OverallIndexingStatusIds.Following}' status`
     );
   }
-  if (!isHash(labelHash)) {
-    throw new Error(
-      `Invalid labelHash: '${labelHash}'. Must start with '0x' and represent 32 bytes.`
+  const approxRealtimeDistance = Math.max(...chainApproxRealtimeDistances);
+  return approxRealtimeDistance;
+}
+function getOmnichainIndexingCursor(chains) {
+  return Math.min(...chains.map((chain) => chain.latestIndexedBlock.timestamp));
+}
+function getActiveChains(chains) {
+  return chains.filter(
+    (chain) => chain.status === ChainIndexingStatusIds.Backfill || chain.status === ChainIndexingStatusIds.Following
+  );
+}
+function getStandbyChains(chains) {
+  return chains.filter(
+    (chain) => chain.status === ChainIndexingStatusIds.Unstarted || chain.status === ChainIndexingStatusIds.Completed
+  );
+}
+function createIndexingConfig(startBlock, endBlock) {
+  if (endBlock) {
+    return {
+      strategy: ChainIndexingStrategyIds.Definite,
+      startBlock,
+      endBlock
+    };
+  }
+  return {
+    strategy: ChainIndexingStrategyIds.Indefinite,
+    startBlock,
+    endBlock: null
+  };
+}
+function checkChainIndexingStatusesForUnstartedOverallStatus(chains) {
+  return chains.every((chain) => chain.status === ChainIndexingStatusIds.Unstarted);
+}
+function checkChainIndexingStatusesForBackfillOverallStatus(chains) {
+  const atLeastOneChainInTargetStatus = chains.some(
+    (chain) => chain.status === ChainIndexingStatusIds.Backfill
+  );
+  const otherChainsHaveValidStatuses = chains.every(
+    (chain) => chain.status === ChainIndexingStatusIds.Unstarted || chain.status === ChainIndexingStatusIds.Backfill || chain.status === ChainIndexingStatusIds.Completed
+  );
+  return atLeastOneChainInTargetStatus && otherChainsHaveValidStatuses;
+}
+function checkChainIndexingStatusesForCompletedOverallStatus(chains) {
+  const allChainsHaveValidStatuses = chains.every(
+    (chain) => chain.status === ChainIndexingStatusIds.Completed
+  );
+  return allChainsHaveValidStatuses;
+}
+function checkChainIndexingStatusesForFollowingOverallStatus(chains) {
+  const allChainsHaveValidStatuses = chains.some(
+    (chain) => chain.status === ChainIndexingStatusIds.Following
+  );
+  return allChainsHaveValidStatuses;
+}
+
+// src/ensindexer/indexing-status/zod-schemas.ts
+var makeChainIndexingConfigSchema = (valueLabel = "Value") => z3.discriminatedUnion("strategy", [
+  z3.strictObject({
+    strategy: z3.literal(ChainIndexingStrategyIds.Indefinite),
+    startBlock: makeBlockRefSchema(valueLabel),
+    endBlock: z3.null()
+  }),
+  z3.strictObject({
+    strategy: z3.literal(ChainIndexingStrategyIds.Definite),
+    startBlock: makeBlockRefSchema(valueLabel),
+    endBlock: makeBlockRefSchema(valueLabel)
+  })
+]);
+var makeChainIndexingUnstartedStatusSchema = (valueLabel = "Value") => z3.strictObject({
+  status: z3.literal(ChainIndexingStatusIds.Unstarted),
+  config: makeChainIndexingConfigSchema(valueLabel)
+}).refine(
+  ({ config }) => config.endBlock === null || isBeforeOrEqualTo(config.startBlock, config.endBlock),
+  {
+    error: `config.startBlock must be before or same as config.endBlock.`
+  }
+);
+var makeChainIndexingBackfillStatusSchema = (valueLabel = "Value") => z3.strictObject({
+  status: z3.literal(ChainIndexingStatusIds.Backfill),
+  config: makeChainIndexingConfigSchema(valueLabel),
+  latestIndexedBlock: makeBlockRefSchema(valueLabel),
+  backfillEndBlock: makeBlockRefSchema(valueLabel)
+}).refine(
+  ({ config, latestIndexedBlock }) => isBeforeOrEqualTo(config.startBlock, latestIndexedBlock),
+  {
+    error: `config.startBlock must be before or same as latestIndexedBlock.`
+  }
+).refine(
+  ({ latestIndexedBlock, backfillEndBlock }) => isBeforeOrEqualTo(latestIndexedBlock, backfillEndBlock),
+  {
+    error: `latestIndexedBlock must be before or same as backfillEndBlock.`
+  }
+).refine(
+  ({ config, backfillEndBlock }) => config.endBlock === null || isEqualTo(backfillEndBlock, config.endBlock),
+  {
+    error: `backfillEndBlock must be the same as config.endBlock.`
+  }
+);
+var makeChainIndexingFollowingStatusSchema = (valueLabel = "Value") => z3.strictObject({
+  status: z3.literal(ChainIndexingStatusIds.Following),
+  config: z3.strictObject({
+    strategy: z3.literal(ChainIndexingStrategyIds.Indefinite),
+    startBlock: makeBlockRefSchema(valueLabel)
+  }),
+  latestIndexedBlock: makeBlockRefSchema(valueLabel),
+  latestKnownBlock: makeBlockRefSchema(valueLabel),
+  approxRealtimeDistance: makeDurationSchema(valueLabel)
+}).refine(
+  ({ config, latestIndexedBlock }) => isBeforeOrEqualTo(config.startBlock, latestIndexedBlock),
+  {
+    error: `config.startBlock must be before or same as latestIndexedBlock.`
+  }
+).refine(
+  ({ latestIndexedBlock, latestKnownBlock }) => isBeforeOrEqualTo(latestIndexedBlock, latestKnownBlock),
+  {
+    error: `latestIndexedBlock must be before or same as latestKnownBlock.`
+  }
+);
+var makeChainIndexingCompletedStatusSchema = (valueLabel = "Value") => z3.strictObject({
+  status: z3.literal(ChainIndexingStatusIds.Completed),
+  config: z3.strictObject({
+    strategy: z3.literal(ChainIndexingStrategyIds.Definite),
+    startBlock: makeBlockRefSchema(valueLabel),
+    endBlock: makeBlockRefSchema(valueLabel)
+  }),
+  latestIndexedBlock: makeBlockRefSchema(valueLabel)
+}).refine(
+  ({ config, latestIndexedBlock }) => isBeforeOrEqualTo(config.startBlock, latestIndexedBlock),
+  {
+    error: `config.startBlock must be before or same as latestIndexedBlock.`
+  }
+).refine(
+  ({ config, latestIndexedBlock }) => isEqualTo(latestIndexedBlock, config.endBlock),
+  {
+    error: `latestIndexedBlock must be the same as config.endBlock.`
+  }
+);
+var makeChainIndexingStatusSchema = (valueLabel = "Value") => z3.discriminatedUnion("status", [
+  makeChainIndexingUnstartedStatusSchema(valueLabel),
+  makeChainIndexingBackfillStatusSchema(valueLabel),
+  makeChainIndexingFollowingStatusSchema(valueLabel),
+  makeChainIndexingCompletedStatusSchema(valueLabel)
+]);
+var makeChainIndexingStatusesSchema = (valueLabel = "Value") => z3.record(makeChainIdStringSchema(), makeChainIndexingStatusSchema(valueLabel), {
+  error: "Chains configuration must be an object mapping valid chain IDs to their configs."
+}).transform((serializedChainsIndexingStatus) => {
+  const chainsIndexingStatus = /* @__PURE__ */ new Map();
+  for (const [chainIdString, chainStatus] of Object.entries(serializedChainsIndexingStatus)) {
+    chainsIndexingStatus.set(deserializeChainId(chainIdString), chainStatus);
+  }
+  return chainsIndexingStatus;
+});
+var makeUnstartedOverallStatusSchema = (valueLabel) => z3.strictObject({
+  overallStatus: z3.literal(OverallIndexingStatusIds.Unstarted),
+  chains: makeChainIndexingStatusesSchema(valueLabel).refine(
+    (chains) => checkChainIndexingStatusesForUnstartedOverallStatus(Array.from(chains.values())),
+    {
+      error: `${valueLabel} at least one chain must be in "unstarted" status and
+each chain has to have a status of either "unstarted", or "completed"`
+    }
+  ).transform((chains) => chains)
+}).refine(
+  (indexingStatus) => {
+    const chains = Array.from(indexingStatus.chains.values());
+    return getOverallIndexingStatus(chains) === indexingStatus.overallStatus;
+  },
+  { error: `${valueLabel} is an invalid overallStatus.` }
+);
+var makeBackfillOverallStatusSchema = (valueLabel) => z3.strictObject({
+  overallStatus: z3.literal(OverallIndexingStatusIds.Backfill),
+  chains: makeChainIndexingStatusesSchema(valueLabel).refine(
+    (chains) => checkChainIndexingStatusesForBackfillOverallStatus(Array.from(chains.values())),
+    {
+      error: `${valueLabel} at least one chain must be in "backfill" status and
+each chain has to have a status of either "unstarted", "backfill" or "completed"`
+    }
+  ).transform((chains) => chains),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+}).refine(
+  (indexingStatus) => {
+    const chains = Array.from(indexingStatus.chains.values());
+    return getOverallIndexingStatus(chains) === indexingStatus.overallStatus;
+  },
+  { error: `${valueLabel} is an invalid overallStatus.` }
+).refine(
+  (indexingStatus) => {
+    const chains = Array.from(indexingStatus.chains.values());
+    const standbyChainStartBlocks = getStandbyChains(chains).map(
+      (chain) => chain.config.startBlock.timestamp
     );
+    const standbyChainEarliestStartBlocks = Math.min(...standbyChainStartBlocks);
+    return indexingStatus.omnichainIndexingCursor <= standbyChainEarliestStartBlocks;
+  },
+  {
+    error: "omnichainIndexingCursor must be lower than or equal to the earliest config.startBlock across all standby chains"
   }
-  const assumedLabel = addrReverseLabel(maybeReverseAddress);
-  if (labelhash(assumedLabel) === labelHash) return assumedLabel;
-  return null;
-};
-var uint256ToHex32 = (num) => toHex(num, { size: 32 });
-var UNINDEXABLE_LABEL_CHARACTERS = [
-  "\0",
-  // null byte: PostgreSQL does not allow storing this character in text fields.
-  ".",
-  // conflicts with ENS label separator logic.
-  "[",
-  // conflicts with "unknown label" representations.
-  "]"
-  // conflicts with "unknown label" representations.
-];
-var UNINDEXABLE_LABEL_CHARACTER_CODES = new Set(
-  UNINDEXABLE_LABEL_CHARACTERS.map((char) => char.charCodeAt(0))
 );
-var isLabelIndexable = (label) => {
-  if (!label) return false;
-  for (let i = 0; i < label.length; i++) {
-    if (UNINDEXABLE_LABEL_CHARACTER_CODES.has(label.charCodeAt(i))) return false;
+var makeCompletedOverallStatusSchema = (valueLabel) => z3.strictObject({
+  overallStatus: z3.literal(OverallIndexingStatusIds.Completed),
+  chains: makeChainIndexingStatusesSchema(valueLabel).refine(
+    (chains) => checkChainIndexingStatusesForCompletedOverallStatus(Array.from(chains.values())),
+    {
+      error: `${valueLabel} all chains must have "completed" status`
+    }
+  ).transform((chains) => chains)
+}).refine(
+  (indexingStatus) => {
+    const chains = Array.from(indexingStatus.chains.values());
+    return getOverallIndexingStatus(chains) === indexingStatus.overallStatus;
+  },
+  { error: `${valueLabel} is an invalid overallStatus.` }
+);
+var makeFollowingOverallStatusSchema = (valueLabel) => z3.strictObject({
+  overallStatus: z3.literal(OverallIndexingStatusIds.Following),
+  chains: makeChainIndexingStatusesSchema(valueLabel),
+  overallApproxRealtimeDistance: makeDurationSchema(valueLabel),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+}).refine(
+  (indexingStatus) => {
+    const chains = Array.from(indexingStatus.chains.values());
+    return getOverallIndexingStatus(chains) === indexingStatus.overallStatus;
+  },
+  { error: `${valueLabel} is an invalid overallStatus.` }
+).refine(
+  (indexingStatus) => checkChainIndexingStatusesForFollowingOverallStatus(
+    Array.from(indexingStatus.chains.values())
+  ),
+  {
+    error: `${valueLabel} at least one chain must be in "following" status`
   }
-  return true;
+).refine(
+  (indexingStatus) => {
+    const chains = Array.from(indexingStatus.chains.values());
+    return getOverallApproxRealtimeDistance(chains) === indexingStatus.overallApproxRealtimeDistance;
+  },
+  { error: `${valueLabel} is an invalid overallApproxRealtimeDistance.` }
+).refine(
+  (indexingStatus) => {
+    const chains = Array.from(indexingStatus.chains.values());
+    const standbyChainStartBlocks = getStandbyChains(chains).map(
+      (chain) => chain.config.startBlock.timestamp
+    );
+    const standbyChainEarliestStartBlocks = Math.min(...standbyChainStartBlocks);
+    return indexingStatus.omnichainIndexingCursor <= standbyChainEarliestStartBlocks;
+  },
+  {
+    error: "omnichainIndexingCursor must be lower than or equal to the earliest config.startBlock across all standby chains"
+  }
+);
+var makeErrorSchemaOverallStatusSchema = (valueLabel) => z3.strictObject({
+  overallStatus: z3.literal(OverallIndexingStatusIds.IndexerError)
+});
+var makeENSIndexerIndexingStatusSchema = (valueLabel = "ENSIndexerIndexingStatus") => z3.discriminatedUnion("overallStatus", [
+  makeUnstartedOverallStatusSchema(valueLabel),
+  makeBackfillOverallStatusSchema(valueLabel),
+  makeCompletedOverallStatusSchema(valueLabel),
+  makeFollowingOverallStatusSchema(valueLabel),
+  makeErrorSchemaOverallStatusSchema(valueLabel)
+]);
+
+// src/ensindexer/indexing-status/deserialize.ts
+function deserializeENSIndexerIndexingStatus(maybeStatus, valueLabel) {
+  const schema = makeENSIndexerIndexingStatusSchema(valueLabel);
+  const parsed = schema.safeParse(maybeStatus);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize ENSIndexerIndexingStatus:
+${prettifyError3(parsed.error)}
+`
+    );
+  }
+  return parsed.data;
+}
+
+// src/ensindexer/indexing-status/serialize.ts
+function serializeChainIndexingStatuses(chainIndexingStatuses) {
+  const serializedChainsIndexingStatuses = {};
+  for (const [chainId, chainIndexingStatus] of chainIndexingStatuses.entries()) {
+    serializedChainsIndexingStatuses[serializeChainId(chainId)] = chainIndexingStatus;
+  }
+  return serializedChainsIndexingStatuses;
+}
+function serializeENSIndexerIndexingStatus(indexingStatus) {
+  switch (indexingStatus.overallStatus) {
+    case OverallIndexingStatusIds.IndexerError:
+      return {
+        overallStatus: OverallIndexingStatusIds.IndexerError
+      };
+    case OverallIndexingStatusIds.Unstarted:
+      return {
+        overallStatus: OverallIndexingStatusIds.Unstarted,
+        chains: serializeChainIndexingStatuses(indexingStatus.chains)
+      };
+    case OverallIndexingStatusIds.Backfill:
+      return {
+        overallStatus: OverallIndexingStatusIds.Backfill,
+        chains: serializeChainIndexingStatuses(indexingStatus.chains),
+        omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
+      };
+    case OverallIndexingStatusIds.Completed: {
+      return {
+        overallStatus: OverallIndexingStatusIds.Completed,
+        chains: serializeChainIndexingStatuses(indexingStatus.chains)
+      };
+    }
+    case OverallIndexingStatusIds.Following:
+      return {
+        overallStatus: OverallIndexingStatusIds.Following,
+        chains: serializeChainIndexingStatuses(indexingStatus.chains),
+        overallApproxRealtimeDistance: indexingStatus.overallApproxRealtimeDistance,
+        omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
+      };
+  }
+}
+
+// src/tracing/index.ts
+var TraceableENSProtocol = /* @__PURE__ */ ((TraceableENSProtocol2) => {
+  TraceableENSProtocol2["ForwardResolution"] = "forward-resolution";
+  TraceableENSProtocol2["ReverseResolution"] = "reverse-resolution";
+  return TraceableENSProtocol2;
+})(TraceableENSProtocol || {});
+var ForwardResolutionProtocolStep = /* @__PURE__ */ ((ForwardResolutionProtocolStep2) => {
+  ForwardResolutionProtocolStep2["Operation"] = "operation";
+  ForwardResolutionProtocolStep2["FindResolver"] = "find-resolver";
+  ForwardResolutionProtocolStep2["ActiveResolverExists"] = "active-resolver-exists";
+  ForwardResolutionProtocolStep2["AccelerateENSIP19ReverseResolver"] = "accelerate-ensip-19-reverse-resolver";
+  ForwardResolutionProtocolStep2["AccelerateKnownOffchainLookupResolver"] = "accelerate-known-offchain-lookup-resolver";
+  ForwardResolutionProtocolStep2["AccelerateKnownOnchainStaticResolver"] = "accelerate-known-onchain-static-resolver";
+  ForwardResolutionProtocolStep2["RequireResolver"] = "require-resolver";
+  ForwardResolutionProtocolStep2["ExecuteResolveCalls"] = "execute-resolve-calls";
+  return ForwardResolutionProtocolStep2;
+})(ForwardResolutionProtocolStep || {});
+var ReverseResolutionProtocolStep = /* @__PURE__ */ ((ReverseResolutionProtocolStep2) => {
+  ReverseResolutionProtocolStep2["Operation"] = "operation";
+  ReverseResolutionProtocolStep2["ResolveReverseName"] = "resolve-reverse-name";
+  ReverseResolutionProtocolStep2["NameRecordExists"] = "name-record-exists-check";
+  ReverseResolutionProtocolStep2["ForwardResolveAddressRecord"] = "forward-resolve-address-record";
+  ReverseResolutionProtocolStep2["VerifyResolvedAddressMatchesAddress"] = "verify-resolved-address-matches-address";
+  return ReverseResolutionProtocolStep2;
+})(ReverseResolutionProtocolStep || {});
+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/client.ts
+var DEFAULT_ENSNODE_API_URL = "https://api.alpha.ensnode.io";
+var ENSNodeClient = class _ENSNodeClient {
+  options;
+  static defaultOptions() {
+    return {
+      url: new URL(DEFAULT_ENSNODE_API_URL)
+    };
+  }
+  constructor(options = {}) {
+    this.options = {
+      ..._ENSNodeClient.defaultOptions(),
+      ...options
+    };
+  }
+  getOptions() {
+    return Object.freeze({
+      url: new URL(this.options.url.href)
+    });
+  }
+  /**
+   * Resolves records for an ENS name (Forward Resolution).
+   *
+   * @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.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
+   *
+   * @example
+   * ```typescript
+   * const { records } = await client.resolveRecords("jesse.base.eth", {
+   *   addresses: [60],
+   *   texts: ["avatar", "com.twitter"]
+   * });
+   *
+   * console.log(records);
+   * // {
+   * //   addresses: {
+   * //     60: "0xabcd..."
+   * //   },
+   * //   texts: {
+   * //     avatar: "https://example.com/image.jpg",
+   * //     "com.twitter": null, // if not set, for example
+   * //   }
+   * // }
+   * ```
+   */
+  async resolveRecords(name, selection, options) {
+    const url = new URL(`/api/resolve/records/${encodeURIComponent(name)}`, this.options.url);
+    if (selection.name) {
+      url.searchParams.set("name", "true");
+    }
+    if (selection.addresses && selection.addresses.length > 0) {
+      url.searchParams.set("addresses", selection.addresses.join(","));
+    }
+    if (selection.texts && selection.texts.length > 0) {
+      url.searchParams.set("texts", selection.texts.join(","));
+    }
+    if (options?.trace) url.searchParams.set("trace", "true");
+    if (options?.accelerate === false) url.searchParams.set("accelerate", "false");
+    const response = await fetch(url);
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(`Records Resolution Failed: ${error.message}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  /**
+   * Resolves the primary name of a specified address (Reverse Resolution) on a specific chain.
+   *
+   * If the `address` specifies a valid [ENSIP-19 Default Name](https://docs.ens.domains/ensip/19/#default-primary-name),
+   * the Default Name will be returned. You _may_ query the Default EVM Chain Id (`0`) in order to
+   * determine the `address`'s Default Name directly.
+   *
+   * @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.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
+   *
+   * @example
+   * ```typescript
+   * // Resolve the address' Primary Name on Ethereum Mainnet
+   * const { name } = await client.resolvePrimaryName("0x179A862703a4adfb29896552DF9e307980D19285", 1);
+   * // name === 'gregskril.eth'
+   *
+   * // Resolve the address' Primary Name on Base
+   * const { name } = await client.resolvePrimaryName("0x179A862703a4adfb29896552DF9e307980D19285", 8453);
+   * // name === 'greg.base.eth'
+   *
+   * // Resolve the address' Default Primary Name
+   * const { name } = await client.resolvePrimaryName("0x179A862703a4adfb29896552DF9e307980D19285", 0);
+   * // name === 'gregskril.eth'
+   * ```
+   */
+  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");
+    const response = await fetch(url);
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(`Primary Name Resolution Failed: ${error.message}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  /**
+   * Resolves the primary names of a specified address across multiple chains.
+   *
+   * If the `address` specifies a valid [ENSIP-19 Default Name](https://docs.ens.domains/ensip/19/#default-primary-name),
+   * the Default Name will be returned for all chainIds for which there is not a chain-specific
+   * Primary Name. To avoid misuse, you _may not_ query the Default EVM Chain Id (`0`) directly, and
+   * should rely on the aforementioned per-chain defaulting behavior.
+   *
+   * @param address The Address whose Primary Names to resolve
+   * @param options additional options
+   * @param options.chainIds The set of chain ids within which to query the address' ENSIP-19
+   *  Multichain Primary Name (default: all ENSIP-19 supported chains)
+   * @param options.accelerate whether to attempt Protocol Acceleration (default: true)
+   * @param options.trace whether to include a trace in the response (default: false)
+   * @returns ResolvePrimaryNamesResponse
+   * @throws If the request fails or the ENSNode API returns an error response
+   *
+   * @example
+   * ```typescript
+   * // Resolve the address' Primary Names on all ENSIP-19 supported chain ids
+   * const { names } = await client.resolvePrimaryNames("0x179A862703a4adfb29896552DF9e307980D19285");
+   *
+   * console.log(names);
+   * // {
+   * //   "1": "gregskril.eth",
+   * //   "10": "gregskril.eth",
+   * //   "8453": "greg.base.eth", // base-specific Primary Name!
+   * //   "42161": "gregskril.eth",
+   * //   "59144": "gregskril.eth",
+   * //   "534352": "gregskril.eth"
+   * // }
+   *
+   * // Resolve the address' Primary Names on specific chain Ids
+   * const { names } = await client.resolvePrimaryNames("0xabcd...", [1, 8453]);
+   *
+   * console.log(names);
+   * // {
+   * //   "1": "gregskril.eth",
+   * //   "8453": "greg.base.eth", // base-specific Primary Name!
+   * // }
+   * ```
+   */
+  async resolvePrimaryNames(address, options) {
+    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");
+    const response = await fetch(url);
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(`Primary Names Resolution Failed: ${error.message}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+};
+
+// 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;
 export {
+  ATTR_PROTOCOL_NAME,
+  ATTR_PROTOCOL_STEP,
+  ATTR_PROTOCOL_STEP_RESULT,
+  ChainIndexingStatusIds,
+  ChainIndexingStrategyIds,
+  DEFAULT_ENSNODE_API_URL,
+  DEFAULT_EVM_CHAIN_ID,
+  DEFAULT_EVM_COIN_TYPE,
+  DEFAULT_RECORDS_SELECTION,
+  ENSNamespaceIds,
+  ENSNodeClient,
   ETH_COIN_TYPE,
+  ForwardResolutionProtocolStep,
   LruCache,
+  OverallIndexingStatusIds,
   PluginName,
   REVERSE_ROOT_NODES,
   ROOT_NODE,
+  ReverseResolutionProtocolStep,
+  TraceableENSProtocol,
+  addrReverseLabel,
+  bigintToCoinType,
+  checkChainIndexingStatusesForBackfillOverallStatus,
+  checkChainIndexingStatusesForCompletedOverallStatus,
+  checkChainIndexingStatusesForFollowingOverallStatus,
+  checkChainIndexingStatusesForUnstartedOverallStatus,
+  coinTypeReverseLabel,
+  coinTypeToEvmChainId,
+  createIndexingConfig,
+  deserializeBlockNumber,
+  deserializeBlockRef,
+  deserializeBlockrange,
+  deserializeChainId,
+  deserializeDatetime,
+  deserializeDuration,
+  deserializeENSIndexerIndexingStatus,
+  deserializeENSIndexerPublicConfig,
+  deserializeUrl,
+  evmChainIdToCoinType,
+  getActiveChains,
+  getNameHierarchy,
+  getOmnichainIndexingCursor,
+  getOverallApproxRealtimeDistance,
+  getOverallIndexingStatus,
+  getStandbyChains,
+  hrTimeToMicroseconds,
   isLabelIndexable,
+  isNormalized,
+  isSelectionEmpty,
+  isSubgraphCompatible,
   makeSubdomainNode,
   maybeHealLabelByReverseAddress,
-  uint256ToHex32
+  parseReverseName,
+  readableSpanToProtocolSpan,
+  reverseName,
+  serializeChainId,
+  serializeChainIndexingStatuses,
+  serializeDatetime,
+  serializeENSIndexerIndexingStatus,
+  serializeENSIndexerPublicConfig,
+  serializeIndexedChainIds,
+  serializeUrl,
+  uint256ToHex32,
+  uniq
 };
 //# sourceMappingURL=index.js.map