@ensnode/ensnode-sdk 0.32.0 → 0.34.0

package/README.md

@@ -54,7 +54,7 @@ Resolves records for an ENS name (Forward Resolution), via ENSNode, which implem
   - `texts`: Array of text record keys to resolve
 - `options`: (optional) additional options
   - `trace`: (optional) Whether to include a trace in the response (default: false)
-  - `accelerate`: (optional) Whether to attempt Protocol Acceleration (default: true)
+  - `accelerate`: (optional) Whether to attempt Protocol Acceleration (default: false)
 
 
 ```ts
@@ -89,7 +89,7 @@ Resolves the primary name of the provided `address` on the specified `chainId`,
 - `chainId`: The chain id within which to query the address' ENSIP-19 Multichain Primary Name
 - `options`: (optional) additional options
   - `trace`: (optional) Whether to include a trace in the response (default: false)
-  - `accelerate`: (optional) Whether to attempt Protocol Acceleration (default: true)
+  - `accelerate`: (optional) Whether to attempt Protocol Acceleration (default: false)
 
 ```ts
 import { mainnet, base } from 'viem/chains';
@@ -116,7 +116,7 @@ Resolves the primary names of the provided `address` on the specified chainIds,
 - `options`: (optional) additional options
   - `chainIds`: The chain ids within which to query the address' ENSIP-19 Multichain Primary Name (default: all ENSIP-19 supported chains)
   - `trace`: (optional) Whether to include a trace in the response (default: false)
-  - `accelerate`: (optional) Whether to attempt Protocol Acceleration (default: true)
+  - `accelerate`: (optional) Whether to attempt Protocol Acceleration (default: false)
 
 ```ts
 import { mainnet, base } from 'viem/chains';

package/dist/index.d.ts

@@ -1,8 +1,10 @@
-import { Hex, Address } from 'viem';
+import { Hex, Address, ByteArray } from 'viem';
+import * as _ensdomains_address_encoder from '@ensdomains/address-encoder';
 import { CoinType, EvmCoinType } from '@ensdomains/address-encoder';
 export { CoinType, EvmCoinType } from '@ensdomains/address-encoder';
 import { ENSNamespaceId } from '@ensnode/datasources';
 export { ENSNamespaceId, ENSNamespaceIds } from '@ensnode/datasources';
+import z from 'zod/v4';
 
 /**
  * A hash value that uniquely identifies a single ENS name.
@@ -43,6 +45,9 @@ type Label = string;
 type EncodedLabelHash = `[${string}]`;
 
 declare const ROOT_NODE: Node;
+declare const ETH_NODE: `0x${string}`;
+declare const BASENAMES_NODE: `0x${string}`;
+declare const LINEANAMES_NODE: `0x${string}`;
 /**
  * A set of nodes whose children are used for reverse resolution.
  *
@@ -77,7 +82,7 @@ declare const maybeHealLabelByReverseAddress: ({ maybeReverseAddress, labelHash,
  * into Node or LabelHash, which is a common behavior in the ENS ecosystem.
  * (see NameWrapper, ETHRegistrarController)
  */
-declare const uint256ToHex32: (num: bigint) => `0x${string}`;
+declare const uint256ToHex32: (num: bigint) => Hex;
 /**
  * Check if any characters in `label` are "unindexable".
  *
@@ -158,6 +163,15 @@ declare const uniq: <T>(arr: T[]) => T[];
  * Guaranteed to be a positive integer.
  **/
 type ChainId = number;
+/**
+ * Represents an account (contract or EOA) at `address` on chain `chainId`.
+ *
+ * @see https://chainagnostic.org/CAIPs/caip-10
+ */
+interface AccountId {
+    chainId: ChainId;
+    address: Address;
+}
 /**
  * Block Number
  *
@@ -286,6 +300,11 @@ declare function deserializeDuration(maybeDuration: string, valueLabel?: string)
 
 declare function isNormalized(name: Name): boolean;
 
+/**
+ * Determines where the provided AccountId values represent the same address on the same chain.
+ */
+declare const accountIdEqual: (a: AccountId, b: AccountId) => boolean;
+
 /**
  * The ETH coinType.
  *
@@ -376,6 +395,57 @@ declare function parseReverseName(name: Name): {
     coinType: CoinType;
 } | null;
 
+/**
+ * A label set ID identifies a set of labels that can be used for deterministic healing.
+ * A label set allows clients to deterministically heal their state against a server,
+ * ensuring that both are operating on the same version of data.
+ *
+ * It is guaranteed to be 1 to 50 characters long and contain only lowercase letters (a-z)
+ * and hyphens (-).
+ */
+type LabelSetId = string;
+/**
+ * A label set version identifies a specific version of a label set. It allows clients to
+ * request data from a specific snapshot in time, ensuring deterministic results.
+ *
+ * It is guaranteed to be a non-negative integer.
+ */
+type LabelSetVersion = number;
+/**
+ * The label set preferences of an ENSRainbow client.
+ */
+interface EnsRainbowClientLabelSet {
+    /**
+     * Optional label set ID that the ENSRainbow server is expected to use. If provided, heal
+     * operations will validate the ENSRainbow server is using this labelSetId.
+     * Required if `labelSetVersion` is defined.
+     */
+    labelSetId?: LabelSetId;
+    /**
+     * Optional highest label set version of label set id to query. Enables deterministic heal
+     * results across time even if the ENSRainbow server ingests label sets with greater versions
+     * than this value. If provided, only labels from label sets with versions less than or equal to this
+     * value will be returned. If not provided, the server will use the latest available version.
+     * When `labelSetVersion` is defined, `labelSetId` must also be defined.
+     */
+    labelSetVersion?: LabelSetVersion;
+}
+/**
+ * The state of label sets managed by an ENSRainbow server.
+ */
+interface EnsRainbowServerLabelSet {
+    /**
+     * The LabelSetId managed by the ENSRainbow server.
+     */
+    labelSetId: LabelSetId;
+    /**
+     * The highest label set version available on the ENSRainbow server for the current
+     * label set ID. This represents the most recent version of the label set that the
+     * server has ingested and can provide label healing results for.
+     */
+    highestLabelSetVersion: LabelSetVersion;
+}
+
 /**
  * A PluginName is a unique id for a 'plugin': we use the notion of
  * 'plugins' to describe bundles of indexing logic.
@@ -386,7 +456,8 @@ declare enum PluginName {
     Lineanames = "lineanames",
     ThreeDNS = "threedns",
     ReverseResolvers = "reverse-resolvers",
-    Referrals = "referrals"
+    Referrals = "referrals",
+    TokenScope = "tokenscope"
 }
 /**
  * Information about ENSIndexer's dependencies.
@@ -432,6 +503,10 @@ interface ENSIndexerPublicConfig {
      * state about the ENSNode instance.
      */
     ensNodePublicUrl: URL;
+    /**
+     * The "fully pinned" label set reference that ENSIndexer will request ENSRainbow use for deterministic label healing across time. This label set reference is "fully pinned" as it requires both the labelSetId and labelSetVersion fields to be defined.
+     */
+    labelSet: Required<EnsRainbowClientLabelSet>;
     /**
      * A Postgres database schema name. This instance of ENSIndexer will write
      * indexed data to the tables in this schema.
@@ -478,10 +553,6 @@ interface ENSIndexerPublicConfig {
      * {@link indexAdditionalResolverRecords} should be `false`.
      */
     indexAdditionalResolverRecords: boolean;
-    /**
-     * Experiment to enable forward/reverse resolution APIs.
-     */
-    experimentalResolution: boolean;
     /**
      * Indexed Chain IDs
      *
@@ -536,7 +607,7 @@ declare function deserializeENSIndexerPublicConfig(maybeConfig: SerializedENSInd
  * Tells if indexer config guarantees data to be indexed while
  * maintaining full subgraph-compatibility.
  */
-declare function isSubgraphCompatible(config: Pick<ENSIndexerPublicConfig, "plugins" | "healReverseAddresses" | "indexAdditionalResolverRecords">): boolean;
+declare function isSubgraphCompatible(config: Pick<ENSIndexerPublicConfig, "plugins" | "healReverseAddresses" | "indexAdditionalResolverRecords" | "labelSet">): boolean;
 
 /**
  * Serializes a {@link ChainConfig} object.
@@ -547,6 +618,159 @@ declare function serializeIndexedChainIds(indexedChainIds: Set<ChainId>): Serial
  */
 declare function serializeENSIndexerPublicConfig(config: ENSIndexerPublicConfig): SerializedENSIndexerPublicConfig;
 
+/**
+ * All zod schemas we define must remain internal implementation details.
+ * We want the freedom to move away from zod in the future without impacting
+ * any users of the ensnode-sdk package.
+ *
+ * The only way to share Zod schemas is to re-export them from
+ * `./src/internal.ts` file.
+ */
+
+/**
+ * Zod `.check()` function input.
+ */
+type ZodCheckFnInput<T> = z.core.ParsePayload<T>;
+
+/**
+ * All zod schemas we define must remain internal implementation details.
+ * We want the freedom to move away from zod in the future without impacting
+ * any users of the ensnode-sdk package.
+ *
+ * The only way to share Zod schemas is to re-export them from
+ * `./src/internal.ts` file.
+ */
+
+/**
+ * Makes a schema for parsing {@link IndexedChainIds}.
+ */
+declare const makeIndexedChainIdsSchema: (valueLabel?: string) => z.ZodPipe<z.ZodArray<z.ZodInt>, z.ZodTransform<Set<number>, number[]>>;
+/**
+ * Makes a schema for parsing a list of {@link PluginName} items.
+ *
+ * The list is guaranteed to include at least one item exists, and no duplicates.
+ */
+declare const makePluginsListSchema: (valueLabel?: string) => z.ZodArray<z.ZodEnum<typeof PluginName>>;
+/**
+ * Makes a schema for parsing a name for a database schema.
+ *
+ * The name is guaranteed to be a non-empty string.
+ */
+declare const makeDatabaseSchemaNameSchema: (valueLabel?: string) => z.ZodString;
+/**
+ * Makes a schema for parsing a label set ID.
+ *
+ * The label set ID is guaranteed to be a string between 1-50 characters
+ * containing only lowercase letters (a-z) and hyphens (-).
+ *
+ * @param valueLabel - The label to use in error messages (e.g., "Label set ID", "LABEL_SET_ID")
+ */
+declare const makeLabelSetIdSchema: (valueLabel: string) => z.ZodString;
+/**
+ * Makes a schema for parsing a label set version.
+ *
+ * The label set version is guaranteed to be a non-negative integer.
+ *
+ * @param valueLabel - The label to use in error messages (e.g., "Label set version", "LABEL_SET_VERSION")
+
+ */
+declare const makeLabelSetVersionSchema: (valueLabel: string) => z.ZodPipe<z.coerce.ZodCoercedNumber<unknown>, z.ZodInt>;
+/**
+ * Makes a schema for parsing a label set where both label set ID and label set version are required.
+ *
+ * @param valueLabel - The label to use in error messages (e.g., "Label set", "LABEL_SET")
+ */
+declare const makeFullyPinnedLabelSetSchema: (valueLabel?: string) => z.ZodObject<{
+    labelSetId: z.ZodString;
+    labelSetVersion: z.ZodPipe<z.coerce.ZodCoercedNumber<unknown>, z.ZodInt>;
+}, z.core.$strip>;
+declare const makeDependencyInfoSchema: (valueLabel?: string) => z.ZodObject<{
+    nodejs: z.ZodString;
+    ponder: z.ZodString;
+    ensRainbow: z.ZodString;
+    ensRainbowSchema: z.ZodInt;
+}, z.core.$strict>;
+declare function invariant_reverseResolversPluginNeedsResolverRecords(ctx: ZodCheckFnInput<Pick<ENSIndexerPublicConfig, "plugins" | "indexAdditionalResolverRecords">>): void;
+declare function invariant_isSubgraphCompatibleRequirements(ctx: ZodCheckFnInput<Pick<ENSIndexerPublicConfig, "plugins" | "isSubgraphCompatible" | "healReverseAddresses" | "indexAdditionalResolverRecords" | "labelSet">>): void;
+/**
+ * ENSIndexer Public Config Schema
+ *
+ * Makes a Zod schema definition for validating all important settings used
+ * during runtime of the ENSIndexer instance.
+ */
+declare const makeENSIndexerPublicConfigSchema: (valueLabel?: string) => z.ZodObject<{
+    ensAdminUrl: z.ZodPipe<z.ZodURL, z.ZodTransform<URL, string>>;
+    ensNodePublicUrl: z.ZodPipe<z.ZodURL, z.ZodTransform<URL, string>>;
+    labelSet: z.ZodObject<{
+        labelSetId: z.ZodString;
+        labelSetVersion: z.ZodPipe<z.coerce.ZodCoercedNumber<unknown>, z.ZodInt>;
+    }, z.core.$strip>;
+    healReverseAddresses: z.ZodBoolean;
+    indexAdditionalResolverRecords: z.ZodBoolean;
+    indexedChainIds: z.ZodPipe<z.ZodArray<z.ZodInt>, z.ZodTransform<Set<number>, number[]>>;
+    isSubgraphCompatible: z.ZodBoolean;
+    namespace: z.ZodEnum<{
+        readonly Mainnet: "mainnet";
+        readonly Sepolia: "sepolia";
+        readonly Holesky: "holesky";
+        readonly EnsTestEnv: "ens-test-env";
+    }>;
+    plugins: z.ZodArray<z.ZodEnum<typeof PluginName>>;
+    databaseSchemaName: z.ZodString;
+    dependencyInfo: z.ZodObject<{
+        nodejs: z.ZodString;
+        ponder: z.ZodString;
+        ensRainbow: z.ZodString;
+        ensRainbowSchema: z.ZodInt;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+
+/**
+ * Builds a valid LabelSetId from a string.
+ * @param maybeLabelSetId - The string to validate and convert to a LabelSetId.
+ * @returns A valid LabelSetId.
+ * @throws If the input string is not a valid LabelSetId.
+ */
+declare function buildLabelSetId(maybeLabelSetId: string): LabelSetId;
+/**
+ * Builds a valid LabelSetVersion from a number or string.
+ * @param maybeLabelSetVersion - The number or string to validate and convert to a LabelSetVersion.
+ * @returns A valid LabelSetVersion.
+ * @throws If the input is not a valid LabelSetVersion.
+ */
+declare function buildLabelSetVersion(maybeLabelSetVersion: number | string): LabelSetVersion;
+/**
+ * Builds an EnsRainbowClientLabelSet.
+ * @param labelSetId - The label set ID.
+ * @param labelSetVersion - The label set version.
+ * @returns A valid EnsRainbowClientLabelSet object.
+ * @throws If `labelSetVersion` is defined without `labelSetId`.
+ */
+declare function buildEnsRainbowClientLabelSet(labelSetId?: LabelSetId, labelSetVersion?: LabelSetVersion): EnsRainbowClientLabelSet;
+/**
+ * Validates that the server's label set is compatible with the client's requested label set.
+ * @param serverSet - The label set provided by the server.
+ * @param clientSet - The label set requested by the client.
+ * @throws If the server set is not compatible with the client set.
+ */
+declare function validateSupportedLabelSetAndVersion(serverSet: EnsRainbowServerLabelSet, clientSet: EnsRainbowClientLabelSet): void;
+
+/**
+ * Converts a Labelhash to bytes, with validation
+ * @param labelHash The Labelhash to convert
+ * @returns A ByteArray containing the bytes
+ * @throws Error if `labelHash` is not a valid 32-byte hex string
+ */
+declare function labelHashToBytes(labelHash: LabelHash): ByteArray;
+
+/**
+ * Parses a string into a non-negative integer.
+ * @param input The string to parse
+ * @returns The parsed non-negative integer
+ * @throws Error if the input is not a valid non-negative integer
+ */
+declare function parseNonNegativeInteger(maybeNumber: string): number;
+
 declare const ChainIndexingStatusIds: {
     readonly Unstarted: "unstarted";
     readonly Backfill: "backfill";
@@ -662,7 +886,8 @@ interface ChainIndexingUnstartedStatus {
  *
  * Invariants:
  * - `config.startBlock` is always before or the same as `latestIndexedBlock`
- * - `latestIndexedBlock` is always before or the same as `backfillEndBlock`
+ * - `latestIndexedBlock` is always before or the same as `latestSyncedBlock`
+ * - `latestSyncedBlock` is always before or the same as `backfillEndBlock`
  * - `backfillEndBlock` is the same as `config.endBlock` if and only if
  *   the config is definite.
  */
@@ -673,6 +898,11 @@ interface ChainIndexingBackfillStatus {
      * The block that was most recently indexed.
      */
     latestIndexedBlock: BlockRef;
+    /**
+     * The "highest" block that has been synced into RPC cache. Backfill indexing
+     * is accelerated by cached RPC calls through this block height.
+     */
+    latestSyncedBlock: BlockRef;
     /**
      * The block that is the target for finishing the backfill.
      */
@@ -939,6 +1169,16 @@ declare function getOverallIndexingStatus(chains: ChainIndexingStatus[]): Exclud
  * @throws an error if none of the indexed chains was in the 'following' status.
  */
 declare function getOverallApproxRealtimeDistance(chains: ChainIndexingStatus[]): Duration;
+/**
+ * Get lowest of the highest end block across all chains which status is
+ * {@link ChainIndexingStatus}.
+ */
+declare function getTimestampForLowestOmnichainStartBlock(chains: ChainIndexingStatus[]): UnixTimestamp;
+/**
+ * Get timestamp of the highest known block across all chains which status is
+ * {@link ChainIndexingStatusForBackfillOverallStatus}.
+ */
+declare function getTimestampForHighestOmnichainKnownBlock(chains: ChainIndexingStatus[]): UnixTimestamp;
 /**
  * Get Omnichain Indexing Cursor across all chains which status is
  * {@link ChainIndexingActiveStatus}.
@@ -995,6 +1235,11 @@ declare function checkChainIndexingStatusesForCompletedOverallStatus(chains: Cha
  * - Any other chain can have any status.
  */
 declare function checkChainIndexingStatusesForFollowingOverallStatus(chains: ChainIndexingStatus[]): chains is ChainIndexingStatus[];
+/**
+ * Sort a list of [{@link ChainId}, {@link ChainIndexingStatus}] tuples
+ * by the omnichain start block timestamp in ascending order.
+ */
+declare function sortAscChainStatusesByStartBlock<ChainStatusType extends ChainIndexingStatus>(chains: [ChainId, ChainStatusType][]): [ChainId, ChainStatusType][];
 
 /**
  * Serialize chain indexing statuses.
@@ -1016,7 +1261,7 @@ declare enum TraceableENSProtocol {
  * Encodes the set of well-known steps in the ENS Forward Resolution protocol.
  */
 declare enum ForwardResolutionProtocolStep {
-    Operation = "operation",
+    Operation = "forward-resolution",
     FindResolver = "find-resolver",
     ActiveResolverExists = "active-resolver-exists",
     AccelerateENSIP19ReverseResolver = "accelerate-ensip-19-reverse-resolver",
@@ -1029,43 +1274,46 @@ declare enum ForwardResolutionProtocolStep {
  * Encodes the set of well-known steps in the ENS Reverse Resolution protocol.
  */
 declare enum ReverseResolutionProtocolStep {
-    Operation = "operation",
+    Operation = "reverse-resolution",
     ResolveReverseName = "resolve-reverse-name",
     NameRecordExists = "name-record-exists-check",
     ForwardResolveAddressRecord = "forward-resolve-address-record",
     VerifyResolvedAddressMatchesAddress = "verify-resolved-address-matches-address"
 }
+declare const PROTOCOL_ATTRIBUTE_PREFIX = "ens";
 declare const ATTR_PROTOCOL_NAME = "ens.protocol";
 declare const ATTR_PROTOCOL_STEP = "ens.protocol.step";
 declare const ATTR_PROTOCOL_STEP_RESULT = "ens.protocol.step.result";
-/**
- * Re-implements hrTimeToMicroseconds to avoid a dependency on @opentelemetry/core.
- *
- * @see https://github.com/open-telemetry/opentelemetry-js/blob/41ba7f57cbf5ae22290168188b467e0c60cd4765/packages/opentelemetry-core/src/common/time.ts#L135
- */
-declare function hrTimeToMicroseconds(time: [number, number]): number;
-/**
- * Encodes a ReadableSpan as a consumer-friendly and externally-visible JSON-representable object.
- *
- * NOTE: to avoid a dependency on @opentelemetry/sdk-trace-base and an obscure typing issue related
- * to the patched version necessary for it to run in ENSIndexer, we type the span as `any`, but note
- * that it is ReadableSpan.
- */
-declare const readableSpanToProtocolSpan: (span: any) => {
-    id: any;
-    traceId: any;
-    parentSpanContext: any;
-    name: any;
+interface SpanAttributes {
+    [key: string]: unknown;
+}
+interface SpanEvent {
+    name: string;
+    attributes: SpanAttributes;
+    time: number;
+}
+interface ProtocolSpan {
+    scope: string;
+    id: string;
+    traceId: string;
+    parentSpanContext: {
+        traceId: string;
+        spanId: string;
+    } | undefined;
+    name: string;
     timestamp: number;
     duration: number;
-    attributes: {
-        [k: string]: unknown;
+    attributes: SpanAttributes;
+    status: {
+        code: number;
+        message?: string;
     };
-    status: any;
-    events: any;
+    events: SpanEvent[];
+}
+type ProtocolSpanTreeNode = ProtocolSpan & {
+    children: ProtocolSpanTreeNode[];
 };
-type ProtocolSpan = ReturnType<typeof readableSpanToProtocolSpan>;
-type ProtocolTrace = ProtocolSpan[];
+type ProtocolTrace = ProtocolSpanTreeNode[];
 
 /**
  * Encodes a selection of Resolver records in the context of a specific Name.
@@ -1087,10 +1335,6 @@ interface ResolverRecordsSelection {
      */
     texts?: string[];
 }
-declare const DEFAULT_RECORDS_SELECTION: {
-    readonly addresses: [CoinType];
-    readonly texts: ["url", "avatar", "header", "description", "email", "com.twitter", "com.farcaster", "com.github"];
-};
 declare const isSelectionEmpty: (selection: ResolverRecordsSelection) => boolean;
 
 /**
@@ -1178,6 +1422,25 @@ interface MultichainPrimaryNameResolutionArgs {
  */
 type MultichainPrimaryNameResolutionResult = Record<ChainId, Name | null>;
 
+declare const DefaultRecordsSelection: {
+    readonly mainnet: {
+        readonly addresses: [_ensdomains_address_encoder.CoinType, ..._ensdomains_address_encoder.CoinType[]];
+        readonly texts: ["url", "avatar", "header", "description", "email", "com.twitter", "com.farcaster", "com.github"];
+    };
+    readonly sepolia: {
+        readonly addresses: [_ensdomains_address_encoder.CoinType, ..._ensdomains_address_encoder.CoinType[]];
+        readonly texts: ["url", "avatar", "header", "description", "email", "com.twitter", "com.farcaster", "com.github"];
+    };
+    readonly holesky: {
+        readonly addresses: [_ensdomains_address_encoder.CoinType, ..._ensdomains_address_encoder.CoinType[]];
+        readonly texts: ["url", "avatar", "header", "description", "email", "com.twitter", "com.farcaster", "com.github"];
+    };
+    readonly "ens-test-env": {
+        readonly addresses: [_ensdomains_address_encoder.CoinType, ..._ensdomains_address_encoder.CoinType[]];
+        readonly texts: ["url", "avatar", "header", "description", "email", "com.twitter", "com.farcaster", "com.github"];
+    };
+};
+
 /**
  * API Error Response Type
  */
@@ -1194,6 +1457,9 @@ interface TraceableResponse {
 interface AcceleratableRequest {
     accelerate?: boolean;
 }
+interface AcceleratableResponse {
+    accelerationAttempted: boolean;
+}
 /**
  * Resolve Records Request Type
  */
@@ -1202,7 +1468,7 @@ interface ResolveRecordsRequest<SELECTION extends ResolverRecordsSelection> exte
 /**
  * Resolve Records Response Type
  */
-interface ResolveRecordsResponse<SELECTION extends ResolverRecordsSelection> extends TraceableResponse {
+interface ResolveRecordsResponse<SELECTION extends ResolverRecordsSelection> extends AcceleratableResponse, TraceableResponse {
     records: ResolverRecordsResponse<SELECTION>;
 }
 /**
@@ -1213,14 +1479,49 @@ interface ResolvePrimaryNameRequest extends ReverseResolutionArgs, Acceleratable
 /**
  * Resolve Primary Name Response Type
  */
-interface ResolvePrimaryNameResponse extends TraceableResponse {
+interface ResolvePrimaryNameResponse extends AcceleratableResponse, TraceableResponse {
     name: ReverseResolutionResult;
 }
 interface ResolvePrimaryNamesRequest extends MultichainPrimaryNameResolutionArgs, AcceleratableRequest, TraceableRequest {
 }
-interface ResolvePrimaryNamesResponse extends TraceableResponse {
+interface ResolvePrimaryNamesResponse extends AcceleratableResponse, TraceableResponse {
     names: MultichainPrimaryNameResolutionResult;
 }
+/**
+ * ENSIndexer Public Config Response
+ */
+type ConfigResponse = ENSIndexerPublicConfig;
+/**
+ * ENSIndexer Overall Indexing Status Request
+ */
+interface IndexingStatusRequest {
+    /**
+     * Max Realtime Distance (optional)
+     *
+     * A duration value in seconds, representing the max allowed distance
+     * between the latest indexed block of each chain and the “tip” of
+     * all indexed chains. Setting this parameter influences the HTTP response
+     * code as follows:
+     * - Success (200 OK): The latest indexed block of each chain
+     *   is within the requested distance from realtime.
+     * - Service Unavailable (503): The latest indexed block of each chain
+     *   is NOT within the requested distance from realtime.
+     */
+    maxRealtimeDistance?: Duration;
+}
+/**
+ * ENSIndexer Overall Indexing Status Response
+ */
+type IndexingStatusResponse = ENSIndexerOverallIndexingStatus;
+/**
+ * ENSIndexer Overall Indexing Status Response Codes
+ *
+ * Define a custom response code for known responses.
+ */
+declare const IndexingStatusResponseCodes: {
+    readonly IndexerError: 512;
+    readonly RequestedDistanceNotAchievedError: 513;
+};
 
 /**
  * Default ENSNode API endpoint URL
@@ -1272,7 +1573,7 @@ declare class ENSNodeClient {
      * @param name The ENS Name whose records to resolve
      * @param selection selection of Resolver records
      * @param options additional options
-     * @param options.accelerate whether to attempt Protocol Acceleration (default true)
+     * @param options.accelerate whether to attempt Protocol Acceleration (default false)
      * @param options.trace whether to include a trace in the response (default false)
      * @returns ResolveRecordsResponse<SELECTION>
      * @throws If the request fails or the ENSNode API returns an error response
@@ -1307,7 +1608,7 @@ declare class ENSNodeClient {
      * @param address The Address whose Primary Name to resolve
      * @param chainId The chain id within which to query the address' ENSIP-19 Multichain Primary Name
      * @param options additional options
-     * @param options.accelerate whether to attempt Protocol Acceleration (default true)
+     * @param options.accelerate whether to attempt Protocol Acceleration (default false)
      * @param options.trace whether to include a trace in the response (default false)
      * @returns ResolvePrimaryNameResponse
      * @throws If the request fails or the ENSNode API returns an error response
@@ -1371,6 +1672,47 @@ declare class ENSNodeClient {
      * ```
      */
     resolvePrimaryNames(address: ResolvePrimaryNamesRequest["address"], options?: Omit<ResolvePrimaryNamesRequest, "address">): Promise<ResolvePrimaryNamesResponse>;
+    /**
+     * 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
+     */
+    config(): Promise<ConfigResponse>;
+    /**
+     * Fetch ENSNode Indexing Status
+     *
+     * Fetch the ENSNode's multichain indexing status.
+     *
+     * @param options additional options
+     * @param options.maxRealtimeDistance the max allowed distance between the
+     *  latest indexed block of each chain and the "tip" of all indexed chains.
+     *  Setting this parameter influences the HTTP response code as follows:
+     *  - Success (200 OK): The latest indexed block of each chain is within the
+     *    requested distance from realtime.
+     *  - Service Unavailable (503): The latest indexed block of each chain is NOT
+     *    within the requested distance from realtime.
+     *
+     * @returns {IndexingStatusResponse}
+     *
+     * @throws if the ENSNode request fails
+     * @throws if the ENSNode API returns an error response
+     * @throws if the ENSNode response breaks required invariants
+     */
+    indexingStatus(options?: IndexingStatusRequest): Promise<IndexingStatusResponse>;
+}
+
+declare function deserializeErrorResponse(maybeErrorResponse: unknown): ErrorResponse;
+
+declare class ClientError extends Error {
+    details?: unknown;
+    constructor(message: string, details?: unknown);
+    static fromErrorResponse({ message, details }: ErrorResponse): ClientError;
 }
 
-export { ATTR_PROTOCOL_NAME, ATTR_PROTOCOL_STEP, ATTR_PROTOCOL_STEP_RESULT, type AcceleratableRequest, type BlockNumber, type BlockRef, type Blockrange, type Cache, type ChainId, type ChainIdString, type ChainIndexingActiveStatus, type ChainIndexingBackfillStatus, type ChainIndexingCompletedStatus, type ChainIndexingConfig, type ChainIndexingDefiniteConfig, type ChainIndexingFollowingStatus, type ChainIndexingIndefiniteConfig, type ChainIndexingStandbyStatus, type ChainIndexingStatus, type ChainIndexingStatusForBackfillOverallStatus, type ChainIndexingStatusId, ChainIndexingStatusIds, type ChainIndexingStrategyId, ChainIndexingStrategyIds, type ChainIndexingUnstartedStatus, type ClientOptions, DEFAULT_ENSNODE_API_URL, DEFAULT_EVM_CHAIN_ID, DEFAULT_EVM_COIN_TYPE, DEFAULT_RECORDS_SELECTION, type Datetime, type DatetimeISO8601, type DeepPartial, type DependencyInfo, type Duration, type ENSIndexerOverallIndexingBackfillStatus, type ENSIndexerOverallIndexingCompletedStatus, type ENSIndexerOverallIndexingErrorStatus, type ENSIndexerOverallIndexingFollowingStatus, type ENSIndexerOverallIndexingStatus, type ENSIndexerOverallIndexingUnstartedStatus, type ENSIndexerPublicConfig, ENSNodeClient, ETH_COIN_TYPE, type EncodedLabelHash, type ErrorResponse, type ForwardResolutionArgs, ForwardResolutionProtocolStep, type ForwardResolutionResult, type Label, type LabelHash, LruCache, type MultichainPrimaryNameResolutionArgs, type MultichainPrimaryNameResolutionResult, type Name, type Node, type OverallIndexingStatusId, OverallIndexingStatusIds, PluginName, type ProtocolSpan, type ProtocolTrace, REVERSE_ROOT_NODES, ROOT_NODE, type ResolvePrimaryNameRequest, type ResolvePrimaryNameResponse, type ResolvePrimaryNamesRequest, type ResolvePrimaryNamesResponse, type ResolveRecordsRequest, type ResolveRecordsResponse, type ResolverRecordsResponse, type ResolverRecordsResponseBase, type ResolverRecordsSelection, type ReverseResolutionArgs, ReverseResolutionProtocolStep, type ReverseResolutionResult, type RpcUrl, type SerializedENSIndexerOverallIndexingBackfillStatus, type SerializedENSIndexerOverallIndexingCompletedStatus, type SerializedENSIndexerOverallIndexingErrorStatus, type SerializedENSIndexerOverallIndexingFollowingStatus, type SerializedENSIndexerOverallIndexingStatus, type SerializedENSIndexerOverallIndexingUnstartedStatus, type SerializedENSIndexerPublicConfig, type SerializedIndexedChainIds, TraceableENSProtocol, type UnixTimestamp, type UrlString, addrReverseLabel, bigintToCoinType, checkChainIndexingStatusesForBackfillOverallStatus, checkChainIndexingStatusesForCompletedOverallStatus, checkChainIndexingStatusesForFollowingOverallStatus, checkChainIndexingStatusesForUnstartedOverallStatus, coinTypeReverseLabel, coinTypeToEvmChainId, createIndexingConfig, deserializeBlockNumber, deserializeBlockRef, deserializeBlockrange, deserializeChainId, deserializeDatetime, deserializeDuration, deserializeENSIndexerIndexingStatus, deserializeENSIndexerPublicConfig, deserializeUrl, evmChainIdToCoinType, getActiveChains, getNameHierarchy, getOmnichainIndexingCursor, getOverallApproxRealtimeDistance, getOverallIndexingStatus, getStandbyChains, hrTimeToMicroseconds, isLabelIndexable, isNormalized, isSelectionEmpty, isSubgraphCompatible, makeSubdomainNode, maybeHealLabelByReverseAddress, parseReverseName, readableSpanToProtocolSpan, reverseName, serializeChainId, serializeChainIndexingStatuses, serializeDatetime, serializeENSIndexerIndexingStatus, serializeENSIndexerPublicConfig, serializeIndexedChainIds, serializeUrl, uint256ToHex32, uniq };
+export { ATTR_PROTOCOL_NAME, ATTR_PROTOCOL_STEP, ATTR_PROTOCOL_STEP_RESULT, type AcceleratableRequest, type AcceleratableResponse, type AccountId, BASENAMES_NODE, type BlockNumber, type BlockRef, type Blockrange, type Cache, type ChainId, type ChainIdString, type ChainIndexingActiveStatus, type ChainIndexingBackfillStatus, type ChainIndexingCompletedStatus, type ChainIndexingConfig, type ChainIndexingDefiniteConfig, type ChainIndexingFollowingStatus, type ChainIndexingIndefiniteConfig, type ChainIndexingStandbyStatus, type ChainIndexingStatus, type ChainIndexingStatusForBackfillOverallStatus, type ChainIndexingStatusId, ChainIndexingStatusIds, type ChainIndexingStrategyId, ChainIndexingStrategyIds, type ChainIndexingUnstartedStatus, ClientError, type ClientOptions, type ConfigResponse, DEFAULT_ENSNODE_API_URL, DEFAULT_EVM_CHAIN_ID, DEFAULT_EVM_COIN_TYPE, type Datetime, type DatetimeISO8601, type DeepPartial, DefaultRecordsSelection, type DependencyInfo, type Duration, type ENSIndexerOverallIndexingBackfillStatus, type ENSIndexerOverallIndexingCompletedStatus, type ENSIndexerOverallIndexingErrorStatus, type ENSIndexerOverallIndexingFollowingStatus, type ENSIndexerOverallIndexingStatus, type ENSIndexerOverallIndexingUnstartedStatus, type ENSIndexerPublicConfig, ENSNodeClient, ETH_COIN_TYPE, ETH_NODE, type EncodedLabelHash, type EnsRainbowClientLabelSet, type EnsRainbowServerLabelSet, type ErrorResponse, type ForwardResolutionArgs, ForwardResolutionProtocolStep, type ForwardResolutionResult, type IndexingStatusRequest, type IndexingStatusResponse, IndexingStatusResponseCodes, LINEANAMES_NODE, type Label, type LabelHash, type LabelSetId, type LabelSetVersion, LruCache, type MultichainPrimaryNameResolutionArgs, type MultichainPrimaryNameResolutionResult, type Name, type Node, type OverallIndexingStatusId, OverallIndexingStatusIds, PROTOCOL_ATTRIBUTE_PREFIX, PluginName, type ProtocolSpan, type ProtocolSpanTreeNode, type ProtocolTrace, REVERSE_ROOT_NODES, ROOT_NODE, type ResolvePrimaryNameRequest, type ResolvePrimaryNameResponse, type ResolvePrimaryNamesRequest, type ResolvePrimaryNamesResponse, type ResolveRecordsRequest, type ResolveRecordsResponse, type ResolverRecordsResponse, type ResolverRecordsResponseBase, type ResolverRecordsSelection, type ReverseResolutionArgs, ReverseResolutionProtocolStep, type ReverseResolutionResult, type RpcUrl, type SerializedENSIndexerOverallIndexingBackfillStatus, type SerializedENSIndexerOverallIndexingCompletedStatus, type SerializedENSIndexerOverallIndexingErrorStatus, type SerializedENSIndexerOverallIndexingFollowingStatus, type SerializedENSIndexerOverallIndexingStatus, type SerializedENSIndexerOverallIndexingUnstartedStatus, type SerializedENSIndexerPublicConfig, type SerializedIndexedChainIds, TraceableENSProtocol, type TraceableRequest, type TraceableResponse, type UnixTimestamp, type UrlString, accountIdEqual, addrReverseLabel, bigintToCoinType, buildEnsRainbowClientLabelSet, buildLabelSetId, buildLabelSetVersion, checkChainIndexingStatusesForBackfillOverallStatus, checkChainIndexingStatusesForCompletedOverallStatus, checkChainIndexingStatusesForFollowingOverallStatus, checkChainIndexingStatusesForUnstartedOverallStatus, coinTypeReverseLabel, coinTypeToEvmChainId, createIndexingConfig, deserializeBlockNumber, deserializeBlockRef, deserializeBlockrange, deserializeChainId, deserializeDatetime, deserializeDuration, deserializeENSIndexerIndexingStatus, deserializeENSIndexerPublicConfig, deserializeErrorResponse, deserializeUrl, evmChainIdToCoinType, getActiveChains, getNameHierarchy, getOmnichainIndexingCursor, getOverallApproxRealtimeDistance, getOverallIndexingStatus, getStandbyChains, getTimestampForHighestOmnichainKnownBlock, getTimestampForLowestOmnichainStartBlock, invariant_isSubgraphCompatibleRequirements, invariant_reverseResolversPluginNeedsResolverRecords, isLabelIndexable, isNormalized, isSelectionEmpty, isSubgraphCompatible, labelHashToBytes, makeDatabaseSchemaNameSchema, makeDependencyInfoSchema, makeENSIndexerPublicConfigSchema, makeFullyPinnedLabelSetSchema, makeIndexedChainIdsSchema, makeLabelSetIdSchema, makeLabelSetVersionSchema, makePluginsListSchema, makeSubdomainNode, maybeHealLabelByReverseAddress, parseNonNegativeInteger, parseReverseName, reverseName, serializeChainId, serializeChainIndexingStatuses, serializeDatetime, serializeENSIndexerIndexingStatus, serializeENSIndexerPublicConfig, serializeIndexedChainIds, serializeUrl, sortAscChainStatusesByStartBlock, uint256ToHex32, uniq, validateSupportedLabelSetAndVersion };