@ensnode/ensnode-sdk 0.36.0 → 1.0.1

package/dist/index.js

@@ -1,15 +1,56 @@
-// 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 ADDR_REVERSE_NODE = namehash("addr.reverse");
+// src/api/deserialize.ts
+import { prettifyError as prettifyError2 } from "zod/v4";
 
-// src/ens/subname-helpers.ts
-import { concat, keccak256, toHex } from "viem";
-var makeSubdomainNode = (labelHash, node) => keccak256(concat([node, labelHash]));
-var uint256ToHex32 = (num) => toHex(num, { size: 32 });
+// src/api/zod-schemas.ts
+import { namehash as namehash2 } from "viem";
+import z7 from "zod/v4";
+
+// src/ensindexer/indexing-status/zod-schemas.ts
+import z2 from "zod/v4";
+
+// src/ens/is-normalized.ts
+import { normalize } from "viem/ens";
+function isNormalizedName(name) {
+  try {
+    return name === normalize(name);
+  } catch {
+    return false;
+  }
+}
+function isNormalizedLabel(label) {
+  if (label === "") return false;
+  if (label.includes(".")) return false;
+  try {
+    return label === normalize(label);
+  } catch {
+    return false;
+  }
+}
+
+// src/shared/account-id.ts
+import { isAddressEqual } from "viem";
+var accountIdEqual = (a, b) => {
+  return a.chainId === b.chainId && isAddressEqual(a.address, b.address);
+};
+
+// src/shared/address.ts
+function asLowerCaseAddress(address) {
+  return address.toLowerCase();
+}
+
+// src/shared/cache.ts
+import { getUnixTime } from "date-fns";
+
+// src/shared/deserialize.ts
+import { prettifyError } from "zod/v4";
+
+// src/shared/zod-schemas.ts
+import { AccountId as CaipAccountId } from "caip";
+import { isAddress as isAddress2, isHex as isHex2, size } from "viem";
+import z from "zod/v4";
+
+// src/ens/index.ts
+import { getENSRootChainId } from "@ensnode/datasources";
 
 // src/ens/coin-type.ts
 import {
@@ -34,29 +75,63 @@ var bigintToCoinType = (value) => {
   return Number(value);
 };
 
-// src/ens/names.ts
-import { ens_beautify } from "@adraffy/ens-normalize";
+// 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 ADDR_REVERSE_NODE = namehash("addr.reverse");
 
-// src/ens/is-normalized.ts
-import { normalize } from "viem/ens";
-function isNormalizedName(name) {
-  try {
-    return name === normalize(name);
-  } catch {
-    return false;
-  }
+// src/ens/dns-encoded-name.ts
+import { bytesToString, hexToBytes } from "viem";
+function decodeDNSEncodedLiteralName(packet) {
+  return decodeDNSEncodedName(packet);
 }
-function isNormalizedLabel(label) {
-  if (label === "") return false;
-  if (label.includes(".")) return false;
-  try {
-    return label === normalize(label);
-  } catch {
-    return false;
+function decodeDNSEncodedName(packet) {
+  const segments = [];
+  const bytes = hexToBytes(packet);
+  if (bytes.length === 0) throw new Error(`Packet is empty.`);
+  let offset = 0;
+  while (offset < bytes.length) {
+    const len = bytes[offset];
+    if (len === void 0) {
+      throw new Error(`Invariant: bytes[offset] is undefined after offset < bytes.length check.`);
+    }
+    if (len < 0 || len > 255) {
+      throw new Error(
+        `Invariant: this should be literally impossible, but an unsigned byte was less than zero or greater than 255. The value in question is ${len}`
+      );
+    }
+    if (len === 0) break;
+    const segment = bytesToString(bytes.subarray(offset + 1, offset + len + 1));
+    segments.push(segment);
+    offset += len + 1;
   }
+  if (offset >= bytes.length) throw new Error(`Overflow, offset >= bytes.length`);
+  if (offset !== bytes.length - 1) throw new Error(`Junk at end of name`);
+  return segments;
+}
+
+// src/ens/labelhash.ts
+import { isHex } from "viem";
+function isLabelHash(maybeLabelHash) {
+  const expectedLength = maybeLabelHash.length === 66;
+  const expectedEncoding = isHex(maybeLabelHash);
+  const expectedCasing = maybeLabelHash === maybeLabelHash.toLowerCase();
+  return expectedLength && expectedEncoding && expectedCasing;
+}
+
+// src/ens/encode-labelhash.ts
+var encodeLabelHash = (labelHash) => `[${labelHash.slice(2)}]`;
+function isEncodedLabelHash(maybeEncodedLabelHash) {
+  const expectedFormatting = maybeEncodedLabelHash.startsWith("[") && maybeEncodedLabelHash.endsWith("]");
+  const includesLabelHash = isLabelHash(`0x${maybeEncodedLabelHash.slice(1, -1)}`);
+  return expectedFormatting && includesLabelHash;
 }
 
 // src/ens/names.ts
+import { ens_beautify } from "@adraffy/ens-normalize";
 var getNameHierarchy = (name) => name.split(".").map((_, i, labels) => labels.slice(i).join("."));
 var beautifyName = (name) => {
   const beautifiedLabels = name.split(".").map((label) => {
@@ -69,6 +144,37 @@ var beautifyName = (name) => {
   return beautifiedLabels.join(".");
 };
 
+// src/ens/parse-reverse-name.ts
+import { hexToBigInt, isAddress } from "viem";
+var REVERSE_NAME_REGEX = /^([0-9a-fA-F]+)\.([0-9a-f]{1,64}|addr|default)\.reverse$/;
+var parseAddressLabel = (addressLabel) => {
+  const maybeAddress = `0x${addressLabel}`;
+  if (!isAddress(maybeAddress)) {
+    throw new Error(`Invalid EVM address "${maybeAddress}"`);
+  }
+  return asLowerCaseAddress(maybeAddress);
+};
+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/ens/reverse-name.ts
 var addrReverseLabel = (address) => address.slice(2);
 var coinTypeReverseLabel = (coinType) => coinType.toString(16);
@@ -87,86 +193,104 @@ function reverseName(address, coinType) {
   return `${label}.${middle}.reverse`;
 }
 
+// src/ens/subname-helpers.ts
+import { concat, keccak256, toHex } from "viem";
+var makeSubdomainNode = (labelHash, node) => keccak256(concat([node, labelHash]));
+var uint256ToHex32 = (num) => toHex(num, { size: 32 });
+
 // src/ens/types.ts
 import { ENSNamespaceIds } from "@ensnode/datasources";
 
-// src/ens/parse-reverse-name.ts
-import { hexToBigInt, isAddress as isAddress2 } from "viem";
-
-// src/shared/address.ts
-function asLowerCaseAddress(address) {
-  return address.toLowerCase();
-}
-
-// src/shared/cache.ts
-var LruCache = class {
-  _cache = /* @__PURE__ */ new Map();
-  _capacity;
-  /**
-   * Create a new LRU cache with the given capacity.
-   *
-   * @param capacity The maximum number of items in the cache. If set to 0, the cache is effectively disabled.
-   * @throws Error if capacity is not a non-negative integer.
-   */
-  constructor(capacity) {
-    if (!Number.isInteger(capacity)) {
-      throw new Error(
-        `LruCache requires capacity to be an integer but a capacity of ${capacity} was requested.`
-      );
-    }
-    if (capacity < 0) {
-      throw new Error(
-        `LruCache requires a non-negative capacity but a capacity of ${capacity} was requested.`
-      );
-    }
-    this._capacity = capacity;
-  }
-  set(key, value) {
-    this._cache.set(key, value);
-    if (this._cache.size > this._capacity) {
-      const oldestKey = this._cache.keys().next().value;
-      this._cache.delete(oldestKey);
-    }
-  }
-  get(key) {
-    const value = this._cache.get(key);
-    if (value) {
-      this._cache.delete(key);
-      this._cache.set(key, value);
-    }
-    return value;
-  }
-  clear() {
-    this._cache.clear();
-  }
-  get size() {
-    return this._cache.size;
-  }
-  get capacity() {
-    return this._capacity;
+// src/shared/currencies.ts
+var CurrencyIds = {
+  ETH: "ETH",
+  USDC: "USDC",
+  DAI: "DAI"
+};
+var currencyInfo = {
+  [CurrencyIds.ETH]: {
+    id: CurrencyIds.ETH,
+    name: "ETH",
+    decimals: 18
+  },
+  [CurrencyIds.USDC]: {
+    id: CurrencyIds.USDC,
+    name: "USDC",
+    decimals: 6
+  },
+  [CurrencyIds.DAI]: {
+    id: CurrencyIds.DAI,
+    name: "Dai Stablecoin",
+    decimals: 18
   }
 };
-
-// src/shared/collections.ts
-var uniq = (arr) => [...new Set(arr)];
-
-// src/shared/serialize.ts
-function serializeChainId(chainId) {
-  return chainId.toString();
+function getCurrencyInfo(currencyId) {
+  return currencyInfo[currencyId];
 }
-function serializeDatetime(datetime) {
-  return datetime.toISOString();
+function priceEth(amount) {
+  return {
+    amount,
+    currency: CurrencyIds.ETH
+  };
 }
-function serializeUrl(url) {
-  return url.toString();
+function priceUsdc(amount) {
+  return {
+    amount,
+    currency: CurrencyIds.USDC
+  };
+}
+function priceDai(amount) {
+  return {
+    amount,
+    currency: CurrencyIds.DAI
+  };
+}
+function isPriceCurrencyEqual(priceA, priceB) {
+  return priceA.currency === priceB.currency;
+}
+function isPriceEqual(priceA, priceB) {
+  return isPriceCurrencyEqual(priceA, priceB) && priceA.amount === priceB.amount;
+}
+function addPrices(...prices) {
+  const firstPrice = prices[0];
+  const allPricesInSameCurrency = prices.every((price) => isPriceCurrencyEqual(firstPrice, price));
+  if (allPricesInSameCurrency === false) {
+    throw new Error("All prices must have the same currency to be added together.");
+  }
+  const { currency } = firstPrice;
+  return prices.reduce(
+    (acc, price) => ({
+      amount: acc.amount + price.amount,
+      currency
+    }),
+    {
+      amount: 0n,
+      currency: firstPrice.currency
+    }
+  );
 }
 
-// src/shared/deserialize.ts
-import { prettifyError } from "zod/v4";
+// src/shared/reinterpretation.ts
+import { labelhash as labelToLabelHash } from "viem";
+function reinterpretLabel(label) {
+  if (label === "") {
+    throw new Error(
+      `Cannot reinterpret an empty label that violates the invariants of an InterpretedLabel.`
+    );
+  }
+  if (isEncodedLabelHash(label)) return label;
+  if (isNormalizedLabel(label)) return label;
+  return encodeLabelHash(labelToLabelHash(label));
+}
+function reinterpretName(name) {
+  if (name === "") return name;
+  const interpretedLabels = name.split(".");
+  const reinterpretedLabels = interpretedLabels.map(reinterpretLabel);
+  const reinterpretedName = reinterpretedLabels.join(".");
+  return reinterpretedName;
+}
 
 // src/shared/zod-schemas.ts
-import { isAddress } from "viem";
-import z from "zod/v4";
 var makeIntegerSchema = (valueLabel = "Value") => z.int({
   error: `${valueLabel} must be an integer.`
 });
@@ -181,10 +305,20 @@ var makeDurationSchema = (valueLabel = "Value") => z.coerce.number({
 }).pipe(makeNonNegativeIntegerSchema(valueLabel));
 var makeChainIdSchema = (valueLabel = "Chain ID") => makePositiveIntegerSchema(valueLabel).transform((val) => val);
 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 makeLowercaseAddressSchema = (valueLabel = "EVM address") => z.string().check((ctx) => {
+  if (!isAddress2(ctx.value)) {
+    ctx.issues.push({
+      code: "custom",
+      message: `${valueLabel} must be a valid EVM address`,
+      input: ctx.value
+    });
+  }
+}).transform((val) => asLowerCaseAddress(val));
 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).`
+  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") => z.strictObject(
@@ -218,23 +352,79 @@ var makeENSNamespaceIdSchema = (valueLabel = "ENSNamespaceId") => z.enum(ENSName
     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:
+var makePriceAmountSchema = (valueLabel = "Amount") => z.coerce.bigint({
+  error: `${valueLabel} must represent a bigint.`
+}).nonnegative({
+  error: `${valueLabel} must not be negative.`
+});
+var makePriceCurrencySchema = (currency, valueLabel = "Price Currency") => z.strictObject({
+  amount: makePriceAmountSchema(`${valueLabel} amount`),
+  currency: 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") => z.strictObject({
+  chainId: makeChainIdStringSchema(`${valueLabel} chain ID`),
+  address: makeLowercaseAddressSchema(`${valueLabel} address`)
+});
+var makeSerializedAccountIdSchema = (valueLabel = "Account ID") => z.coerce.string().transform((v) => {
+  const result = new CaipAccountId(v);
+  return {
+    chainId: result.chainId.reference,
+    address: result.address
+  };
+}).pipe(makeAccountIdSchema(valueLabel));
+var makeHexStringSchema = (options, valueLabel = "String representation of bytes array") => z.string().check(function invariant_isHexEncoded(ctx) {
+  if (!isHex2(ctx.value)) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `${valueLabel} must start with '0x'.`
+    });
+  }
+}).transform((v) => v).check(function invariant_encodesRequiredBytesCount(ctx) {
+  const expectedBytesCount = options.bytesCount;
+  const actualBytesCount = size(ctx.value);
+  if (actualBytesCount !== expectedBytesCount) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `${valueLabel} must represent exactly ${expectedBytesCount} bytes. Currently represented bytes count: ${actualBytesCount}.`
+    });
+  }
+});
+var makeNodeSchema = (valueLabel = "Node") => makeHexStringSchema({ bytesCount: 32 }, valueLabel);
+var makeTransactionHashSchema = (valueLabel = "Transaction hash") => makeHexStringSchema({ bytesCount: 32 }, valueLabel);
+var makeReinterpretedNameSchema = (valueLabel = "Reinterpreted Name") => z.string().transform((v) => v).check((ctx) => {
+  try {
+    reinterpretName(ctx.value);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `${valueLabel} cannot be reinterpreted: ${errorMessage}`
+    });
+  }
+}).transform(reinterpretName);
+
+// 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)}
 `);
   }
@@ -300,12 +490,171 @@ ${prettifyError(parsed.error)}
   }
   return parsed.data;
 }
+function deserializeAccountId(maybeAccountId, valueLabel) {
+  const schema = makeSerializedAccountIdSchema(valueLabel);
+  const parsed = schema.safeParse(maybeAccountId);
+  if (parsed.error) {
+    throw new RangeError(`Cannot deserialize AccountId:
+${prettifyError(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
 
-// src/shared/account-id.ts
-import { isAddressEqual } from "viem";
-var accountIdEqual = (a, b) => {
-  return a.chainId === b.chainId && isAddressEqual(a.address, b.address);
+// src/shared/datetime.ts
+function durationBetween(start, end) {
+  return deserializeDuration(end - start, "Duration");
+}
+function addDuration(timestamp, duration) {
+  return deserializeUnixTimestamp(timestamp + duration, "UnixTimestamp");
+}
+
+// src/shared/cache.ts
+var LruCache = class {
+  _cache = /* @__PURE__ */ new Map();
+  _capacity;
+  /**
+   * Create a new LRU cache with the given capacity.
+   *
+   * @param capacity The maximum number of items in the cache. If set to 0, the cache is effectively disabled.
+   * @throws Error if capacity is not a non-negative integer.
+   */
+  constructor(capacity) {
+    if (!Number.isInteger(capacity)) {
+      throw new Error(
+        `LruCache requires capacity to be an integer but a capacity of ${capacity} was requested.`
+      );
+    }
+    if (capacity < 0) {
+      throw new Error(
+        `LruCache requires a non-negative capacity but a capacity of ${capacity} was requested.`
+      );
+    }
+    this._capacity = capacity;
+  }
+  set(key, value) {
+    this._cache.set(key, value);
+    if (this._cache.size > this._capacity) {
+      const oldestKey = this._cache.keys().next().value;
+      this._cache.delete(oldestKey);
+    }
+  }
+  get(key) {
+    const value = this._cache.get(key);
+    if (value) {
+      this._cache.delete(key);
+      this._cache.set(key, value);
+    }
+    return value;
+  }
+  clear() {
+    this._cache.clear();
+  }
+  get size() {
+    return this._cache.size;
+  }
+  get capacity() {
+    return this._capacity;
+  }
+};
+var TtlCache = class {
+  _cache = /* @__PURE__ */ new Map();
+  _ttl;
+  /**
+   * Create a new TTL cache with the given TTL.
+   *
+   * @param ttl Time-to-live duration in seconds. Items expire after this duration.
+   */
+  constructor(ttl) {
+    this._ttl = ttl;
+  }
+  _cleanup() {
+    const now = getUnixTime(/* @__PURE__ */ new Date());
+    for (const [key, entry] of this._cache.entries()) {
+      if (entry.expiresAt <= now) {
+        this._cache.delete(key);
+      }
+    }
+  }
+  set(key, value) {
+    this._cleanup();
+    const expiresAt = addDuration(getUnixTime(/* @__PURE__ */ new Date()), this._ttl);
+    this._cache.set(key, { value, expiresAt });
+  }
+  get(key) {
+    this._cleanup();
+    const entry = this._cache.get(key);
+    if (!entry) {
+      return void 0;
+    }
+    if (entry.expiresAt <= getUnixTime(/* @__PURE__ */ new Date())) {
+      this._cache.delete(key);
+      return void 0;
+    }
+    return entry.value;
+  }
+  clear() {
+    this._cache.clear();
+  }
+  get size() {
+    this._cleanup();
+    return this._cache.size;
+  }
+  get capacity() {
+    return Number.MAX_SAFE_INTEGER;
+  }
+  has(key) {
+    this._cleanup();
+    const entry = this._cache.get(key);
+    if (!entry) {
+      return false;
+    }
+    if (entry.expiresAt <= getUnixTime(/* @__PURE__ */ new Date())) {
+      this._cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  delete(key) {
+    return this._cache.delete(key);
+  }
 };
+function staleWhileRevalidate(options) {
+  const { fn, ttl } = options;
+  let cache = null;
+  let cacheInitializer = null;
+  return async () => {
+    if (!cache) {
+      if (cacheInitializer) {
+        return cacheInitializer;
+      }
+      cacheInitializer = fn().then((value) => {
+        cache = { value, updatedAt: getUnixTime(/* @__PURE__ */ new Date()) };
+        cacheInitializer = null;
+        return value;
+      }).catch(() => {
+        cacheInitializer = null;
+        return null;
+      });
+      return cacheInitializer;
+    }
+    const isStale = durationBetween(cache.updatedAt, getUnixTime(/* @__PURE__ */ new Date())) > ttl;
+    if (!isStale) return cache.value;
+    if (cache.inProgressRevalidation) return cache.value;
+    const revalidationPromise = fn().then((value) => {
+      cache = { value, updatedAt: getUnixTime(/* @__PURE__ */ new Date()) };
+    }).catch(() => {
+      if (cache) {
+        cache.inProgressRevalidation = void 0;
+      }
+    });
+    cache.inProgressRevalidation = revalidationPromise;
+    return cache.value;
+  };
+}
+
+// src/shared/collections.ts
+var uniq = (arr) => [...new Set(arr)];
 
 // src/shared/labelhash.ts
 import { keccak256 as keccak2562, stringToBytes } from "viem";
@@ -326,317 +675,60 @@ function literalLabelsToLiteralName(labels) {
   return labels.join(".");
 }
 
-// src/shared/url.ts
-function isHttpProtocol(url) {
-  return ["http:", "https:"].includes(url.protocol);
-}
-function isWebSocketProtocol(url) {
-  return ["ws:", "wss:"].includes(url.protocol);
-}
+// src/shared/null-bytes.ts
+var hasNullByte = (value) => value.indexOf("\0") !== -1;
+var stripNullBytes = (value) => value.replaceAll("\0", "");
 
-// src/ens/parse-reverse-name.ts
-var REVERSE_NAME_REGEX = /^([0-9a-fA-F]+)\.([0-9a-f]{1,64}|addr|default)\.reverse$/;
-var parseAddressLabel = (addressLabel) => {
-  const maybeAddress = `0x${addressLabel}`;
-  if (!isAddress2(maybeAddress)) {
-    throw new Error(`Invalid EVM address "${maybeAddress}"`);
+// src/shared/numbers.ts
+function bigIntToNumber(n) {
+  if (n < Number.MIN_SAFE_INTEGER) {
+    throw new Error(
+      `The bigint '${n.toString()}' value is too low to be to converted into a number.'`
+    );
   }
-  return asLowerCaseAddress(maybeAddress);
-};
-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;
+  if (n > Number.MAX_SAFE_INTEGER) {
+    throw new Error(
+      `The bigint '${n.toString()}' value is too high to be to converted into a number.'`
+    );
   }
+  return Number(n);
 }
 
-// src/ens/encode-labelhash.ts
-var encodeLabelHash = (labelHash) => `[${labelHash.slice(2)}]`;
-
-// src/ens/dns-encoded-name.ts
-import { bytesToString, hexToBytes } from "viem";
-function decodeDNSEncodedLiteralName(packet) {
-  return decodeDNSEncodedName(packet);
+// src/shared/serialize.ts
+import { AccountId as CaipAccountId2 } from "caip";
+function serializeChainId(chainId) {
+  return chainId.toString();
 }
-function decodeDNSEncodedName(packet) {
-  const segments = [];
-  const bytes = hexToBytes(packet);
-  if (bytes.length === 0) throw new Error(`Packet is empty.`);
-  let offset = 0;
-  while (offset < bytes.length) {
-    const len = bytes[offset];
-    if (len === void 0) {
-      throw new Error(`Invariant: bytes[offset] is undefined after offset < bytes.length check.`);
-    }
-    if (len < 0 || len > 255) {
-      throw new Error(
-        `Invariant: this should be literally impossible, but an unsigned byte was less than zero or greater than 255. The value in question is ${len}`
-      );
-    }
-    if (len === 0) break;
-    const segment = bytesToString(bytes.subarray(offset + 1, offset + len + 1));
-    segments.push(segment);
-    offset += len + 1;
-  }
-  if (offset >= bytes.length) throw new Error(`Overflow, offset >= bytes.length`);
-  if (offset !== bytes.length - 1) throw new Error(`Junk at end of name`);
-  return segments;
+function serializeDatetime(datetime) {
+  return datetime.toISOString();
 }
-
-// src/ens/index.ts
-import { getENSRootChainId } from "@ensnode/datasources";
-
-// src/ensindexer/config/deserialize.ts
-import { prettifyError as prettifyError2 } from "zod/v4";
-
-// src/ensindexer/config/zod-schemas.ts
-import z2 from "zod/v4";
-
-// src/ensindexer/config/helpers.ts
-import { ENSNamespaceIds as ENSNamespaceIds2 } from "@ensnode/datasources";
-
-// src/ensindexer/config/types.ts
-var PluginName = /* @__PURE__ */ ((PluginName2) => {
-  PluginName2["Subgraph"] = "subgraph";
-  PluginName2["Basenames"] = "basenames";
-  PluginName2["Lineanames"] = "lineanames";
-  PluginName2["ThreeDNS"] = "threedns";
-  PluginName2["ProtocolAcceleration"] = "protocol-acceleration";
-  PluginName2["Referrals"] = "referrals";
-  PluginName2["TokenScope"] = "tokenscope";
-  return PluginName2;
-})(PluginName || {});
-
-// src/ensindexer/config/helpers.ts
-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 === ENSNamespaceIds2.EnsTestEnv && isEnsTestEnvLabelSet;
-  return onlySubgraphPluginActivated && labelSetIsSubgraphCompatible;
+function serializeUrl(url) {
+  return url.toString();
 }
-
-// src/ensindexer/config/validations.ts
-function invariant_ensDbVersionIsSameAsEnsIndexerVersion(ctx) {
-  const versionInfo = ctx.value;
-  if (versionInfo.ensDb !== versionInfo.ensIndexer) {
-    ctx.issues.push({
-      code: "custom",
-      input: versionInfo,
-      message: "`ensDb` version must be same as `ensIndexer` version"
-    });
-  }
+function serializePrice(price) {
+  return {
+    currency: price.currency,
+    amount: price.amount.toString()
+  };
+}
+function serializePriceEth(price) {
+  return serializePrice(price);
+}
+function serializeAccountId(accountId) {
+  return CaipAccountId2.format({
+    chainId: { namespace: "eip155", reference: accountId.chainId.toString() },
+    address: accountId.address
+  }).toLowerCase();
 }
 
-// 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.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") => 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 makeENSIndexerVersionInfoSchema = (valueLabel = "Value") => z2.strictObject(
-  {
-    nodejs: makeNonEmptyStringSchema(),
-    ponder: makeNonEmptyStringSchema(),
-    ensDb: makeNonEmptyStringSchema(),
-    ensIndexer: makeNonEmptyStringSchema(),
-    ensNormalize: makeNonEmptyStringSchema(),
-    ensRainbow: makeNonEmptyStringSchema(),
-    ensRainbowSchema: makePositiveIntegerSchema()
-  },
-  {
-    error: `${valueLabel} must be a valid ENSIndexerVersionInfo object.`
-  }
-).check(invariant_ensDbVersionIsSameAsEnsIndexerVersion);
-function invariant_isSubgraphCompatibleRequirements(ctx) {
-  const { value: config } = ctx;
-  if (config.isSubgraphCompatible && !isSubgraphCompatible(config)) {
-    ctx.issues.push({
-      code: "custom",
-      input: config,
-      message: `'isSubgraphCompatible' requires only the '${"subgraph" /* Subgraph */}' plugin to be active and labelSet must be {labelSetId: "subgraph", labelSetVersion: 0}`
-    });
-  }
-}
-var makeENSIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") => z2.object({
-  labelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.labelSet`),
-  indexedChainIds: makeIndexedChainIdsSchema(`${valueLabel}.indexedChainIds`),
-  isSubgraphCompatible: z2.boolean({ error: `${valueLabel}.isSubgraphCompatible` }),
-  namespace: makeENSNamespaceIdSchema(`${valueLabel}.namespace`),
-  plugins: makePluginsListSchema(`${valueLabel}.plugins`),
-  databaseSchemaName: makeDatabaseSchemaNameSchema(`${valueLabel}.databaseSchemaName`),
-  versionInfo: makeENSIndexerVersionInfoSchema(`${valueLabel}.versionInfo`)
-}).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 {
-    labelSet,
-    indexedChainIds,
-    databaseSchemaName,
-    isSubgraphCompatible: isSubgraphCompatible2,
-    namespace,
-    plugins,
-    versionInfo
-  } = config;
-  return {
-    labelSet,
-    indexedChainIds: serializeIndexedChainIds(indexedChainIds),
-    databaseSchemaName,
-    isSubgraphCompatible: isSubgraphCompatible2,
-    namespace,
-    plugins,
-    versionInfo
-  };
-}
-
-// 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 as hexToBytes2 } 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 = hexToBytes2(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/shared/url.ts
+function isHttpProtocol(url) {
+  return ["http:", "https:"].includes(url.protocol);
 }
-
-// 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;
+function isWebSocketProtocol(url) {
+  return ["ws:", "wss:"].includes(url.protocol);
 }
 
-// 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/ensindexer/indexing-status/types.ts
 var ChainIndexingConfigTypeIds = {
   /**
@@ -761,7 +853,7 @@ function getTimestampForHighestOmnichainKnownBlock(chains) {
   for (const chain of chains) {
     switch (chain.chainStatus) {
       case ChainIndexingStatusIds.Queued:
-        if (chain.config.endBlock) {
+        if (chain.config.configType === ChainIndexingConfigTypeIds.Definite && chain.config.endBlock) {
           latestKnownBlockTimestamps.push(chain.config.endBlock.timestamp);
         }
         break;
@@ -839,6 +931,9 @@ function sortChainStatusesByStartBlockAsc(chains) {
 // src/ensindexer/indexing-status/validations.ts
 function invariant_chainSnapshotQueuedBlocks(ctx) {
   const { config } = ctx.value;
+  if (config.configType === ChainIndexingConfigTypeIds.Indefinite) {
+    return;
+  }
   if (config.endBlock && isBeforeOrEqualTo(config.startBlock, config.endBlock) === false) {
     ctx.issues.push({
       code: "custom",
@@ -863,6 +958,9 @@ function invariant_chainSnapshotBackfillBlocks(ctx) {
       message: "`latestIndexedBlock` must be before or same as `backfillEndBlock`."
     });
   }
+  if (config.configType === ChainIndexingConfigTypeIds.Indefinite) {
+    return;
+  }
   if (config.endBlock && isEqualTo(backfillEndBlock, config.endBlock) === false) {
     ctx.issues.push({
       code: "custom",
@@ -1000,188 +1098,809 @@ function invariant_omnichainStatusSnapshotBackfillHasValidChains(ctx) {
     });
   }
 }
-function invariant_omnichainStatusSnapshotCompletedHasValidChains(ctx) {
-  const chains = ctx.value;
-  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(
-    Array.from(chains.values())
-  );
-  if (hasValidChains === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: chains,
-      message: `For omnichain status snapshot 'completed', all chains must have "completed" status.`
-    });
-  }
+function invariant_omnichainStatusSnapshotCompletedHasValidChains(ctx) {
+  const chains = ctx.value;
+  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(
+    Array.from(chains.values())
+  );
+  if (hasValidChains === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: chains,
+      message: `For omnichain status snapshot 'completed', all chains must have "completed" status.`
+    });
+  }
+}
+function invariant_slowestChainEqualsToOmnichainSnapshotTime(ctx) {
+  const { slowestChainIndexingCursor, omnichainSnapshot } = ctx.value;
+  const { omnichainIndexingCursor } = omnichainSnapshot;
+  if (slowestChainIndexingCursor !== omnichainIndexingCursor) {
+    console.log("invariant_slowestChainEqualsToOmnichainSnapshotTime", {
+      slowestChainIndexingCursor,
+      omnichainIndexingCursor
+    });
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `'slowestChainIndexingCursor' must be equal to 'omnichainSnapshot.omnichainIndexingCursor'`
+    });
+  }
+}
+function invariant_snapshotTimeIsTheHighestKnownBlockTimestamp(ctx) {
+  const { snapshotTime, omnichainSnapshot } = ctx.value;
+  const chains = Array.from(omnichainSnapshot.chains.values());
+  const startBlockTimestamps = chains.map((chain) => chain.config.startBlock.timestamp);
+  const endBlockTimestamps = chains.map((chain) => chain.config).filter((chainConfig) => chainConfig.configType === ChainIndexingConfigTypeIds.Definite).map((chainConfig) => chainConfig.endBlock.timestamp);
+  const backfillEndBlockTimestamps = chains.filter((chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill).map((chain) => chain.backfillEndBlock.timestamp);
+  const latestKnownBlockTimestamps = chains.filter((chain) => chain.chainStatus === ChainIndexingStatusIds.Following).map((chain) => chain.latestKnownBlock.timestamp);
+  const highestKnownBlockTimestamp = Math.max(
+    ...startBlockTimestamps,
+    ...endBlockTimestamps,
+    ...backfillEndBlockTimestamps,
+    ...latestKnownBlockTimestamps
+  );
+  if (snapshotTime < highestKnownBlockTimestamp) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `'snapshotTime' must be greater than or equal to  the "highest known block timestamp" (${highestKnownBlockTimestamp})`
+    });
+  }
+}
+function invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime(ctx) {
+  const projection = ctx.value;
+  const { snapshot, projectedAt } = projection;
+  if (snapshot.snapshotTime > projectedAt) {
+    ctx.issues.push({
+      code: "custom",
+      input: projection,
+      message: "`projectedAt` must be after or same as `snapshot.snapshotTime`."
+    });
+  }
+}
+function invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect(ctx) {
+  const projection = ctx.value;
+  const { projectedAt, snapshot, worstCaseDistance } = projection;
+  const { omnichainSnapshot } = snapshot;
+  const expectedWorstCaseDistance = projectedAt - omnichainSnapshot.omnichainIndexingCursor;
+  if (worstCaseDistance !== expectedWorstCaseDistance) {
+    ctx.issues.push({
+      code: "custom",
+      input: projection,
+      message: "`worstCaseDistance` must be the exact difference between `projectedAt` and `snapshot.omnichainIndexingCursor`."
+    });
+  }
+}
+
+// src/ensindexer/indexing-status/zod-schemas.ts
+var makeChainIndexingConfigSchema = (valueLabel = "Value") => z2.discriminatedUnion("configType", [
+  z2.strictObject({
+    configType: z2.literal(ChainIndexingConfigTypeIds.Indefinite),
+    startBlock: makeBlockRefSchema(valueLabel)
+  }),
+  z2.strictObject({
+    configType: z2.literal(ChainIndexingConfigTypeIds.Definite),
+    startBlock: makeBlockRefSchema(valueLabel),
+    endBlock: makeBlockRefSchema(valueLabel)
+  })
+]);
+var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => z2.strictObject({
+  chainStatus: z2.literal(ChainIndexingStatusIds.Queued),
+  config: makeChainIndexingConfigSchema(valueLabel)
+}).check(invariant_chainSnapshotQueuedBlocks);
+var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => z2.strictObject({
+  chainStatus: z2.literal(ChainIndexingStatusIds.Backfill),
+  config: makeChainIndexingConfigSchema(valueLabel),
+  latestIndexedBlock: makeBlockRefSchema(valueLabel),
+  backfillEndBlock: makeBlockRefSchema(valueLabel)
+}).check(invariant_chainSnapshotBackfillBlocks);
+var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => z2.strictObject({
+  chainStatus: z2.literal(ChainIndexingStatusIds.Completed),
+  config: z2.strictObject({
+    configType: z2.literal(ChainIndexingConfigTypeIds.Definite),
+    startBlock: makeBlockRefSchema(valueLabel),
+    endBlock: makeBlockRefSchema(valueLabel)
+  }),
+  latestIndexedBlock: makeBlockRefSchema(valueLabel)
+}).check(invariant_chainSnapshotCompletedBlocks);
+var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => z2.strictObject({
+  chainStatus: z2.literal(ChainIndexingStatusIds.Following),
+  config: z2.strictObject({
+    configType: z2.literal(ChainIndexingConfigTypeIds.Indefinite),
+    startBlock: makeBlockRefSchema(valueLabel)
+  }),
+  latestIndexedBlock: makeBlockRefSchema(valueLabel),
+  latestKnownBlock: makeBlockRefSchema(valueLabel)
+}).check(invariant_chainSnapshotFollowingBlocks);
+var makeChainIndexingStatusSnapshotSchema = (valueLabel = "Value") => z2.discriminatedUnion("chainStatus", [
+  makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
+  makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
+  makeChainIndexingStatusSnapshotCompletedSchema(valueLabel),
+  makeChainIndexingStatusSnapshotFollowingSchema(valueLabel)
+]);
+var makeChainIndexingStatusesSchema = (valueLabel = "Value") => z2.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();
+  for (const [chainIdString, chainStatus] of Object.entries(serializedChainsIndexingStatus)) {
+    chainsIndexingStatus.set(deserializeChainId(chainIdString), chainStatus);
+  }
+  return chainsIndexingStatus;
+});
+var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => z2.strictObject({
+  omnichainStatus: z2.literal(OmnichainIndexingStatusIds.Unstarted),
+  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainSnapshotUnstartedHasValidChains).transform((chains) => chains),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+});
+var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => z2.strictObject({
+  omnichainStatus: z2.literal(OmnichainIndexingStatusIds.Backfill),
+  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotBackfillHasValidChains).transform(
+    (chains) => chains
+  ),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+});
+var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => z2.strictObject({
+  omnichainStatus: z2.literal(OmnichainIndexingStatusIds.Completed),
+  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotCompletedHasValidChains).transform((chains) => chains),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+});
+var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => z2.strictObject({
+  omnichainStatus: z2.literal(OmnichainIndexingStatusIds.Following),
+  chains: makeChainIndexingStatusesSchema(valueLabel),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+});
+var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => z2.discriminatedUnion("omnichainStatus", [
+  makeOmnichainIndexingStatusSnapshotUnstartedSchema(valueLabel),
+  makeOmnichainIndexingStatusSnapshotBackfillSchema(valueLabel),
+  makeOmnichainIndexingStatusSnapshotCompletedSchema(valueLabel),
+  makeOmnichainIndexingStatusSnapshotFollowingSchema(valueLabel)
+]).check(invariant_omnichainSnapshotStatusIsConsistentWithChainSnapshot).check(invariant_omnichainIndexingCursorLowerThanEarliestStartBlockAcrossQueuedChains).check(
+  invariant_omnichainIndexingCursorLowerThanOrEqualToLatestBackfillEndBlockAcrossBackfillChains
+).check(invariant_omnichainIndexingCursorIsEqualToHighestLatestIndexedBlockAcrossIndexedChain);
+var makeCrossChainIndexingStatusSnapshotOmnichainSchema = (valueLabel = "Cross-chain Indexing Status Snapshot Omnichain") => z2.strictObject({
+  strategy: z2.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") => z2.discriminatedUnion("strategy", [
+  makeCrossChainIndexingStatusSnapshotOmnichainSchema(valueLabel)
+]);
+var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => z2.strictObject({
+  projectedAt: makeUnixTimestampSchema(valueLabel),
+  worstCaseDistance: makeDurationSchema(valueLabel),
+  snapshot: makeCrossChainIndexingStatusSnapshotSchema(valueLabel)
+}).check(invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime).check(invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect);
+
+// src/ensindexer/config/zod-schemas.ts
+import z3 from "zod/v4";
+
+// src/ensindexer/config/is-subgraph-compatible.ts
+import { ENSNamespaceIds as ENSNamespaceIds2 } from "@ensnode/datasources";
+
+// src/ensindexer/config/types.ts
+var PluginName = /* @__PURE__ */ ((PluginName2) => {
+  PluginName2["Subgraph"] = "subgraph";
+  PluginName2["Basenames"] = "basenames";
+  PluginName2["Lineanames"] = "lineanames";
+  PluginName2["ThreeDNS"] = "threedns";
+  PluginName2["ProtocolAcceleration"] = "protocol-acceleration";
+  PluginName2["Registrars"] = "registrars";
+  PluginName2["TokenScope"] = "tokenscope";
+  return PluginName2;
+})(PluginName || {});
+
+// src/ensindexer/config/is-subgraph-compatible.ts
+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 === ENSNamespaceIds2.EnsTestEnv && isEnsTestEnvLabelSet;
+  return onlySubgraphPluginActivated && labelSetIsSubgraphCompatible;
+}
+
+// src/ensindexer/config/validations.ts
+function invariant_ensDbVersionIsSameAsEnsIndexerVersion(ctx) {
+  const versionInfo = ctx.value;
+  if (versionInfo.ensDb !== versionInfo.ensIndexer) {
+    ctx.issues.push({
+      code: "custom",
+      input: versionInfo,
+      message: "`ensDb` version must be same as `ensIndexer` version"
+    });
+  }
+}
+
+// src/ensindexer/config/zod-schemas.ts
+var makeIndexedChainIdsSchema = (valueLabel = "Indexed Chain IDs") => z3.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") => z3.array(z3.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") => z3.string({ error: `${valueLabel} must be a string` }).trim().nonempty({
+  error: `${valueLabel} is required and must be a non-empty string.`
+});
+var makeLabelSetIdSchema = (valueLabel) => {
+  return z3.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 z3.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 z3.object({
+    labelSetId: makeLabelSetIdSchema(valueLabelLabelSetId),
+    labelSetVersion: makeLabelSetVersionSchema(valueLabelLabelSetVersion)
+  });
+};
+var makeNonEmptyStringSchema = (valueLabel = "Value") => z3.string().nonempty({ error: `${valueLabel} must be a non-empty string.` });
+var makeENSIndexerVersionInfoSchema = (valueLabel = "Value") => z3.strictObject(
+  {
+    nodejs: makeNonEmptyStringSchema(),
+    ponder: makeNonEmptyStringSchema(),
+    ensDb: makeNonEmptyStringSchema(),
+    ensIndexer: makeNonEmptyStringSchema(),
+    ensNormalize: makeNonEmptyStringSchema(),
+    ensRainbow: makeNonEmptyStringSchema(),
+    ensRainbowSchema: makePositiveIntegerSchema()
+  },
+  {
+    error: `${valueLabel} must be a valid ENSIndexerVersionInfo object.`
+  }
+).check(invariant_ensDbVersionIsSameAsEnsIndexerVersion);
+function invariant_isSubgraphCompatibleRequirements(ctx) {
+  const { value: config } = ctx;
+  if (config.isSubgraphCompatible && !isSubgraphCompatible(config)) {
+    ctx.issues.push({
+      code: "custom",
+      input: config,
+      message: `'isSubgraphCompatible' requires only the '${"subgraph" /* Subgraph */}' plugin to be active and labelSet must be {labelSetId: "subgraph", labelSetVersion: 0}`
+    });
+  }
+}
+var makeENSIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") => z3.object({
+  labelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.labelSet`),
+  indexedChainIds: makeIndexedChainIdsSchema(`${valueLabel}.indexedChainIds`),
+  isSubgraphCompatible: z3.boolean({ error: `${valueLabel}.isSubgraphCompatible` }),
+  namespace: makeENSNamespaceIdSchema(`${valueLabel}.namespace`),
+  plugins: makePluginsListSchema(`${valueLabel}.plugins`),
+  databaseSchemaName: makeDatabaseSchemaNameSchema(`${valueLabel}.databaseSchemaName`),
+  versionInfo: makeENSIndexerVersionInfoSchema(`${valueLabel}.versionInfo`)
+}).check(invariant_isSubgraphCompatibleRequirements);
+
+// src/shared/config/build-rpc-urls.ts
+import {
+  arbitrum,
+  arbitrumSepolia,
+  base,
+  baseSepolia,
+  holesky,
+  linea,
+  lineaSepolia,
+  mainnet,
+  optimism,
+  optimismSepolia,
+  scroll,
+  scrollSepolia,
+  sepolia
+} from "viem/chains";
+
+// src/shared/config/rpc-configs-from-env.ts
+import { getENSNamespace } from "@ensnode/datasources";
+
+// src/shared/config/validatons.ts
+import { getENSRootChainId as getENSRootChainId2 } from "@ensnode/datasources";
+function invariant_rpcEndpointConfigIncludesAtLeastOneHTTPProtocolURL(ctx) {
+  const endpoints = ctx.value;
+  const httpEndpoints = endpoints.filter(isHttpProtocol);
+  if (httpEndpoints.length < 1) {
+    ctx.issues.push({
+      code: "custom",
+      input: endpoints,
+      message: `RPC endpoint configuration for a chain must include at least one http/https protocol URL.`
+    });
+  }
+}
+function invariant_rpcEndpointConfigIncludesAtMostOneWebSocketsProtocolURL(ctx) {
+  const endpoints = ctx.value;
+  const wsEndpoints = endpoints.filter(isWebSocketProtocol);
+  if (wsEndpoints.length > 1) {
+    ctx.issues.push({
+      code: "custom",
+      input: endpoints,
+      message: `RPC endpoint configuration for a chain must include at most one websocket (ws/wss) protocol URL.`
+    });
+  }
+}
+
+// src/shared/config/zod-schemas.ts
+import { z as z4 } from "zod/v4";
+import { ENSNamespaceIds as ENSNamespaceIds3 } from "@ensnode/datasources";
+var DatabaseSchemaNameSchema = z4.string({
+  error: "DATABASE_SCHEMA is required."
+}).trim().min(1, {
+  error: "DATABASE_SCHEMA is required and cannot be an empty string."
+});
+var RpcConfigSchema = z4.string().transform((val) => val.split(",")).pipe(z4.array(makeUrlSchema("RPC URL"))).check(invariant_rpcEndpointConfigIncludesAtLeastOneHTTPProtocolURL).check(invariant_rpcEndpointConfigIncludesAtMostOneWebSocketsProtocolURL);
+var RpcConfigsSchema = z4.record(makeChainIdStringSchema("RPC URL"), RpcConfigSchema, {
+  error: "Chains configuration must be an object mapping valid chain IDs to their configs."
+}).transform((records) => {
+  const rpcConfigs = /* @__PURE__ */ new Map();
+  for (const [chainIdString, rpcConfig] of Object.entries(records)) {
+    const httpRPCs = rpcConfig.filter(isHttpProtocol);
+    const websocketRPC = rpcConfig.find(isWebSocketProtocol);
+    rpcConfigs.set(deserializeChainId(chainIdString), {
+      httpRPCs,
+      websocketRPC
+    });
+  }
+  return rpcConfigs;
+});
+var EnsIndexerUrlSchema = makeUrlSchema("ENSINDEXER_URL");
+var ENSNamespaceSchema = z4.enum(ENSNamespaceIds3, {
+  error: ({ input }) => `Invalid NAMESPACE. Got '${input}', but supported ENS namespaces are: ${Object.keys(ENSNamespaceIds3).join(", ")}`
+});
+var PortSchema = z4.coerce.number({ error: "PORT must be a number." }).min(1, { error: "PORT must be greater than 1." }).max(65535, { error: "PORT must be less than 65535" }).optional();
+var TheGraphApiKeySchema = z4.string().optional();
+
+// src/shared/datasources-with-resolvers.ts
+import {
+  DatasourceNames,
+  maybeGetDatasource
+} from "@ensnode/datasources";
+var DATASOURCE_NAMES_WITH_RESOLVERS = [
+  DatasourceNames.ENSRoot,
+  DatasourceNames.Basenames,
+  DatasourceNames.Lineanames,
+  DatasourceNames.ThreeDNSOptimism,
+  DatasourceNames.ThreeDNSBase
+];
+
+// src/shared/log-level.ts
+import { z as z5 } from "zod/v4";
+var LogLevelSchema = z5.enum(["fatal", "error", "warn", "info", "debug", "trace", "silent"]);
+
+// src/shared/protocol-acceleration/interpret-record-values.ts
+import { isAddress as isAddress3, isAddressEqual as isAddressEqual2, zeroAddress } from "viem";
+
+// src/registrars/zod-schemas.ts
+import { decodeEncodedReferrer as decodeEncodedReferrer2, ENCODED_REFERRER_BYTE_LENGTH } from "@namehash/ens-referrals";
+import z6 from "zod/v4";
+
+// src/registrars/registrar-action.ts
+import { decodeEncodedReferrer, zeroEncodedReferrer } from "@namehash/ens-referrals";
+
+// src/registrars/subregistry.ts
+function serializeSubregistry(subregistry) {
+  return {
+    subregistryId: serializeAccountId(subregistry.subregistryId),
+    node: subregistry.node
+  };
+}
+
+// src/registrars/registration-lifecycle.ts
+function serializeRegistrationLifecycle(registrationLifecycle) {
+  return {
+    subregistry: serializeSubregistry(registrationLifecycle.subregistry),
+    node: registrationLifecycle.node,
+    expiresAt: registrationLifecycle.expiresAt
+  };
+}
+
+// src/registrars/registrar-action.ts
+var RegistrarActionTypes = {
+  Registration: "registration",
+  Renewal: "renewal"
+};
+function isRegistrarActionPricingAvailable(registrarActionPricing) {
+  const { baseCost, premium, total } = registrarActionPricing;
+  return baseCost !== null && premium !== null && total !== null;
+}
+function isRegistrarActionReferralAvailable(registrarActionReferral) {
+  const { encodedReferrer, decodedReferrer } = registrarActionReferral;
+  return encodedReferrer !== null && decodedReferrer !== null;
+}
+function serializeRegistrarActionPricing(pricing) {
+  if (isRegistrarActionPricingAvailable(pricing)) {
+    return {
+      baseCost: serializePriceEth(pricing.baseCost),
+      premium: serializePriceEth(pricing.premium),
+      total: serializePriceEth(pricing.total)
+    };
+  }
+  return pricing;
+}
+function serializeRegistrarAction(registrarAction) {
+  return {
+    id: registrarAction.id,
+    type: registrarAction.type,
+    incrementalDuration: registrarAction.incrementalDuration,
+    registrant: registrarAction.registrant,
+    registrationLifecycle: serializeRegistrationLifecycle(registrarAction.registrationLifecycle),
+    pricing: serializeRegistrarActionPricing(registrarAction.pricing),
+    referral: registrarAction.referral,
+    block: registrarAction.block,
+    transactionHash: registrarAction.transactionHash,
+    eventIds: registrarAction.eventIds
+  };
+}
+
+// src/registrars/zod-schemas.ts
+var makeSubregistrySchema = (valueLabel = "Subregistry") => z6.object({
+  subregistryId: makeSerializedAccountIdSchema(`${valueLabel} Subregistry ID`),
+  node: makeNodeSchema(`${valueLabel} Node`)
+});
+var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => z6.object({
+  subregistry: makeSubregistrySchema(`${valueLabel} Subregistry`),
+  node: makeNodeSchema(`${valueLabel} Node`),
+  expiresAt: makeUnixTimestampSchema(`${valueLabel} Expires at`)
+});
+function invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium(ctx) {
+  const { baseCost, premium, total } = ctx.value;
+  const actualTotal = addPrices(baseCost, premium);
+  if (!isPriceEqual(actualTotal, total)) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `'total' must be equal to the sum of 'baseCost' and 'premium'`
+    });
+  }
+}
+var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => z6.union([
+  // pricing available
+  z6.object({
+    baseCost: makePriceEthSchema(`${valueLabel} Base Cost`),
+    premium: makePriceEthSchema(`${valueLabel} Premium`),
+    total: makePriceEthSchema(`${valueLabel} Total`)
+  }).check(invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium).transform((v) => v),
+  // pricing unknown
+  z6.object({
+    baseCost: z6.null(),
+    premium: z6.null(),
+    total: z6.null()
+  }).transform((v) => v)
+]);
+function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
+  const { encodedReferrer, decodedReferrer } = ctx.value;
+  try {
+    const expectedDecodedReferrer = decodeEncodedReferrer2(encodedReferrer).toLowerCase();
+    if (decodedReferrer !== expectedDecodedReferrer) {
+      ctx.issues.push({
+        code: "custom",
+        input: ctx.value,
+        message: `'decodedReferrer' must be based on 'encodedReferrer'`
+      });
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: errorMessage
+    });
+  }
+}
+var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => z6.union([
+  // referral available
+  z6.object({
+    encodedReferrer: makeHexStringSchema(
+      { bytesCount: ENCODED_REFERRER_BYTE_LENGTH },
+      `${valueLabel} Encoded Referrer`
+    ),
+    decodedReferrer: makeLowercaseAddressSchema(`${valueLabel} Decoded Referrer`)
+  }).check(invariant_registrarActionDecodedReferrerBasedOnRawReferrer),
+  // referral not applicable
+  z6.object({
+    encodedReferrer: z6.null(),
+    decodedReferrer: z6.null()
+  })
+]);
+function invariant_eventIdsInitialElementIsTheActionId(ctx) {
+  const { id, eventIds } = ctx.value;
+  if (eventIds[0] !== id) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "The initial element of `eventIds` must be the `id` value"
+    });
+  }
+}
+var EventIdSchema = z6.string().nonempty();
+var EventIdsSchema = z6.array(EventIdSchema).min(1).transform((v) => v);
+var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => z6.object({
+  id: EventIdSchema,
+  incrementalDuration: makeDurationSchema(`${valueLabel} Incremental Duration`),
+  registrant: makeLowercaseAddressSchema(`${valueLabel} Registrant`),
+  registrationLifecycle: makeRegistrationLifecycleSchema(
+    `${valueLabel} Registration Lifecycle`
+  ),
+  pricing: makeRegistrarActionPricingSchema(`${valueLabel} Pricing`),
+  referral: makeRegistrarActionReferralSchema(`${valueLabel} Referral`),
+  block: makeBlockRefSchema(`${valueLabel} Block`),
+  transactionHash: makeTransactionHashSchema(`${valueLabel} Transaction Hash`),
+  eventIds: EventIdsSchema
+}).check(invariant_eventIdsInitialElementIsTheActionId);
+var makeRegistrarActionRegistrationSchema = (valueLabel = "Registration ") => makeBaseRegistrarActionSchema(valueLabel).extend({
+  type: z6.literal(RegistrarActionTypes.Registration)
+});
+var makeRegistrarActionRenewalSchema = (valueLabel = "Renewal") => makeBaseRegistrarActionSchema(valueLabel).extend({
+  type: z6.literal(RegistrarActionTypes.Renewal)
+});
+var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => z6.discriminatedUnion("type", [
+  makeRegistrarActionRegistrationSchema(`${valueLabel} Registration`),
+  makeRegistrarActionRenewalSchema(`${valueLabel} Renewal`)
+]);
+
+// src/api/types.ts
+var IndexingStatusResponseCodes = {
+  /**
+   * Represents that the indexing status is available.
+   */
+  Ok: "ok",
+  /**
+   * Represents that the indexing status is unavailable.
+   */
+  Error: "error"
+};
+var RegistrarActionsFilterTypes = {
+  BySubregistryNode: "bySubregistryNode",
+  WithEncodedReferral: "withEncodedReferral"
+};
+var RegistrarActionsOrders = {
+  LatestRegistrarActions: "orderBy[timestamp]=desc"
+};
+var RegistrarActionsResponseCodes = {
+  /**
+   * Represents that Registrar Actions are available.
+   */
+  Ok: "ok",
+  /**
+   * Represents that Registrar Actions are unavailable.
+   */
+  Error: "error"
+};
+
+// src/api/zod-schemas.ts
+var ErrorResponseSchema = z7.object({
+  message: z7.string(),
+  details: z7.optional(z7.unknown())
+});
+var makeIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => z7.strictObject({
+  responseCode: z7.literal(IndexingStatusResponseCodes.Ok),
+  realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel)
+});
+var makeIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => z7.strictObject({
+  responseCode: z7.literal(IndexingStatusResponseCodes.Error)
+});
+var makeIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => z7.discriminatedUnion("responseCode", [
+  makeIndexingStatusResponseOkSchema(valueLabel),
+  makeIndexingStatusResponseErrorSchema(valueLabel)
+]);
+function invariant_registrationLifecycleNodeMatchesName(ctx) {
+  const { name, action } = ctx.value;
+  const expectedNode = action.registrationLifecycle.node;
+  const actualNode = namehash2(name);
+  if (actualNode !== expectedNode) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `The 'action.registrationLifecycle.node' must match namehash of 'name'`
+    });
+  }
+}
+var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => z7.object({
+  action: makeRegistrarActionSchema(valueLabel),
+  name: makeReinterpretedNameSchema(valueLabel)
+}).check(invariant_registrationLifecycleNodeMatchesName);
+var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => z7.strictObject({
+  responseCode: z7.literal(RegistrarActionsResponseCodes.Ok),
+  registrarActions: z7.array(makeNamedRegistrarActionSchema(valueLabel))
+});
+var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => z7.strictObject({
+  responseCode: z7.literal(RegistrarActionsResponseCodes.Error),
+  error: ErrorResponseSchema
+});
+var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => z7.discriminatedUnion("responseCode", [
+  makeRegistrarActionsResponseOkSchema(valueLabel),
+  makeRegistrarActionsResponseErrorSchema(valueLabel)
+]);
+
+// src/api/deserialize.ts
+function deserializeErrorResponse(maybeErrorResponse) {
+  const parsed = ErrorResponseSchema.safeParse(maybeErrorResponse);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize ErrorResponse:
+${prettifyError2(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+function deserializeIndexingStatusResponse(maybeResponse) {
+  const parsed = makeIndexingStatusResponseSchema().safeParse(maybeResponse);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize IndexingStatusResponse:
+${prettifyError2(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+function deserializeRegistrarActionsResponse(maybeResponse) {
+  const parsed = makeRegistrarActionsResponseSchema().safeParse(maybeResponse);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize RegistrarActionsResponse:
+${prettifyError2(parsed.error)}
+`
+    );
+  }
+  return parsed.data;
+}
+
+// src/api/registrar-actions/filters.ts
+function byParentNode(parentNode) {
+  if (typeof parentNode === "undefined") {
+    return void 0;
+  }
+  return {
+    filterType: RegistrarActionsFilterTypes.BySubregistryNode,
+    value: parentNode
+  };
+}
+function withReferral(withReferral2) {
+  if (!withReferral2) {
+    return void 0;
+  }
+  return {
+    filterType: RegistrarActionsFilterTypes.WithEncodedReferral
+  };
+}
+var registrarActionsFilter = {
+  byParentNode,
+  withReferral
+};
+
+// src/ensindexer/config/deserialize.ts
+import { prettifyError as prettifyError3 } from "zod/v4";
+function deserializeENSIndexerPublicConfig(maybeConfig, valueLabel) {
+  const schema = makeENSIndexerPublicConfigSchema(valueLabel);
+  const parsed = schema.safeParse(maybeConfig);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize ENSIndexerPublicConfig:
+${prettifyError3(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+
+// src/ensindexer/config/label-utils.ts
+import { hexToBytes as hexToBytes2 } 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 = hexToBytes2(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/labelset-utils.ts
+function buildLabelSetId(maybeLabelSetId) {
+  return makeLabelSetIdSchema("LabelSetId").parse(maybeLabelSetId);
 }
-function invariant_slowestChainEqualsToOmnichainSnapshotTime(ctx) {
-  const { slowestChainIndexingCursor, omnichainSnapshot } = ctx.value;
-  const { omnichainIndexingCursor } = omnichainSnapshot;
-  if (slowestChainIndexingCursor !== omnichainIndexingCursor) {
-    console.log("invariant_slowestChainEqualsToOmnichainSnapshotTime", {
-      slowestChainIndexingCursor,
-      omnichainIndexingCursor
-    });
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: `'slowestChainIndexingCursor' must be equal to 'omnichainSnapshot.omnichainIndexingCursor'`
-    });
-  }
+function buildLabelSetVersion(maybeLabelSetVersion) {
+  return makeLabelSetVersionSchema("LabelSetVersion").parse(maybeLabelSetVersion);
 }
-function invariant_snapshotTimeIsTheHighestKnownBlockTimestamp(ctx) {
-  const { snapshotTime, omnichainSnapshot } = ctx.value;
-  const chains = Array.from(omnichainSnapshot.chains.values());
-  const startBlockTimestamps = chains.map((chain) => chain.config.startBlock.timestamp);
-  const endBlockTimestamps = chains.filter((chain) => chain.config.configType === ChainIndexingConfigTypeIds.Definite).map((chain) => chain.config.endBlock.timestamp);
-  const backfillEndBlockTimestamps = chains.filter((chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill).map((chain) => chain.backfillEndBlock.timestamp);
-  const latestKnownBlockTimestamps = chains.filter((chain) => chain.chainStatus === ChainIndexingStatusIds.Following).map((chain) => chain.latestKnownBlock.timestamp);
-  const highestKnownBlockTimestamp = Math.max(
-    ...startBlockTimestamps,
-    ...endBlockTimestamps,
-    ...backfillEndBlockTimestamps,
-    ...latestKnownBlockTimestamps
-  );
-  if (snapshotTime < highestKnownBlockTimestamp) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: `'snapshotTime' must be greater than or equal to  the "highest known block timestamp" (${highestKnownBlockTimestamp})`
-    });
+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 invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime(ctx) {
-  const projection = ctx.value;
-  const { snapshot, projectedAt } = projection;
-  if (snapshot.snapshotTime > projectedAt) {
-    ctx.issues.push({
-      code: "custom",
-      input: projection,
-      message: "`projectedAt` must be after or same as `snapshot.snapshotTime`."
-    });
+function validateSupportedLabelSetAndVersion(serverSet, clientSet) {
+  if (clientSet.labelSetId === void 0) {
+    return;
   }
-}
-function invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect(ctx) {
-  const projection = ctx.value;
-  const { projectedAt, snapshot, worstCaseDistance } = projection;
-  const { omnichainSnapshot } = snapshot;
-  const expectedWorstCaseDistance = projectedAt - omnichainSnapshot.omnichainIndexingCursor;
-  if (worstCaseDistance !== expectedWorstCaseDistance) {
-    ctx.issues.push({
-      code: "custom",
-      input: projection,
-      message: "`worstCaseDistance` must be the exact difference between `projectedAt` and `snapshot.omnichainIndexingCursor`."
-    });
+  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/indexing-status/zod-schemas.ts
-var makeChainIndexingConfigSchema = (valueLabel = "Value") => z3.discriminatedUnion("configType", [
-  z3.strictObject({
-    configType: z3.literal(ChainIndexingConfigTypeIds.Indefinite),
-    startBlock: makeBlockRefSchema(valueLabel)
-  }),
-  z3.strictObject({
-    configType: z3.literal(ChainIndexingConfigTypeIds.Definite),
-    startBlock: makeBlockRefSchema(valueLabel),
-    endBlock: makeBlockRefSchema(valueLabel)
-  })
-]);
-var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => z3.strictObject({
-  chainStatus: z3.literal(ChainIndexingStatusIds.Queued),
-  config: makeChainIndexingConfigSchema(valueLabel)
-}).check(invariant_chainSnapshotQueuedBlocks);
-var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => z3.strictObject({
-  chainStatus: z3.literal(ChainIndexingStatusIds.Backfill),
-  config: makeChainIndexingConfigSchema(valueLabel),
-  latestIndexedBlock: makeBlockRefSchema(valueLabel),
-  backfillEndBlock: makeBlockRefSchema(valueLabel)
-}).check(invariant_chainSnapshotBackfillBlocks);
-var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => z3.strictObject({
-  chainStatus: z3.literal(ChainIndexingStatusIds.Completed),
-  config: z3.strictObject({
-    configType: z3.literal(ChainIndexingConfigTypeIds.Definite),
-    startBlock: makeBlockRefSchema(valueLabel),
-    endBlock: makeBlockRefSchema(valueLabel)
-  }),
-  latestIndexedBlock: makeBlockRefSchema(valueLabel)
-}).check(invariant_chainSnapshotCompletedBlocks);
-var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => z3.strictObject({
-  chainStatus: z3.literal(ChainIndexingStatusIds.Following),
-  config: z3.strictObject({
-    configType: z3.literal(ChainIndexingConfigTypeIds.Indefinite),
-    startBlock: makeBlockRefSchema(valueLabel)
-  }),
-  latestIndexedBlock: makeBlockRefSchema(valueLabel),
-  latestKnownBlock: makeBlockRefSchema(valueLabel)
-}).check(invariant_chainSnapshotFollowingBlocks);
-var makeChainIndexingStatusSnapshotSchema = (valueLabel = "Value") => z3.discriminatedUnion("chainStatus", [
-  makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
-  makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
-  makeChainIndexingStatusSnapshotCompletedSchema(valueLabel),
-  makeChainIndexingStatusSnapshotFollowingSchema(valueLabel)
-]);
-var makeChainIndexingStatusesSchema = (valueLabel = "Value") => z3.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();
-  for (const [chainIdString, chainStatus] of Object.entries(serializedChainsIndexingStatus)) {
-    chainsIndexingStatus.set(deserializeChainId(chainIdString), chainStatus);
+// src/ensindexer/config/parsing.ts
+function parseNonNegativeInteger(maybeNumber) {
+  const trimmed = maybeNumber.trim();
+  if (!trimmed) {
+    throw new Error("Input cannot be empty");
   }
-  return chainsIndexingStatus;
-});
-var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => z3.strictObject({
-  omnichainStatus: z3.literal(OmnichainIndexingStatusIds.Unstarted),
-  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainSnapshotUnstartedHasValidChains).transform((chains) => chains),
-  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
-});
-var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => z3.strictObject({
-  omnichainStatus: z3.literal(OmnichainIndexingStatusIds.Backfill),
-  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotBackfillHasValidChains).transform(
-    (chains) => chains
-  ),
-  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
-});
-var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => z3.strictObject({
-  omnichainStatus: z3.literal(OmnichainIndexingStatusIds.Completed),
-  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotCompletedHasValidChains).transform((chains) => chains),
-  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
-});
-var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => z3.strictObject({
-  omnichainStatus: z3.literal(OmnichainIndexingStatusIds.Following),
-  chains: makeChainIndexingStatusesSchema(valueLabel),
-  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
-});
-var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => z3.discriminatedUnion("omnichainStatus", [
-  makeOmnichainIndexingStatusSnapshotUnstartedSchema(valueLabel),
-  makeOmnichainIndexingStatusSnapshotBackfillSchema(valueLabel),
-  makeOmnichainIndexingStatusSnapshotCompletedSchema(valueLabel),
-  makeOmnichainIndexingStatusSnapshotFollowingSchema(valueLabel)
-]).check(invariant_omnichainSnapshotStatusIsConsistentWithChainSnapshot).check(invariant_omnichainIndexingCursorLowerThanEarliestStartBlockAcrossQueuedChains).check(
-  invariant_omnichainIndexingCursorLowerThanOrEqualToLatestBackfillEndBlockAcrossBackfillChains
-).check(invariant_omnichainIndexingCursorIsEqualToHighestLatestIndexedBlockAcrossIndexedChain);
-var makeCrossChainIndexingStatusSnapshotOmnichainSchema = (valueLabel = "Cross-chain Indexing Status Snapshot Omnichain") => z3.strictObject({
-  strategy: z3.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") => z3.discriminatedUnion("strategy", [
-  makeCrossChainIndexingStatusSnapshotOmnichainSchema(valueLabel)
-]);
-var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => z3.strictObject({
-  projectedAt: makeUnixTimestampSchema(valueLabel),
-  worstCaseDistance: makeDurationSchema(valueLabel),
-  snapshot: makeCrossChainIndexingStatusSnapshotSchema(valueLabel)
-}).check(invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime).check(invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect);
+  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/config/serialize.ts
+function serializeIndexedChainIds(indexedChainIds) {
+  return Array.from(indexedChainIds);
+}
+function serializeENSIndexerPublicConfig(config) {
+  const {
+    labelSet,
+    indexedChainIds,
+    databaseSchemaName,
+    isSubgraphCompatible: isSubgraphCompatible2,
+    namespace,
+    plugins,
+    versionInfo
+  } = config;
+  return {
+    labelSet,
+    indexedChainIds: serializeIndexedChainIds(indexedChainIds),
+    databaseSchemaName,
+    isSubgraphCompatible: isSubgraphCompatible2,
+    namespace,
+    plugins,
+    versionInfo
+  };
+}
 
 // src/ensindexer/indexing-status/deserialize.ts
+import { prettifyError as prettifyError4 } from "zod/v4";
 function deserializeChainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
   const schema = makeChainIndexingStatusSnapshotSchema(valueLabel);
   const parsed = schema.safeParse(maybeSnapshot);
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize into ChainIndexingStatusSnapshot:
-${prettifyError3(parsed.error)}
+${prettifyError4(parsed.error)}
 `
     );
   }
@@ -1193,7 +1912,7 @@ function deserializeOmnichainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize into OmnichainIndexingStatusSnapshot:
-${prettifyError3(parsed.error)}
+${prettifyError4(parsed.error)}
 `
     );
   }
@@ -1205,7 +1924,7 @@ function deserializeCrossChainIndexingStatusSnapshot(maybeSnapshot, valueLabel)
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize into CrossChainIndexingStatusSnapshot:
-${prettifyError3(parsed.error)}
+${prettifyError4(parsed.error)}
 `
     );
   }
@@ -1217,7 +1936,7 @@ function deserializeRealtimeIndexingStatusProjection(maybeProjection, valueLabel
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize into RealtimeIndexingStatusProjection:
-${prettifyError3(parsed.error)}
+${prettifyError4(parsed.error)}
 `
     );
   }
@@ -1281,100 +2000,82 @@ function serializeOmnichainIndexingStatusSnapshot(indexingStatus) {
         omnichainStatus: OmnichainIndexingStatusIds.Completed,
         chains: serializeChainIndexingSnapshots(indexingStatus.chains),
         omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
-      };
-    }
-    case OmnichainIndexingStatusIds.Following:
-      return {
-        omnichainStatus: OmnichainIndexingStatusIds.Following,
-        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
-        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"] = "forward-resolution";
-  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"] = "reverse-resolution";
-  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`;
-
-// src/api/deserialize.ts
-import { prettifyError as prettifyError4 } from "zod/v4";
-
-// src/api/zod-schemas.ts
-import z4 from "zod/v4";
+      };
+    }
+    case OmnichainIndexingStatusIds.Following:
+      return {
+        omnichainStatus: OmnichainIndexingStatusIds.Following,
+        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
+        omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
+      };
+  }
+}
 
-// src/api/types.ts
-var IndexingStatusResponseCodes = {
+// src/api/registrar-actions/prerequisites.ts
+var registrarActionsPrerequisites = Object.freeze({
   /**
-   * Represents that the indexing status is available.
+   * Required plugins to enable Registrar Actions API routes.
+   *
+   * 1. `registrars` plugin is required so that data in the `registrarActions`
+   *    table is populated.
+   * 2. `subgraph`, `basenames`, and `lineanames` are required to get the data
+   *    for the name associated with each registrar action.
+   * 3. In theory not all of `subgraph`, `basenames`, and `lineanames` plugins
+   *    might be required. Ex: At least one, but the current logic in
+   *    the `registrars` plugin always indexes registrar actions across
+   *    Ethnames (subgraph), Basenames, and Lineanames and therefore we need to
+   *    ensure each value in the registrar actions table has
+   *    an associated record in the domains table.
    */
-  Ok: "ok",
+  requiredPlugins: [
+    "subgraph" /* Subgraph */,
+    "basenames" /* Basenames */,
+    "lineanames" /* Lineanames */,
+    "registrars" /* Registrars */
+  ],
   /**
-   * Represents that the indexing status is unavailable.
+   * Check if provided ENSApiPublicConfig supports the Registrar Actions API.
    */
-  Error: "error"
-};
-
-// src/api/zod-schemas.ts
-var ErrorResponseSchema = z4.object({
-  message: z4.string(),
-  details: z4.optional(z4.unknown())
-});
-var makeIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => z4.strictObject({
-  responseCode: z4.literal(IndexingStatusResponseCodes.Ok),
-  realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel)
-});
-var makeIndexingStatusResponseErrorSchema = (valueLabel = "Indexing Status Response Error") => z4.strictObject({
-  responseCode: z4.literal(IndexingStatusResponseCodes.Error)
+  hasEnsIndexerConfigSupport(config) {
+    return registrarActionsPrerequisites.requiredPlugins.every(
+      (plugin) => config.plugins.includes(plugin)
+    );
+  },
+  /**
+   * Required Indexing Status IDs
+   *
+   * Database indexes are created by the time the omnichain indexing status
+   * is either `completed` or `following`.
+   */
+  supportedIndexingStatusIds: [
+    OmnichainIndexingStatusIds.Completed,
+    OmnichainIndexingStatusIds.Following
+  ],
+  /**
+   * Check if provided indexing status supports the Registrar Actions API.
+   */
+  hasIndexingStatusSupport(omnichainIndexingStatusId) {
+    return registrarActionsPrerequisites.supportedIndexingStatusIds.some(
+      (supportedIndexingStatusId) => supportedIndexingStatusId === omnichainIndexingStatusId
+    );
+  }
 });
-var makeIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => z4.discriminatedUnion("responseCode", [
-  makeIndexingStatusResponseOkSchema(valueLabel),
-  makeIndexingStatusResponseErrorSchema(valueLabel)
-]);
 
-// src/api/deserialize.ts
-function deserializeErrorResponse(maybeErrorResponse) {
-  const parsed = ErrorResponseSchema.safeParse(maybeErrorResponse);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize ErrorResponse:
-${prettifyError4(parsed.error)}
-`);
+// src/registrars/ethnames-subregistry.ts
+import { DatasourceNames as DatasourceNames2, maybeGetDatasource as maybeGetDatasource2 } from "@ensnode/datasources";
+function getEthnamesSubregistryId(namespace) {
+  const datasource = maybeGetDatasource2(namespace, DatasourceNames2.ENSRoot);
+  if (!datasource) {
+    throw new Error(`Datasource not found for ${namespace} ${DatasourceNames2.ENSRoot}`);
   }
-  return parsed.data;
-}
-function deserializeIndexingStatusResponse(maybeResponse) {
-  const parsed = makeIndexingStatusResponseSchema().safeParse(maybeResponse);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize IndexingStatusResponse:
-${prettifyError4(parsed.error)}
-`);
+  const address = datasource.contracts.BaseRegistrar?.address;
+  if (address === void 0 || Array.isArray(address)) {
+    throw new Error(`BaseRegistrar contract not found or has multiple addresses for ${namespace}`);
   }
-  return parsed.data;
+  return {
+    chainId: datasource.chain.id,
+    address
+  };
 }
 
 // src/api/serialize.ts
@@ -1389,6 +2090,26 @@ function serializeIndexingStatusResponse(response) {
       return response;
   }
 }
+function serializeNamedRegistrarAction({
+  action,
+  name
+}) {
+  return {
+    action: serializeRegistrarAction(action),
+    name
+  };
+}
+function serializeRegistrarActionsResponse(response) {
+  switch (response.responseCode) {
+    case RegistrarActionsResponseCodes.Ok:
+      return {
+        responseCode: response.responseCode,
+        registrarActions: response.registrarActions.map(serializeNamedRegistrarAction)
+      };
+    case RegistrarActionsResponseCodes.Error:
+      return response;
+  }
+}
 
 // src/client-error.ts
 var ClientError = class _ClientError extends Error {
@@ -1403,6 +2124,161 @@ var ClientError = class _ClientError extends Error {
   }
 };
 
+// src/ensanalytics/deserialize.ts
+import { prettifyError as prettifyError5 } from "zod/v4";
+
+// src/ensanalytics/zod-schemas.ts
+import z8 from "zod/v4";
+
+// src/ensanalytics/types.ts
+var ITEMS_PER_PAGE_DEFAULT = 25;
+var ITEMS_PER_PAGE_MAX = 100;
+var PaginatedAggregatedReferrersResponseCodes = {
+  /**
+   * Represents that the aggregated referrers data is available.
+   * @note The response may contain an empty array for the first page if there are no qualified referrers.
+   * When the array is empty, total will be 0, page will be 1, and both hasNext and hasPrev will be false.
+   */
+  Ok: "ok",
+  /**
+   * Represents that the aggregated referrers data is not available.
+   */
+  Error: "error"
+};
+
+// src/ensanalytics/zod-schemas.ts
+var makeAggregatedReferrerMetricsSchema = (valueLabel = "AggregatedReferrerMetrics") => z8.object({
+  referrer: makeLowercaseAddressSchema(`${valueLabel}.referrer`),
+  totalReferrals: makePositiveIntegerSchema(`${valueLabel}.totalReferrals`),
+  totalIncrementalDuration: makeDurationSchema(`${valueLabel}.totalIncrementalDuration`)
+});
+var makeAggregatedReferrerMetricsContributionSchema = (valueLabel = "AggregatedReferrerMetricsContribution") => makeAggregatedReferrerMetricsSchema(valueLabel).extend({
+  totalReferralsContribution: z8.number({
+    error: `${valueLabel}.totalReferralsContribution must be a number`
+  }).min(0, `${valueLabel}.totalReferralsContribution must be >= 0`).max(1, `${valueLabel}.totalReferralsContribution must be <= 1`),
+  totalIncrementalDurationContribution: z8.number({
+    error: `${valueLabel}.totalIncrementalDurationContribution must be a number`
+  }).min(0, `${valueLabel}.totalIncrementalDurationContribution must be >= 0`).max(1, `${valueLabel}.totalIncrementalDurationContribution must be <= 1`)
+});
+var makePaginationParamsSchema = (valueLabel = "PaginationParams") => z8.object({
+  page: makePositiveIntegerSchema(`${valueLabel}.page`).default(1),
+  itemsPerPage: makePositiveIntegerSchema(`${valueLabel}.itemsPerPage`).max(ITEMS_PER_PAGE_MAX, `${valueLabel}.itemsPerPage must not exceed ${ITEMS_PER_PAGE_MAX}`).default(ITEMS_PER_PAGE_DEFAULT)
+});
+var makePaginatedAggregatedReferrersSchema = (valueLabel = "PaginatedAggregatedReferrers") => z8.object({
+  referrers: z8.array(
+    makeAggregatedReferrerMetricsContributionSchema(`${valueLabel}.referrers[item]`)
+  ),
+  total: makeNonNegativeIntegerSchema(`${valueLabel}.total`),
+  paginationParams: makePaginationParamsSchema(`${valueLabel}.paginationParams`),
+  hasNext: z8.boolean(),
+  hasPrev: z8.boolean(),
+  updatedAt: makeUnixTimestampSchema(`${valueLabel}.updatedAt`)
+}).check((ctx) => {
+  const { paginationParams, hasNext, hasPrev, total } = ctx.value;
+  const expectedHasPrev = paginationParams.page > 1;
+  if (hasPrev !== expectedHasPrev) {
+    ctx.issues.push({
+      code: "custom",
+      message: `${valueLabel}.hasPrev must be ${expectedHasPrev} when page is ${paginationParams.page}`,
+      input: ctx.value
+    });
+  }
+  const endIndex = paginationParams.page * paginationParams.itemsPerPage;
+  const expectedHasNext = endIndex < total;
+  if (hasNext !== expectedHasNext) {
+    ctx.issues.push({
+      code: "custom",
+      message: `${valueLabel}.hasNext must be ${expectedHasNext} when page=${paginationParams.page}, itemsPerPage=${paginationParams.itemsPerPage}, total=${total}`,
+      input: ctx.value
+    });
+  }
+});
+var makePaginatedAggregatedReferrersResponseOkSchema = (valueLabel = "PaginatedAggregatedReferrersResponse") => z8.object({
+  responseCode: z8.literal(PaginatedAggregatedReferrersResponseCodes.Ok),
+  data: makePaginatedAggregatedReferrersSchema(`${valueLabel}.data`)
+});
+var makePaginatedAggregatedReferrersResponseErrorSchema = (_valueLabel = "PaginatedAggregatedReferrersResponse") => z8.object({
+  responseCode: z8.literal(PaginatedAggregatedReferrersResponseCodes.Error),
+  error: z8.string(),
+  errorMessage: z8.string()
+});
+var makePaginatedAggregatedReferrersResponseSchema = (valueLabel = "PaginatedAggregatedReferrersResponse") => z8.union([
+  makePaginatedAggregatedReferrersResponseOkSchema(valueLabel),
+  makePaginatedAggregatedReferrersResponseErrorSchema(valueLabel)
+]);
+
+// src/ensanalytics/deserialize.ts
+function deserializePaginatedAggregatedReferrersResponse(maybeResponse, valueLabel) {
+  const schema = makePaginatedAggregatedReferrersResponseSchema(valueLabel);
+  const parsed = schema.safeParse(maybeResponse);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize PaginatedAggregatedReferrersResponse:
+${prettifyError5(parsed.error)}
+`
+    );
+  }
+  return parsed.data;
+}
+
+// src/ensanalytics/serialize.ts
+function serializePaginatedAggregatedReferrersResponse(response) {
+  switch (response.responseCode) {
+    case PaginatedAggregatedReferrersResponseCodes.Ok:
+      return response;
+    case PaginatedAggregatedReferrersResponseCodes.Error:
+      return response;
+  }
+}
+
+// src/ensapi/config/deserialize.ts
+import { prettifyError as prettifyError6, ZodError } from "zod/v4";
+
+// src/ensapi/config/zod-schemas.ts
+import { z as z9 } from "zod/v4";
+var TheGraphCannotFallbackReasonSchema = z9.enum({
+  NotSubgraphCompatible: "not-subgraph-compatible",
+  NoApiKey: "no-api-key",
+  NoSubgraphUrl: "no-subgraph-url"
+});
+var TheGraphFallbackSchema = z9.strictObject({
+  canFallback: z9.boolean(),
+  reason: TheGraphCannotFallbackReasonSchema.nullable()
+});
+function makeENSApiPublicConfigSchema(valueLabel) {
+  const label = valueLabel ?? "ENSApiPublicConfig";
+  return z9.strictObject({
+    version: z9.string().min(1, `${label}.version must be a non-empty string`),
+    theGraphFallback: TheGraphFallbackSchema,
+    ensIndexerPublicConfig: makeENSIndexerPublicConfigSchema(`${label}.ensIndexerPublicConfig`)
+  });
+}
+
+// src/ensapi/config/deserialize.ts
+function deserializeENSApiPublicConfig(maybeConfig, valueLabel) {
+  const schema = makeENSApiPublicConfigSchema(valueLabel);
+  try {
+    return schema.parse(maybeConfig);
+  } catch (error) {
+    if (error instanceof ZodError) {
+      throw new Error(`Cannot deserialize ENSApiPublicConfig:
+${prettifyError6(error)}
+`);
+    }
+    throw error;
+  }
+}
+
+// src/ensapi/config/serialize.ts
+function serializeENSApiPublicConfig(config) {
+  const { version, theGraphFallback, ensIndexerPublicConfig } = config;
+  return {
+    version,
+    theGraphFallback,
+    ensIndexerPublicConfig: serializeENSIndexerPublicConfig(ensIndexerPublicConfig)
+  };
+}
+
 // src/client.ts
 var DEFAULT_ENSNODE_API_URL = "https://api.alpha.ensnode.io";
 var ENSNodeClient = class _ENSNodeClient {
@@ -1606,7 +2482,7 @@ var ENSNodeClient = class _ENSNodeClient {
       const errorResponse = deserializeErrorResponse(responseData);
       throw new Error(`Fetching ENSNode Config Failed: ${errorResponse.message}`);
     }
-    return deserializeENSIndexerPublicConfig(responseData);
+    return deserializeENSApiPublicConfig(responseData);
   }
   /**
    * Fetch ENSNode Indexing Status
@@ -1639,12 +2515,170 @@ var ENSNodeClient = class _ENSNodeClient {
     }
     return deserializeIndexingStatusResponse(responseData);
   }
+  /**
+   * Fetch Paginated Aggregated Referrers
+   *
+   * Retrieves a paginated list of aggregated referrer metrics with contribution percentages.
+   * Each referrer's contribution is calculated as a percentage of the grand totals across all referrers.
+   *
+   * @param request - Pagination parameters
+   * @param request.page - The page number to retrieve (1-indexed, default: 1)
+   * @param request.itemsPerPage - Number of items per page (default: 25, max: 100)
+   * @returns {PaginatedAggregatedReferrersResponse}
+   *
+   * @throws if the ENSNode request fails
+   * @throws if the ENSNode API returns an error response
+   * @throws if the ENSNode response breaks required invariants
+   *
+   * @example
+   * ```typescript
+   * // Get first page with default page size (25 items)
+   * const response = await client.getAggregatedReferrers();
+   * if (response.responseCode === 'ok') {
+   *   console.log(response.data.referrers);
+   *   console.log(`Page ${response.data.paginationParams.page} of ${Math.ceil(response.data.total / response.data.paginationParams.itemsPerPage)}`);
+   * }
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Get second page with 50 items per page
+   * const response = await client.getAggregatedReferrers({ page: 2, itemsPerPage: 50 });
+   * ```
+   */
+  async getAggregatedReferrers(request) {
+    const url = new URL(`/ensanalytics/aggregated-referrers`, this.options.url);
+    if (request?.page) url.searchParams.set("page", request.page.toString());
+    if (request?.itemsPerPage)
+      url.searchParams.set("itemsPerPage", request.itemsPerPage.toString());
+    const response = await fetch(url);
+    let responseData;
+    try {
+      responseData = await response.json();
+    } catch {
+      throw new Error("Malformed response data: invalid JSON");
+    }
+    return deserializePaginatedAggregatedReferrersResponse(
+      responseData
+    );
+  }
+  /**
+   * Fetch ENSNode Registrar Actions
+   *
+   * @param {RegistrarActionsRequestFilter} request.filter is
+   *        an optional request filter configuration.
+   * @param {number} request.limit sets the maximum count of results in the response.
+   * @param {RegistrarActionsRequestOrder} request.order sets the order of
+   *        results in the response by field and direction.
+   * @returns {RegistrarActionsResponse}
+   *
+   * @throws if the ENSNode request fails
+   * @throws if the ENSNode API returns an error response
+   * @throws if the ENSNode response breaks required invariants
+   *
+   * @example
+   * ```ts
+   * import {
+   *   registrarActionsFilter,,
+   *   ENSNodeClient,
+   * } from "@ensnode/ensnode-sdk";
+   * import { namehash } from "viem/ens";
+   *
+   * const client: ENSNodeClient;
+   *
+   * // get latest registrar action records across all indexed subregistries
+   * // NOTE: when no `limit` value is passed,
+   * //       the default RESPONSE_ITEMS_PER_PAGE_DEFAULT applies.
+   * const registrarActions = await client.registrarActions();
+   *
+   * // get latest 5 registrar action records across all indexed subregistries
+   * // NOTE: when a `limit` value is passed, it must be lower than or equal to
+   * //       the RESPONSE_ITEMS_PER_PAGE_MAX value.
+   * const registrarActions = await client.registrarActions({
+   *   limit: 5,
+   * });
+   *
+   * // get latest registrar action records associated with
+   * // subregistry managing `eth` name
+   * await client.registrarActions({
+   *   filters: [registrarActionsFilter.byParentNode(namehash('eth'))],
+   * });
+   *
+   * // get latest registrar action records which include referral info
+   * await client.registrarActions({
+   *   filters: [registrarActionsFilter.withReferral(true)],
+   * });
+   *
+   * // get latest 10 registrar action records associated with
+   * // subregistry managing `base.eth` name
+   * await client.registrarActions({
+   *   filters: [registrarActionsFilter.byParentNode(namehash('base.eth'))],
+   *   limit: 10
+   * });
+   * ```
+   */
+  async registrarActions(request = {}) {
+    const buildUrlPath = (filters) => {
+      const bySubregistryNodeFilter = filters?.find(
+        (f) => f.filterType === RegistrarActionsFilterTypes.BySubregistryNode
+      );
+      return bySubregistryNodeFilter ? new URL(`/api/registrar-actions/${bySubregistryNodeFilter.value}`, this.options.url) : new URL(`/api/registrar-actions`, this.options.url);
+    };
+    const buildWithReferralArg = (filters) => {
+      const withReferralFilter = filters?.find(
+        (f) => f.filterType === RegistrarActionsFilterTypes.WithEncodedReferral
+      );
+      return withReferralFilter ? { key: "withReferral", value: "true" } : null;
+    };
+    const buildOrderArg = (order) => {
+      switch (order) {
+        case RegistrarActionsOrders.LatestRegistrarActions: {
+          const [field, direction] = order.split("=");
+          return {
+            key: `sort[${field}]`,
+            value: `${direction}`
+          };
+        }
+      }
+    };
+    const url = buildUrlPath(request.filters);
+    if (request.order) {
+      const orderArgs = buildOrderArg(request.order);
+      url.searchParams.set(orderArgs.key, orderArgs.value);
+    }
+    if (request.itemsPerPage) {
+      url.searchParams.set("itemsPerPage", request.itemsPerPage.toString());
+    }
+    const referralArg = buildWithReferralArg(request.filters);
+    if (referralArg) {
+      url.searchParams.set(referralArg.key, referralArg.value);
+    }
+    const response = await fetch(url);
+    let responseData;
+    try {
+      responseData = await response.json();
+    } catch {
+      throw new Error("Malformed response data: invalid JSON");
+    }
+    if (!response.ok) {
+      let errorResponse;
+      try {
+        errorResponse = deserializeErrorResponse(responseData);
+      } catch {
+        console.log("Registrar Actions API: handling a known server error.");
+      }
+      if (typeof errorResponse !== "undefined") {
+        throw new Error(`Fetching ENSNode Registrar Actions Failed: ${errorResponse.message}`);
+      }
+    }
+    return deserializeRegistrarActionsResponse(responseData);
+  }
 };
 
-// src/resolution/resolver-records-selection.ts
-var isSelectionEmpty = (selection) => !selection.name && !selection.addresses?.length && !selection.texts?.length;
+// src/identity/identity.ts
+import { getENSRootChainId as getENSRootChainId3 } from "@ensnode/datasources";
 
-// src/resolution/types.ts
+// src/identity/types.ts
 var ResolutionStatusIds = {
   /**
    * Represents that the `Identity` is not resolved yet.
@@ -1665,66 +2699,7 @@ var ResolutionStatusIds = {
   Unknown: "unknown"
 };
 
-// src/resolution/default-records-selection.ts
-import {
-  DatasourceNames,
-  ENSNamespaceIds as ENSNamespaceIds3,
-  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 getCommonCoinTypes = (namespace) => {
-  return [ETH_COIN_TYPE, ...getENSIP19SupportedCoinTypes(namespace)];
-};
-var TEXTS = [
-  "url",
-  "avatar",
-  "header",
-  "description",
-  "email",
-  "com.twitter",
-  "com.farcaster",
-  "com.github"
-];
-var DefaultRecordsSelection = {
-  [ENSNamespaceIds3.Mainnet]: {
-    addresses: getCommonCoinTypes(ENSNamespaceIds3.Mainnet),
-    texts: TEXTS
-  },
-  [ENSNamespaceIds3.Sepolia]: {
-    addresses: getCommonCoinTypes(ENSNamespaceIds3.Sepolia),
-    texts: TEXTS
-  },
-  [ENSNamespaceIds3.Holesky]: {
-    addresses: getCommonCoinTypes(ENSNamespaceIds3.Holesky),
-    texts: TEXTS
-  },
-  [ENSNamespaceIds3.EnsTestEnv]: {
-    addresses: getCommonCoinTypes(ENSNamespaceIds3.EnsTestEnv),
-    texts: TEXTS
-  }
-};
-
-// src/resolution/ensip19-chainid.ts
-import { getENSRootChainId as getENSRootChainId2 } from "@ensnode/datasources";
-import { mainnet } from "viem/chains";
-var getResolvePrimaryNameChainIdParam = (chainId, namespaceId) => {
-  const ensRootChainId = getENSRootChainId2(namespaceId);
-  return chainId === ensRootChainId ? mainnet.id : chainId;
-};
-var translateDefaultableChainIdToChainId = (chainId, namespaceId) => {
-  return chainId === DEFAULT_EVM_CHAIN_ID ? getENSRootChainId2(namespaceId) : chainId;
-};
-
-// src/resolution/identity.ts
-import { getENSRootChainId as getENSRootChainId3 } from "@ensnode/datasources";
+// src/identity/identity.ts
 function buildUnresolvedIdentity(address, namespaceId, chainId) {
   return {
     resolutionStatus: ResolutionStatusIds.Unresolved,
@@ -1735,6 +2710,50 @@ function buildUnresolvedIdentity(address, namespaceId, chainId) {
 function isResolvedIdentity(identity) {
   return identity.resolutionStatus !== ResolutionStatusIds.Unresolved;
 }
+
+// src/resolution/ensip19-chainid.ts
+import { mainnet as mainnet2 } from "viem/chains";
+import { getENSRootChainId as getENSRootChainId4 } from "@ensnode/datasources";
+var getResolvePrimaryNameChainIdParam = (chainId, namespaceId) => {
+  const ensRootChainId = getENSRootChainId4(namespaceId);
+  return chainId === ensRootChainId ? mainnet2.id : chainId;
+};
+var translateDefaultableChainIdToChainId = (chainId, namespaceId) => {
+  return chainId === DEFAULT_EVM_CHAIN_ID ? getENSRootChainId4(namespaceId) : chainId;
+};
+
+// src/resolution/resolver-records-selection.ts
+var isSelectionEmpty = (selection) => !selection.name && !selection.addresses?.length && !selection.texts?.length;
+
+// 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"] = "forward-resolution";
+  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"] = "reverse-resolution";
+  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`;
 export {
   ADDR_REVERSE_NODE,
   ATTR_PROTOCOL_NAME,
@@ -1745,29 +2764,41 @@ export {
   ChainIndexingStatusIds,
   ClientError,
   CrossChainIndexingStrategyIds,
-  DEFAULT_ENSNODE_API_URL,
+  CurrencyIds,
   DEFAULT_EVM_CHAIN_ID,
   DEFAULT_EVM_COIN_TYPE,
-  DefaultRecordsSelection,
   ENSNamespaceIds,
   ENSNodeClient,
   ETH_COIN_TYPE,
   ETH_NODE,
   ForwardResolutionProtocolStep,
+  ITEMS_PER_PAGE_DEFAULT,
+  ITEMS_PER_PAGE_MAX,
   IndexingStatusResponseCodes,
   LINEANAMES_NODE,
   LruCache,
   OmnichainIndexingStatusIds,
   PROTOCOL_ATTRIBUTE_PREFIX,
+  PaginatedAggregatedReferrersResponseCodes,
   PluginName,
   ROOT_NODE,
+  RegistrarActionTypes,
+  RegistrarActionsFilterTypes,
+  RegistrarActionsOrders,
+  RegistrarActionsResponseCodes,
   ResolutionStatusIds,
   ReverseResolutionProtocolStep,
+  TheGraphCannotFallbackReasonSchema,
+  TheGraphFallbackSchema,
   TraceableENSProtocol,
+  TtlCache,
   accountIdEqual,
+  addDuration,
+  addPrices,
   addrReverseLabel,
   asLowerCaseAddress,
   beautifyName,
+  bigIntToNumber,
   bigintToCoinType,
   buildEnsRainbowClientLabelSet,
   buildLabelSetId,
@@ -1783,6 +2814,8 @@ export {
   createRealtimeIndexingStatusProjection,
   decodeDNSEncodedLiteralName,
   decodeDNSEncodedName,
+  decodeEncodedReferrer,
+  deserializeAccountId,
   deserializeBlockNumber,
   deserializeBlockRef,
   deserializeBlockrange,
@@ -1791,27 +2824,39 @@ export {
   deserializeCrossChainIndexingStatusSnapshot,
   deserializeDatetime,
   deserializeDuration,
+  deserializeENSApiPublicConfig,
   deserializeENSIndexerPublicConfig,
   deserializeErrorResponse,
   deserializeIndexingStatusResponse,
   deserializeOmnichainIndexingStatusSnapshot,
+  deserializePaginatedAggregatedReferrersResponse,
   deserializeRealtimeIndexingStatusProjection,
+  deserializeRegistrarActionsResponse,
   deserializeUnixTimestamp,
   deserializeUrl,
+  durationBetween,
   encodeLabelHash,
   evmChainIdToCoinType,
-  getCommonCoinTypes,
+  getCurrencyInfo,
   getENSRootChainId,
+  getEthnamesSubregistryId,
   getNameHierarchy,
   getOmnichainIndexingCursor,
   getOmnichainIndexingStatus,
   getResolvePrimaryNameChainIdParam,
   getTimestampForHighestOmnichainKnownBlock,
   getTimestampForLowestOmnichainStartBlock,
+  hasNullByte,
   interpretedLabelsToInterpretedName,
+  isEncodedLabelHash,
   isHttpProtocol,
+  isLabelHash,
   isNormalizedLabel,
   isNormalizedName,
+  isPriceCurrencyEqual,
+  isPriceEqual,
+  isRegistrarActionPricingAvailable,
+  isRegistrarActionReferralAvailable,
   isResolvedIdentity,
   isSelectionEmpty,
   isSubgraphCompatible,
@@ -1821,24 +2866,44 @@ export {
   literalLabelToInterpretedLabel,
   literalLabelsToInterpretedName,
   literalLabelsToLiteralName,
+  makeENSApiPublicConfigSchema,
   makeSubdomainNode,
   parseNonNegativeInteger,
   parseReverseName,
+  priceDai,
+  priceEth,
+  priceUsdc,
+  registrarActionsFilter,
+  registrarActionsPrerequisites,
   reverseName,
+  serializeAccountId,
   serializeChainId,
   serializeChainIndexingSnapshots,
   serializeCrossChainIndexingStatusSnapshotOmnichain,
   serializeDatetime,
+  serializeENSApiPublicConfig,
   serializeENSIndexerPublicConfig,
   serializeIndexedChainIds,
   serializeIndexingStatusResponse,
+  serializeNamedRegistrarAction,
   serializeOmnichainIndexingStatusSnapshot,
+  serializePaginatedAggregatedReferrersResponse,
+  serializePrice,
+  serializePriceEth,
   serializeRealtimeIndexingStatusProjection,
+  serializeRegistrarAction,
+  serializeRegistrarActionPricing,
+  serializeRegistrarActionsResponse,
+  serializeRegistrationLifecycle,
+  serializeSubregistry,
   serializeUrl,
   sortChainStatusesByStartBlockAsc,
+  staleWhileRevalidate,
+  stripNullBytes,
   translateDefaultableChainIdToChainId,
   uint256ToHex32,
   uniq,
-  validateSupportedLabelSetAndVersion
+  validateSupportedLabelSetAndVersion,
+  zeroEncodedReferrer
 };
 //# sourceMappingURL=index.js.map