@ensnode/ensnode-react 1.9.0 → 1.10.1

package/dist/index.d.ts

@@ -2,16 +2,16 @@ import * as _tanstack_react_query from '@tanstack/react-query';
 import { QueryObserverOptions, DefaultError, QueryKey, DefinedInitialDataOptions, QueryClient, DefinedUseQueryResult, UndefinedInitialDataOptions, UseQueryResult, UseQueryOptions } from '@tanstack/react-query';
 export { QueryClient } from '@tanstack/react-query';
 import * as _ensnode_ensnode_sdk from '@ensnode/ensnode-sdk';
-import { ClientOptions, ResolvePrimaryNameRequest, ResolvePrimaryNameResponse, ResolvePrimaryNamesRequest, ResolvePrimaryNamesResponse, ResolverRecordsSelection, ResolveRecordsRequest, ResolveRecordsResponse, AcceleratableRequest, UnresolvedIdentity, ConfigResponse, IndexingStatusRequest, IndexingStatusResponse, NameTokensRequest, NameTokensResponse, RegistrarActionsRequest, RegistrarActionsResponse, Identity } from '@ensnode/ensnode-sdk';
+import { EnsNodeClientOptions, ResolvePrimaryNameRequest, ResolvePrimaryNameResponse, ResolvePrimaryNamesRequest, ResolvePrimaryNamesResponse, ResolverRecordsSelection, ResolveRecordsRequest, ResolveRecordsResponse, AcceleratableRequest, UnresolvedIdentity, ENSNamespaceId, EnsApiIndexingStatusRequest, EnsApiIndexingStatusResponse, NameTokensRequest, NameTokensResponse, RegistrarActionsRequest, RegistrarActionsResponse, Identity } from '@ensnode/ensnode-sdk';
 export { ResolverRecordsSelection } from '@ensnode/ensnode-sdk';
 import * as react from 'react';
 
 /**
  * Configuration options for the ENSNode provider
  */
-interface ENSNodeSDKConfig {
-    /** The ENSNode API client configuration */
-    client: ClientOptions;
+interface EnsNodeProviderOptions {
+    /** The ENSNode client configuration */
+    client: EnsNodeClientOptions;
 }
 /**
  * Base query parameters that can be passed to hooks
@@ -22,8 +22,8 @@ interface QueryParameter<TData = unknown, TError = Error> {
 /**
  * Configuration parameter for hooks that need access to config
  */
-interface WithSDKConfigParameter<TConfig extends ENSNodeSDKConfig = ENSNodeSDKConfig> {
-    config?: TConfig | undefined;
+interface WithEnsNodeProviderOptions<TOptions extends EnsNodeProviderOptions = EnsNodeProviderOptions> {
+    options?: TOptions | undefined;
 }
 /**
  * Parameters for the useRecords hook.
@@ -54,28 +54,25 @@ interface UsePrimaryNamesParameters extends Omit<ResolvePrimaryNamesRequest, "ad
  */
 interface UseResolvedIdentityParameters extends QueryParameter<ResolvePrimaryNameResponse>, AcceleratableRequest {
     identity: UnresolvedIdentity;
+    namespace: ENSNamespaceId;
 }
 
 /**
- * React context for ENSNode configuration
+ * React context for ENSNodeProvider options
  */
-declare const ENSNodeContext: react.Context<ENSNodeSDKConfig | undefined>;
-
-type UseENSNodeConfigParameters = QueryParameter<ConfigResponse>;
-declare function useENSNodeConfig(parameters?: WithSDKConfigParameter & UseENSNodeConfigParameters): _tanstack_react_query.UseQueryResult<_ensnode_ensnode_sdk.EnsApiPublicConfig, Error>;
+declare const EnsNodeContext: react.Context<EnsNodeProviderOptions | undefined>;
 
 /**
- * Hook to access the ENSNodeSDKConfig from context or parameters.
+ * Hook to access the {@link EnsNodeProviderOptions} from context or parameters.
  *
- * @param parameters - Optional config parameter that overrides context
- * @returns The ENSNode configuration
- * @throws Error if no config is available in context or parameters
+ * @param options - Options parameter that overrides context
+ * @throws Error if no options are available in context or parameters
  */
-declare function useENSNodeSDKConfig<TConfig extends ENSNodeSDKConfig = ENSNodeSDKConfig>(config: TConfig | undefined): TConfig;
+declare function useEnsNodeProviderOptions<ProviderOptionsType extends EnsNodeProviderOptions = EnsNodeProviderOptions>(options?: ProviderOptionsType): ProviderOptionsType;
 
-interface UseIndexingStatusParameters extends IndexingStatusRequest, QueryParameter<IndexingStatusResponse> {
+interface UseIndexingStatusParameters extends EnsApiIndexingStatusRequest, QueryParameter<EnsApiIndexingStatusResponse> {
 }
-declare function useIndexingStatus(parameters?: WithSDKConfigParameter & UseIndexingStatusParameters): _tanstack_react_query.UseQueryResult<_ensnode_ensnode_sdk.EnsApiIndexingStatusResponse, Error>;
+declare function useIndexingStatus(parameters?: WithEnsNodeProviderOptions & UseIndexingStatusParameters): _tanstack_react_query.UseQueryResult<EnsApiIndexingStatusResponse, Error>;
 
 type UseNameTokensParameters = NameTokensRequest & QueryParameter<NameTokensResponse>;
 /**
@@ -83,7 +80,7 @@ type UseNameTokensParameters = NameTokensRequest & QueryParameter<NameTokensResp
  *
  * Query ENSNode Name Tokens API.
  */
-declare function useNameTokens(parameters: WithSDKConfigParameter & UseNameTokensParameters): _tanstack_react_query.UseQueryResult<NameTokensResponse, Error>;
+declare function useNameTokens(parameters: WithEnsNodeProviderOptions & UseNameTokensParameters): _tanstack_react_query.UseQueryResult<NameTokensResponse, Error>;
 
 /**
  * Resolves the primary name of a specified address (Reverse Resolution).
@@ -117,7 +114,7 @@ declare function useNameTokens(parameters: WithSDKConfigParameter & UseNameToken
  * }
  * ```
  */
-declare function usePrimaryName(parameters: UsePrimaryNameParameters & WithSDKConfigParameter): _tanstack_react_query.UseQueryResult<_ensnode_ensnode_sdk.ResolvePrimaryNameResponse, Error>;
+declare function usePrimaryName(parameters: UsePrimaryNameParameters & WithEnsNodeProviderOptions): _tanstack_react_query.UseQueryResult<_ensnode_ensnode_sdk.ResolvePrimaryNameResponse, Error>;
 
 /**
  * Resolves the primary names of a specified address across multiple chains.
@@ -153,7 +150,7 @@ declare function usePrimaryName(parameters: UsePrimaryNameParameters & WithSDKCo
  * }
  * ```
  */
-declare function usePrimaryNames(parameters: UsePrimaryNamesParameters & WithSDKConfigParameter): _tanstack_react_query.UseQueryResult<_ensnode_ensnode_sdk.ResolvePrimaryNamesResponse, Error>;
+declare function usePrimaryNames(parameters: UsePrimaryNamesParameters & WithEnsNodeProviderOptions): _tanstack_react_query.UseQueryResult<_ensnode_ensnode_sdk.ResolvePrimaryNamesResponse, Error>;
 
 /**
  * Resolves records for an ENS name (Forward Resolution).
@@ -197,7 +194,7 @@ declare function usePrimaryNames(parameters: UsePrimaryNamesParameters & WithSDK
  * }
  * ```
  */
-declare function useRecords<SELECTION extends ResolverRecordsSelection>(parameters: UseRecordsParameters<SELECTION> & WithSDKConfigParameter): _tanstack_react_query.UseQueryResult<_ensnode_ensnode_sdk.ResolveRecordsResponse<SELECTION>, Error>;
+declare function useRecords<SELECTION extends ResolverRecordsSelection>(parameters: UseRecordsParameters<SELECTION> & WithEnsNodeProviderOptions): _tanstack_react_query.UseQueryResult<_ensnode_ensnode_sdk.ResolveRecordsResponse<SELECTION>, Error>;
 
 interface UseRegistrarActionsParameters extends RegistrarActionsRequest, QueryParameter<RegistrarActionsResponse> {
 }
@@ -206,7 +203,7 @@ interface UseRegistrarActionsParameters extends RegistrarActionsRequest, QueryPa
  *
  * Query ENSNode Registrar Actions API.
  */
-declare function useRegistrarActions(parameters?: WithSDKConfigParameter & UseRegistrarActionsParameters): _tanstack_react_query.UseQueryResult<RegistrarActionsResponse, Error>;
+declare function useRegistrarActions(parameters?: WithEnsNodeProviderOptions & UseRegistrarActionsParameters): _tanstack_react_query.UseQueryResult<RegistrarActionsResponse, Error>;
 
 /**
  * Hook to perform ENSIP-19 primary name resolution to resolve an
@@ -215,7 +212,7 @@ declare function useRegistrarActions(parameters?: WithSDKConfigParameter & UseRe
  * @param parameters - Configuration object for the hook
  * @param parameters.identity - An {@link UnresolvedIdentity} containing the {@link DefaultableChainId}
  *                              and {@link Address} to resolve.
- * @param parameters.namespaceId - The {@link ENSNamespaceId} that `identity.chainId` should be interpreted
+ * @param parameters.namespace - The {@link ENSNamespaceId} that `identity.chainId` should be interpreted
  *                                 through (via {@link getResolvePrimaryNameChainIdParam}) to determine the literal
  *                                 chainId that should be used for ENSIP-19 primary name resolution.
  * @param parameters.accelerate - Whether to attempt Protocol Acceleration (default: false)
@@ -432,12 +429,12 @@ declare function useSwrQuery<TQueryFnData = unknown, TError = DefaultError, TDat
 declare function useSwrQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryResult<NoInfer<TData>, TError>;
 declare function useSwrQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryResult<NoInfer<TData>, TError>;
 
-interface ENSNodeProviderProps {
-    /** ENSNode configuration */
-    config: ENSNodeSDKConfig;
+interface EnsNodeProviderProps {
+    /** ENSNode Provider Options */
+    options: EnsNodeProviderOptions;
     /**
      * Optional QueryClient instance. If provided, you must wrap your app with QueryClientProvider yourself.
-     * If not provided, ENSNodeProvider will create and manage its own QueryClient internally.
+     * If not provided, EnsNodeProvider will create and manage its own QueryClient internally.
      */
     queryClient?: QueryClient;
     /**
@@ -446,16 +443,16 @@ interface ENSNodeProviderProps {
      */
     queryClientOptions?: ConstructorParameters<typeof QueryClient>[0];
 }
-declare function ENSNodeProvider(parameters: React.PropsWithChildren<ENSNodeProviderProps>): react.FunctionComponentElement<{
+declare function EnsNodeProvider(parameters: React.PropsWithChildren<EnsNodeProviderProps>): react.FunctionComponentElement<{
     children?: React.ReactNode;
-    config: ENSNodeSDKConfig;
+    options: EnsNodeProviderOptions;
 }> | react.FunctionComponentElement<_tanstack_react_query.QueryClientProviderProps>;
 /**
- * Helper function to create ENSNode configuration
+ * Helper function to create ENSNode Provider Options
  */
-declare function createConfig(options?: {
+declare function createEnsNodeProviderOptions(options?: {
     url?: string | URL;
-}): ENSNodeSDKConfig;
+}): EnsNodeProviderOptions;
 
 /**
  * Immutable query options for data that is assumed to be immutable and should only be fetched once per full page refresh per unique key.
@@ -488,7 +485,6 @@ declare const queryKeys: {
     records: (url: string, args: ResolveRecordsRequest<any>) => readonly ["ensnode", string, "resolve", "records", ResolveRecordsRequest<any>];
     primaryName: (url: string, args: ResolvePrimaryNameRequest) => readonly ["ensnode", string, "resolve", "primary-name", ResolvePrimaryNameRequest];
     primaryNames: (url: string, args: ResolvePrimaryNamesRequest) => readonly ["ensnode", string, "resolve", "primary-names", ResolvePrimaryNamesRequest];
-    config: (url: string) => readonly ["ensnode", string, "config"];
     indexingStatus: (url: string) => readonly ["ensnode", string, "indexing-status"];
     registrarActions: (url: string, args: RegistrarActionsRequest) => readonly ["ensnode", string, "registrar-actions", RegistrarActionsRequest];
     nameTokens: (url: string, args: NameTokensRequest) => readonly ["ensnode", string, "name-tokens", NameTokensRequest];
@@ -496,7 +492,7 @@ declare const queryKeys: {
 /**
  * Creates query options for Records Resolution
  */
-declare function createRecordsQueryOptions<SELECTION extends ResolverRecordsSelection>(config: ENSNodeSDKConfig, args: ResolveRecordsRequest<SELECTION>): {
+declare function createRecordsQueryOptions<SELECTION extends ResolverRecordsSelection>(config: EnsNodeProviderOptions, args: ResolveRecordsRequest<SELECTION>): {
     enabled: boolean;
     queryKey: readonly ["ensnode", string, "resolve", "records", ResolveRecordsRequest<any>];
     queryFn: () => Promise<_ensnode_ensnode_sdk.ResolveRecordsResponse<SELECTION>>;
@@ -504,7 +500,7 @@ declare function createRecordsQueryOptions<SELECTION extends ResolverRecordsSele
 /**
  * Creates query options for Primary Name Resolution
  */
-declare function createPrimaryNameQueryOptions(config: ENSNodeSDKConfig, args: ResolvePrimaryNameRequest): {
+declare function createPrimaryNameQueryOptions(config: EnsNodeProviderOptions, args: ResolvePrimaryNameRequest): {
     enabled: boolean;
     queryKey: readonly ["ensnode", string, "resolve", "primary-name", ResolvePrimaryNameRequest];
     queryFn: () => Promise<_ensnode_ensnode_sdk.ResolvePrimaryNameResponse>;
@@ -512,23 +508,15 @@ declare function createPrimaryNameQueryOptions(config: ENSNodeSDKConfig, args: R
 /**
  * Creates query options for Primary Name Resolution
  */
-declare function createPrimaryNamesQueryOptions(config: ENSNodeSDKConfig, args: ResolvePrimaryNamesRequest): {
+declare function createPrimaryNamesQueryOptions(config: EnsNodeProviderOptions, args: ResolvePrimaryNamesRequest): {
     enabled: boolean;
     queryKey: readonly ["ensnode", string, "resolve", "primary-names", ResolvePrimaryNamesRequest];
     queryFn: () => Promise<_ensnode_ensnode_sdk.ResolvePrimaryNamesResponse>;
 };
-/**
- * Creates query options for ENSNode Config API
- */
-declare function createConfigQueryOptions(config: ENSNodeSDKConfig): {
-    enabled: boolean;
-    queryKey: readonly ["ensnode", string, "config"];
-    queryFn: () => Promise<_ensnode_ensnode_sdk.EnsApiPublicConfig>;
-};
 /**
  * Creates query options for ENSNode Indexing Status API
  */
-declare function createIndexingStatusQueryOptions(config: ENSNodeSDKConfig): {
+declare function createIndexingStatusQueryOptions(config: EnsNodeProviderOptions): {
     enabled: boolean;
     queryKey: readonly ["ensnode", string, "indexing-status"];
     queryFn: () => Promise<_ensnode_ensnode_sdk.EnsApiIndexingStatusResponse>;
@@ -536,7 +524,7 @@ declare function createIndexingStatusQueryOptions(config: ENSNodeSDKConfig): {
 /**
  * Creates query options for ENSNode Registrar Actions API
  */
-declare function createRegistrarActionsQueryOptions(config: ENSNodeSDKConfig, args: RegistrarActionsRequest): {
+declare function createRegistrarActionsQueryOptions(config: EnsNodeProviderOptions, args: RegistrarActionsRequest): {
     enabled: boolean;
     queryKey: readonly ["ensnode", string, "registrar-actions", RegistrarActionsRequest];
     queryFn: () => Promise<_ensnode_ensnode_sdk.RegistrarActionsResponse>;
@@ -544,10 +532,10 @@ declare function createRegistrarActionsQueryOptions(config: ENSNodeSDKConfig, ar
 /**
  * Creates query options for Name Tokens API
  */
-declare function createNameTokensQueryOptions(config: ENSNodeSDKConfig, args: NameTokensRequest): {
+declare function createNameTokensQueryOptions(config: EnsNodeProviderOptions, args: NameTokensRequest): {
     enabled: boolean;
     queryKey: readonly ["ensnode", string, "name-tokens", NameTokensRequest];
     queryFn: () => Promise<_ensnode_ensnode_sdk.NameTokensResponse>;
 };
 
-export { ASSUME_IMMUTABLE_QUERY, ENSNodeContext, ENSNodeProvider, type ENSNodeProviderProps, type ENSNodeSDKConfig, type QueryParameter, type UsePrimaryNameParameters, type UsePrimaryNamesParameters, type UseRecordsParameters, type UseResolvedIdentityParameters, type WithSDKConfigParameter, createConfig, createConfigQueryOptions, createIndexingStatusQueryOptions, createNameTokensQueryOptions, createPrimaryNameQueryOptions, createPrimaryNamesQueryOptions, createRecordsQueryOptions, createRegistrarActionsQueryOptions, queryKeys, useENSNodeConfig, useENSNodeSDKConfig, useIndexingStatus, useNameTokens, usePrimaryName, usePrimaryNames, useRecords, useRegistrarActions, useResolvedIdentity, useSwrQuery };
+export { ASSUME_IMMUTABLE_QUERY, EnsNodeContext, EnsNodeProvider, type EnsNodeProviderOptions, type EnsNodeProviderProps, type QueryParameter, type UsePrimaryNameParameters, type UsePrimaryNamesParameters, type UseRecordsParameters, type UseResolvedIdentityParameters, type WithEnsNodeProviderOptions, createEnsNodeProviderOptions, createIndexingStatusQueryOptions, createNameTokensQueryOptions, createPrimaryNameQueryOptions, createPrimaryNamesQueryOptions, createRecordsQueryOptions, createRegistrarActionsQueryOptions, queryKeys, useEnsNodeProviderOptions, useIndexingStatus, useNameTokens, usePrimaryName, usePrimaryNames, useRecords, useRegistrarActions, useResolvedIdentity, useSwrQuery };

package/dist/index.js

@@ -1,14 +1,27 @@
 // src/context.ts
 import { createContext } from "react";
-var ENSNodeContext = createContext(void 0);
-ENSNodeContext.displayName = "ENSNodeContext";
+var EnsNodeContext = createContext(void 0);
+EnsNodeContext.displayName = "EnsNodeContext";
 
-// src/hooks/useENSNodeConfig.ts
+// src/hooks/useEnsNodeProviderOptions.ts
+import { useContext } from "react";
+function useEnsNodeProviderOptions(options) {
+  const contextOptions = useContext(EnsNodeContext);
+  const resolvedOptions = options ?? contextOptions;
+  if (!resolvedOptions) {
+    throw new Error(
+      "useEnsNodeProviderOptions must be used within an EnsNodeProvider or you must pass the options parameter"
+    );
+  }
+  return resolvedOptions;
+}
+
+// src/hooks/useIndexingStatus.ts
 import { useQuery } from "@tanstack/react-query";
 
 // src/utils/query.ts
 import {
-  ENSNodeClient
+  EnsNodeClient
 } from "@ensnode/ensnode-sdk";
 var ASSUME_IMMUTABLE_QUERY = {
   staleTime: Infinity,
@@ -23,7 +36,6 @@ var queryKeys = {
   records: (url, args) => [...queryKeys.resolve(url), "records", args],
   primaryName: (url, args) => [...queryKeys.resolve(url), "primary-name", args],
   primaryNames: (url, args) => [...queryKeys.resolve(url), "primary-names", args],
-  config: (url) => [...queryKeys.base(url), "config"],
   indexingStatus: (url) => [...queryKeys.base(url), "indexing-status"],
   registrarActions: (url, args) => [...queryKeys.base(url), "registrar-actions", args],
   nameTokens: (url, args) => [...queryKeys.base(url), "name-tokens", args]
@@ -33,7 +45,7 @@ function createRecordsQueryOptions(config, args) {
     enabled: true,
     queryKey: queryKeys.records(config.client.url.href, args),
     queryFn: async () => {
-      const client = new ENSNodeClient(config.client);
+      const client = new EnsNodeClient(config.client);
       return client.resolveRecords(args.name, args.selection, args);
     }
   };
@@ -43,7 +55,7 @@ function createPrimaryNameQueryOptions(config, args) {
     enabled: true,
     queryKey: queryKeys.primaryName(config.client.url.href, args),
     queryFn: async () => {
-      const client = new ENSNodeClient(config.client);
+      const client = new EnsNodeClient(config.client);
       return client.resolvePrimaryName(args.address, args.chainId, args);
     }
   };
@@ -53,27 +65,17 @@ function createPrimaryNamesQueryOptions(config, args) {
     enabled: true,
     queryKey: queryKeys.primaryNames(config.client.url.href, args),
     queryFn: async () => {
-      const client = new ENSNodeClient(config.client);
+      const client = new EnsNodeClient(config.client);
       return client.resolvePrimaryNames(args.address, args);
     }
   };
 }
-function createConfigQueryOptions(config) {
-  return {
-    enabled: true,
-    queryKey: queryKeys.config(config.client.url.href),
-    queryFn: async () => {
-      const client = new ENSNodeClient(config.client);
-      return client.config();
-    }
-  };
-}
 function createIndexingStatusQueryOptions(config) {
   return {
     enabled: true,
     queryKey: queryKeys.indexingStatus(config.client.url.href),
     queryFn: async () => {
-      const client = new ENSNodeClient(config.client);
+      const client = new EnsNodeClient(config.client);
       return client.indexingStatus();
     }
   };
@@ -83,7 +85,7 @@ function createRegistrarActionsQueryOptions(config, args) {
     enabled: true,
     queryKey: queryKeys.registrarActions(config.client.url.href, args),
     queryFn: async () => {
-      const client = new ENSNodeClient(config.client);
+      const client = new EnsNodeClient(config.client);
       return client.registrarActions(args);
     }
   };
@@ -93,62 +95,33 @@ function createNameTokensQueryOptions(config, args) {
     enabled: true,
     queryKey: queryKeys.nameTokens(config.client.url.href, args),
     queryFn: async () => {
-      const client = new ENSNodeClient(config.client);
+      const client = new EnsNodeClient(config.client);
       return client.nameTokens(args);
     }
   };
 }
 
-// src/hooks/useENSNodeSDKConfig.ts
-import { useContext } from "react";
-function useENSNodeSDKConfig(config) {
-  const contextConfig = useContext(ENSNodeContext);
-  const resolvedConfig = config ?? contextConfig;
-  if (!resolvedConfig) {
-    throw new Error(
-      "useENSNodeSDKConfig must be used within an ENSNodeProvider or you must pass a config parameter"
-    );
-  }
-  return resolvedConfig;
-}
-
-// src/hooks/useENSNodeConfig.ts
-function useENSNodeConfig(parameters = {}) {
-  const { config, query = {} } = parameters;
-  const _config = useENSNodeSDKConfig(config);
-  const queryOptions = createConfigQueryOptions(_config);
-  const options = {
-    ...queryOptions,
-    ...ASSUME_IMMUTABLE_QUERY,
-    ...query,
-    enabled: query.enabled ?? queryOptions.enabled
-  };
-  return useQuery(options);
-}
-
 // src/hooks/useIndexingStatus.ts
-import { useQuery as useQuery2 } from "@tanstack/react-query";
 function useIndexingStatus(parameters = {}) {
-  const { config, query = {} } = parameters;
-  const _config = useENSNodeSDKConfig(config);
-  const queryOptions = createIndexingStatusQueryOptions(_config);
-  const options = {
+  const { options, query = {} } = parameters;
+  const providerOptions = useEnsNodeProviderOptions(options);
+  const queryOptions = createIndexingStatusQueryOptions(providerOptions);
+  return useQuery({
     ...queryOptions,
     refetchInterval: 10 * 1e3,
     // 10 seconds - indexing status changes frequently
     ...query,
     enabled: query.enabled ?? queryOptions.enabled
-  };
-  return useQuery2(options);
+  });
 }
 
 // src/hooks/useNameTokens.ts
-import { useQuery as useQuery3 } from "@tanstack/react-query";
+import { useQuery as useQuery2 } from "@tanstack/react-query";
 function useNameTokens(parameters) {
-  const { config, query = {} } = parameters;
-  const _config = useENSNodeSDKConfig(config);
-  const queryOptions = createNameTokensQueryOptions(_config, parameters);
-  return useQuery3({
+  const { options, query = {}, ...request } = parameters;
+  const providerOptions = useEnsNodeProviderOptions(options);
+  const queryOptions = createNameTokensQueryOptions(providerOptions, request);
+  return useQuery2({
     ...queryOptions,
     refetchInterval: false,
     // no refetching - assume data is immutable until a full page refresh
@@ -158,64 +131,60 @@ function useNameTokens(parameters) {
 }
 
 // src/hooks/usePrimaryName.ts
-import { useQuery as useQuery4 } from "@tanstack/react-query";
+import { useQuery as useQuery3 } from "@tanstack/react-query";
 function usePrimaryName(parameters) {
-  const { config, query = {}, address, ...args } = parameters;
-  const _config = useENSNodeSDKConfig(config);
+  const { options, query = {}, address, ...args } = parameters;
+  const providerOptions = useEnsNodeProviderOptions(options);
   const canEnable = address !== null;
-  const queryOptions = canEnable ? createPrimaryNameQueryOptions(_config, { ...args, address }) : { enabled: false, queryKey: ["disabled"] };
-  const options = {
+  const queryOptions = canEnable ? createPrimaryNameQueryOptions(providerOptions, { ...args, address }) : { enabled: false, queryKey: ["disabled"] };
+  return useQuery3({
     ...queryOptions,
     ...query,
     enabled: canEnable && (query.enabled ?? queryOptions.enabled)
-  };
-  return useQuery4(options);
+  });
 }
 
 // src/hooks/usePrimaryNames.ts
-import { useQuery as useQuery5 } from "@tanstack/react-query";
+import { useQuery as useQuery4 } from "@tanstack/react-query";
 function usePrimaryNames(parameters) {
-  const { config, query = {}, address, ...args } = parameters;
-  const _config = useENSNodeSDKConfig(config);
+  const { options, query = {}, address, ...args } = parameters;
+  const providerOptions = useEnsNodeProviderOptions(options);
   const canEnable = address !== null;
-  const queryOptions = canEnable ? createPrimaryNamesQueryOptions(_config, { ...args, address }) : { enabled: false, queryKey: ["disabled"] };
-  const options = {
+  const queryOptions = canEnable ? createPrimaryNamesQueryOptions(providerOptions, { ...args, address }) : { enabled: false, queryKey: ["disabled"] };
+  return useQuery4({
     ...queryOptions,
     ...query,
     enabled: canEnable && (query.enabled ?? queryOptions.enabled)
-  };
-  return useQuery5(options);
+  });
 }
 
 // src/hooks/useRecords.ts
-import { useQuery as useQuery6 } from "@tanstack/react-query";
+import { useQuery as useQuery5 } from "@tanstack/react-query";
 function useRecords(parameters) {
-  const { config, query = {}, name, ...args } = parameters;
-  const _config = useENSNodeSDKConfig(config);
+  const { options, query = {}, name, ...args } = parameters;
+  const _config = useEnsNodeProviderOptions(options);
   const canEnable = name !== null;
   const queryOptions = canEnable ? createRecordsQueryOptions(_config, { ...args, name }) : { enabled: false, queryKey: ["disabled"] };
-  const options = {
+  return useQuery5({
     ...queryOptions,
     ...query,
     enabled: canEnable && (query.enabled ?? queryOptions.enabled)
-  };
-  return useQuery6(options);
+  });
 }
 
 // src/hooks/useRegistrarActions.ts
-import { useQuery as useQuery7 } from "@tanstack/react-query";
+import { useQuery as useQuery6 } from "@tanstack/react-query";
 function useRegistrarActions(parameters = {}) {
-  const { config, query = {} } = parameters;
-  const _config = useENSNodeSDKConfig(config);
-  const queryOptions = createRegistrarActionsQueryOptions(_config, parameters);
-  const options = {
+  const { options, query = {}, ...request } = parameters;
+  const providerOptions = useEnsNodeProviderOptions(options);
+  const queryOptions = createRegistrarActionsQueryOptions(providerOptions, request);
+  return useQuery6({
     ...queryOptions,
     refetchInterval: 10 * 1e3,
     // 10 seconds - latest registrar actions change frequently
     ...query,
     enabled: query.enabled ?? queryOptions.enabled
-  };
-  return useQuery7(options);
+  });
 }
 
 // src/hooks/useResolvedIdentity.ts
@@ -225,9 +194,7 @@ import {
   ResolutionStatusIds
 } from "@ensnode/ensnode-sdk";
 function useResolvedIdentity(parameters) {
-  const { identity, accelerate, query: _query = {} } = parameters;
-  const { data } = useENSNodeConfig();
-  const namespace = data?.ensIndexerPublicConfig.namespace;
+  const { identity, namespace, accelerate, query: _query = {} } = parameters;
   const {
     data: primaryNameData,
     status,
@@ -240,7 +207,15 @@ function useResolvedIdentity(parameters) {
       namespace ?? ENSNamespaceIds.Mainnet
     ),
     accelerate,
+    // NOTE: Overriding `gcTime` to prevent unbounded memory growth
+    // in long-running sessions with many identities.
     query: {
+      ...ASSUME_IMMUTABLE_QUERY,
+      // identity changes very rarely
+      gcTime: 60 * 60 * 1e3,
+      // 1 hour
+      refetchInterval: false,
+      // not covered by ASSUME_IMMUTABLE_QUERY
       ..._query,
       enabled: (_query.enabled ?? true) && namespace !== void 0
     }
@@ -277,7 +252,7 @@ function useResolvedIdentity(parameters) {
 
 // src/hooks/useSwrQuery.ts
 import {
-  useQuery as useQuery8,
+  useQuery as useQuery7,
   useQueryClient
 } from "@tanstack/react-query";
 import { useMemo } from "react";
@@ -285,7 +260,7 @@ function useSwrQuery(options, queryClient) {
   const queryClientFromContext = useQueryClient();
   const derivedQueryClient = queryClient ?? queryClientFromContext;
   const cachedSuccessfulResult = derivedQueryClient.getQueryData(options.queryKey);
-  const queryResult = useQuery8(
+  const queryResult = useQuery7(
     {
       ...options,
       // cached result can never be stale
@@ -318,16 +293,15 @@ function useSwrQuery(options, queryClient) {
 // src/provider.tsx
 import { QueryClient, QueryClientProvider, useQueryClient as useQueryClient2 } from "@tanstack/react-query";
 import { createElement, useMemo as useMemo2 } from "react";
-import { ENSNodeClient as ENSNodeClient2 } from "@ensnode/ensnode-sdk";
-function ENSNodeInternalProvider({
+import { EnsNodeClient as EnsNodeClient2 } from "@ensnode/ensnode-sdk";
+function EnsNodeInternalProvider({
   children,
-  config
+  options
 }) {
-  const memoizedConfig = useMemo2(() => config, [config]);
-  return createElement(ENSNodeContext.Provider, { value: memoizedConfig }, children);
+  return createElement(EnsNodeContext.Provider, { value: options }, children);
 }
-function ENSNodeProvider(parameters) {
-  const { children, config, queryClient, queryClientOptions } = parameters;
+function EnsNodeProvider(parameters) {
+  const { children, options, queryClient, queryClientOptions } = parameters;
   let hasExistingQueryClient = false;
   try {
     hasExistingQueryClient = Boolean(useQueryClient2());
@@ -340,10 +314,10 @@ function ENSNodeProvider(parameters) {
         "When providing a custom queryClient, you must wrap your app with QueryClientProvider. Either remove the queryClient prop to use auto-managed setup, or wrap with QueryClientProvider."
       );
     }
-    return createElement(ENSNodeInternalProvider, { config, children });
+    return createElement(EnsNodeInternalProvider, { options, children });
   }
   if (hasExistingQueryClient) {
-    return createElement(ENSNodeInternalProvider, { config, children });
+    return createElement(EnsNodeInternalProvider, { options, children });
   }
   const defaultQueryClient = useMemo2(
     () => new QueryClient({
@@ -365,24 +339,23 @@ function ENSNodeProvider(parameters) {
   return createElement(
     QueryClientProvider,
     { client: defaultQueryClient },
-    createElement(ENSNodeInternalProvider, { config, children })
+    createElement(EnsNodeInternalProvider, { options, children })
   );
 }
-function createConfig(options) {
-  const url = options?.url ? new URL(options.url) : ENSNodeClient2.defaultOptions().url;
+function createEnsNodeProviderOptions(options) {
+  const url = options?.url ? new URL(options.url) : EnsNodeClient2.defaultOptions().url;
   return {
     client: {
-      ...ENSNodeClient2.defaultOptions(),
+      ...EnsNodeClient2.defaultOptions(),
       url
     }
   };
 }
 export {
   ASSUME_IMMUTABLE_QUERY,
-  ENSNodeContext,
-  ENSNodeProvider,
-  createConfig,
-  createConfigQueryOptions,
+  EnsNodeContext,
+  EnsNodeProvider,
+  createEnsNodeProviderOptions,
   createIndexingStatusQueryOptions,
   createNameTokensQueryOptions,
   createPrimaryNameQueryOptions,
@@ -390,8 +363,7 @@ export {
   createRecordsQueryOptions,
   createRegistrarActionsQueryOptions,
   queryKeys,
-  useENSNodeConfig,
-  useENSNodeSDKConfig,
+  useEnsNodeProviderOptions,
   useIndexingStatus,
   useNameTokens,
   usePrimaryName,