@ic-reactor/react 3.13.0 → 4.0.0-beta.1

package/src/defineReactorShared.ts

@@ -1,268 +0,0 @@
-/**
- * The body `defineReactor` and `defineDisplayReactor` share.
- *
- * It takes the reactor's construction as a callback, so this module imports
- * neither reactor class. That matters for bundle size: `DisplayReactor` builds
- * its codecs on zod, and a module that imported it here would put zod in every
- * app that calls `defineReactor`, whether or not it ever builds a
- * DisplayReactor. Keep it that way — no `DisplayReactor` import in this file.
- */
-import { ClientManager, reactorRetry } from "@ic-reactor/core"
-import type {
-  Reactor,
-  TransformKey,
-  ReactorParameters,
-  ClientManagerParameters,
-} from "@ic-reactor/core"
-import { QueryClient } from "@tanstack/react-query"
-import { createActorHooks, ActorHooks } from "./createActorHooks.js"
-import { AuthenticationManager } from "./auth/authentication-manager.js"
-import { IdentityAttributesManager } from "./auth/identity-attributes-manager.js"
-import { createIdentityAttributeHooks } from "./auth/createIdentityAttributeHooks.js"
-import type { UseIdentityAttributesReturn } from "./auth/createIdentityAttributeHooks.js"
-import { createAuthHooks } from "./hooks/createAuthHooks.js"
-import type { CreateAuthHooksReturn } from "./hooks/createAuthHooks.js"
-import type { AuthenticationManagerParameters } from "./auth/authentication-manager.js"
-import { registerAuthentication } from "./ownedAuthentication.js"
-
-/** Options shared by both the standard and display variants of defineReactor. */
-export interface DefineReactorSharedParameters
-  extends
-    Omit<ReactorParameters, "clientManager">,
-    Omit<ClientManagerParameters, "queryClient"> {
-  /**
-   * Reuse an existing ClientManager (e.g. to share one agent across canisters).
-   * When omitted, a ClientManager is created from the agent options below.
-   *
-   * A supplied or adopted manager brings its own agent and QueryClient, so
-   * `agentOptions`, `queryClient` and `allowEnvConfig` apply only when this
-   * call creates one.
-   */
-  clientManager?: ClientManager
-  /**
-   * QueryClient for a ClientManager created by this call.
-   *
-   * Ignored when `clientManager` or `authentication` is supplied — queries run
-   * against that manager's own QueryClient, which is what is returned.
-   */
-  queryClient?: QueryClient
-  /**
-   * Reuse an existing AuthenticationManager, so several reactors share one
-   * Internet Identity session. When omitted, one is created for this reactor.
-   *
-   * Its `clientManager` is adopted for this reactor, so sign-in updates the
-   * same agent the reactor calls through. Supplying a different `clientManager`
-   * alongside it is rejected.
-   */
-  authentication?: AuthenticationManager
-  /**
-   * Internet Identity options forwarded to the AuthenticationManager
-   * (`identityProvider`, `derivationOrigin`, `idleOptions`, `storage`, …).
-   *
-   * Not every option reaches both `@icp-sdk/auth` majors. `idleOptions`,
-   * `storage`, `keyType` and `identity` are honoured only by v8: v10 has no
-   * equivalent, so IC Reactor drops each with a one-time warning. For idle
-   * handling on v10, pass `maxTimeToIdle` to `login()` and set
-   * `disableBrowserActivity` here. `disableBrowserActivity` is v10-only.
-   *
-   * Mutually exclusive with `authentication`: a manager built elsewhere is
-   * already configured, so these could not be applied to it.
-   */
-  auth?: Omit<AuthenticationManagerParameters, "clientManager">
-}
-
-/** The reactor instance plus its bound hooks and shared infrastructure. */
-export type DefineReactorResult<
-  Service,
-  Transform extends TransformKey,
-  R extends Reactor<Service, Transform>,
-> = ActorHooks<Service, Transform> &
-  CreateAuthHooksReturn & {
-    reactor: R
-    clientManager: ClientManager
-    queryClient: QueryClient
-    /** Internet Identity session manager backing `useAuth`. */
-    authentication: AuthenticationManager
-    /** Signed identity attribute requests backing `useIdentityAttributes`. */
-    identityAttributes: IdentityAttributesManager
-    useIdentityAttributes: () => UseIdentityAttributesReturn
-  }
-
-/**
- * The QueryClient this module creates when the caller does not supply one.
- *
- * React Query retries every failure three times by default, which for canister
- * calls means four attempts and several seconds of backoff on outcomes that
- * cannot change — a canister `Err`, a validation failure, a Candid encode
- * error that never reached the network. `reactorRetry` keeps the same three
- * attempts for transport failures and stops immediately on the rest.
- *
- * A caller-supplied `queryClient` is left exactly as given; opt in there with
- * `defaultOptions: { queries: { retry: reactorRetry } }`.
- */
-const createDefaultQueryClient = () =>
-  new QueryClient({
-    defaultOptions: { queries: { retry: reactorRetry } },
-  })
-
-/**
- * Builds the ClientManager, the reactor `createReactor` returns, its hooks and
- * the lazily created auth managers, for `defineReactor` and
- * `defineDisplayReactor`. Not part of the public API.
- *
- * `caller` is the function the app called; the errors below name it, so an
- * app that called `defineDisplayReactor` is not sent looking for a
- * `defineReactor` call it never made.
- *
- * @internal
- */
-export function defineReactorWith<
-  Service,
-  Transform extends TransformKey,
-  R extends Reactor<Service, Transform>,
->(
-  caller: "defineReactor" | "defineDisplayReactor",
-  params: DefineReactorSharedParameters,
-  createReactor: (config: ReactorParameters) => R
-): DefineReactorResult<Service, Transform, R> {
-  const {
-    clientManager: providedClientManager,
-    queryClient: providedQueryClient,
-    authentication: providedAuthentication,
-    auth,
-    agentOptions,
-    allowEnvConfig,
-    allowEnvRootKey,
-    name,
-    idlFactory,
-    canisterId,
-    pollingOptions,
-  } = params
-
-  // A shared AuthenticationManager updates the identity on its own
-  // ClientManager. Giving this reactor a different one would leave its calls
-  // anonymous after sign-in, so adopt the manager's rather than building a new
-  // one, and refuse an explicit mismatch instead of splitting them silently.
-  if (
-    providedClientManager &&
-    providedAuthentication &&
-    providedAuthentication.clientManager !== providedClientManager
-  ) {
-    throw new Error(
-      `[ic-reactor] ${caller}("${name}") received an \`authentication\` manager bound to a different \`clientManager\`. ` +
-        `Sign-in would update the authentication manager's agent while this reactor calls through another one, ` +
-        `leaving its calls anonymous. Pass \`clientManager: authentication.clientManager\`, or omit \`clientManager\` to adopt it.`
-    )
-  }
-
-  // `auth` configures a manager this call would build; an existing one is
-  // already constructed, so these options could only be dropped on the floor.
-  if (providedAuthentication && auth) {
-    throw new Error(
-      `[ic-reactor] ${caller}("${name}") received both \`authentication\` and \`auth\`. ` +
-        `The supplied manager is already configured, so \`auth\` (${Object.keys(auth).join(", ")}) would be ignored. ` +
-        `Pass those options where that AuthenticationManager is created, or drop \`authentication\` to build one here.`
-    )
-  }
-
-  // Same reasoning as `auth`, and it matters more here: an ignored
-  // `allowEnvConfig: false` reads as "I locked the cookie out" while the
-  // supplied manager carries whatever decision it was built with.
-  if (
-    (providedClientManager || providedAuthentication) &&
-    (allowEnvConfig !== undefined || allowEnvRootKey !== undefined)
-  ) {
-    const passed = [
-      allowEnvConfig !== undefined && "allowEnvConfig",
-      allowEnvRootKey !== undefined && "allowEnvRootKey",
-    ]
-      .filter(Boolean)
-      .join(", ")
-    throw new Error(
-      `[ic-reactor] ${caller}("${name}") received both a ClientManager and \`${passed}\`. ` +
-        `That option is resolved when a ClientManager is constructed, so the supplied one already carries its own ` +
-        `decision and this would be ignored — silently changing nothing about whether the ic_env cookie is trusted. ` +
-        `Pass it where that ClientManager is created, or drop \`clientManager\` to build one here.`
-    )
-  }
-
-  const clientManager =
-    providedClientManager ??
-    providedAuthentication?.clientManager ??
-    new ClientManager({
-      queryClient: providedQueryClient ?? createDefaultQueryClient(),
-      agentOptions,
-      // Forwarded, not dropped: the type has always accepted these (it extends
-      // ClientManagerParameters) while the call ignored them, so the one
-      // documented setup path silently discarded the ic_env opt-in it advertised.
-      allowEnvConfig,
-      allowEnvRootKey,
-    })
-
-  // Always report the QueryClient actually in use: when a ClientManager is
-  // supplied or adopted, its own QueryClient is the one queries run against.
-  const queryClient = clientManager.queryClient
-
-  const reactor = createReactor({
-    clientManager,
-    name,
-    idlFactory,
-    canisterId,
-    pollingOptions,
-  })
-
-  const hooks = createActorHooks<Service, Transform>(reactor)
-
-  // Auth is built on first use. `AuthenticationManager` dynamically imports the
-  // optional `@icp-sdk/auth` peer as soon as it is constructed, and reactors
-  // that never touch authentication should not pay for that.
-  let authenticationInstance: AuthenticationManager | undefined
-  const getAuthentication = () =>
-    (authenticationInstance ??=
-      providedAuthentication ??
-      new AuthenticationManager({ ...auth, clientManager }))
-
-  let identityAttributesInstance: IdentityAttributesManager | undefined
-  const getIdentityAttributes = () =>
-    (identityAttributesInstance ??= new IdentityAttributesManager(
-      getAuthentication()
-    ))
-
-  let authHooks: CreateAuthHooksReturn | undefined
-  const getAuthHooks = () =>
-    (authHooks ??= createAuthHooks(getAuthentication()))
-
-  let attributeHooks:
-    ReturnType<typeof createIdentityAttributeHooks> | undefined
-  const getAttributeHooks = () =>
-    (attributeHooks ??= createIdentityAttributeHooks(getIdentityAttributes()))
-
-  const result: DefineReactorResult<Service, Transform, R> = {
-    ...hooks,
-    reactor,
-    clientManager,
-    queryClient,
-    // Stable wrappers: the hook call order inside them never changes, so the
-    // rules of hooks still hold.
-    useAuth: () => getAuthHooks().useAuth(),
-    useAgentState: () => getAuthHooks().useAgentState(),
-    useUserPrincipal: () => getAuthHooks().useUserPrincipal(),
-    useIdentityAttributes: () => getAttributeHooks().useIdentityAttributes(),
-    get authentication() {
-      return getAuthentication()
-    },
-    get identityAttributes() {
-      return getIdentityAttributes()
-    },
-  }
-
-  // For `createReactorProvider`, which disposes the manager this result
-  // builds when its tree unmounts. It reads the manager without the getter
-  // above, so a tree that never touched authentication does not build one
-  // just to release it. A supplied manager is not this result's to release.
-  registerAuthentication(result, () =>
-    providedAuthentication ? undefined : authenticationInstance
-  )
-
-  return result
-}

package/src/hooks/createAuthHooks.ts

@@ -1,371 +0,0 @@
-import { useSyncExternalStore, useEffect, useRef, useMemo } from "react"
-import type { AuthenticationManager } from "../auth/authentication-manager.js"
-import type { AuthState, AuthenticationSignInOptions } from "../auth/types.js"
-import type { AgentState } from "@ic-reactor/core"
-import type { Principal } from "@icp-sdk/core/principal"
-import type { Identity } from "@icp-sdk/core/agent"
-
-export interface UseAuthReturn {
-  authenticate: () => Promise<Identity | undefined>
-  login: (options?: AuthenticationSignInOptions) => Promise<void>
-  logout: (options?: { returnTo?: string }) => Promise<void>
-  isAuthenticated: boolean
-  /**
-   * `true` while a sign-in or sign-out is in progress, and until the session
-   * restore the first `useAuth()` starts has settled: on the first render, in
-   * a server render and while the stored session is read. A restore that fails
-   * settles it too. Show a loading state while it is `true` rather than
-   * treating `isAuthenticated: false` as signed out.
-   */
-  isAuthenticating: boolean
-  /**
-   * The signed-in user's principal, or `null` while signed out. A signed-out
-   * session still holds an anonymous `identity`, and its principal is not
-   * returned here.
-   */
-  principal: Principal | null
-  identity: Identity | null
-  error: Error | undefined
-}
-
-export interface CreateAuthHooksReturn {
-  useAgentState: () => AgentState
-  useUserPrincipal: () => Principal | null
-  useAuth: () => UseAuthReturn
-}
-
-/**
- * The managers whose session a `useAuth()` has already started restoring.
- *
- * Restoring ends in `authenticate()`, which publishes `isAuthenticating: true`
- * and then the restored state. It used to run once per mounted `useAuth()`
- * rather than once per manager, so every consumer that mounted while signed out
- * flipped `isAuthenticating` for the whole app, and one that mounted while a
- * sign-in popup was open cleared `isAuthenticating` before the sign-in ended. A
- * component that hides a `useAuth()` consumer while `isAuthenticating` never
- * settled: each restore unmounted the consumer, and each remount restored
- * again. Both clients answer from memory once loaded, so that loop ran on the
- * microtask queue and the page never painted again.
- *
- * Keyed by manager rather than by `createAuthHooks` call, because reactors that
- * share one `AuthenticationManager` each build their own hooks.
- */
-const restoredSessions = new WeakSet<AuthenticationManager>()
-
-/**
- * How many `useAuth()` consumers of each manager are mounted, so that a
- * restore can tell a manager that was discarded from one StrictMode released
- * and mounted again; see `useAuth()`.
- */
-const mountedConsumers = new WeakMap<AuthenticationManager, number>()
-
-/**
- * The principal both hooks return.
- *
- * `authenticate()` and `logout()` leave the client's anonymous identity in
- * `authState.identity` with `isAuthenticated: false`, so deriving the principal
- * from the identity alone reported `2vxsx-fae` for a signed-out user, and
- * `principal ? <SignedIn /> : <SignedOut />` rendered the signed-in branch.
- * Memoized on the identity, because `getPrincipal()` may build a new object on
- * each call and the result is often a hook dependency.
- */
-function usePrincipal(
-  isAuthenticated: boolean,
-  identity: Identity | null
-): Principal | null {
-  return useMemo(
-    () => (isAuthenticated && identity ? identity.getPrincipal() : null),
-    [isAuthenticated, identity]
-  )
-}
-
-/**
- * The auth state a server render shows, and so the one hydration shows.
- *
- * `useSyncExternalStore` renders `getServerSnapshot` on the server and again
- * while hydrating, and both renders have to produce the HTML the server sent.
- * The hooks passed the live state for both. A server holds no session, so its
- * HTML is signed out. A component that hydrates after the session is restored,
- * such as one inside a Suspense boundary whose code arrives later, read the
- * restored state and no longer matched that HTML. React then reported a
- * hydration error and threw the boundary's server HTML away to render it again
- * on the client. A constant also keeps a server render from showing whatever a
- * manager shared across requests happens to hold.
- *
- * It is the state the hooks report before the session has been checked: a
- * server cannot know the session, so it renders the "checking" state that a
- * browser shows until its restore settles. Once hydrated, React compares it
- * with the live state and renders again with that.
- */
-const SERVER_AUTH_STATE: AuthState = Object.freeze({
-  identity: null,
-  isAuthenticating: true,
-  isAuthenticated: false,
-  error: undefined,
-})
-
-/**
- * Create authentication hooks for managing user sessions with Internet Identity.
- *
- * @example
- * const { useAuth, useUserPrincipal, useAgentState } = createAuthHooks(authentication)
- *
- * function App() {
- *   const { login, logout, principal, isAuthenticated } = useAuth()
- *
- *   return isAuthenticated
- *     ? <button onClick={() => logout()}>Logout {principal?.toText()}</button>
- *     : <button onClick={() => login()}>Login with II</button>
- * }
- */
-export const createAuthHooks = (
-  authentication: AuthenticationManager
-): CreateAuthHooksReturn => {
-  // Passing a ClientManager here is the natural mistake — it is what
-  // `AuthenticationManager` is built from, and the two are adjacent in every
-  // setup snippet. TypeScript rejects it, but a JS caller got no error until
-  // render, where it surfaced as "Cannot destructure property 'isAuthenticated'
-  // of 'useAuthState(...)' as it is undefined" — which names neither the cause
-  // nor this function.
-  if (
-    !authentication ||
-    typeof authentication.subscribeAuthState !== "function"
-  ) {
-    throw new TypeError(
-      "[ic-reactor] createAuthHooks() expects an AuthenticationManager, not a " +
-        "ClientManager. Build one first: " +
-        "`new AuthenticationManager({ clientManager })`, or take it from " +
-        "`defineReactor(...).authentication`."
-    )
-  }
-
-  const { clientManager } = authentication
-
-  // The agent state a manager starts in, for the reason given at
-  // SERVER_AUTH_STATE: `useAuth()` initializes the agent once hydrated, so a
-  // component hydrating later read `isInitialized: true` against server HTML
-  // rendered before any initialization. The network is kept: it comes from the
-  // agent's host, which initialization does not change.
-  const serverAgentState: AgentState = Object.freeze({
-    isInitialized: false,
-    isInitializing: false,
-    error: undefined,
-    network: clientManager.network,
-    isLocalhost: clientManager.isLocal,
-  })
-
-  // What every consumer hands `useSyncExternalStore`, built once rather than
-  // on each render. React unsubscribes and subscribes again whenever the
-  // subscribe function changes, and each unsubscribe filters the manager's
-  // whole subscriber list. An auth state change re-renders every consumer, so
-  // a function per render cost k re-subscriptions and about k²/2 subscriber
-  // visits for k consumers: two million for 2,000 `useUserPrincipal()` rows.
-  const subscribeAgentState = (callback: () => void) =>
-    clientManager.subscribeAgentState(callback)
-  const getAgentState = () => clientManager.agentState
-  const getServerAgentState = () => serverAgentState
-
-  // Until the session has been checked, `authState` is the signed-out state
-  // the manager starts in, and reporting it as the answer sent signed-in users
-  // to the login page (#621). `useAuth()` starts the check from an effect, so
-  // on the first render nothing had been checked, yet `isAuthenticating` was
-  // false: a guard that redirects when `!isAuthenticating && !isAuthenticated`
-  // redirected before the session was ever read. The hooks report
-  // `isAuthenticating: true` until the check settles instead. The snapshot is
-  // kept per source state, because `useSyncExternalStore` needs the same object
-  // back until something changes.
-  let unchecked: { source: AuthState; state: AuthState } | undefined
-  const subscribeAuthState = (callback: () => void) => {
-    const unsubscribeState = authentication.subscribeAuthState(callback)
-    const unsubscribeChecked = authentication.subscribeSessionChecked(callback)
-    return () => {
-      unsubscribeState()
-      unsubscribeChecked()
-    }
-  }
-  const getAuthState = () => {
-    const state = authentication.authState
-    if (authentication.sessionChecked || state.isAuthenticating) return state
-    if (unchecked?.source !== state) {
-      unchecked = {
-        source: state,
-        state: Object.freeze({ ...state, isAuthenticating: true }),
-      }
-    }
-    return unchecked.state
-  }
-  const getServerAuthState = () => SERVER_AUTH_STATE
-
-  /**
-   * Subscribe to agent state changes.
-   * Returns the current agent state (agent, isInitialized, etc.)
-   */
-  const useAgentState = (): AgentState =>
-    useSyncExternalStore(
-      subscribeAgentState,
-      getAgentState,
-      getServerAgentState
-    )
-
-  /**
-   * Subscribe to authentication state changes.
-   * Returns auth state (isAuthenticated, isAuthenticating, identity, error)
-   */
-  const useAuthState = (): AuthState =>
-    useSyncExternalStore(subscribeAuthState, getAuthState, getServerAuthState)
-
-  /**
-   * Main authentication hook that provides login/logout methods and auth state.
-   * Automatically initializes the session on first use, restoring any previous session.
-   *
-   * `isAuthenticating` is `true` until that restore has settled, including on
-   * the first render and in a server render, so a guard that shows a spinner
-   * while `isAuthenticating` never takes the state before the restore for a
-   * signed-out user. A restore that fails settles it too.
-   *
-   * @example
-   * function AuthButton() {
-   *   const { login, logout, isAuthenticated, isAuthenticating } = useAuth()
-   *
-   *   if (isAuthenticated) {
-   *     return <button onClick={() => logout()}>Logout</button>
-   *   }
-   *   return (
-   *     <button onClick={() => login()} disabled={isAuthenticating}>
-   *       {isAuthenticating ? "Connecting..." : "Login"}
-   *     </button>
-   *   )
-   * }
-   */
-  const useAuth = (): UseAuthReturn => {
-    const { login, logout, authenticate } = authentication
-    const { isAuthenticated, isAuthenticating, identity, error } =
-      useAuthState()
-
-    // Keeps a StrictMode re-run of the effect below from repeating it.
-    const initializedRef = useRef(false)
-
-    // Restore the previous session when the first consumer of this manager
-    // mounts. `prepareClient` also warms up the AuthClient so a later
-    // `login()` can open the identity provider window inside the click handler.
-    useEffect(() => {
-      mountedConsumers.set(
-        authentication,
-        (mountedConsumers.get(authentication) ?? 0) + 1
-      )
-      const unmount = () => {
-        mountedConsumers.set(
-          authentication,
-          (mountedConsumers.get(authentication) ?? 1) - 1
-        )
-      }
-
-      if (initializedRef.current && restoredSessions.has(authentication)) {
-        return unmount
-      }
-      const firstRun = !initializedRef.current
-      initializedRef.current = true
-
-      if (restoredSessions.has(authentication)) {
-        // Restored already. A live session is still checked again, which
-        // notices a delegation that has lapsed since and publishes nothing
-        // while it is valid.
-        if (firstRun && authentication.authState.isAuthenticated) {
-          authentication.authenticate().catch(() => undefined)
-        }
-        return unmount
-      }
-      restoredSessions.add(authentication)
-
-      // A provider that builds its managers per mount disposes the manager
-      // from its cleanup. One that unmounted before this restore had built
-      // the client still got one, built after `dispose()` and never released,
-      // so each quick remount left a live client listening to the page. The
-      // restore stops instead once the manager has been disposed since it
-      // began and no `useAuth()` of it is mounted, releasing what it built.
-      // StrictMode's cleanup disposes the manager too, but mounts this
-      // consumer again before the restore looks, and that restore goes on.
-      // One that stopped counts as not having run, so a manager mounted again,
-      // as `<Activity>` mounts a tree it showed again, restores.
-      const releases = authentication.releaseCount
-      const abandoned = () => {
-        if (
-          authentication.releaseCount === releases ||
-          (mountedConsumers.get(authentication) ?? 0) > 0
-        ) {
-          return false
-        }
-        authentication.dispose()
-        restoredSessions.delete(authentication)
-        return true
-      }
-
-      void authentication
-        .prepareClient()
-        .catch(() => undefined)
-        .then(async () => {
-          if (abandoned()) return false
-          await clientManager.initialize()
-          if (abandoned()) return false
-          // A check that has settled already and found no session, such as
-          // the one a manager runs over a client handed to its constructor,
-          // or a route loader's `authenticate()`, answered what this restore
-          // would. Running it again only flashed `isAuthenticating`, and a
-          // guard redirected a second time. A live session is still checked,
-          // which publishes nothing while it is valid.
-          const { isAuthenticated, error } = authentication.authState
-          if (authentication.sessionChecked && !isAuthenticated && !error) {
-            return true
-          }
-          await authentication.authenticate().catch(() => undefined)
-          return !abandoned()
-        })
-        // Failures are already reflected in authState/agentState; without
-        // this the rejection escapes as an unhandled promise rejection. A
-        // restore that failed before it reached `authenticate()`, such as a
-        // root key that could not be fetched, has settled all the same.
-        .catch(() => true)
-        .then((settled) => {
-          if (settled) authentication.markSessionChecked()
-        })
-
-      return unmount
-    }, [])
-
-    const principal = usePrincipal(isAuthenticated, identity)
-
-    return {
-      authenticate,
-      login,
-      logout,
-      isAuthenticated,
-      isAuthenticating,
-      principal,
-      identity,
-      error,
-    }
-  }
-
-  /**
-   * Get the current user's Principal.
-   * Returns null if not authenticated, including while the signed-out session
-   * holds the anonymous identity.
-   *
-   * @example
-   * function UserInfo() {
-   *   const principal = useUserPrincipal()
-   *   if (!principal) return null
-   *   return <span>Logged in as: {principal.toText()}</span>
-   * }
-   */
-  const useUserPrincipal = (): Principal | null => {
-    const { isAuthenticated, identity } = useAuthState()
-    return usePrincipal(isAuthenticated, identity)
-  }
-
-  return {
-    useAuth,
-    useAgentState,
-    useUserPrincipal,
-  }
-}