@ensnode/ensnode-sdk 0.0.0-next-20260102143513

package/dist/index.js

@@ -0,0 +1,4378 @@
+// src/ensapi/config/deserialize.ts
+import { prettifyError as prettifyError2, ZodError } from "zod/v4";
+
+// src/ensapi/config/zod-schemas.ts
+import { z as z4 } from "zod/v4";
+
+// src/ensindexer/config/zod-schemas.ts
+import z2 from "zod/v4";
+
+// 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/lru-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/cache/swr-cache.ts
+import { secondsToMilliseconds } from "date-fns";
+import { getUnixTime } from "date-fns/getUnixTime";
+
+// 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 {
+  coinTypeToEvmChainId as _coinTypeToEvmChainId,
+  evmChainIdToCoinType as _evmChainIdToCoinType
+} from "@ensdomains/address-encoder/utils";
+var ETH_COIN_TYPE = 60;
+var DEFAULT_EVM_CHAIN_ID = 0;
+var DEFAULT_EVM_COIN_TYPE = 2147483648;
+var coinTypeToEvmChainId = (coinType) => {
+  if (coinType === ETH_COIN_TYPE) return 1;
+  return _coinTypeToEvmChainId(coinType);
+};
+var evmChainIdToCoinType = (chainId) => {
+  if (chainId === 1) return ETH_COIN_TYPE;
+  return _evmChainIdToCoinType(chainId);
+};
+var bigintToCoinType = (value) => {
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error(`'${value}' cannot represent as CoinType, it is too large.`);
+  }
+  return Number(value);
+};
+
+// src/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/dns-encoded-name.ts
+import { bytesToString, hexToBytes } from "viem";
+function decodeDNSEncodedLiteralName(packet) {
+  return decodeDNSEncodedName(packet);
+}
+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/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/ens/names.ts
+import { ens_beautify } from "@adraffy/ens-normalize";
+var ENS_ROOT = "";
+var getNameHierarchy = (name) => name.split(".").map((_, i, labels) => labels.slice(i).join("."));
+var getParentNameFQDN = (name) => {
+  if (name === ENS_ROOT) {
+    throw new Error("There is no parent name for ENS Root.");
+  }
+  const labels = name.split(".");
+  if (labels.length === 1) {
+    return ENS_ROOT;
+  }
+  return labels.slice(1).join(".");
+};
+var beautifyName = (name) => {
+  const beautifiedLabels = name.split(".").map((label) => {
+    if (isNormalizedLabel(label)) {
+      return ens_beautify(label);
+    } else {
+      return label;
+    }
+  });
+  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);
+function reverseName(address, coinType) {
+  const label = addrReverseLabel(address);
+  const middle = (() => {
+    switch (coinType) {
+      case ETH_COIN_TYPE:
+        return "addr";
+      case DEFAULT_EVM_COIN_TYPE:
+        return "default";
+      default:
+        return coinTypeReverseLabel(coinType);
+    }
+  })();
+  return `${label}.${middle}.reverse`;
+}
+
+// src/ens/subname-helpers.ts
+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/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
+  }
+};
+function getCurrencyInfo(currencyId) {
+  return currencyInfo[currencyId];
+}
+function priceEth(amount) {
+  return {
+    amount,
+    currency: CurrencyIds.ETH
+  };
+}
+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/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
+var makeFiniteNonNegativeNumberSchema = (valueLabel = "Value") => z.number({
+  // NOTE: Zod's implementation of `number` automatically rejects NaN and Infinity values.
+  // and therefore the finite check is implicit.
+  error: `${valueLabel} must be a finite number.`
+}).nonnegative({
+  error: `${valueLabel} must be a non-negative number (>=0).`
+});
+var makeIntegerSchema = (valueLabel = "Value") => z.int({
+  error: `${valueLabel} must be an integer.`
+});
+var makePositiveIntegerSchema = (valueLabel = "Value") => makeIntegerSchema(valueLabel).positive({
+  error: `${valueLabel} must be a positive integer (>0).`
+});
+var makeNonNegativeIntegerSchema = (valueLabel = "Value") => makeIntegerSchema(valueLabel).nonnegative({
+  error: `${valueLabel} must be a non-negative integer (>=0).`
+});
+var makeDurationSchema = (valueLabel = "Value") => z.coerce.number({
+  error: `${valueLabel} must be a number.`
+}).pipe(makeNonNegativeIntegerSchema(valueLabel));
+var makeChainIdSchema = (valueLabel = "Chain ID") => makePositiveIntegerSchema(valueLabel).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).`,
+  abort: true
+}).transform((v) => new URL(v));
+var makeBlockNumberSchema = (valueLabel = "Block number") => makeNonNegativeIntegerSchema(valueLabel);
+var makeBlockrangeSchema = (valueLabel = "Value") => z.strictObject(
+  {
+    startBlock: makeBlockNumberSchema(`${valueLabel}.startBlock`).optional(),
+    endBlock: makeBlockNumberSchema(`${valueLabel}.endBlock`).optional()
+  },
+  {
+    error: `${valueLabel} must be a valid Blockrange object.`
+  }
+).refine(
+  (v) => {
+    if (v.startBlock && v.endBlock) {
+      return v.startBlock <= v.endBlock;
+    }
+    return true;
+  },
+  { error: `${valueLabel}: startBlock must be before or equal to endBlock` }
+);
+var makeBlockRefSchema = (valueLabel = "Value") => z.strictObject(
+  {
+    timestamp: makeUnixTimestampSchema(`${valueLabel}.timestamp`),
+    number: makeBlockNumberSchema(`${valueLabel}.number`)
+  },
+  {
+    error: `${valueLabel} must be a valid BlockRef object.`
+  }
+);
+var makeENSNamespaceIdSchema = (valueLabel = "ENSNamespaceId") => z.enum(ENSNamespaceIds, {
+  error() {
+    return `Invalid ${valueLabel}. Supported ENS namespace IDs are: ${Object.keys(ENSNamespaceIds).join(", ")}`;
+  }
+});
+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: makeChainIdSchema(`${valueLabel} chain ID`),
+  address: makeLowercaseAddressSchema(`${valueLabel} address`)
+});
+var makeAccountIdStringSchema = (valueLabel = "Account ID String") => z.coerce.string().transform((v) => {
+  const result = new CaipAccountId(v);
+  return {
+    chainId: Number(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 be a hexadecimal value which starts 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)}
+`);
+  }
+  return parsed.data;
+}
+function deserializeUnixTimestamp(maybeTimestamp, valueLabel) {
+  const schema = makeUnixTimestampSchema(valueLabel);
+  const parsed = schema.safeParse(maybeTimestamp);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize Unix Timestamp:
+${prettifyError(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+function deserializeUrl(maybeUrl, valueLabel) {
+  const schema = makeUrlSchema(valueLabel);
+  const parsed = schema.safeParse(maybeUrl);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize URL:
+${prettifyError(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+function deserializeBlockNumber(maybeBlockNumber, valueLabel) {
+  const schema = makeBlockNumberSchema(valueLabel);
+  const parsed = schema.safeParse(maybeBlockNumber);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize BlockNumber:
+${prettifyError(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+function deserializeBlockrange(maybeBlockrange, valueLabel) {
+  const schema = makeBlockrangeSchema(valueLabel);
+  const parsed = schema.safeParse(maybeBlockrange);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize Blockrange:
+${prettifyError(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+function deserializeBlockRef(maybeBlockRef, valueLabel) {
+  const schema = makeBlockRefSchema(valueLabel);
+  const parsed = schema.safeParse(maybeBlockRef);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize BlockRef:
+${prettifyError(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+function deserializeDuration(maybeDuration, valueLabel) {
+  const schema = makeDurationSchema(valueLabel);
+  const parsed = schema.safeParse(maybeDuration);
+  if (parsed.error) {
+    throw new RangeError(`Cannot deserialize Duration:
+${prettifyError(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+function parseAccountId(maybeAccountId, valueLabel) {
+  const schema = makeAccountIdStringSchema(valueLabel);
+  const parsed = schema.safeParse(maybeAccountId);
+  if (parsed.error) {
+    throw new RangeError(`Cannot deserialize AccountId:
+${prettifyError(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+
+// 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/swr-cache.ts
+var SWRCache = class {
+  constructor(options) {
+    this.options = options;
+    if (options.proactiveRevalidationInterval) {
+      this.backgroundInterval = setInterval(
+        () => this.revalidate(),
+        secondsToMilliseconds(options.proactiveRevalidationInterval)
+      );
+    }
+    if (options.proactivelyInitialize) this.revalidate();
+  }
+  cache = null;
+  inProgressRevalidate = null;
+  backgroundInterval = null;
+  async revalidate() {
+    if (!this.inProgressRevalidate) {
+      this.inProgressRevalidate = this.options.fn().then((result) => {
+        this.cache = {
+          result,
+          updatedAt: getUnixTime(/* @__PURE__ */ new Date())
+        };
+      }).catch((error) => {
+        if (!this.cache) {
+          this.cache = {
+            // ensure thrown value is always an Error instance
+            result: error instanceof Error ? error : new Error(String(error)),
+            updatedAt: getUnixTime(/* @__PURE__ */ new Date())
+          };
+        }
+      }).finally(() => {
+        this.inProgressRevalidate = null;
+      });
+    }
+    return this.inProgressRevalidate;
+  }
+  /**
+   * Read the most recently cached result from the `SWRCache`.
+   *
+   * @returns a `ValueType` that was most recently successfully returned by `fn` or `Error` if `fn`
+   * has never successfully returned.
+   */
+  async read() {
+    if (!this.cache) await this.revalidate();
+    if (!this.cache) throw new Error("never");
+    if (durationBetween(this.cache.updatedAt, getUnixTime(/* @__PURE__ */ new Date())) > this.options.ttl) {
+      this.revalidate();
+    }
+    return this.cache.result;
+  }
+  /**
+   * Destroys the background revalidation interval, if exists.
+   */
+  destroy() {
+    if (this.backgroundInterval) {
+      clearInterval(this.backgroundInterval);
+      this.backgroundInterval = null;
+    }
+  }
+};
+
+// src/shared/cache/ttl-cache.ts
+import { getUnixTime as getUnixTime2 } from "date-fns/getUnixTime";
+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 = getUnixTime2(/* @__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(getUnixTime2(/* @__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 <= getUnixTime2(/* @__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 <= getUnixTime2(/* @__PURE__ */ new Date())) {
+      this._cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  delete(key) {
+    return this._cache.delete(key);
+  }
+};
+
+// src/shared/collections.ts
+var uniq = (arr) => [...new Set(arr)];
+
+// src/shared/datasource-contract.ts
+import { maybeGetDatasource } from "@ensnode/datasources";
+var maybeGetDatasourceContract = (namespaceId, datasourceName, contractName) => {
+  const datasource = maybeGetDatasource(namespaceId, datasourceName);
+  if (!datasource) return void 0;
+  const address = datasource.contracts[contractName]?.address;
+  if (address === void 0 || Array.isArray(address)) return void 0;
+  return {
+    chainId: datasource.chain.id,
+    address
+  };
+};
+var getDatasourceContract = (namespaceId, datasourceName, contractName) => {
+  const contract = maybeGetDatasourceContract(namespaceId, datasourceName, contractName);
+  if (!contract) {
+    throw new Error(
+      `Expected contract not found for ${namespaceId} ${datasourceName} ${contractName}`
+    );
+  }
+  return contract;
+};
+
+// src/shared/labelhash.ts
+import { keccak256 as keccak2562, stringToBytes } from "viem";
+var labelhashLiteralLabel = (label) => keccak2562(stringToBytes(label));
+
+// src/shared/interpretation.ts
+function literalLabelToInterpretedLabel(label) {
+  if (isNormalizedLabel(label)) return label;
+  return encodeLabelHash(labelhashLiteralLabel(label));
+}
+function literalLabelsToInterpretedName(labels) {
+  return labels.map(literalLabelToInterpretedLabel).join(".");
+}
+function interpretedLabelsToInterpretedName(labels) {
+  return labels.join(".");
+}
+function literalLabelsToLiteralName(labels) {
+  return labels.join(".");
+}
+
+// src/shared/null-bytes.ts
+var hasNullByte = (value) => value.indexOf("\0") !== -1;
+var stripNullBytes = (value) => value.replaceAll("\0", "");
+
+// 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.'`
+    );
+  }
+  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/shared/serialize.ts
+import { AccountId as CaipAccountId2 } from "caip";
+function serializeChainId(chainId) {
+  return chainId.toString();
+}
+function serializeDatetime(datetime) {
+  return datetime.toISOString();
+}
+function serializeUrl(url) {
+  return url.toString();
+}
+function serializePrice(price) {
+  return {
+    currency: price.currency,
+    amount: price.amount.toString()
+  };
+}
+function serializePriceEth(price) {
+  return serializePrice(price);
+}
+function formatAccountId(accountId) {
+  return CaipAccountId2.format({
+    chainId: { namespace: "eip155", reference: accountId.chainId.toString() },
+    address: accountId.address
+  }).toLowerCase();
+}
+
+// src/shared/url.ts
+function isHttpProtocol(url) {
+  return ["http:", "https:"].includes(url.protocol);
+}
+function isWebSocketProtocol(url) {
+  return ["ws:", "wss:"].includes(url.protocol);
+}
+
+// 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") => 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/shared/config/thegraph.ts
+import { z as z3 } from "zod/v4";
+var TheGraphCannotFallbackReasonSchema = z3.enum({
+  NotSubgraphCompatible: "not-subgraph-compatible",
+  NoApiKey: "no-api-key",
+  NoSubgraphUrl: "no-subgraph-url"
+});
+var TheGraphFallbackSchema = z3.discriminatedUnion("canFallback", [
+  z3.strictObject({
+    canFallback: z3.literal(true),
+    url: z3.string()
+  }),
+  z3.strictObject({
+    canFallback: z3.literal(false),
+    reason: TheGraphCannotFallbackReasonSchema
+  })
+]);
+
+// src/ensapi/config/zod-schemas.ts
+function makeENSApiPublicConfigSchema(valueLabel) {
+  const label = valueLabel ?? "ENSApiPublicConfig";
+  return z4.strictObject({
+    version: z4.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:
+${prettifyError2(error)}
+`);
+    }
+    throw error;
+  }
+}
+
+// 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 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/parsing.ts
+function parseNonNegativeInteger(maybeNumber) {
+  const trimmed = maybeNumber.trim();
+  if (!trimmed) {
+    throw new Error("Input cannot be empty");
+  }
+  if (trimmed === "-0") {
+    throw new Error("Negative zero is not a valid non-negative integer");
+  }
+  const num = Number(maybeNumber);
+  if (Number.isNaN(num)) {
+    throw new Error(`"${maybeNumber}" is not a valid number`);
+  }
+  if (!Number.isFinite(num)) {
+    throw new Error(`"${maybeNumber}" is not a finite number`);
+  }
+  if (!Number.isInteger(num)) {
+    throw new Error(`"${maybeNumber}" is not an integer`);
+  }
+  if (num < 0) {
+    throw new Error(`"${maybeNumber}" is not a non-negative integer`);
+  }
+  return num;
+}
+
+// src/ensindexer/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";
+
+// src/ensindexer/indexing-status/zod-schemas.ts
+import z5 from "zod/v4";
+
+// src/ensindexer/indexing-status/types.ts
+var ChainIndexingConfigTypeIds = {
+  /**
+   * Represents that indexing of the chain should be performed for an indefinite range.
+   */
+  Indefinite: "indefinite",
+  /**
+   * Represents that indexing of the chain should be performed for a definite range.
+   */
+  Definite: "definite"
+};
+var ChainIndexingStatusIds = {
+  /**
+   * Represents that indexing of the chain is not ready to begin yet because:
+   * - ENSIndexer is in its initialization phase and the data to build a
+   *   "true" {@link ChainIndexingSnapshot} for the chain is still being loaded; or
+   * - ENSIndexer is using an omnichain indexing strategy and the
+   *   `omnichainIndexingCursor` is <= `config.startBlock.timestamp` for the chain's
+   *   {@link ChainIndexingSnapshot}.
+   */
+  Queued: "chain-queued",
+  /**
+   * Represents that indexing of the chain is in progress and under a special
+   * "backfill" phase that optimizes for accelerated indexing until reaching the
+   * "fixed target" `backfillEndBlock`.
+   */
+  Backfill: "chain-backfill",
+  /**
+   * Represents that the "backfill" phase of indexing the chain is completed
+   * and that the chain is configured to be indexed for an indefinite range.
+   * Therefore, indexing of the chain remains indefinitely in progress where
+   * ENSIndexer will continuously work to discover and index new blocks as they
+   * are added to the chain across time.
+   */
+  Following: "chain-following",
+  /**
+   * Represents that indexing of the chain is completed as the chain is configured
+   * to be indexed for a definite range and the indexing of all blocks through
+   * that definite range is completed.
+   */
+  Completed: "chain-completed"
+};
+var OmnichainIndexingStatusIds = {
+  /**
+   * Represents that omnichain indexing is not ready to begin yet because
+   * ENSIndexer is in its initialization phase and the data to build a "true"
+   * {@link OmnichainIndexingStatusSnapshot} is still being loaded.
+   */
+  Unstarted: "omnichain-unstarted",
+  /**
+   * Represents that omnichain indexing is in an overall "backfill" status because
+   * - At least one indexed chain has a `chainStatus` of
+   *   {@link ChainIndexingStatusIds.Backfill}; and
+   * - No indexed chain has a `chainStatus` of {@link ChainIndexingStatusIds.Following}.
+   */
+  Backfill: "omnichain-backfill",
+  /**
+   * Represents that omnichain indexing is in an overall "following" status because
+   * at least one indexed chain has a `chainStatus` of
+   * {@link ChainIndexingStatusIds.Following}.
+   */
+  Following: "omnichain-following",
+  /**
+   * Represents that omnichain indexing has completed because all indexed chains have
+   * a `chainStatus` of {@link ChainIndexingStatusIds.Completed}.
+   */
+  Completed: "omnichain-completed"
+};
+var CrossChainIndexingStrategyIds = {
+  /**
+   * Represents that the indexing of events across all indexed chains will
+   * proceed in a deterministic "omnichain" ordering by block timestamp, chain ID,
+   * and block number.
+   *
+   * This strategy is "deterministic" in that the order of processing cross-chain indexed
+   * events and each resulting indexed data state transition recorded in ENSDb is always
+   * the same for each ENSIndexer instance operating with an equivalent
+   * `ENSIndexerConfig` and ENSIndexer version. However it also has the drawbacks of:
+   * - increased indexing latency that must wait for the slowest indexed chain to
+   *   add new blocks or to discover new blocks through the configured RPCs.
+   * - if any indexed chain gets "stuck" due to chain or RPC failures, all indexed chains
+   *   will be affected.
+   */
+  Omnichain: "omnichain"
+};
+
+// src/shared/block-ref.ts
+function isBefore(blockA, blockB) {
+  return blockA.number < blockB.number && blockA.timestamp < blockB.timestamp;
+}
+function isEqualTo(blockA, blockB) {
+  return blockA.number === blockB.number && blockA.timestamp === blockB.timestamp;
+}
+function isBeforeOrEqualTo(blockA, blockB) {
+  return isBefore(blockA, blockB) || isEqualTo(blockA, blockB);
+}
+
+// src/ensindexer/indexing-status/helpers.ts
+function getOmnichainIndexingStatus(chains) {
+  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains)) {
+    return OmnichainIndexingStatusIds.Following;
+  }
+  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(chains)) {
+    return OmnichainIndexingStatusIds.Backfill;
+  }
+  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(chains)) {
+    return OmnichainIndexingStatusIds.Unstarted;
+  }
+  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(chains)) {
+    return OmnichainIndexingStatusIds.Completed;
+  }
+  throw new Error(`Unable to determine omnichain indexing status for provided chains.`);
+}
+function getTimestampForLowestOmnichainStartBlock(chains) {
+  const earliestKnownBlockTimestamps = chains.map(
+    (chain) => chain.config.startBlock.timestamp
+  );
+  return Math.min(...earliestKnownBlockTimestamps);
+}
+function getTimestampForHighestOmnichainKnownBlock(chains) {
+  const latestKnownBlockTimestamps = [];
+  for (const chain of chains) {
+    switch (chain.chainStatus) {
+      case ChainIndexingStatusIds.Queued:
+        if (chain.config.configType === ChainIndexingConfigTypeIds.Definite && chain.config.endBlock) {
+          latestKnownBlockTimestamps.push(chain.config.endBlock.timestamp);
+        }
+        break;
+      case ChainIndexingStatusIds.Backfill:
+        latestKnownBlockTimestamps.push(chain.backfillEndBlock.timestamp);
+        break;
+      case ChainIndexingStatusIds.Completed:
+        latestKnownBlockTimestamps.push(chain.latestIndexedBlock.timestamp);
+        break;
+      case ChainIndexingStatusIds.Following:
+        latestKnownBlockTimestamps.push(chain.latestKnownBlock.timestamp);
+        break;
+    }
+  }
+  return Math.max(...latestKnownBlockTimestamps);
+}
+function getOmnichainIndexingCursor(chains) {
+  if (chains.length === 0) {
+    throw new Error(`Unable to determine omnichain indexing cursor when no chains were provided.`);
+  }
+  if (getOmnichainIndexingStatus(chains) === OmnichainIndexingStatusIds.Unstarted) {
+    const earliestStartBlockTimestamps = chains.map((chain) => chain.config.startBlock.timestamp);
+    return Math.min(...earliestStartBlockTimestamps) - 1;
+  }
+  const latestIndexedBlockTimestamps = chains.filter((chain) => chain.chainStatus !== ChainIndexingStatusIds.Queued).map((chain) => chain.latestIndexedBlock.timestamp);
+  if (latestIndexedBlockTimestamps.length < 1) {
+    throw new Error("latestIndexedBlockTimestamps array must include at least one element");
+  }
+  return Math.max(...latestIndexedBlockTimestamps);
+}
+function createIndexingConfig(startBlock, endBlock) {
+  if (endBlock) {
+    return {
+      configType: ChainIndexingConfigTypeIds.Definite,
+      startBlock,
+      endBlock
+    };
+  }
+  return {
+    configType: ChainIndexingConfigTypeIds.Indefinite,
+    startBlock
+  };
+}
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(chains) {
+  return chains.every((chain) => chain.chainStatus === ChainIndexingStatusIds.Queued);
+}
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(chains) {
+  const atLeastOneChainInTargetStatus = chains.some(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill
+  );
+  const otherChainsHaveValidStatuses = chains.every(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Queued || chain.chainStatus === ChainIndexingStatusIds.Backfill || chain.chainStatus === ChainIndexingStatusIds.Completed
+  );
+  return atLeastOneChainInTargetStatus && otherChainsHaveValidStatuses;
+}
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(chains) {
+  const allChainsHaveValidStatuses = chains.every(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Completed
+  );
+  return allChainsHaveValidStatuses;
+}
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains) {
+  const allChainsHaveValidStatuses = chains.some(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Following
+  );
+  return allChainsHaveValidStatuses;
+}
+function sortChainStatusesByStartBlockAsc(chains) {
+  chains.sort(
+    ([, chainA], [, chainB]) => chainA.config.startBlock.timestamp - chainB.config.startBlock.timestamp
+  );
+  return chains;
+}
+function getLatestIndexedBlockRef(indexingStatus, chainId) {
+  const chainIndexingStatus = indexingStatus.omnichainSnapshot.chains.get(chainId);
+  if (chainIndexingStatus === void 0) {
+    return null;
+  }
+  if (chainIndexingStatus.chainStatus === ChainIndexingStatusIds.Queued) {
+    return null;
+  }
+  return chainIndexingStatus.latestIndexedBlock;
+}
+
+// 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",
+      input: ctx.value,
+      message: "`config.startBlock` must be before or same as `config.endBlock`."
+    });
+  }
+}
+function invariant_chainSnapshotBackfillBlocks(ctx) {
+  const { config, latestIndexedBlock, backfillEndBlock } = ctx.value;
+  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
+    });
+  }
+  if (isBeforeOrEqualTo(latestIndexedBlock, backfillEndBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      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",
+      input: ctx.value,
+      message: "`backfillEndBlock` must be the same as `config.endBlock`."
+    });
+  }
+}
+function invariant_chainSnapshotCompletedBlocks(ctx) {
+  const { config, latestIndexedBlock } = ctx.value;
+  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
+    });
+  }
+  if (isBeforeOrEqualTo(latestIndexedBlock, config.endBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`latestIndexedBlock` must be before or same as `config.endBlock`."
+    });
+  }
+}
+function invariant_chainSnapshotFollowingBlocks(ctx) {
+  const { config, latestIndexedBlock, latestKnownBlock } = ctx.value;
+  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
+    });
+  }
+  if (isBeforeOrEqualTo(latestIndexedBlock, latestKnownBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`latestIndexedBlock` must be before or same as `latestKnownBlock`."
+    });
+  }
+}
+function invariant_omnichainSnapshotStatusIsConsistentWithChainSnapshot(ctx) {
+  const snapshot = ctx.value;
+  const chains = Array.from(snapshot.chains.values());
+  const expectedOmnichainStatus = getOmnichainIndexingStatus(chains);
+  const actualOmnichainStatus = snapshot.omnichainStatus;
+  if (expectedOmnichainStatus !== actualOmnichainStatus) {
+    ctx.issues.push({
+      code: "custom",
+      input: snapshot,
+      message: `'${actualOmnichainStatus}' is an invalid omnichainStatus. Expected '${expectedOmnichainStatus}' based on the statuses of individual chains.`
+    });
+  }
+}
+function invariant_omnichainIndexingCursorLowerThanEarliestStartBlockAcrossQueuedChains(ctx) {
+  const snapshot = ctx.value;
+  const queuedChains = Array.from(snapshot.chains.values()).filter(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Queued
+  );
+  if (queuedChains.length === 0) {
+    return;
+  }
+  const queuedChainStartBlocks = queuedChains.map((chain) => chain.config.startBlock.timestamp);
+  const queuedChainEarliestStartBlock = Math.min(...queuedChainStartBlocks);
+  if (snapshot.omnichainIndexingCursor >= queuedChainEarliestStartBlock) {
+    ctx.issues.push({
+      code: "custom",
+      input: snapshot,
+      message: "`omnichainIndexingCursor` must be lower than the earliest start block across all queued chains."
+    });
+  }
+}
+function invariant_omnichainIndexingCursorLowerThanOrEqualToLatestBackfillEndBlockAcrossBackfillChains(ctx) {
+  const snapshot = ctx.value;
+  const backfillChains = Array.from(snapshot.chains.values()).filter(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill
+  );
+  if (backfillChains.length === 0) {
+    return;
+  }
+  const backfillEndBlocks = backfillChains.map((chain) => chain.backfillEndBlock.timestamp);
+  const highestBackfillEndBlock = Math.max(...backfillEndBlocks);
+  if (snapshot.omnichainIndexingCursor > highestBackfillEndBlock) {
+    ctx.issues.push({
+      code: "custom",
+      input: snapshot,
+      message: "`omnichainIndexingCursor` must be lower than or equal to the highest `backfillEndBlock` across all backfill chains."
+    });
+  }
+}
+function invariant_omnichainIndexingCursorIsEqualToHighestLatestIndexedBlockAcrossIndexedChain(ctx) {
+  const snapshot = ctx.value;
+  const indexedChains = Array.from(snapshot.chains.values()).filter(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill || chain.chainStatus === ChainIndexingStatusIds.Completed || chain.chainStatus === ChainIndexingStatusIds.Following
+  );
+  if (indexedChains.length === 0) {
+    return;
+  }
+  const indexedChainLatestIndexedBlocks = indexedChains.map(
+    (chain) => chain.latestIndexedBlock.timestamp
+  );
+  const indexedChainHighestLatestIndexedBlock = Math.max(...indexedChainLatestIndexedBlocks);
+  if (snapshot.omnichainIndexingCursor !== indexedChainHighestLatestIndexedBlock) {
+    ctx.issues.push({
+      code: "custom",
+      input: snapshot,
+      message: "`omnichainIndexingCursor` must be same as the highest `latestIndexedBlock` across all indexed chains."
+    });
+  }
+}
+function invariant_omnichainSnapshotUnstartedHasValidChains(ctx) {
+  const chains = ctx.value;
+  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(
+    Array.from(chains.values())
+  );
+  if (hasValidChains === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: chains,
+      message: `For omnichain status snapshot 'unstarted', all chains must have "queued" status.`
+    });
+  }
+}
+function invariant_omnichainStatusSnapshotBackfillHasValidChains(ctx) {
+  const chains = ctx.value;
+  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(
+    Array.from(chains.values())
+  );
+  if (hasValidChains === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: chains,
+      message: `For omnichain status snapshot 'backfill', at least one chain must be in "backfill" status and each chain has to have a status of either "queued", "backfill" or "completed".`
+    });
+  }
+}
+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") => z5.discriminatedUnion("configType", [
+  z5.strictObject({
+    configType: z5.literal(ChainIndexingConfigTypeIds.Indefinite),
+    startBlock: makeBlockRefSchema(valueLabel)
+  }),
+  z5.strictObject({
+    configType: z5.literal(ChainIndexingConfigTypeIds.Definite),
+    startBlock: makeBlockRefSchema(valueLabel),
+    endBlock: makeBlockRefSchema(valueLabel)
+  })
+]);
+var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => z5.strictObject({
+  chainStatus: z5.literal(ChainIndexingStatusIds.Queued),
+  config: makeChainIndexingConfigSchema(valueLabel)
+}).check(invariant_chainSnapshotQueuedBlocks);
+var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => z5.strictObject({
+  chainStatus: z5.literal(ChainIndexingStatusIds.Backfill),
+  config: makeChainIndexingConfigSchema(valueLabel),
+  latestIndexedBlock: makeBlockRefSchema(valueLabel),
+  backfillEndBlock: makeBlockRefSchema(valueLabel)
+}).check(invariant_chainSnapshotBackfillBlocks);
+var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => z5.strictObject({
+  chainStatus: z5.literal(ChainIndexingStatusIds.Completed),
+  config: z5.strictObject({
+    configType: z5.literal(ChainIndexingConfigTypeIds.Definite),
+    startBlock: makeBlockRefSchema(valueLabel),
+    endBlock: makeBlockRefSchema(valueLabel)
+  }),
+  latestIndexedBlock: makeBlockRefSchema(valueLabel)
+}).check(invariant_chainSnapshotCompletedBlocks);
+var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => z5.strictObject({
+  chainStatus: z5.literal(ChainIndexingStatusIds.Following),
+  config: z5.strictObject({
+    configType: z5.literal(ChainIndexingConfigTypeIds.Indefinite),
+    startBlock: makeBlockRefSchema(valueLabel)
+  }),
+  latestIndexedBlock: makeBlockRefSchema(valueLabel),
+  latestKnownBlock: makeBlockRefSchema(valueLabel)
+}).check(invariant_chainSnapshotFollowingBlocks);
+var makeChainIndexingStatusSnapshotSchema = (valueLabel = "Value") => z5.discriminatedUnion("chainStatus", [
+  makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
+  makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
+  makeChainIndexingStatusSnapshotCompletedSchema(valueLabel),
+  makeChainIndexingStatusSnapshotFollowingSchema(valueLabel)
+]);
+var makeChainIndexingStatusesSchema = (valueLabel = "Value") => z5.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) => z5.strictObject({
+  omnichainStatus: z5.literal(OmnichainIndexingStatusIds.Unstarted),
+  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainSnapshotUnstartedHasValidChains).transform((chains) => chains),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+});
+var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => z5.strictObject({
+  omnichainStatus: z5.literal(OmnichainIndexingStatusIds.Backfill),
+  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotBackfillHasValidChains).transform(
+    (chains) => chains
+  ),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+});
+var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => z5.strictObject({
+  omnichainStatus: z5.literal(OmnichainIndexingStatusIds.Completed),
+  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotCompletedHasValidChains).transform((chains) => chains),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+});
+var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => z5.strictObject({
+  omnichainStatus: z5.literal(OmnichainIndexingStatusIds.Following),
+  chains: makeChainIndexingStatusesSchema(valueLabel),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+});
+var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => z5.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") => z5.strictObject({
+  strategy: z5.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") => z5.discriminatedUnion("strategy", [
+  makeCrossChainIndexingStatusSnapshotOmnichainSchema(valueLabel)
+]);
+var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => z5.strictObject({
+  projectedAt: makeUnixTimestampSchema(valueLabel),
+  worstCaseDistance: makeDurationSchema(valueLabel),
+  snapshot: makeCrossChainIndexingStatusSnapshotSchema(valueLabel)
+}).check(invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime).check(invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect);
+
+// src/ensindexer/indexing-status/deserialize.ts
+function deserializeChainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
+  const schema = makeChainIndexingStatusSnapshotSchema(valueLabel);
+  const parsed = schema.safeParse(maybeSnapshot);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize into ChainIndexingStatusSnapshot:
+${prettifyError4(parsed.error)}
+`
+    );
+  }
+  return parsed.data;
+}
+function deserializeOmnichainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
+  const schema = makeOmnichainIndexingStatusSnapshotSchema(valueLabel);
+  const parsed = schema.safeParse(maybeSnapshot);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize into OmnichainIndexingStatusSnapshot:
+${prettifyError4(parsed.error)}
+`
+    );
+  }
+  return parsed.data;
+}
+function deserializeCrossChainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
+  const schema = makeCrossChainIndexingStatusSnapshotSchema(valueLabel);
+  const parsed = schema.safeParse(maybeSnapshot);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize into CrossChainIndexingStatusSnapshot:
+${prettifyError4(parsed.error)}
+`
+    );
+  }
+  return parsed.data;
+}
+function deserializeRealtimeIndexingStatusProjection(maybeProjection, valueLabel) {
+  const schema = makeRealtimeIndexingStatusProjectionSchema(valueLabel);
+  const parsed = schema.safeParse(maybeProjection);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize into RealtimeIndexingStatusProjection:
+${prettifyError4(parsed.error)}
+`
+    );
+  }
+  return parsed.data;
+}
+
+// src/ensindexer/indexing-status/projection.ts
+function createRealtimeIndexingStatusProjection(snapshot, now) {
+  const projectedAt = Math.max(now, snapshot.snapshotTime);
+  return {
+    projectedAt,
+    worstCaseDistance: projectedAt - snapshot.slowestChainIndexingCursor,
+    snapshot
+  };
+}
+
+// src/ensindexer/indexing-status/serialize.ts
+function serializeCrossChainIndexingStatusSnapshotOmnichain({
+  strategy,
+  slowestChainIndexingCursor,
+  snapshotTime,
+  omnichainSnapshot
+}) {
+  return {
+    strategy,
+    slowestChainIndexingCursor,
+    snapshotTime,
+    omnichainSnapshot: serializeOmnichainIndexingStatusSnapshot(omnichainSnapshot)
+  };
+}
+function serializeRealtimeIndexingStatusProjection(indexingProjection) {
+  return {
+    projectedAt: indexingProjection.projectedAt,
+    worstCaseDistance: indexingProjection.worstCaseDistance,
+    snapshot: serializeCrossChainIndexingStatusSnapshotOmnichain(indexingProjection.snapshot)
+  };
+}
+function serializeChainIndexingSnapshots(chains) {
+  const serializedSnapshots = {};
+  for (const [chainId, snapshot] of chains.entries()) {
+    serializedSnapshots[serializeChainId(chainId)] = snapshot;
+  }
+  return serializedSnapshots;
+}
+function serializeOmnichainIndexingStatusSnapshot(indexingStatus) {
+  switch (indexingStatus.omnichainStatus) {
+    case OmnichainIndexingStatusIds.Unstarted:
+      return {
+        omnichainStatus: OmnichainIndexingStatusIds.Unstarted,
+        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
+        omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
+      };
+    case OmnichainIndexingStatusIds.Backfill:
+      return {
+        omnichainStatus: OmnichainIndexingStatusIds.Backfill,
+        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
+        omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
+      };
+    case OmnichainIndexingStatusIds.Completed: {
+      return {
+        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/ensapi/config/serialize.ts
+function serializeENSApiPublicConfig(config) {
+  const { version, theGraphFallback, ensIndexerPublicConfig } = config;
+  return {
+    version,
+    theGraphFallback,
+    ensIndexerPublicConfig: serializeENSIndexerPublicConfig(ensIndexerPublicConfig)
+  };
+}
+
+// src/api/config/deserialize.ts
+function deserializeConfigResponse(serializedResponse) {
+  return deserializeENSApiPublicConfig(serializedResponse);
+}
+
+// src/api/config/serialize.ts
+function serializeConfigResponse(response) {
+  return serializeENSApiPublicConfig(response);
+}
+
+// src/api/indexing-status/deserialize.ts
+import { prettifyError as prettifyError5 } from "zod/v4";
+
+// src/api/indexing-status/zod-schemas.ts
+import z6 from "zod/v4";
+
+// src/api/indexing-status/response.ts
+var IndexingStatusResponseCodes = {
+  /**
+   * Represents that the indexing status is available.
+   */
+  Ok: "ok",
+  /**
+   * Represents that the indexing status is unavailable.
+   */
+  Error: "error"
+};
+
+// src/api/indexing-status/zod-schemas.ts
+var makeIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => z6.strictObject({
+  responseCode: z6.literal(IndexingStatusResponseCodes.Ok),
+  realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel)
+});
+var makeIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => z6.strictObject({
+  responseCode: z6.literal(IndexingStatusResponseCodes.Error)
+});
+var makeIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => z6.discriminatedUnion("responseCode", [
+  makeIndexingStatusResponseOkSchema(valueLabel),
+  makeIndexingStatusResponseErrorSchema(valueLabel)
+]);
+
+// src/api/indexing-status/deserialize.ts
+function deserializeIndexingStatusResponse(maybeResponse) {
+  const parsed = makeIndexingStatusResponseSchema().safeParse(maybeResponse);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize IndexingStatusResponse:
+${prettifyError5(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+
+// src/api/indexing-status/serialize.ts
+function serializeIndexingStatusResponse(response) {
+  switch (response.responseCode) {
+    case IndexingStatusResponseCodes.Ok:
+      return {
+        responseCode: response.responseCode,
+        realtimeProjection: serializeRealtimeIndexingStatusProjection(response.realtimeProjection)
+      };
+    case IndexingStatusResponseCodes.Error:
+      return response;
+  }
+}
+
+// src/api/name-tokens/deserialize.ts
+import { prettifyError as prettifyError7 } from "zod/v4";
+
+// src/api/name-tokens/zod-schemas.ts
+import { namehash as namehash2 } from "viem";
+import z9 from "zod/v4";
+
+// src/tokenscope/assets.ts
+import { AssetId as CaipAssetId2 } from "caip";
+import { isAddressEqual as isAddressEqual3, zeroAddress as zeroAddress3 } from "viem";
+import { prettifyError as prettifyError6 } from "zod/v4";
+
+// src/tokenscope/zod-schemas.ts
+import { AssetId as CaipAssetId } from "caip";
+import { zeroAddress as zeroAddress2 } from "viem";
+import z7 from "zod/v4";
+
+// src/tokenscope/name-token.ts
+import { isAddressEqual as isAddressEqual2, zeroAddress } from "viem";
+import { DatasourceNames } from "@ensnode/datasources";
+var NameTokenOwnershipTypes = {
+  /**
+   * Name Token is owned by NameWrapper account.
+   */
+  NameWrapper: "namewrapper",
+  /**
+   * Name Token is owned fully onchain.
+   *
+   * This ownership type can only apply to direct subnames of `.eth`
+   */
+  FullyOnchain: "fully-onchain",
+  /**
+   * Name Token ownership has been transferred to the null address.
+   */
+  Burned: "burned",
+  /**
+   * Name Token ownership is unknown.
+   */
+  Unknown: "unknown"
+};
+function serializeNameToken(nameToken) {
+  return {
+    token: serializeAssetId(nameToken.token),
+    ownership: nameToken.ownership,
+    mintStatus: nameToken.mintStatus
+  };
+}
+function getNameWrapperAccounts(namespaceId) {
+  const ethnamesNameWrapperAccount = getDatasourceContract(
+    namespaceId,
+    DatasourceNames.ENSRoot,
+    "NameWrapper"
+  );
+  const lineanamesNameWrapperAccount = maybeGetDatasourceContract(
+    namespaceId,
+    DatasourceNames.Lineanames,
+    "NameWrapper"
+  );
+  const nameWrapperAccounts = [
+    // NameWrapper for direct subnames of .eth is defined for all ENS namespaces
+    ethnamesNameWrapperAccount
+  ];
+  if (lineanamesNameWrapperAccount) {
+    nameWrapperAccounts.push(lineanamesNameWrapperAccount);
+  }
+  return nameWrapperAccounts;
+}
+function getNameTokenOwnership(namespaceId, name, owner) {
+  const nameWrapperAccounts = getNameWrapperAccounts(namespaceId);
+  const hasNameWrapperOwnership = nameWrapperAccounts.some(
+    (nameWrapperAccount) => accountIdEqual(owner, nameWrapperAccount)
+  );
+  if (hasNameWrapperOwnership) {
+    return {
+      ownershipType: NameTokenOwnershipTypes.NameWrapper,
+      owner
+    };
+  }
+  if (isAddressEqual2(owner.address, zeroAddress)) {
+    return {
+      ownershipType: NameTokenOwnershipTypes.Burned,
+      owner
+    };
+  }
+  const parentName = getParentNameFQDN(name);
+  if (parentName === "eth") {
+    return {
+      ownershipType: NameTokenOwnershipTypes.FullyOnchain,
+      owner
+    };
+  }
+  return {
+    ownershipType: NameTokenOwnershipTypes.Unknown,
+    owner
+  };
+}
+
+// src/tokenscope/zod-schemas.ts
+var tokenIdSchemaSerializable = z7.string();
+var tokenIdSchemaNative = z7.preprocess(
+  (v) => typeof v === "string" ? BigInt(v) : v,
+  z7.bigint().positive()
+);
+function makeTokenIdSchema(_valueLabel = "Token ID Schema", serializable = false) {
+  if (serializable) {
+    return tokenIdSchemaSerializable;
+  } else {
+    return tokenIdSchemaNative;
+  }
+}
+var makeAssetIdSchema = (valueLabel = "Asset ID Schema", serializable) => {
+  return z7.object({
+    assetNamespace: z7.enum(AssetNamespaces),
+    contract: makeAccountIdSchema(valueLabel),
+    tokenId: makeTokenIdSchema(valueLabel, serializable ?? false)
+  });
+};
+var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => z7.preprocess((v) => {
+  if (typeof v === "string") {
+    const result = new CaipAssetId(v);
+    return {
+      assetNamespace: result.assetName.namespace,
+      contract: {
+        chainId: Number(result.chainId.reference),
+        address: result.assetName.reference
+      },
+      tokenId: result.tokenId
+    };
+  }
+  return v;
+}, makeAssetIdSchema(valueLabel));
+function invariant_nameTokenOwnershipHasNonZeroAddressOwner(ctx) {
+  const ownership = ctx.value;
+  if (ctx.value.owner.address === zeroAddress2) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `Name Token Ownership with '${ownership.ownershipType}' must have 'address' other than the zero address.`
+    });
+  }
+}
+var makeNameTokenOwnershipNameWrapperSchema = (valueLabel = "Name Token Ownership NameWrapper") => z7.object({
+  ownershipType: z7.literal(NameTokenOwnershipTypes.NameWrapper),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
+var makeNameTokenOwnershipFullyOnchainSchema = (valueLabel = "Name Token Ownership Fully Onchain") => z7.object({
+  ownershipType: z7.literal(NameTokenOwnershipTypes.FullyOnchain),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
+var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => z7.object({
+  ownershipType: z7.literal(NameTokenOwnershipTypes.Burned),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasZeroAddressOwner);
+var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => z7.object({
+  ownershipType: z7.literal(NameTokenOwnershipTypes.Unknown),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
+function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
+  const ownership = ctx.value;
+  if (ctx.value.owner.address !== zeroAddress2) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `Name Token Ownership with '${ownership.ownershipType}' must have 'address' set to the zero address.`
+    });
+  }
+}
+var makeNameTokenOwnershipSchema = (valueLabel = "Name Token Ownership") => z7.discriminatedUnion("ownershipType", [
+  makeNameTokenOwnershipNameWrapperSchema(valueLabel),
+  makeNameTokenOwnershipFullyOnchainSchema(valueLabel),
+  makeNameTokenOwnershipBurnedSchema(valueLabel),
+  makeNameTokenOwnershipUnknownSchema(valueLabel)
+]);
+var makeNameTokenSchema = (valueLabel = "Name Token Schema", serializable) => z7.object({
+  token: makeAssetIdSchema(`${valueLabel}.token`, serializable),
+  ownership: makeNameTokenOwnershipSchema(`${valueLabel}.ownership`),
+  mintStatus: z7.enum(NFTMintStatuses)
+});
+
+// src/tokenscope/assets.ts
+var AssetNamespaces = {
+  ERC721: "erc721",
+  ERC1155: "erc1155"
+};
+function serializeAssetId(assetId) {
+  return {
+    assetNamespace: assetId.assetNamespace,
+    contract: assetId.contract,
+    tokenId: uint256ToHex32(assetId.tokenId)
+  };
+}
+function deserializeAssetId(maybeAssetId, valueLabel) {
+  const schema = makeAssetIdSchema(valueLabel);
+  const parsed = schema.safeParse(maybeAssetId);
+  if (parsed.error) {
+    throw new RangeError(`Cannot deserialize AssetId:
+${prettifyError6(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+function formatAssetId(assetId) {
+  const { assetNamespace, contract, tokenId } = serializeAssetId(assetId);
+  return CaipAssetId2.format({
+    chainId: { namespace: "eip155", reference: contract.chainId.toString() },
+    assetName: { namespace: assetNamespace, reference: contract.address },
+    tokenId
+  }).toLowerCase();
+}
+function parseAssetId(maybeAssetId, valueLabel) {
+  const schema = makeAssetIdStringSchema(valueLabel);
+  const parsed = schema.safeParse(maybeAssetId);
+  if (parsed.error) {
+    throw new RangeError(`Cannot parse AssetId:
+${prettifyError6(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+var buildAssetId = (contract, tokenId, assetNamespace) => {
+  return {
+    assetNamespace,
+    contract,
+    tokenId
+  };
+};
+function serializeDomainAssetId(domainAsset) {
+  return {
+    ...serializeAssetId(domainAsset),
+    domainId: domainAsset.domainId
+  };
+}
+var NFTMintStatuses = {
+  Minted: "minted",
+  Burned: "burned"
+};
+var formatNFTTransferEventMetadata = (metadata) => {
+  const serializedAssetId = serializeAssetId(metadata.nft);
+  return [
+    `Event: ${metadata.eventHandlerName}`,
+    `Chain ID: ${metadata.chainId}`,
+    `Block Number: ${metadata.blockNumber}`,
+    `Transaction Hash: ${metadata.transactionHash}`,
+    `NFT: ${serializedAssetId}`
+  ].map((line) => ` - ${line}`).join("\n");
+};
+var NFTTransferTypes = {
+  /**
+   * Initial transfer from zeroAddress to a non-zeroAddress
+   * Can happen at most once to a NFT AssetId
+   *
+   * Invariants:
+   * - NFT is not indexed and therefore has no previous mint status or owner
+   * - new NFT mint status is `minted`
+   * - new NFT owner is a non-zeroAddress
+   */
+  Mint: "mint",
+  /**
+   * Subsequent transfer from zeroAddress to a non-zeroAddress
+   * Can happen any number of times to a NFT AssetId as it passes in a cycle from
+   * mint -> burn -> remint -> burn -> remint -> ...
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous NFT mint status was `burned`
+   * - previous NFT owner is the zeroAddress
+   * - new NFT mint status is `minted`
+   * - new NFT owner is a non-zeroAddress
+   */
+  Remint: "remint",
+  /**
+   * Special transfer type for improperly implemented NFT contracts that allow a NFT
+   * that is currently minted to be reminted before an intermediate burn.
+   *
+   * Transfer from zeroAddress to non-zeroAddress for an indexed NFT where the
+   * previously indexed nft had status `minted` with a non-zeroAddress owner.
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous NFT mint status was `minted`
+   * - previous NFT owner was a non-zeroAddress
+   * - new NFT mint status is `minted`
+   * - new NFT owner is a non-zeroAddress
+   */
+  MintedRemint: "minted-remint",
+  /**
+   * Transfer from a non-zeroAddress to zeroAddress
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous NFT mint status was `minted`
+   * - previous NFT owner is a non-zeroAddress
+   * - new NFT mint status is `burned`
+   * - new NFT owner is the zeroAddress
+   */
+  Burn: "burn",
+  /**
+   * Transfer from a non-zeroAddress to a distinct non-zeroAddress
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous and new NFT mint status is `minted`
+   * - previous and new NFT owner are distinct non-zeroAddress
+   */
+  Transfer: "transfer",
+  /**
+   * Transfer from a non-zeroAddress to the same non-zeroAddress
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous and new NFT mint status is `minted`
+   * - previous and new NFT owner are equivalent non-zeroAddress
+   */
+  SelfTransfer: "self-transfer",
+  /**
+   * Transfer from zeroAddress to zeroAddress for an indexed NFT
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous and new NFT mint status is `burned`
+   * - previous and new NFT owner are zeroAddress
+   */
+  RemintBurn: "remint-burn",
+  /**
+   * Special transfer type for improperly implemented NFT contracts that allow a NFT
+   * that is currently minted to be reminted again before an intermediate burn.
+   *
+   * Transfer from zeroAddress to zeroAddress for an indexed NFT where the
+   * previously indexed nft had status `minted` with a non-zeroAddress owner.
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous NFT mint status was `minted`
+   * - previous NFT owner was a non-zeroAddress
+   * - new NFT mint status is `burned`
+   * - new NFT owner is the zeroAddress
+   */
+  MintedRemintBurn: "minted-remint-burn",
+  /**
+   * Transfer from zeroAddress to zeroAddress for an unindexed NFT
+   *
+   * Invariants:
+   * - NFT is not indexed and therefore has no previous mint status or owner
+   * - NFT should remain unindexed and without any mint status or owner
+   */
+  MintBurn: "mint-burn"
+};
+var getNFTTransferType = (from, to, allowMintedRemint, metadata, currentlyIndexedOwner) => {
+  const isIndexed = currentlyIndexedOwner !== void 0;
+  const isIndexedAsMinted = isIndexed && !isAddressEqual3(currentlyIndexedOwner, zeroAddress3);
+  const isMint = isAddressEqual3(from, zeroAddress3);
+  const isBurn = isAddressEqual3(to, zeroAddress3);
+  const isSelfTransfer = isAddressEqual3(from, to);
+  if (isIndexed && !isAddressEqual3(currentlyIndexedOwner, from)) {
+    if (isMint && allowMintedRemint) {
+    } else {
+      throw new Error(
+        `Error: Sending from ${from} conflicts with currently indexed owner ${currentlyIndexedOwner}.
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    }
+  }
+  if (isSelfTransfer) {
+    if (isMint) {
+      if (!isIndexed) {
+        return NFTTransferTypes.MintBurn;
+      } else if (!isIndexedAsMinted) {
+        return NFTTransferTypes.RemintBurn;
+      } else if (allowMintedRemint) {
+        return NFTTransferTypes.MintedRemintBurn;
+      } else {
+        throw new Error(
+          `Error: Invalid state transition from minted -> remint-burn
+${formatNFTTransferEventMetadata(metadata)}`
+        );
+      }
+    } else {
+      if (!isIndexed) {
+        throw new Error(
+          `Error: Invalid state transition from unindexed -> self-transfer
+${formatNFTTransferEventMetadata(metadata)}`
+        );
+      } else if (!isIndexedAsMinted) {
+        throw new Error(
+          `Error: invalid state transition from burned -> self-transfer
+${formatNFTTransferEventMetadata(metadata)}`
+        );
+      } else {
+        return NFTTransferTypes.SelfTransfer;
+      }
+    }
+  } else if (isMint) {
+    if (!isIndexed) {
+      return NFTTransferTypes.Mint;
+    } else if (!isIndexedAsMinted) {
+      return NFTTransferTypes.Remint;
+    } else if (allowMintedRemint) {
+      return NFTTransferTypes.MintedRemint;
+    } else {
+      throw new Error(
+        `Error: Invalid state transition from minted -> mint
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    }
+  } else if (isBurn) {
+    if (!isIndexed) {
+      throw new Error(
+        `Error: Invalid state transition from unindexed -> burn
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    } else if (!isIndexedAsMinted) {
+      throw new Error(
+        `Error: Invalid state transition from burned -> burn
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    } else {
+      return NFTTransferTypes.Burn;
+    }
+  } else {
+    if (!isIndexed) {
+      throw new Error(
+        `Error: Invalid state transition from unindexed -> transfer
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    } else if (!isIndexedAsMinted) {
+      throw new Error(
+        `Error: Invalid state transition from burned -> transfer
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    } else {
+      return NFTTransferTypes.Transfer;
+    }
+  }
+};
+
+// src/api/shared/errors/zod-schemas.ts
+import z8 from "zod/v4";
+var ErrorResponseSchema = z8.object({
+  message: z8.string(),
+  details: z8.optional(z8.unknown())
+});
+
+// src/api/name-tokens/response.ts
+var NameTokensResponseCodes = {
+  /**
+   * Represents a response when Name Tokens API can respond with requested data.
+   */
+  Ok: "ok",
+  /**
+   * Represents a response when Name Tokens API could not respond with requested data.
+   */
+  Error: "error"
+};
+var NameTokensResponseErrorCodes = {
+  /**
+   * Name tokens not indexed
+   *
+   * Represents an error when tokens for the requested name are not indexed by
+   * the ENSNode instance's configuration.
+   */
+  NameTokensNotIndexed: "name-tokens-not-indexed",
+  /**
+   * Unsupported ENSIndexer Config
+   *
+   * Represents a prerequisites error when connected ENSIndexer config lacks
+   * params required to enable Name Tokens API.
+   */
+  EnsIndexerConfigUnsupported: "unsupported-ensindexer-config",
+  /**
+   * Unsupported Indexing Status
+   *
+   * Represents a prerequisites error when Indexing Status has not yet reached
+   * status required to enable Name Tokens API.
+   */
+  IndexingStatusUnsupported: "unsupported-indexing-status"
+};
+
+// src/api/name-tokens/zod-schemas.ts
+var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", serializable) => z9.object({
+  domainId: makeNodeSchema(`${valueLabel}.domainId`),
+  name: makeReinterpretedNameSchema(valueLabel),
+  tokens: z9.array(makeNameTokenSchema(`${valueLabel}.tokens`, serializable)).nonempty(),
+  expiresAt: makeUnixTimestampSchema(`${valueLabel}.expiresAt`),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
+}).check(function invariant_nameIsAssociatedWithDomainId(ctx) {
+  const { name, domainId } = ctx.value;
+  if (namehash2(name) !== domainId) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `'name' must be associated with 'domainId': ${domainId}`
+    });
+  }
+}).check(
+  function invariant_nameTokensOwnershipTypeNameWrapperRequiresOwnershipTypeFullyOnchainOrUnknown(ctx) {
+    const { tokens } = ctx.value;
+    const containsOwnershipNameWrapper = tokens.some(
+      (t) => t.ownership.ownershipType === NameTokenOwnershipTypes.NameWrapper
+    );
+    const containsOwnershipFullyOnchainOrUnknown = tokens.some(
+      (t) => t.ownership.ownershipType === NameTokenOwnershipTypes.FullyOnchain || t.ownership.ownershipType === NameTokenOwnershipTypes.Unknown
+    );
+    if (containsOwnershipNameWrapper && !containsOwnershipFullyOnchainOrUnknown) {
+      ctx.issues.push({
+        code: "custom",
+        input: ctx.value,
+        message: `'tokens' must contain name token with ownership type 'fully-onchain' or 'unknown' when name token with ownership type 'namewrapper' in listed`
+      });
+    }
+  }
+).check(function invariant_nameTokensContainAtMostOneWithOwnershipTypeEffective(ctx) {
+  const { tokens } = ctx.value;
+  const tokensCountWithOwnershipFullyOnchain = tokens.filter(
+    (t) => t.ownership.ownershipType === NameTokenOwnershipTypes.FullyOnchain
+  ).length;
+  if (tokensCountWithOwnershipFullyOnchain > 1) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `'tokens' must contain at most one name token with ownership type 'fully-onchain', current count: ${tokensCountWithOwnershipFullyOnchain}`
+    });
+  }
+});
+var makeNameTokensResponseOkSchema = (valueLabel = "Name Tokens Response OK", serializable) => z9.strictObject({
+  responseCode: z9.literal(NameTokensResponseCodes.Ok),
+  registeredNameTokens: makeRegisteredNameTokenSchema(`${valueLabel}.nameTokens`, serializable)
+});
+var makeNameTokensResponseErrorNameTokensNotIndexedSchema = (_valueLabel = "Name Tokens Response Error Name Not Indexed") => z9.strictObject({
+  responseCode: z9.literal(NameTokensResponseCodes.Error),
+  errorCode: z9.literal(NameTokensResponseErrorCodes.NameTokensNotIndexed),
+  error: ErrorResponseSchema
+});
+var makeNameTokensResponseErrorEnsIndexerConfigUnsupported = (_valueLabel = "Name Tokens Response Error ENSIndexer Config Unsupported") => z9.strictObject({
+  responseCode: z9.literal(NameTokensResponseCodes.Error),
+  errorCode: z9.literal(NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported),
+  error: ErrorResponseSchema
+});
+var makeNameTokensResponseErrorNameIndexingStatusUnsupported = (_valueLabel = "Name Tokens Response Error Indexing Status Unsupported") => z9.strictObject({
+  responseCode: z9.literal(NameTokensResponseCodes.Error),
+  errorCode: z9.literal(NameTokensResponseErrorCodes.IndexingStatusUnsupported),
+  error: ErrorResponseSchema
+});
+var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => z9.discriminatedUnion("errorCode", [
+  makeNameTokensResponseErrorNameTokensNotIndexedSchema(valueLabel),
+  makeNameTokensResponseErrorEnsIndexerConfigUnsupported(valueLabel),
+  makeNameTokensResponseErrorNameIndexingStatusUnsupported(valueLabel)
+]);
+var makeNameTokensResponseSchema = (valueLabel = "Name Tokens Response", serializable) => {
+  return z9.discriminatedUnion("responseCode", [
+    makeNameTokensResponseOkSchema(valueLabel, serializable ?? false),
+    makeNameTokensResponseErrorSchema(valueLabel)
+  ]);
+};
+
+// src/api/name-tokens/deserialize.ts
+function deserializedNameTokensResponse(maybeResponse) {
+  const parsed = makeNameTokensResponseSchema("Name Tokens Response", false).safeParse(
+    maybeResponse
+  );
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize NameTokensResponse:
+${prettifyError7(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+
+// src/api/name-tokens/prerequisites.ts
+var nameTokensPrerequisites = Object.freeze({
+  /**
+   * Required plugins to enable Name Tokens API routes.
+   *
+   * 1. `registrars` plugin is required so that data in the `registrationLifecycles`
+   *    table is populated.
+   * 2. `tokenscope` plugin is required so that data in the `nameTokens`
+   *    table is populated.
+   */
+  requiredPlugins: ["registrars" /* Registrars */, "tokenscope" /* TokenScope */],
+  /**
+   * Check if provided ENSApiPublicConfig supports the Name Tokens API.
+   */
+  hasEnsIndexerConfigSupport(config) {
+    return nameTokensPrerequisites.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 Name Tokens API.
+   */
+  hasIndexingStatusSupport(omnichainIndexingStatusId) {
+    return nameTokensPrerequisites.supportedIndexingStatusIds.some(
+      (supportedIndexingStatusId) => supportedIndexingStatusId === omnichainIndexingStatusId
+    );
+  }
+});
+
+// src/api/name-tokens/serialize.ts
+function serializeRegisteredNameTokens({
+  domainId,
+  name,
+  tokens,
+  expiresAt,
+  accurateAsOf
+}) {
+  return {
+    domainId,
+    name,
+    tokens: tokens.map(serializeNameToken),
+    expiresAt,
+    accurateAsOf
+  };
+}
+function serializeNameTokensResponse(response) {
+  switch (response.responseCode) {
+    case NameTokensResponseCodes.Ok:
+      return {
+        responseCode: response.responseCode,
+        registeredNameTokens: serializeRegisteredNameTokens(response.registeredNameTokens)
+      };
+    case NameTokensResponseCodes.Error:
+      return response;
+  }
+}
+
+// src/api/registrar-actions/deserialize.ts
+import { prettifyError as prettifyError8 } from "zod/v4";
+
+// src/api/registrar-actions/zod-schemas.ts
+import { namehash as namehash3 } from "viem/ens";
+import z12 from "zod/v4";
+
+// ../ens-referrals/src/address.ts
+import { isAddress as isAddress3 } from "viem";
+
+// ../ens-referrals/src/encoding.ts
+import { getAddress, pad, size as size2, slice, zeroAddress as zeroAddress4 } from "viem";
+var ENCODED_REFERRER_BYTE_OFFSET = 12;
+var ENCODED_REFERRER_BYTE_LENGTH = 32;
+var EXPECTED_ENCODED_REFERRER_PADDING = pad("0x", {
+  size: ENCODED_REFERRER_BYTE_OFFSET,
+  dir: "left"
+});
+var ZERO_ENCODED_REFERRER = pad("0x", {
+  size: ENCODED_REFERRER_BYTE_LENGTH,
+  dir: "left"
+});
+function decodeEncodedReferrer(encodedReferrer) {
+  if (size2(encodedReferrer) !== ENCODED_REFERRER_BYTE_LENGTH) {
+    throw new Error(
+      `Encoded referrer value must be represented by ${ENCODED_REFERRER_BYTE_LENGTH} bytes.`
+    );
+  }
+  const padding = slice(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
+  if (padding !== EXPECTED_ENCODED_REFERRER_PADDING) {
+    return zeroAddress4;
+  }
+  const decodedReferrer = slice(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
+  try {
+    return getAddress(decodedReferrer);
+  } catch {
+    throw new Error(`Decoded referrer value must be a valid EVM address.`);
+  }
+}
+
+// ../ens-referrals/src/leaderboard-page.ts
+var REFERRERS_PER_LEADERBOARD_PAGE_MAX = 100;
+
+// ../ens-referrals/src/link.ts
+import { getAddress as getAddress2 } from "viem";
+
+// ../ens-referrals/src/referrer-detail.ts
+var ReferrerDetailTypeIds = {
+  /**
+   * Represents a referrer who is ranked on the leaderboard.
+   */
+  Ranked: "ranked",
+  /**
+   * Represents a referrer who is not ranked on the leaderboard.
+   */
+  Unranked: "unranked"
+};
+
+// src/registrars/zod-schemas.ts
+import z10 from "zod/v4";
+
+// 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: 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") => z10.object({
+  subregistryId: makeAccountIdSchema(`${valueLabel} Subregistry ID`),
+  node: makeNodeSchema(`${valueLabel} Node`)
+});
+var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => z10.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") => z10.union([
+  // pricing available
+  z10.object({
+    baseCost: makePriceEthSchema(`${valueLabel} Base Cost`),
+    premium: makePriceEthSchema(`${valueLabel} Premium`),
+    total: makePriceEthSchema(`${valueLabel} Total`)
+  }).check(invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium).transform((v) => v),
+  // pricing unknown
+  z10.object({
+    baseCost: z10.null(),
+    premium: z10.null(),
+    total: z10.null()
+  }).transform((v) => v)
+]);
+function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
+  const { encodedReferrer, decodedReferrer } = ctx.value;
+  try {
+    const expectedDecodedReferrer = decodeEncodedReferrer(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") => z10.union([
+  // referral available
+  z10.object({
+    encodedReferrer: makeHexStringSchema(
+      { bytesCount: ENCODED_REFERRER_BYTE_LENGTH },
+      `${valueLabel} Encoded Referrer`
+    ),
+    decodedReferrer: makeLowercaseAddressSchema(`${valueLabel} Decoded Referrer`)
+  }).check(invariant_registrarActionDecodedReferrerBasedOnRawReferrer),
+  // referral not applicable
+  z10.object({
+    encodedReferrer: z10.null(),
+    decodedReferrer: z10.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 = z10.string().nonempty();
+var EventIdsSchema = z10.array(EventIdSchema).min(1).transform((v) => v);
+var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => z10.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: z10.literal(RegistrarActionTypes.Registration)
+});
+var makeRegistrarActionRenewalSchema = (valueLabel = "Renewal") => makeBaseRegistrarActionSchema(valueLabel).extend({
+  type: z10.literal(RegistrarActionTypes.Renewal)
+});
+var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => z10.discriminatedUnion("type", [
+  makeRegistrarActionRegistrationSchema(`${valueLabel} Registration`),
+  makeRegistrarActionRenewalSchema(`${valueLabel} Renewal`)
+]);
+
+// src/api/shared/pagination/zod-schemas.ts
+import z11 from "zod/v4";
+
+// src/api/shared/pagination/request.ts
+var RECORDS_PER_PAGE_DEFAULT = 10;
+var RECORDS_PER_PAGE_MAX = 100;
+
+// src/api/shared/pagination/zod-schemas.ts
+var makeRequestPageParamsSchema = (valueLabel = "RequestPageParams") => z11.object({
+  page: makePositiveIntegerSchema(`${valueLabel}.page`),
+  recordsPerPage: makePositiveIntegerSchema(`${valueLabel}.recordsPerPage`).max(
+    RECORDS_PER_PAGE_MAX,
+    `${valueLabel}.recordsPerPage must not exceed ${RECORDS_PER_PAGE_MAX}`
+  )
+});
+var makeResponsePageContextSchemaWithNoRecords = (valueLabel = "ResponsePageContextWithNoRecords") => z11.object({
+  totalRecords: z11.literal(0),
+  totalPages: z11.literal(1),
+  hasNext: z11.literal(false),
+  hasPrev: z11.literal(false),
+  startIndex: z11.undefined(),
+  endIndex: z11.undefined()
+}).extend(makeRequestPageParamsSchema(valueLabel).shape);
+function invariant_responsePageWithRecordsIsCorrect(ctx) {
+  const { hasNext, hasPrev, recordsPerPage, page, totalRecords, startIndex, endIndex } = ctx.value;
+  const expectedHasNext = page * recordsPerPage < totalRecords;
+  if (hasNext !== expectedHasNext) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `hasNext must be equal to '${expectedHasNext ? "true" : "false"}'`
+    });
+  }
+  const expectedHasPrev = page > 1;
+  if (hasPrev !== expectedHasPrev) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `hasPrev must be equal to '${expectedHasPrev ? "true" : "false"}'`
+    });
+  }
+  if (endIndex < startIndex) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `endIndex must be greater than or equal to startIndex`
+    });
+  }
+  if (endIndex >= totalRecords) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `endIndex must be lower than totalRecords`
+    });
+  }
+}
+var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => z11.object({
+  totalRecords: makePositiveIntegerSchema(`${valueLabel}.totalRecords`),
+  totalPages: makePositiveIntegerSchema(`${valueLabel}.totalPages`),
+  hasNext: z11.boolean(),
+  hasPrev: z11.boolean(),
+  startIndex: makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`),
+  endIndex: makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`)
+}).extend(makeRequestPageParamsSchema(valueLabel).shape).check(invariant_responsePageWithRecordsIsCorrect);
+var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => z11.union([
+  makeResponsePageContextSchemaWithNoRecords(valueLabel),
+  makeResponsePageContextSchemaWithRecords(valueLabel)
+]);
+
+// src/api/registrar-actions/response.ts
+var RegistrarActionsResponseCodes = {
+  /**
+   * Represents that Registrar Actions are available.
+   */
+  Ok: "ok",
+  /**
+   * Represents that Registrar Actions are unavailable.
+   */
+  Error: "error"
+};
+
+// src/api/registrar-actions/zod-schemas.ts
+function invariant_registrationLifecycleNodeMatchesName(ctx) {
+  const { name, action } = ctx.value;
+  const expectedNode = action.registrationLifecycle.node;
+  const actualNode = namehash3(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") => z12.object({
+  action: makeRegistrarActionSchema(valueLabel),
+  name: makeReinterpretedNameSchema(valueLabel)
+}).check(invariant_registrationLifecycleNodeMatchesName);
+var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => z12.strictObject({
+  responseCode: z12.literal(RegistrarActionsResponseCodes.Ok),
+  registrarActions: z12.array(makeNamedRegistrarActionSchema(valueLabel)),
+  pageContext: makeResponsePageContextSchema(`${valueLabel}.pageContext`)
+});
+var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => z12.strictObject({
+  responseCode: z12.literal(RegistrarActionsResponseCodes.Error),
+  error: ErrorResponseSchema
+});
+var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => z12.discriminatedUnion("responseCode", [
+  makeRegistrarActionsResponseOkSchema(valueLabel),
+  makeRegistrarActionsResponseErrorSchema(valueLabel)
+]);
+
+// src/api/registrar-actions/deserialize.ts
+function deserializeRegistrarActionsResponse(maybeResponse) {
+  const parsed = makeRegistrarActionsResponseSchema().safeParse(maybeResponse);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize RegistrarActionsResponse:
+${prettifyError8(parsed.error)}
+`
+    );
+  }
+  return parsed.data;
+}
+
+// src/api/registrar-actions/request.ts
+var RegistrarActionsFilterTypes = {
+  BySubregistryNode: "bySubregistryNode",
+  WithEncodedReferral: "withEncodedReferral",
+  ByDecodedReferrer: "byDecodedReferrer",
+  BeginTimestamp: "beginTimestamp",
+  EndTimestamp: "endTimestamp"
+};
+var RegistrarActionsOrders = {
+  LatestRegistrarActions: "orderBy[timestamp]=desc"
+};
+
+// 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
+  };
+}
+function byDecodedReferrer(decodedReferrer) {
+  if (typeof decodedReferrer === "undefined") {
+    return void 0;
+  }
+  return {
+    filterType: RegistrarActionsFilterTypes.ByDecodedReferrer,
+    value: decodedReferrer
+  };
+}
+function beginTimestamp(timestamp) {
+  if (typeof timestamp === "undefined") {
+    return void 0;
+  }
+  return {
+    filterType: RegistrarActionsFilterTypes.BeginTimestamp,
+    value: timestamp
+  };
+}
+function endTimestamp(timestamp) {
+  if (typeof timestamp === "undefined") {
+    return void 0;
+  }
+  return {
+    filterType: RegistrarActionsFilterTypes.EndTimestamp,
+    value: timestamp
+  };
+}
+var registrarActionsFilter = {
+  byParentNode,
+  withReferral,
+  byDecodedReferrer,
+  beginTimestamp,
+  endTimestamp
+};
+
+// src/api/registrar-actions/prerequisites.ts
+var registrarActionsPrerequisites = Object.freeze({
+  /**
+   * 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.
+   */
+  requiredPlugins: [
+    "subgraph" /* Subgraph */,
+    "basenames" /* Basenames */,
+    "lineanames" /* Lineanames */,
+    "registrars" /* Registrars */
+  ],
+  /**
+   * Check if provided ENSApiPublicConfig supports the Registrar Actions API.
+   */
+  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
+    );
+  }
+});
+
+// src/registrars/basenames-subregistry.ts
+import {
+  DatasourceNames as DatasourceNames2,
+  ENSNamespaceIds as ENSNamespaceIds3,
+  maybeGetDatasource as maybeGetDatasource2
+} from "@ensnode/datasources";
+function getBasenamesSubregistryId(namespace) {
+  const datasource = maybeGetDatasource2(namespace, DatasourceNames2.Basenames);
+  if (!datasource) {
+    throw new Error(`Datasource not found for ${namespace} ${DatasourceNames2.Basenames}`);
+  }
+  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 {
+    chainId: datasource.chain.id,
+    address
+  };
+}
+function getBasenamesSubregistryManagedName(namespaceId) {
+  switch (namespaceId) {
+    case ENSNamespaceIds3.Mainnet:
+      return "base.eth";
+    case ENSNamespaceIds3.Sepolia:
+      return "basetest.eth";
+    case ENSNamespaceIds3.Holesky:
+    case ENSNamespaceIds3.EnsTestEnv:
+      throw new Error(
+        `No registrar managed name is known for the 'basenames' subregistry within the "${namespaceId}" namespace.`
+      );
+  }
+}
+
+// src/registrars/ethnames-subregistry.ts
+import {
+  DatasourceNames as DatasourceNames3,
+  ENSNamespaceIds as ENSNamespaceIds4,
+  maybeGetDatasource as maybeGetDatasource3
+} from "@ensnode/datasources";
+function getEthnamesSubregistryId(namespace) {
+  const datasource = maybeGetDatasource3(namespace, DatasourceNames3.ENSRoot);
+  if (!datasource) {
+    throw new Error(`Datasource not found for ${namespace} ${DatasourceNames3.ENSRoot}`);
+  }
+  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 {
+    chainId: datasource.chain.id,
+    address
+  };
+}
+function getEthnamesSubregistryManagedName(namespaceId) {
+  switch (namespaceId) {
+    case ENSNamespaceIds4.Mainnet:
+    case ENSNamespaceIds4.Sepolia:
+    case ENSNamespaceIds4.Holesky:
+    case ENSNamespaceIds4.EnsTestEnv:
+      return "eth";
+  }
+}
+
+// src/registrars/lineanames-subregistry.ts
+import {
+  DatasourceNames as DatasourceNames4,
+  ENSNamespaceIds as ENSNamespaceIds5,
+  maybeGetDatasource as maybeGetDatasource4
+} from "@ensnode/datasources";
+function getLineanamesSubregistryId(namespace) {
+  const datasource = maybeGetDatasource4(namespace, DatasourceNames4.Lineanames);
+  if (!datasource) {
+    throw new Error(`Datasource not found for ${namespace} ${DatasourceNames4.Lineanames}`);
+  }
+  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 {
+    chainId: datasource.chain.id,
+    address
+  };
+}
+function getLineanamesSubregistryManagedName(namespaceId) {
+  switch (namespaceId) {
+    case ENSNamespaceIds5.Mainnet:
+      return "linea.eth";
+    case ENSNamespaceIds5.Sepolia:
+      return "linea-sepolia.eth";
+    case ENSNamespaceIds5.Holesky:
+    case ENSNamespaceIds5.EnsTestEnv:
+      throw new Error(
+        `No registrar managed name is known for the 'Lineanames' subregistry within the "${namespaceId}" namespace.`
+      );
+  }
+}
+
+// src/api/registrar-actions/serialize.ts
+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),
+        pageContext: response.pageContext
+      };
+    case RegistrarActionsResponseCodes.Error:
+      return response;
+  }
+}
+
+// src/api/shared/errors/deserialize.ts
+import { prettifyError as prettifyError9 } from "zod/v4";
+function deserializeErrorResponse(maybeErrorResponse) {
+  const parsed = ErrorResponseSchema.safeParse(maybeErrorResponse);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize ErrorResponse:
+${prettifyError9(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+
+// src/api/shared/pagination/build-page-context.ts
+function buildPageContext(page, recordsPerPage, totalRecords) {
+  const totalPages = Math.max(1, Math.ceil(totalRecords / recordsPerPage));
+  if (page > totalPages) {
+    throw new Error(`Invalid page: page ${page} exceeds total pages ${totalPages}.`);
+  }
+  if (totalRecords === 0) {
+    return {
+      page,
+      recordsPerPage,
+      totalRecords: 0,
+      totalPages: 1,
+      hasNext: false,
+      hasPrev: false,
+      startIndex: void 0,
+      endIndex: void 0
+    };
+  }
+  const startIndex = (page - 1) * recordsPerPage;
+  const maxTheoreticalIndexOnPage = startIndex + (recordsPerPage - 1);
+  const endIndex = Math.min(maxTheoreticalIndexOnPage, totalRecords - 1);
+  const hasNext = maxTheoreticalIndexOnPage < totalRecords - 1;
+  const hasPrev = page > 1;
+  return {
+    page,
+    recordsPerPage,
+    totalRecords,
+    totalPages,
+    hasNext,
+    hasPrev,
+    startIndex,
+    endIndex
+  };
+}
+
+// src/client-error.ts
+var ClientError = class _ClientError extends Error {
+  details;
+  constructor(message, details) {
+    super(message);
+    this.name = "ClientError";
+    this.details = details;
+  }
+  static fromErrorResponse({ message, details }) {
+    return new _ClientError(message, details);
+  }
+};
+
+// src/ensanalytics/deserialize.ts
+import { prettifyError as prettifyError10 } from "zod/v4";
+
+// src/ensanalytics/zod-schemas.ts
+import z13 from "zod/v4";
+
+// src/ensanalytics/types.ts
+var ReferrerLeaderboardPageResponseCodes = {
+  /**
+   * Represents that the requested referrer leaderboard page is available.
+   */
+  Ok: "ok",
+  /**
+   * Represents that the referrer leaderboard data is not available.
+   */
+  Error: "error"
+};
+var ReferrerDetailResponseCodes = {
+  /**
+   * Represents that the referrer detail data is available.
+   */
+  Ok: "ok",
+  /**
+   * Represents that an error occurred while fetching the data.
+   */
+  Error: "error"
+};
+
+// src/ensanalytics/zod-schemas.ts
+var makeRevenueContributionSchema = (valueLabel = "RevenueContribution") => z13.coerce.bigint({
+  error: `${valueLabel} must represent a bigint.`
+}).nonnegative({
+  error: `${valueLabel} must not be negative.`
+});
+var makeReferralProgramRulesSchema = (valueLabel = "ReferralProgramRules") => z13.object({
+  totalAwardPoolValue: makeFiniteNonNegativeNumberSchema(`${valueLabel}.totalAwardPoolValue`),
+  maxQualifiedReferrers: makeNonNegativeIntegerSchema(`${valueLabel}.maxQualifiedReferrers`),
+  startTime: makeUnixTimestampSchema(`${valueLabel}.startTime`),
+  endTime: makeUnixTimestampSchema(`${valueLabel}.endTime`),
+  subregistryId: makeAccountIdSchema(`${valueLabel}.subregistryId`)
+});
+var makeAwardedReferrerMetricsSchema = (valueLabel = "AwardedReferrerMetrics") => z13.object({
+  referrer: makeLowercaseAddressSchema(`${valueLabel}.referrer`),
+  totalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.totalReferrals`),
+  totalIncrementalDuration: makeDurationSchema(`${valueLabel}.totalIncrementalDuration`),
+  totalRevenueContribution: makeRevenueContributionSchema(
+    `${valueLabel}.totalRevenueContribution`
+  ),
+  score: makeFiniteNonNegativeNumberSchema(`${valueLabel}.score`),
+  rank: makePositiveIntegerSchema(`${valueLabel}.rank`),
+  isQualified: z13.boolean(),
+  finalScoreBoost: makeFiniteNonNegativeNumberSchema(`${valueLabel}.finalScoreBoost`).max(
+    1,
+    `${valueLabel}.finalScoreBoost must be <= 1`
+  ),
+  finalScore: makeFiniteNonNegativeNumberSchema(`${valueLabel}.finalScore`),
+  awardPoolShare: makeFiniteNonNegativeNumberSchema(`${valueLabel}.awardPoolShare`).max(
+    1,
+    `${valueLabel}.awardPoolShare must be <= 1`
+  ),
+  awardPoolApproxValue: makeFiniteNonNegativeNumberSchema(`${valueLabel}.awardPoolApproxValue`)
+});
+var makeUnrankedReferrerMetricsSchema = (valueLabel = "UnrankedReferrerMetrics") => z13.object({
+  referrer: makeLowercaseAddressSchema(`${valueLabel}.referrer`),
+  totalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.totalReferrals`),
+  totalIncrementalDuration: makeDurationSchema(`${valueLabel}.totalIncrementalDuration`),
+  totalRevenueContribution: makeRevenueContributionSchema(
+    `${valueLabel}.totalRevenueContribution`
+  ),
+  score: makeFiniteNonNegativeNumberSchema(`${valueLabel}.score`),
+  rank: z13.null(),
+  isQualified: z13.literal(false),
+  finalScoreBoost: makeFiniteNonNegativeNumberSchema(`${valueLabel}.finalScoreBoost`).max(
+    1,
+    `${valueLabel}.finalScoreBoost must be <= 1`
+  ),
+  finalScore: makeFiniteNonNegativeNumberSchema(`${valueLabel}.finalScore`),
+  awardPoolShare: makeFiniteNonNegativeNumberSchema(`${valueLabel}.awardPoolShare`).max(
+    1,
+    `${valueLabel}.awardPoolShare must be <= 1`
+  ),
+  awardPoolApproxValue: makeFiniteNonNegativeNumberSchema(`${valueLabel}.awardPoolApproxValue`)
+});
+var makeAggregatedReferrerMetricsSchema = (valueLabel = "AggregatedReferrerMetrics") => z13.object({
+  grandTotalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.grandTotalReferrals`),
+  grandTotalIncrementalDuration: makeDurationSchema(
+    `${valueLabel}.grandTotalIncrementalDuration`
+  ),
+  grandTotalRevenueContribution: makeRevenueContributionSchema(
+    `${valueLabel}.grandTotalRevenueContribution`
+  ),
+  grandTotalQualifiedReferrersFinalScore: makeFiniteNonNegativeNumberSchema(
+    `${valueLabel}.grandTotalQualifiedReferrersFinalScore`
+  ),
+  minFinalScoreToQualify: makeFiniteNonNegativeNumberSchema(
+    `${valueLabel}.minFinalScoreToQualify`
+  )
+});
+var makeReferrerLeaderboardPageContextSchema = (valueLabel = "ReferrerLeaderboardPageContext") => z13.object({
+  page: makePositiveIntegerSchema(`${valueLabel}.page`),
+  recordsPerPage: makePositiveIntegerSchema(`${valueLabel}.recordsPerPage`).max(
+    REFERRERS_PER_LEADERBOARD_PAGE_MAX,
+    `${valueLabel}.recordsPerPage must not exceed ${REFERRERS_PER_LEADERBOARD_PAGE_MAX}`
+  ),
+  totalRecords: makeNonNegativeIntegerSchema(`${valueLabel}.totalRecords`),
+  totalPages: makePositiveIntegerSchema(`${valueLabel}.totalPages`),
+  hasNext: z13.boolean(),
+  hasPrev: z13.boolean(),
+  startIndex: z13.optional(makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`)),
+  endIndex: z13.optional(makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`))
+});
+var makeReferrerLeaderboardPageSchema = (valueLabel = "ReferrerLeaderboardPage") => z13.object({
+  rules: makeReferralProgramRulesSchema(`${valueLabel}.rules`),
+  referrers: z13.array(makeAwardedReferrerMetricsSchema(`${valueLabel}.referrers[record]`)),
+  aggregatedMetrics: makeAggregatedReferrerMetricsSchema(`${valueLabel}.aggregatedMetrics`),
+  pageContext: makeReferrerLeaderboardPageContextSchema(`${valueLabel}.pageContext`),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
+});
+var makeReferrerLeaderboardPageResponseOkSchema = (valueLabel = "ReferrerLeaderboardPageResponseOk") => z13.object({
+  responseCode: z13.literal(ReferrerLeaderboardPageResponseCodes.Ok),
+  data: makeReferrerLeaderboardPageSchema(`${valueLabel}.data`)
+});
+var makeReferrerLeaderboardPageResponseErrorSchema = (_valueLabel = "ReferrerLeaderboardPageResponseError") => z13.object({
+  responseCode: z13.literal(ReferrerLeaderboardPageResponseCodes.Error),
+  error: z13.string(),
+  errorMessage: z13.string()
+});
+var makeReferrerLeaderboardPageResponseSchema = (valueLabel = "ReferrerLeaderboardPageResponse") => z13.union([
+  makeReferrerLeaderboardPageResponseOkSchema(valueLabel),
+  makeReferrerLeaderboardPageResponseErrorSchema(valueLabel)
+]);
+var makeReferrerDetailRankedSchema = (valueLabel = "ReferrerDetailRanked") => z13.object({
+  type: z13.literal(ReferrerDetailTypeIds.Ranked),
+  rules: makeReferralProgramRulesSchema(`${valueLabel}.rules`),
+  referrer: makeAwardedReferrerMetricsSchema(`${valueLabel}.referrer`),
+  aggregatedMetrics: makeAggregatedReferrerMetricsSchema(`${valueLabel}.aggregatedMetrics`),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
+});
+var makeReferrerDetailUnrankedSchema = (valueLabel = "ReferrerDetailUnranked") => z13.object({
+  type: z13.literal(ReferrerDetailTypeIds.Unranked),
+  rules: makeReferralProgramRulesSchema(`${valueLabel}.rules`),
+  referrer: makeUnrankedReferrerMetricsSchema(`${valueLabel}.referrer`),
+  aggregatedMetrics: makeAggregatedReferrerMetricsSchema(`${valueLabel}.aggregatedMetrics`),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
+});
+var makeReferrerDetailResponseOkSchema = (valueLabel = "ReferrerDetailResponse") => z13.object({
+  responseCode: z13.literal(ReferrerDetailResponseCodes.Ok),
+  data: z13.union([
+    makeReferrerDetailRankedSchema(`${valueLabel}.data`),
+    makeReferrerDetailUnrankedSchema(`${valueLabel}.data`)
+  ])
+});
+var makeReferrerDetailResponseErrorSchema = (_valueLabel = "ReferrerDetailResponse") => z13.object({
+  responseCode: z13.literal(ReferrerDetailResponseCodes.Error),
+  error: z13.string(),
+  errorMessage: z13.string()
+});
+var makeReferrerDetailResponseSchema = (valueLabel = "ReferrerDetailResponse") => z13.union([
+  makeReferrerDetailResponseOkSchema(valueLabel),
+  makeReferrerDetailResponseErrorSchema(valueLabel)
+]);
+
+// src/ensanalytics/deserialize.ts
+function deserializeRevenueContribution(value) {
+  return BigInt(value);
+}
+function deserializeReferralProgramRules(rules) {
+  return rules;
+}
+function deserializeAwardedReferrerMetrics(metrics) {
+  return {
+    referrer: metrics.referrer,
+    totalReferrals: metrics.totalReferrals,
+    totalIncrementalDuration: metrics.totalIncrementalDuration,
+    totalRevenueContribution: deserializeRevenueContribution(metrics.totalRevenueContribution),
+    score: metrics.score,
+    rank: metrics.rank,
+    isQualified: metrics.isQualified,
+    finalScoreBoost: metrics.finalScoreBoost,
+    finalScore: metrics.finalScore,
+    awardPoolShare: metrics.awardPoolShare,
+    awardPoolApproxValue: metrics.awardPoolApproxValue
+  };
+}
+function deserializeUnrankedReferrerMetrics(metrics) {
+  return {
+    referrer: metrics.referrer,
+    totalReferrals: metrics.totalReferrals,
+    totalIncrementalDuration: metrics.totalIncrementalDuration,
+    totalRevenueContribution: deserializeRevenueContribution(metrics.totalRevenueContribution),
+    score: metrics.score,
+    rank: metrics.rank,
+    isQualified: metrics.isQualified,
+    finalScoreBoost: metrics.finalScoreBoost,
+    finalScore: metrics.finalScore,
+    awardPoolShare: metrics.awardPoolShare,
+    awardPoolApproxValue: metrics.awardPoolApproxValue
+  };
+}
+function deserializeAggregatedReferrerMetrics(metrics) {
+  return {
+    grandTotalReferrals: metrics.grandTotalReferrals,
+    grandTotalIncrementalDuration: metrics.grandTotalIncrementalDuration,
+    grandTotalRevenueContribution: deserializeRevenueContribution(
+      metrics.grandTotalRevenueContribution
+    ),
+    grandTotalQualifiedReferrersFinalScore: metrics.grandTotalQualifiedReferrersFinalScore,
+    minFinalScoreToQualify: metrics.minFinalScoreToQualify
+  };
+}
+function deserializeReferrerLeaderboardPage(page) {
+  return {
+    rules: deserializeReferralProgramRules(page.rules),
+    referrers: page.referrers.map(deserializeAwardedReferrerMetrics),
+    aggregatedMetrics: deserializeAggregatedReferrerMetrics(page.aggregatedMetrics),
+    pageContext: page.pageContext,
+    accurateAsOf: page.accurateAsOf
+  };
+}
+function deserializeReferrerDetailRanked(detail) {
+  return {
+    type: detail.type,
+    rules: deserializeReferralProgramRules(detail.rules),
+    referrer: deserializeAwardedReferrerMetrics(detail.referrer),
+    aggregatedMetrics: deserializeAggregatedReferrerMetrics(detail.aggregatedMetrics),
+    accurateAsOf: detail.accurateAsOf
+  };
+}
+function deserializeReferrerDetailUnranked(detail) {
+  return {
+    type: detail.type,
+    rules: deserializeReferralProgramRules(detail.rules),
+    referrer: deserializeUnrankedReferrerMetrics(detail.referrer),
+    aggregatedMetrics: deserializeAggregatedReferrerMetrics(detail.aggregatedMetrics),
+    accurateAsOf: detail.accurateAsOf
+  };
+}
+function deserializeReferrerLeaderboardPageResponse(maybeResponse, valueLabel) {
+  let deserialized;
+  switch (maybeResponse.responseCode) {
+    case "ok": {
+      deserialized = {
+        responseCode: maybeResponse.responseCode,
+        data: deserializeReferrerLeaderboardPage(maybeResponse.data)
+      };
+      break;
+    }
+    case "error":
+      deserialized = maybeResponse;
+      break;
+  }
+  const schema = makeReferrerLeaderboardPageResponseSchema(valueLabel);
+  const parsed = schema.safeParse(deserialized);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize SerializedReferrerLeaderboardPageResponse:
+${prettifyError10(parsed.error)}
+`
+    );
+  }
+  return parsed.data;
+}
+function deserializeReferrerDetailResponse(maybeResponse, valueLabel) {
+  let deserialized;
+  switch (maybeResponse.responseCode) {
+    case "ok": {
+      switch (maybeResponse.data.type) {
+        case "ranked":
+          deserialized = {
+            responseCode: maybeResponse.responseCode,
+            data: deserializeReferrerDetailRanked(maybeResponse.data)
+          };
+          break;
+        case "unranked":
+          deserialized = {
+            responseCode: maybeResponse.responseCode,
+            data: deserializeReferrerDetailUnranked(maybeResponse.data)
+          };
+          break;
+      }
+      break;
+    }
+    case "error":
+      deserialized = maybeResponse;
+      break;
+  }
+  const schema = makeReferrerDetailResponseSchema(valueLabel);
+  const parsed = schema.safeParse(deserialized);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize ReferrerDetailResponse:
+${prettifyError10(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+
+// src/ensanalytics/serialize.ts
+function serializeRevenueContribution(revenueContribution) {
+  return revenueContribution.toString();
+}
+function serializeReferralProgramRules(rules) {
+  return rules;
+}
+function serializeAwardedReferrerMetrics(metrics) {
+  return {
+    referrer: metrics.referrer,
+    totalReferrals: metrics.totalReferrals,
+    totalIncrementalDuration: metrics.totalIncrementalDuration,
+    totalRevenueContribution: serializeRevenueContribution(metrics.totalRevenueContribution),
+    score: metrics.score,
+    rank: metrics.rank,
+    isQualified: metrics.isQualified,
+    finalScoreBoost: metrics.finalScoreBoost,
+    finalScore: metrics.finalScore,
+    awardPoolShare: metrics.awardPoolShare,
+    awardPoolApproxValue: metrics.awardPoolApproxValue
+  };
+}
+function serializeUnrankedReferrerMetrics(metrics) {
+  return {
+    referrer: metrics.referrer,
+    totalReferrals: metrics.totalReferrals,
+    totalIncrementalDuration: metrics.totalIncrementalDuration,
+    totalRevenueContribution: serializeRevenueContribution(metrics.totalRevenueContribution),
+    score: metrics.score,
+    rank: metrics.rank,
+    isQualified: metrics.isQualified,
+    finalScoreBoost: metrics.finalScoreBoost,
+    finalScore: metrics.finalScore,
+    awardPoolShare: metrics.awardPoolShare,
+    awardPoolApproxValue: metrics.awardPoolApproxValue
+  };
+}
+function serializeAggregatedReferrerMetrics(metrics) {
+  return {
+    grandTotalReferrals: metrics.grandTotalReferrals,
+    grandTotalIncrementalDuration: metrics.grandTotalIncrementalDuration,
+    grandTotalRevenueContribution: serializeRevenueContribution(
+      metrics.grandTotalRevenueContribution
+    ),
+    grandTotalQualifiedReferrersFinalScore: metrics.grandTotalQualifiedReferrersFinalScore,
+    minFinalScoreToQualify: metrics.minFinalScoreToQualify
+  };
+}
+function serializeReferrerLeaderboardPage(page) {
+  return {
+    rules: serializeReferralProgramRules(page.rules),
+    referrers: page.referrers.map(serializeAwardedReferrerMetrics),
+    aggregatedMetrics: serializeAggregatedReferrerMetrics(page.aggregatedMetrics),
+    pageContext: page.pageContext,
+    accurateAsOf: page.accurateAsOf
+  };
+}
+function serializeReferrerDetailRanked(detail) {
+  return {
+    type: detail.type,
+    rules: serializeReferralProgramRules(detail.rules),
+    referrer: serializeAwardedReferrerMetrics(detail.referrer),
+    aggregatedMetrics: serializeAggregatedReferrerMetrics(detail.aggregatedMetrics),
+    accurateAsOf: detail.accurateAsOf
+  };
+}
+function serializeReferrerDetailUnranked(detail) {
+  return {
+    type: detail.type,
+    rules: serializeReferralProgramRules(detail.rules),
+    referrer: serializeUnrankedReferrerMetrics(detail.referrer),
+    aggregatedMetrics: serializeAggregatedReferrerMetrics(detail.aggregatedMetrics),
+    accurateAsOf: detail.accurateAsOf
+  };
+}
+function serializeReferrerLeaderboardPageResponse(response) {
+  switch (response.responseCode) {
+    case ReferrerLeaderboardPageResponseCodes.Ok:
+      return {
+        responseCode: response.responseCode,
+        data: serializeReferrerLeaderboardPage(response.data)
+      };
+    case ReferrerLeaderboardPageResponseCodes.Error:
+      return response;
+  }
+}
+function serializeReferrerDetailResponse(response) {
+  switch (response.responseCode) {
+    case ReferrerDetailResponseCodes.Ok:
+      switch (response.data.type) {
+        case "ranked":
+          return {
+            responseCode: response.responseCode,
+            data: serializeReferrerDetailRanked(response.data)
+          };
+        case "unranked":
+          return {
+            responseCode: response.responseCode,
+            data: serializeReferrerDetailUnranked(response.data)
+          };
+      }
+      break;
+    case ReferrerDetailResponseCodes.Error:
+      return response;
+  }
+}
+
+// src/client.ts
+var DEFAULT_ENSNODE_API_URL = "https://api.alpha.ensnode.io";
+var ENSNodeClient = class _ENSNodeClient {
+  options;
+  static defaultOptions() {
+    return {
+      url: new URL(DEFAULT_ENSNODE_API_URL)
+    };
+  }
+  constructor(options = {}) {
+    this.options = {
+      ..._ENSNodeClient.defaultOptions(),
+      ...options
+    };
+  }
+  getOptions() {
+    return Object.freeze({
+      url: new URL(this.options.url.href)
+    });
+  }
+  /**
+   * Resolves records for an ENS name (Forward Resolution).
+   *
+   * The returned `name` field, if set, is guaranteed to be a [Normalized Name](https://ensnode.io/docs/reference/terminology#normalized-name).
+   * If the name record returned by the resolver is not normalized, `null` is returned as if no name record was set.
+   *
+   * @param name The ENS Name whose records to resolve
+   * @param selection selection of Resolver records
+   * @param options additional options
+   * @param options.accelerate whether to attempt Protocol Acceleration (default false)
+   * @param options.trace whether to include a trace in the response (default false)
+   * @returns ResolveRecordsResponse<SELECTION>
+   * @throws If the request fails or the ENSNode API returns an error response
+   *
+   * @example
+   * ```typescript
+   * const { records } = await client.resolveRecords("jesse.base.eth", {
+   *   addresses: [60],
+   *   texts: ["avatar", "com.twitter"]
+   * });
+   *
+   * console.log(records);
+   * // {
+   * //   addresses: {
+   * //     60: "0xabcd..."
+   * //   },
+   * //   texts: {
+   * //     avatar: "https://example.com/image.jpg",
+   * //     "com.twitter": null, // if not set, for example
+   * //   }
+   * // }
+   * ```
+   */
+  async resolveRecords(name, selection, options) {
+    const url = new URL(`/api/resolve/records/${encodeURIComponent(name)}`, this.options.url);
+    if (selection.name) {
+      url.searchParams.set("name", "true");
+    }
+    if (selection.addresses && selection.addresses.length > 0) {
+      url.searchParams.set("addresses", selection.addresses.join(","));
+    }
+    if (selection.texts && selection.texts.length > 0) {
+      url.searchParams.set("texts", selection.texts.join(","));
+    }
+    if (options?.trace) url.searchParams.set("trace", "true");
+    if (options?.accelerate) url.searchParams.set("accelerate", "true");
+    const response = await fetch(url);
+    if (!response.ok) {
+      const error = await response.json();
+      throw ClientError.fromErrorResponse(error);
+    }
+    const data = await response.json();
+    return data;
+  }
+  /**
+   * Resolves the primary name of a specified address (Reverse Resolution) on a specific chain.
+   *
+   * If the chainId-specific Primary Name is not defined, but the `address` specifies a valid
+   * [ENSIP-19 Default Name](https://docs.ens.domains/ensip/19/#default-primary-name), the Default
+   * Name will be returned. You _may_ query the Default EVM Chain Id (`0`) in order to determine the
+   * `address`'s Default Name directly.
+   *
+   * The returned Primary Name, if set, is guaranteed to be a [Normalized Name](https://ensnode.io/docs/reference/terminology#normalized-name).
+   * If the primary name set for the address is not normalized, `null` is returned as if no primary name was set.
+   *
+   * @param address The Address whose Primary Name to resolve
+   * @param chainId The chain id within which to query the address' ENSIP-19 Multichain Primary Name
+   * @param options additional options
+   * @param options.accelerate whether to attempt Protocol Acceleration (default false)
+   * @param options.trace whether to include a trace in the response (default false)
+   * @returns ResolvePrimaryNameResponse
+   * @throws If the request fails or the ENSNode API returns an error response
+   *
+   * @example
+   * ```typescript
+   * // Resolve the address' Primary Name on Ethereum Mainnet
+   * const { name } = await client.resolvePrimaryName("0x179A862703a4adfb29896552DF9e307980D19285", 1);
+   * // name === 'gregskril.eth'
+   *
+   * // Resolve the address' Primary Name on Base
+   * const { name } = await client.resolvePrimaryName("0x179A862703a4adfb29896552DF9e307980D19285", 8453);
+   * // name === 'greg.base.eth'
+   *
+   * // Resolve the address' Default Primary Name
+   * const { name } = await client.resolvePrimaryName("0x179A862703a4adfb29896552DF9e307980D19285", 0);
+   * // name === 'gregskril.eth'
+   * ```
+   */
+  async resolvePrimaryName(address, chainId, options) {
+    const url = new URL(`/api/resolve/primary-name/${address}/${chainId}`, this.options.url);
+    if (options?.trace) url.searchParams.set("trace", "true");
+    if (options?.accelerate) url.searchParams.set("accelerate", "true");
+    const response = await fetch(url);
+    if (!response.ok) {
+      const error = await response.json();
+      throw ClientError.fromErrorResponse(error);
+    }
+    const data = await response.json();
+    return data;
+  }
+  /**
+   * Resolves the primary names of a specified address across multiple chains.
+   *
+   * For each Primary Name, if the chainId-specific Primary Name is not defined, but the `address`
+   * specifies a valid [ENSIP-19 Default Name](https://docs.ens.domains/ensip/19/#default-primary-name),
+   * the Default Name will be returned. You _may not_ query the Default EVM Chain Id (`0`) directly,
+   * and should rely on the aforementioned per-chain defaulting behavior.
+   *
+   * Each returned Primary Name, if set, is guaranteed to be a [Normalized Name](https://ensnode.io/docs/reference/terminology#normalized-name).
+   * If the primary name set for the address on any chain is not normalized, `null` is returned for
+   * that chain as if no primary name was set.
+   *
+   * @param address The Address whose Primary Names to resolve
+   * @param options additional options
+   * @param options.chainIds The set of chain ids within which to query the address' ENSIP-19
+   *  Multichain Primary Name (default: all ENSIP-19 supported chains)
+   * @param options.accelerate whether to attempt Protocol Acceleration (default: true)
+   * @param options.trace whether to include a trace in the response (default: false)
+   * @returns ResolvePrimaryNamesResponse
+   * @throws If the request fails or the ENSNode API returns an error response
+   *
+   * @example
+   * ```typescript
+   * // Resolve the address' Primary Names on all ENSIP-19 supported chain ids
+   * const { names } = await client.resolvePrimaryNames("0x179A862703a4adfb29896552DF9e307980D19285");
+   *
+   * console.log(names);
+   * // {
+   * //   "1": "gregskril.eth", // Default Primary Name
+   * //   "10": "gregskril.eth", // Default Primary Name
+   * //   "8453": "greg.base.eth", // Base-specific Primary Name!
+   * //   "42161": "gregskril.eth", // Default Primary Name
+   * //   "59144": "gregskril.eth", // Default Primary Name
+   * //   "534352": "gregskril.eth" // Default Primary Name
+   * // }
+   *
+   * // Resolve the address' Primary Names on specific chain Ids
+   * const { names } = await client.resolvePrimaryNames("0xabcd...", [1, 8453]);
+   *
+   * console.log(names);
+   * // {
+   * //   "1": "gregskril.eth",
+   * //   "8453": "greg.base.eth", // base-specific Primary Name!
+   * // }
+   * ```
+   */
+  async resolvePrimaryNames(address, options) {
+    const url = new URL(`/api/resolve/primary-names/${address}`, this.options.url);
+    if (options?.chainIds) url.searchParams.set("chainIds", options.chainIds.join(","));
+    if (options?.trace) url.searchParams.set("trace", "true");
+    if (options?.accelerate) url.searchParams.set("accelerate", "true");
+    const response = await fetch(url);
+    if (!response.ok) {
+      const error = await response.json();
+      throw ClientError.fromErrorResponse(error);
+    }
+    const data = await response.json();
+    return data;
+  }
+  /**
+   * Fetch ENSNode Config
+   *
+   * Fetch the ENSNode's configuration.
+   *
+   * @returns {ConfigResponse}
+   *
+   * @throws if the ENSNode request fails
+   * @throws if the ENSNode API returns an error response
+   * @throws if the ENSNode response breaks required invariants
+   */
+  async config() {
+    const url = new URL(`/api/config`, this.options.url);
+    const response = await fetch(url);
+    let responseData;
+    try {
+      responseData = await response.json();
+    } catch {
+      throw new Error("Malformed response data: invalid JSON");
+    }
+    if (!response.ok) {
+      const errorResponse = deserializeErrorResponse(responseData);
+      throw new Error(`Fetching ENSNode Config Failed: ${errorResponse.message}`);
+    }
+    return deserializeConfigResponse(responseData);
+  }
+  /**
+   * Fetch ENSNode Indexing Status
+   *
+   * @returns {IndexingStatusResponse}
+   *
+   * @throws if the ENSNode request fails
+   * @throws if the ENSNode API returns an error response
+   * @throws if the ENSNode response breaks required invariants
+   */
+  async indexingStatus() {
+    const url = new URL(`/api/indexing-status`, this.options.url);
+    const response = await fetch(url);
+    let responseData;
+    try {
+      responseData = await response.json();
+    } catch {
+      throw new Error("Malformed response data: invalid JSON");
+    }
+    if (!response.ok) {
+      let errorResponse;
+      try {
+        errorResponse = deserializeErrorResponse(responseData);
+      } catch {
+        console.log("Indexing Status API: handling a known indexing status server error.");
+      }
+      if (typeof errorResponse !== "undefined") {
+        throw new Error(`Fetching ENSNode Indexing Status Failed: ${errorResponse.message}`);
+      }
+    }
+    return deserializeIndexingStatusResponse(responseData);
+  }
+  /**
+   * Fetch Referrer Leaderboard Page
+   *
+   * Retrieves a paginated list of referrer leaderboard 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.recordsPerPage - Number of records per page (default: 25, max: 100)
+   * @returns {ReferrerLeaderboardPageResponse}
+   *
+   * @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 records)
+   * const response = await client.getReferrerLeaderboardPage();
+   * if (response.responseCode === ReferrerLeaderboardPageResponseCodes.Ok) {
+   *   const {
+   *     aggregatedMetrics,
+   *     referrers,
+   *     rules,
+   *     pageContext,
+   *     updatedAt
+   *   } = response.data;
+   *   console.log(aggregatedMetrics);
+   *   console.log(referrers);
+   *   console.log(rules);
+   *   console.log(updatedAt);
+   *   console.log(`Page ${pageContext.page} of ${pageContext.totalPages}`);
+   * }
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Get second page with 50 records per page
+   * const response = await client.getReferrerLeaderboardPage({ page: 2, recordsPerPage: 50 });
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Handle error response, ie. when Referrer Leaderboard is not currently available.
+   * const response = await client.getReferrerLeaderboardPage();
+   *
+   * if (response.responseCode === ReferrerLeaderboardPageResponseCodes.Error) {
+   *   console.error(response.error);
+   *   console.error(response.errorMessage);
+   * }
+   * ```
+   */
+  async getReferrerLeaderboardPage(request) {
+    const url = new URL(`/ensanalytics/referrers`, this.options.url);
+    if (request?.page) url.searchParams.set("page", request.page.toString());
+    if (request?.recordsPerPage)
+      url.searchParams.set("recordsPerPage", request.recordsPerPage.toString());
+    const response = await fetch(url);
+    let responseData;
+    try {
+      responseData = await response.json();
+    } catch {
+      throw new Error("Malformed response data: invalid JSON");
+    }
+    return deserializeReferrerLeaderboardPageResponse(
+      responseData
+    );
+  }
+  /**
+   * Fetch Referrer Detail
+   *
+   * Retrieves detailed information about a specific referrer, whether they are on the
+   * leaderboard or not.
+   *
+   * The response data is a discriminated union type with a `type` field:
+   *
+   * **For referrers on the leaderboard** (`ReferrerDetailRanked`):
+   * - `type`: {@link ReferrerDetailTypeIds.Ranked}
+   * - `referrer`: The `AwardedReferrerMetrics` from @namehash/ens-referrals
+   * - `rules`: The referral program rules
+   * - `aggregatedMetrics`: Aggregated metrics for all referrers on the leaderboard
+   * - `accurateAsOf`: Unix timestamp indicating when the data was last updated
+   *
+   * **For referrers NOT on the leaderboard** (`ReferrerDetailUnranked`):
+   * - `type`: {@link ReferrerDetailTypeIds.Unranked}
+   * - `referrer`: The `UnrankedReferrerMetrics` from @namehash/ens-referrals
+   * - `rules`: The referral program rules
+   * - `aggregatedMetrics`: Aggregated metrics for all referrers on the leaderboard
+   * - `accurateAsOf`: Unix timestamp indicating when the data was last updated
+   *
+   * @see {@link https://www.npmjs.com/package/@namehash/ens-referrals|@namehash/ens-referrals} for calculation details
+   *
+   * @param request The referrer address to query
+   * @returns {ReferrerDetailResponse} Returns the referrer detail response
+   *
+   * @throws if the ENSNode request fails
+   * @throws if the response data is malformed
+   *
+   * @example
+   * ```typescript
+   * // Get referrer detail for a specific address
+   * const response = await client.getReferrerDetail({
+   *   referrer: "0x1234567890123456789012345678901234567890"
+   * });
+   * if (response.responseCode === ReferrerDetailResponseCodes.Ok) {
+   *   const { type, referrer, rules, aggregatedMetrics, accurateAsOf } = response.data;
+   *   console.log(type); // ReferrerDetailTypeIds.Ranked or ReferrerDetailTypeIds.Unranked
+   *   console.log(referrer);
+   *   console.log(accurateAsOf);
+   * }
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Use discriminated union to check if referrer is ranked
+   * const response = await client.getReferrerDetail({
+   *   referrer: "0x1234567890123456789012345678901234567890"
+   * });
+   * if (response.responseCode === ReferrerDetailResponseCodes.Ok) {
+   *   if (response.data.type === ReferrerDetailTypeIds.Ranked) {
+   *     // TypeScript knows this is ReferrerDetailRanked
+   *     console.log(`Rank: ${response.data.referrer.rank}`);
+   *     console.log(`Qualified: ${response.data.referrer.isQualified}`);
+   *     console.log(`Award Pool Share: ${response.data.referrer.awardPoolShare * 100}%`);
+   *   } else {
+   *     // TypeScript knows this is ReferrerDetailUnranked
+   *     console.log("Referrer is not on the leaderboard (no referrals yet)");
+   *   }
+   * }
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Handle error response, ie. when Referrer Detail is not currently available.
+   * const response = await client.getReferrerDetail({
+   *   referrer: "0x1234567890123456789012345678901234567890"
+   * });
+   *
+   * if (response.responseCode === ReferrerDetailResponseCodes.Error) {
+   *   console.error(response.error);
+   *   console.error(response.errorMessage);
+   * }
+   * ```
+   */
+  async getReferrerDetail(request) {
+    const url = new URL(
+      `/api/ensanalytics/referrers/${encodeURIComponent(request.referrer)}`,
+      this.options.url
+    );
+    const response = await fetch(url);
+    let responseData;
+    try {
+      responseData = await response.json();
+    } catch {
+      throw new Error("Malformed response data: invalid JSON");
+    }
+    return deserializeReferrerDetailResponse(responseData);
+  }
+  /**
+   * Fetch ENSNode Registrar Actions
+   *
+   * Retrieves a paginated list of registrar actions with optional filters.
+   *
+   * @param request is a request configuration.
+   * @param request.page sets the page number to retrieve (1-indexed, default: 1)
+   * @param request.recordsPerPage sets the number of records per page (default: 10, max: 100)
+   * @param request.filters is an optional request filter configuration.
+   * @param 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 first page with default page size (10 records)
+   * const response = await client.registrarActions();
+   * if (response.responseCode === RegistrarActionsResponseCodes.Ok) {
+   *   const { registrarActions, pageContext } = response;
+   *   console.log(registrarActions);
+   *   console.log(`Page ${pageContext.page} of ${pageContext.totalPages}`);
+   * }
+   *
+   * // Get second page with 25 records per page
+   * const response = await client.registrarActions({
+   *   page: 2,
+   *   recordsPerPage: 25,
+   * });
+   *
+   * // 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 registrar action records for a specific decoded referrer
+   * await client.registrarActions({
+   *   filters: [registrarActionsFilter.byDecodedReferrer("0x1234567890123456789012345678901234567890")],
+   * });
+   *
+   * // get latest 10 registrar action records associated with
+   * // subregistry managing `base.eth` name
+   * await client.registrarActions({
+   *   filters: [registrarActionsFilter.byParentNode(namehash('base.eth'))],
+   *   recordsPerPage: 10
+   * });
+   *
+   * // get registrar actions within a specific time range
+   * const beginTimestamp = 1764547200; // Dec 1, 2025, 00:00:00 UTC
+   * const endTimestamp = 1767225600; // Jan 1, 2026, 00:00:00 UTC
+   * await client.registrarActions({
+   *   filters: [
+   *     registrarActionsFilter.beginTimestamp(beginTimestamp),
+   *     registrarActionsFilter.endTimestamp(endTimestamp),
+   *   ],
+   * });
+   *
+   * // get registrar actions from a specific timestamp onwards
+   * await client.registrarActions({
+   *   filters: [registrarActionsFilter.beginTimestamp(1764547200)],
+   * });
+   *
+   * // get registrar actions up to a specific timestamp
+   * await client.registrarActions({
+   *   filters: [registrarActionsFilter.endTimestamp(1767225600)],
+   * });
+   * ```
+   */
+  async registrarActions(request = {}) {
+    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 buildDecodedReferrerArg = (filters) => {
+      const decodedReferrerFilter = filters?.find(
+        (f) => f.filterType === RegistrarActionsFilterTypes.ByDecodedReferrer
+      );
+      return decodedReferrerFilter ? { key: "decodedReferrer", value: decodedReferrerFilter.value } : null;
+    };
+    const buildBeginTimestampArg = (filters) => {
+      const beginTimestampFilter = filters?.find(
+        (f) => f.filterType === RegistrarActionsFilterTypes.BeginTimestamp
+      );
+      return beginTimestampFilter ? { key: "beginTimestamp", value: beginTimestampFilter.value.toString() } : null;
+    };
+    const buildEndTimestampArg = (filters) => {
+      const endTimestampFilter = filters?.find(
+        (f) => f.filterType === RegistrarActionsFilterTypes.EndTimestamp
+      );
+      return endTimestampFilter ? { key: "endTimestamp", value: endTimestampFilter.value.toString() } : null;
+    };
+    const buildOrderArg = (order) => {
+      switch (order) {
+        case RegistrarActionsOrders.LatestRegistrarActions: {
+          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.page) {
+      url.searchParams.set("page", request.page.toString());
+    }
+    if (request.recordsPerPage) {
+      url.searchParams.set("recordsPerPage", request.recordsPerPage.toString());
+    }
+    const referralArg = buildWithReferralArg(request.filters);
+    if (referralArg) {
+      url.searchParams.set(referralArg.key, referralArg.value);
+    }
+    const decodedReferrerArg = buildDecodedReferrerArg(request.filters);
+    if (decodedReferrerArg) {
+      url.searchParams.set(decodedReferrerArg.key, decodedReferrerArg.value);
+    }
+    const beginTimestampArg = buildBeginTimestampArg(request.filters);
+    if (beginTimestampArg) {
+      url.searchParams.set(beginTimestampArg.key, beginTimestampArg.value);
+    }
+    const endTimestampArg = buildEndTimestampArg(request.filters);
+    if (endTimestampArg) {
+      url.searchParams.set(endTimestampArg.key, endTimestampArg.value);
+    }
+    const response = await fetch(url);
+    let responseData;
+    try {
+      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);
+  }
+  /**
+   * Fetch Name Tokens for requested name.
+   *
+   * @param request.name - Name for which Name Tokens will be fetched.
+   * @returns {NameTokensResponse}
+   *
+   * @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 {
+   *   ENSNodeClient,
+   * } from "@ensnode/ensnode-sdk";
+   * import { namehash } from "viem/ens";
+   *
+   * const client: ENSNodeClient;
+   *
+   * // get latest name token records from the indexed subregistry based on the requested name
+   * const response = await client.nameTokens({
+   *   name: "vitalik.eth"
+   * });
+   *
+   * const response = await client.nameTokens({
+   *   domainId: "0xee6c4522aab0003e8d14cd40a6af439055fd2577951148c14b6cea9a53475835" // namehash('vitalik.eth')
+   * })
+   * ```
+   */
+  async nameTokens(request) {
+    const url = new URL(`/api/name-tokens`, this.options.url);
+    if (request.name !== void 0) {
+      url.searchParams.set("name", request.name);
+    } else if (request.domainId !== void 0) {
+      url.searchParams.set("domainId", request.domainId);
+    }
+    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("Name Tokens API: handling a known server error.");
+      }
+      if (typeof errorResponse !== "undefined") {
+        throw new Error(`Fetching ENSNode Name Tokens Failed: ${errorResponse.message}`);
+      }
+    }
+    return deserializedNameTokensResponse(responseData);
+  }
+};
+
+// src/identity/identity.ts
+import { getENSRootChainId as getENSRootChainId2 } from "@ensnode/datasources";
+
+// src/identity/types.ts
+var ResolutionStatusIds = {
+  /**
+   * Represents that the `Identity` is not resolved yet.
+   */
+  Unresolved: "unresolved",
+  /**
+   * Represents that resolution of the `Identity` resulted in a named identity.
+   */
+  Named: "named",
+  /**
+   * Represents that resolution of the `Identity` resulted in an unnamed identity.
+   */
+  Unnamed: "unnamed",
+  /**
+   * Represents that attempted resolution of the `Identity` resulted in an error
+   * and therefore it is unknown if the `Identity` resolves to a named or unnamed identity.
+   */
+  Unknown: "unknown"
+};
+
+// src/identity/identity.ts
+function buildUnresolvedIdentity(address, namespaceId, chainId) {
+  return {
+    resolutionStatus: ResolutionStatusIds.Unresolved,
+    chainId: chainId ?? getENSRootChainId2(namespaceId),
+    address
+  };
+}
+function isResolvedIdentity(identity) {
+  return identity.resolutionStatus !== ResolutionStatusIds.Unresolved;
+}
+
+// src/resolution/ensip19-chainid.ts
+import { mainnet } from "viem/chains";
+import { getENSRootChainId as getENSRootChainId3 } from "@ensnode/datasources";
+var getResolvePrimaryNameChainIdParam = (chainId, namespaceId) => {
+  const ensRootChainId = getENSRootChainId3(namespaceId);
+  return chainId === ensRootChainId ? mainnet.id : chainId;
+};
+var translateDefaultableChainIdToChainId = (chainId, namespaceId) => {
+  return chainId === DEFAULT_EVM_CHAIN_ID ? getENSRootChainId3(namespaceId) : chainId;
+};
+
+// src/resolution/resolver-records-selection.ts
+var isSelectionEmpty = (selection) => !selection.name && !selection.addresses?.length && !selection.texts?.length;
+
+// src/tracing/ens-protocol-tracing.ts
+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`;
+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 || {});
+export {
+  ADDR_REVERSE_NODE,
+  ATTR_PROTOCOL_NAME,
+  ATTR_PROTOCOL_STEP,
+  ATTR_PROTOCOL_STEP_RESULT,
+  AssetNamespaces,
+  BASENAMES_NODE,
+  ChainIndexingConfigTypeIds,
+  ChainIndexingStatusIds,
+  ClientError,
+  CrossChainIndexingStrategyIds,
+  CurrencyIds,
+  DEFAULT_EVM_CHAIN_ID,
+  DEFAULT_EVM_COIN_TYPE,
+  ENSNamespaceIds,
+  ENSNodeClient,
+  ENS_ROOT,
+  ETH_COIN_TYPE,
+  ETH_NODE,
+  ForwardResolutionProtocolStep,
+  IndexingStatusResponseCodes,
+  LINEANAMES_NODE,
+  LruCache,
+  NFTMintStatuses,
+  NFTTransferTypes,
+  NameTokenOwnershipTypes,
+  NameTokensResponseCodes,
+  NameTokensResponseErrorCodes,
+  OmnichainIndexingStatusIds,
+  PROTOCOL_ATTRIBUTE_PREFIX,
+  PluginName,
+  RECORDS_PER_PAGE_DEFAULT,
+  RECORDS_PER_PAGE_MAX,
+  ROOT_NODE,
+  ReferrerDetailResponseCodes,
+  ReferrerLeaderboardPageResponseCodes,
+  RegistrarActionTypes,
+  RegistrarActionsFilterTypes,
+  RegistrarActionsOrders,
+  RegistrarActionsResponseCodes,
+  ResolutionStatusIds,
+  ReverseResolutionProtocolStep,
+  SWRCache,
+  TheGraphCannotFallbackReasonSchema,
+  TheGraphFallbackSchema,
+  TraceableENSProtocol,
+  TtlCache,
+  ZERO_ENCODED_REFERRER,
+  accountIdEqual,
+  addDuration,
+  addPrices,
+  addrReverseLabel,
+  asLowerCaseAddress,
+  beautifyName,
+  bigIntToNumber,
+  bigintToCoinType,
+  buildAssetId,
+  buildEnsRainbowClientLabelSet,
+  buildLabelSetId,
+  buildLabelSetVersion,
+  buildPageContext,
+  buildUnresolvedIdentity,
+  checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill,
+  checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted,
+  checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing,
+  checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted,
+  coinTypeReverseLabel,
+  coinTypeToEvmChainId,
+  createIndexingConfig,
+  createRealtimeIndexingStatusProjection,
+  decodeDNSEncodedLiteralName,
+  decodeDNSEncodedName,
+  decodeEncodedReferrer,
+  deserializeAssetId,
+  deserializeBlockNumber,
+  deserializeBlockRef,
+  deserializeBlockrange,
+  deserializeChainId,
+  deserializeChainIndexingStatusSnapshot,
+  deserializeConfigResponse,
+  deserializeCrossChainIndexingStatusSnapshot,
+  deserializeDatetime,
+  deserializeDuration,
+  deserializeENSApiPublicConfig,
+  deserializeENSIndexerPublicConfig,
+  deserializeErrorResponse,
+  deserializeIndexingStatusResponse,
+  deserializeOmnichainIndexingStatusSnapshot,
+  deserializeRealtimeIndexingStatusProjection,
+  deserializeReferrerDetailResponse,
+  deserializeReferrerLeaderboardPageResponse,
+  deserializeRegistrarActionsResponse,
+  deserializeUnixTimestamp,
+  deserializeUrl,
+  deserializedNameTokensResponse,
+  durationBetween,
+  encodeLabelHash,
+  evmChainIdToCoinType,
+  formatAccountId,
+  formatAssetId,
+  formatNFTTransferEventMetadata,
+  getBasenamesSubregistryId,
+  getBasenamesSubregistryManagedName,
+  getCurrencyInfo,
+  getDatasourceContract,
+  getENSRootChainId,
+  getEthnamesSubregistryId,
+  getEthnamesSubregistryManagedName,
+  getLatestIndexedBlockRef,
+  getLineanamesSubregistryId,
+  getLineanamesSubregistryManagedName,
+  getNFTTransferType,
+  getNameHierarchy,
+  getNameTokenOwnership,
+  getNameWrapperAccounts,
+  getOmnichainIndexingCursor,
+  getOmnichainIndexingStatus,
+  getParentNameFQDN,
+  getResolvePrimaryNameChainIdParam,
+  getTimestampForHighestOmnichainKnownBlock,
+  getTimestampForLowestOmnichainStartBlock,
+  hasNullByte,
+  interpretedLabelsToInterpretedName,
+  isEncodedLabelHash,
+  isHttpProtocol,
+  isLabelHash,
+  isNormalizedLabel,
+  isNormalizedName,
+  isPriceCurrencyEqual,
+  isPriceEqual,
+  isRegistrarActionPricingAvailable,
+  isRegistrarActionReferralAvailable,
+  isResolvedIdentity,
+  isSelectionEmpty,
+  isSubgraphCompatible,
+  isWebSocketProtocol,
+  labelHashToBytes,
+  labelhashLiteralLabel,
+  literalLabelToInterpretedLabel,
+  literalLabelsToInterpretedName,
+  literalLabelsToLiteralName,
+  makeENSApiPublicConfigSchema,
+  makeSubdomainNode,
+  maybeGetDatasourceContract,
+  nameTokensPrerequisites,
+  parseAccountId,
+  parseAssetId,
+  parseNonNegativeInteger,
+  parseReverseName,
+  priceDai,
+  priceEth,
+  priceUsdc,
+  registrarActionsFilter,
+  registrarActionsPrerequisites,
+  reverseName,
+  serializeAssetId,
+  serializeChainId,
+  serializeChainIndexingSnapshots,
+  serializeConfigResponse,
+  serializeCrossChainIndexingStatusSnapshotOmnichain,
+  serializeDatetime,
+  serializeDomainAssetId,
+  serializeENSApiPublicConfig,
+  serializeENSIndexerPublicConfig,
+  serializeIndexedChainIds,
+  serializeIndexingStatusResponse,
+  serializeNameToken,
+  serializeNameTokensResponse,
+  serializeNamedRegistrarAction,
+  serializeOmnichainIndexingStatusSnapshot,
+  serializePrice,
+  serializePriceEth,
+  serializeRealtimeIndexingStatusProjection,
+  serializeReferrerDetailResponse,
+  serializeReferrerLeaderboardPageResponse,
+  serializeRegisteredNameTokens,
+  serializeRegistrarAction,
+  serializeRegistrarActionPricing,
+  serializeRegistrarActionsResponse,
+  serializeUrl,
+  sortChainStatusesByStartBlockAsc,
+  stripNullBytes,
+  translateDefaultableChainIdToChainId,
+  uint256ToHex32,
+  uniq,
+  validateSupportedLabelSetAndVersion
+};
+//# sourceMappingURL=index.js.map