@ensnode/ensnode-react 1.9.0 → 1.10.1

package/README.md

@@ -16,18 +16,18 @@ Note: `@tanstack/react-query` is a peer dependency but you don't need to interac
 
 ### 1. Setup the Provider
 
-Wrap your app with the `ENSNodeProvider`:
+Wrap your app with the `EnsNodeProvider`:
 
 ```tsx
-import { ENSNodeProvider, createConfig } from "@ensnode/ensnode-react";
+import { EnsNodeProvider, createEnsNodeProviderOptions } from "@ensnode/ensnode-react";
 
-const config = createConfig({ url: "https://api.alpha.ensnode.io" });
+const options = createEnsNodeProviderOptions({ url: "https://api.alpha.ensnode.io" });
 
 function App() {
   return (
-    <ENSNodeProvider config={config}>
+    <EnsNodeProvider options={options}>
       <YourApp />
-    </ENSNodeProvider>
+    </EnsNodeProvider>
   );
 }
 ```
@@ -124,13 +124,13 @@ function DisplayPrimaryNames() {
 
 ## API Reference
 
-### ENSNodeProvider
+### EnsNodeProvider
 
-The provider component that supplies ENSNode configuration to all child components.
+The provider component that supplies ENSNode Provider Options to all child components.
 
 ```tsx
-interface ENSNodeProviderProps {
-  config: ENSNodeConfig;
+interface EnsNodeProviderProps {
+  options: EnsNodeProviderOptions;
   queryClient?: QueryClient;
   queryClientOptions?: QueryClientOptions;
 }
@@ -138,16 +138,16 @@ interface ENSNodeProviderProps {
 
 #### Props
 
-- `config`: ENSNode configuration object
+- `options`: ENSNode Provider Options object
 - `queryClient`: Optional TanStack Query client instance (requires manual QueryClientProvider setup)
 - `queryClientOptions`: Optional Custom options for auto-created QueryClient (only used when queryClient is not provided)
 
-### createConfig
+### createEnsNodeProviderOptions
 
-Helper function to create ENSNode configuration with defaults.
+Helper function to create ENSNode Provider Options with defaults.
 
 ```tsx
-const config = createConfig({
+const options = createEnsNodeProviderOptions({
   url: "https://api.alpha.ensnode.io",
 });
 ```
@@ -230,12 +230,12 @@ const { data, isLoading, error, refetch } = usePrimaryNames({
 
 ### Custom Query Configuration
 
-The `ENSNodeProvider` automatically creates and manages a QueryClient for you. Cache keys include the ENSNode endpoint URL, so different endpoints (mainnet vs testnet) maintain separate caches. You can customize the QueryClient without importing TanStack Query:
+The `EnsNodeProvider` automatically creates and manages a QueryClient for you. Cache keys include the ENSNode endpoint URL, so different ENSNode endpoints that may have different configurations (ex: mainnet vs sepolia) maintain separate caches. You can customize the QueryClient without importing TanStack Query:
 
 ```tsx
 // Simple setup - no TanStack Query knowledge needed
-<ENSNodeProvider
-  config={config}
+<EnsNodeProvider
+  options={options}
   queryClientOptions={{
     defaultOptions: {
       queries: {
@@ -247,7 +247,7 @@ The `ENSNodeProvider` automatically creates and manages a QueryClient for you. C
   }}
 >
   <App />
-</ENSNodeProvider>
+</EnsNodeProvider>
 ```
 
 ### Advanced: Bring Your Own QueryClient
@@ -268,9 +268,9 @@ const queryClient = new QueryClient({
 });
 
 <QueryClientProvider client={queryClient}>
-  <ENSNodeProvider config={config} queryClient={queryClient}>
+  <EnsNodeProvider options={options} queryClient={queryClient}>
     <App />
-  </ENSNodeProvider>
+  </EnsNodeProvider>
 </QueryClientProvider>;
 ```
 

package/dist/index.cjs

@@ -21,10 +21,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   ASSUME_IMMUTABLE_QUERY: () => ASSUME_IMMUTABLE_QUERY,
-  ENSNodeContext: () => ENSNodeContext,
-  ENSNodeProvider: () => ENSNodeProvider,
-  createConfig: () => createConfig,
-  createConfigQueryOptions: () => createConfigQueryOptions,
+  EnsNodeContext: () => EnsNodeContext,
+  EnsNodeProvider: () => EnsNodeProvider,
+  createEnsNodeProviderOptions: () => createEnsNodeProviderOptions,
   createIndexingStatusQueryOptions: () => createIndexingStatusQueryOptions,
   createNameTokensQueryOptions: () => createNameTokensQueryOptions,
   createPrimaryNameQueryOptions: () => createPrimaryNameQueryOptions,
@@ -32,8 +31,7 @@ __export(index_exports, {
   createRecordsQueryOptions: () => createRecordsQueryOptions,
   createRegistrarActionsQueryOptions: () => createRegistrarActionsQueryOptions,
   queryKeys: () => queryKeys,
-  useENSNodeConfig: () => useENSNodeConfig,
-  useENSNodeSDKConfig: () => useENSNodeSDKConfig,
+  useEnsNodeProviderOptions: () => useEnsNodeProviderOptions,
   useIndexingStatus: () => useIndexingStatus,
   useNameTokens: () => useNameTokens,
   usePrimaryName: () => usePrimaryName,
@@ -47,10 +45,23 @@ module.exports = __toCommonJS(index_exports);
 
 // src/context.ts
 var import_react = require("react");
-var ENSNodeContext = (0, import_react.createContext)(void 0);
-ENSNodeContext.displayName = "ENSNodeContext";
+var EnsNodeContext = (0, import_react.createContext)(void 0);
+EnsNodeContext.displayName = "EnsNodeContext";
 
-// src/hooks/useENSNodeConfig.ts
+// src/hooks/useEnsNodeProviderOptions.ts
+var import_react2 = require("react");
+function useEnsNodeProviderOptions(options) {
+  const contextOptions = (0, import_react2.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
 var import_react_query = require("@tanstack/react-query");
 
 // src/utils/query.ts
@@ -68,7 +79,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]
@@ -78,7 +88,7 @@ function createRecordsQueryOptions(config, args) {
     enabled: true,
     queryKey: queryKeys.records(config.client.url.href, args),
     queryFn: async () => {
-      const client = new import_ensnode_sdk.ENSNodeClient(config.client);
+      const client = new import_ensnode_sdk.EnsNodeClient(config.client);
       return client.resolveRecords(args.name, args.selection, args);
     }
   };
@@ -88,7 +98,7 @@ function createPrimaryNameQueryOptions(config, args) {
     enabled: true,
     queryKey: queryKeys.primaryName(config.client.url.href, args),
     queryFn: async () => {
-      const client = new import_ensnode_sdk.ENSNodeClient(config.client);
+      const client = new import_ensnode_sdk.EnsNodeClient(config.client);
       return client.resolvePrimaryName(args.address, args.chainId, args);
     }
   };
@@ -98,27 +108,17 @@ function createPrimaryNamesQueryOptions(config, args) {
     enabled: true,
     queryKey: queryKeys.primaryNames(config.client.url.href, args),
     queryFn: async () => {
-      const client = new import_ensnode_sdk.ENSNodeClient(config.client);
+      const client = new import_ensnode_sdk.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 import_ensnode_sdk.ENSNodeClient(config.client);
-      return client.config();
-    }
-  };
-}
 function createIndexingStatusQueryOptions(config) {
   return {
     enabled: true,
     queryKey: queryKeys.indexingStatus(config.client.url.href),
     queryFn: async () => {
-      const client = new import_ensnode_sdk.ENSNodeClient(config.client);
+      const client = new import_ensnode_sdk.EnsNodeClient(config.client);
       return client.indexingStatus();
     }
   };
@@ -128,7 +128,7 @@ function createRegistrarActionsQueryOptions(config, args) {
     enabled: true,
     queryKey: queryKeys.registrarActions(config.client.url.href, args),
     queryFn: async () => {
-      const client = new import_ensnode_sdk.ENSNodeClient(config.client);
+      const client = new import_ensnode_sdk.EnsNodeClient(config.client);
       return client.registrarActions(args);
     }
   };
@@ -138,62 +138,33 @@ function createNameTokensQueryOptions(config, args) {
     enabled: true,
     queryKey: queryKeys.nameTokens(config.client.url.href, args),
     queryFn: async () => {
-      const client = new import_ensnode_sdk.ENSNodeClient(config.client);
+      const client = new import_ensnode_sdk.EnsNodeClient(config.client);
       return client.nameTokens(args);
     }
   };
 }
 
-// src/hooks/useENSNodeSDKConfig.ts
-var import_react2 = require("react");
-function useENSNodeSDKConfig(config) {
-  const contextConfig = (0, import_react2.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 (0, import_react_query.useQuery)(options);
-}
-
 // src/hooks/useIndexingStatus.ts
-var import_react_query2 = require("@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 (0, import_react_query.useQuery)({
     ...queryOptions,
     refetchInterval: 10 * 1e3,
     // 10 seconds - indexing status changes frequently
     ...query,
     enabled: query.enabled ?? queryOptions.enabled
-  };
-  return (0, import_react_query2.useQuery)(options);
+  });
 }
 
 // src/hooks/useNameTokens.ts
-var import_react_query3 = require("@tanstack/react-query");
+var import_react_query2 = require("@tanstack/react-query");
 function useNameTokens(parameters) {
-  const { config, query = {} } = parameters;
-  const _config = useENSNodeSDKConfig(config);
-  const queryOptions = createNameTokensQueryOptions(_config, parameters);
-  return (0, import_react_query3.useQuery)({
+  const { options, query = {}, ...request } = parameters;
+  const providerOptions = useEnsNodeProviderOptions(options);
+  const queryOptions = createNameTokensQueryOptions(providerOptions, request);
+  return (0, import_react_query2.useQuery)({
     ...queryOptions,
     refetchInterval: false,
     // no refetching - assume data is immutable until a full page refresh
@@ -203,72 +174,66 @@ function useNameTokens(parameters) {
 }
 
 // src/hooks/usePrimaryName.ts
-var import_react_query4 = require("@tanstack/react-query");
+var import_react_query3 = require("@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 (0, import_react_query3.useQuery)({
     ...queryOptions,
     ...query,
     enabled: canEnable && (query.enabled ?? queryOptions.enabled)
-  };
-  return (0, import_react_query4.useQuery)(options);
+  });
 }
 
 // src/hooks/usePrimaryNames.ts
-var import_react_query5 = require("@tanstack/react-query");
+var import_react_query4 = require("@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 (0, import_react_query4.useQuery)({
     ...queryOptions,
     ...query,
     enabled: canEnable && (query.enabled ?? queryOptions.enabled)
-  };
-  return (0, import_react_query5.useQuery)(options);
+  });
 }
 
 // src/hooks/useRecords.ts
-var import_react_query6 = require("@tanstack/react-query");
+var import_react_query5 = require("@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 (0, import_react_query5.useQuery)({
     ...queryOptions,
     ...query,
     enabled: canEnable && (query.enabled ?? queryOptions.enabled)
-  };
-  return (0, import_react_query6.useQuery)(options);
+  });
 }
 
 // src/hooks/useRegistrarActions.ts
-var import_react_query7 = require("@tanstack/react-query");
+var import_react_query6 = require("@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 (0, import_react_query6.useQuery)({
     ...queryOptions,
     refetchInterval: 10 * 1e3,
     // 10 seconds - latest registrar actions change frequently
     ...query,
     enabled: query.enabled ?? queryOptions.enabled
-  };
-  return (0, import_react_query7.useQuery)(options);
+  });
 }
 
 // src/hooks/useResolvedIdentity.ts
 var import_ensnode_sdk2 = require("@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,
@@ -281,7 +246,15 @@ function useResolvedIdentity(parameters) {
       namespace ?? import_ensnode_sdk2.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
     }
@@ -317,13 +290,13 @@ function useResolvedIdentity(parameters) {
 }
 
 // src/hooks/useSwrQuery.ts
-var import_react_query8 = require("@tanstack/react-query");
+var import_react_query7 = require("@tanstack/react-query");
 var import_react3 = require("react");
 function useSwrQuery(options, queryClient) {
-  const queryClientFromContext = (0, import_react_query8.useQueryClient)();
+  const queryClientFromContext = (0, import_react_query7.useQueryClient)();
   const derivedQueryClient = queryClient ?? queryClientFromContext;
   const cachedSuccessfulResult = derivedQueryClient.getQueryData(options.queryKey);
-  const queryResult = (0, import_react_query8.useQuery)(
+  const queryResult = (0, import_react_query7.useQuery)(
     {
       ...options,
       // cached result can never be stale
@@ -354,21 +327,20 @@ function useSwrQuery(options, queryClient) {
 }
 
 // src/provider.tsx
-var import_react_query9 = require("@tanstack/react-query");
+var import_react_query8 = require("@tanstack/react-query");
 var import_react4 = require("react");
 var import_ensnode_sdk3 = require("@ensnode/ensnode-sdk");
-function ENSNodeInternalProvider({
+function EnsNodeInternalProvider({
   children,
-  config
+  options
 }) {
-  const memoizedConfig = (0, import_react4.useMemo)(() => config, [config]);
-  return (0, import_react4.createElement)(ENSNodeContext.Provider, { value: memoizedConfig }, children);
+  return (0, import_react4.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((0, import_react_query9.useQueryClient)());
+    hasExistingQueryClient = Boolean((0, import_react_query8.useQueryClient)());
   } catch {
     hasExistingQueryClient = false;
   }
@@ -378,13 +350,13 @@ 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 (0, import_react4.createElement)(ENSNodeInternalProvider, { config, children });
+    return (0, import_react4.createElement)(EnsNodeInternalProvider, { options, children });
   }
   if (hasExistingQueryClient) {
-    return (0, import_react4.createElement)(ENSNodeInternalProvider, { config, children });
+    return (0, import_react4.createElement)(EnsNodeInternalProvider, { options, children });
   }
   const defaultQueryClient = (0, import_react4.useMemo)(
-    () => new import_react_query9.QueryClient({
+    () => new import_react_query8.QueryClient({
       defaultOptions: {
         queries: {
           retry: 3,
@@ -401,16 +373,16 @@ function ENSNodeProvider(parameters) {
     [queryClientOptions]
   );
   return (0, import_react4.createElement)(
-    import_react_query9.QueryClientProvider,
+    import_react_query8.QueryClientProvider,
     { client: defaultQueryClient },
-    (0, import_react4.createElement)(ENSNodeInternalProvider, { config, children })
+    (0, import_react4.createElement)(EnsNodeInternalProvider, { options, children })
   );
 }
-function createConfig(options) {
-  const url = options?.url ? new URL(options.url) : import_ensnode_sdk3.ENSNodeClient.defaultOptions().url;
+function createEnsNodeProviderOptions(options) {
+  const url = options?.url ? new URL(options.url) : import_ensnode_sdk3.EnsNodeClient.defaultOptions().url;
   return {
     client: {
-      ...import_ensnode_sdk3.ENSNodeClient.defaultOptions(),
+      ...import_ensnode_sdk3.EnsNodeClient.defaultOptions(),
       url
     }
   };