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

package/src/auth/constants.ts

@@ -1,32 +0,0 @@
-export const IC_INTERNET_IDENTITY_PROVIDER = "https://id.ai/authorize"
-
-/**
- * `ic_env` key used to provide a fully resolved Internet Identity URL.
- */
-export const INTERNET_IDENTITY_PROVIDER_ENV_KEY = "INTERNET_IDENTITY_PROVIDER"
-
-/**
- * Well-known Internet Identity canister ID used when deploying II locally.
- */
-export const LOCAL_INTERNET_IDENTITY_CANISTER_ID = "rdmx6-jaaaa-aaaaa-aaadq-cai"
-
-/**
- * Builds the local Internet Identity provider URL for the given replica port.
- *
- * `authorizePath` selects the shape the installed build understands: modern
- * builds serve `/authorize` as a real asset, while pre-2026 ones serve the SPA
- * at `/` and drive the flow from a `#authorize` fragment. `AuthenticationManager`
- * probes the canister and passes the right one; the default keeps the previous
- * behaviour for direct callers.
- */
-export const localInternetIdentityProvider = (
-  port: number,
-  canisterId: string = LOCAL_INTERNET_IDENTITY_CANISTER_ID,
-  authorizePath: "/authorize" | "/#authorize" = "/authorize"
-) => `http://${canisterId}.localhost:${port}${authorizePath}`
-
-/**
- * Legacy default URL for local Internet Identity, using port `4943`.
- */
-export const LOCAL_INTERNET_IDENTITY_PROVIDER =
-  localInternetIdentityProvider(4943)

package/src/auth/createIdentityAttributeHooks.ts

@@ -1,169 +0,0 @@
-import { useCallback, useEffect, useRef, useState } from "react"
-import { Principal } from "@icp-sdk/core/principal"
-import type { IdentityAttributesManager } from "./identity-attributes-manager.js"
-import type {
-  IdentityAttributeResult,
-  RequestIdentityAttributesParameters,
-  RequestOpenIdIdentityAttributesParameters,
-} from "./types.js"
-
-export interface UseIdentityAttributesReturn {
-  requestAttributes: (
-    params: RequestIdentityAttributesParameters
-  ) => Promise<IdentityAttributeResult>
-  requestOpenIdAttributes: (
-    params: RequestOpenIdIdentityAttributesParameters
-  ) => Promise<IdentityAttributeResult>
-  attributes: IdentityAttributeResult | null
-  isRequestingAttributes: boolean
-  attributeError: Error | null
-  clearAttributes: () => void
-}
-
-/** What `request()` reports as the principal of a signed-out session. */
-const ANONYMOUS_PRINCIPAL = Principal.anonymous().toText()
-
-export function createIdentityAttributeHooks(
-  identityAttributes: IdentityAttributesManager
-) {
-  const useIdentityAttributes = (): UseIdentityAttributesReturn => {
-    const [attributes, setAttributes] =
-      useState<IdentityAttributeResult | null>(null)
-    const [isRequestingAttributes, setIsRequestingAttributes] = useState(false)
-    const [attributeError, setAttributeError] = useState<Error | null>(null)
-
-    /** The principal the session is currently signed in as, if any. */
-    const currentPrincipal = useCallback(() => {
-      const { authState } = identityAttributes.authentication
-      return authState.isAuthenticated
-        ? authState.identity?.getPrincipal().toText()
-        : undefined
-    }, [])
-
-    /**
-     * A request started before a sign-out or an account switch resolves after
-     * it, and publishing that result would put the previous user's decoded PII
-     * back on screen with no further auth event to clear it again. So a result
-     * is committed only when it is the current session's own: it carries the
-     * principal signed in when it resolves or, while nobody is, the anonymous
-     * principal that a `signIn: false` request made while signed out reports.
-     *
-     * With `signIn: true` the request itself signs the user in, so the
-     * principal seen before the request (none, for a first sign-in; the old
-     * account, for a switch made inside the provider window) is never the one
-     * the result belongs to. Comparing against it left `attributes` null after
-     * every successful first-time sign-in. Nor does "the same principal before
-     * and after" mean the session never changed: the request's own sign-in is
-     * published only when the whole request ends, so a user who signed in
-     * through it and signed out before it ended is nobody on both sides. Their
-     * name and email then went up on the signed-out screen.
-     */
-    const publishIfCurrent = useCallback(
-      (result: IdentityAttributeResult) => {
-        const session = currentPrincipal() ?? ANONYMOUS_PRINCIPAL
-        if (result.principal !== session) return false
-        setAttributes(result)
-        return true
-      },
-      [currentPrincipal]
-    )
-
-    /**
-     * The failure counterpart of `publishIfCurrent`. A request that signs in
-     * can fail on its attribute side after its own sign-in went through, and
-     * the manager keeps that sign-in before it reports the failure, so the
-     * session is now the one this request opened and the failure is that
-     * user's to see. A failure that lands after a sign-out is still dropped.
-     */
-    const publishErrorIfCurrent = useCallback(
-      (requestedFor: string | undefined, signsIn: boolean, error: Error) => {
-        const current = currentPrincipal()
-        if (requestedFor !== current && !(signsIn && current !== undefined)) {
-          return
-        }
-        setAttributeError(error)
-      },
-      [currentPrincipal]
-    )
-
-    const requestAttributes = useCallback(
-      async (params: RequestIdentityAttributesParameters) => {
-        setIsRequestingAttributes(true)
-        setAttributeError(null)
-        const requestedFor = currentPrincipal()
-        try {
-          const result = await identityAttributes.request(params)
-          publishIfCurrent(result)
-          return result
-        } catch (error) {
-          publishErrorIfCurrent(
-            requestedFor,
-            params.signIn !== false,
-            error as Error
-          )
-          throw error
-        } finally {
-          setIsRequestingAttributes(false)
-        }
-      },
-      []
-    )
-
-    const requestOpenIdAttributes = useCallback(
-      async (params: RequestOpenIdIdentityAttributesParameters) => {
-        setIsRequestingAttributes(true)
-        setAttributeError(null)
-        const requestedFor = currentPrincipal()
-        try {
-          const result = await identityAttributes.requestOpenId(params)
-          publishIfCurrent(result)
-          return result
-        } catch (error) {
-          publishErrorIfCurrent(
-            requestedFor,
-            params.signIn !== false,
-            error as Error
-          )
-          throw error
-        } finally {
-          setIsRequestingAttributes(false)
-        }
-      },
-      []
-    )
-
-    const clearAttributes = useCallback(() => {
-      setAttributes(null)
-      setAttributeError(null)
-    }, [])
-
-    // Decoded attributes are the signed-in user's personal data — a name, an
-    // email. They used to survive a sign-out or a switch to another account,
-    // so the next person to look at the screen saw the previous user's details.
-    // Drop them whenever the principal behind them changes.
-    const attributedPrincipal = useRef<string | undefined>(undefined)
-    useEffect(() => {
-      const { authentication } = identityAttributes
-      attributedPrincipal.current ??= currentPrincipal()
-
-      return authentication.subscribeAuthState(() => {
-        const principal = currentPrincipal()
-        if (principal === attributedPrincipal.current) return
-        attributedPrincipal.current = principal
-        setAttributes(null)
-        setAttributeError(null)
-      })
-    }, [])
-
-    return {
-      requestAttributes,
-      requestOpenIdAttributes,
-      attributes,
-      isRequestingAttributes,
-      attributeError,
-      clearAttributes,
-    }
-  }
-
-  return { useIdentityAttributes }
-}

package/src/auth/identity-attributes-manager.ts

@@ -1,226 +0,0 @@
-import type { Identity } from "@icp-sdk/core/agent"
-import type {
-  AuthClientLike,
-  IdentityAttributeNonce,
-  IdentityAttributeResult,
-  RequestIdentityAttributesParameters,
-  RequestOpenIdIdentityAttributesParameters,
-} from "./types.js"
-
-import { AuthenticationManager } from "./authentication-manager.js"
-import {
-  decodeIdentityAttributeValues,
-  identityAttributeKeys,
-  normalizeSignedIdentityAttributes,
-} from "./identity-attributes.js"
-
-/**
- * Requests and decodes signed identity attributes for an authenticated
- * Internet Identity session.
- *
- * Await `authentication.prepareClient()` once during startup (the `useAuth`
- * hook already does) so that {@link request} can open the identity provider
- * window synchronously from a click handler.
- *
- * @example
- * ```ts
- * const attributes = new IdentityAttributesManager(authentication)
- * const result = await attributes.request({
- *   keys: ["name"],
- *   nonce: () => fetchNonceFromCanister(),
- * })
- * ```
- */
-export class IdentityAttributesManager {
-  constructor(public readonly authentication: AuthenticationManager) {}
-
-  public request = async ({
-    keys,
-    nonce,
-    signIn = true,
-    maxTimeToLive,
-    maxTimeToIdle,
-    targets,
-    ...clientOptions
-  }: RequestIdentityAttributesParameters): Promise<IdentityAttributeResult> => {
-    // Nothing may be awaited before `requestAttributes` / `signIn` are invoked:
-    // the ICRC-29 transport only opens the identity provider window while the
-    // browser still considers us inside the user gesture. `getPreparedClient`
-    // is synchronous whenever `prepareClient()` has run.
-    const preparedClient = this.authentication.getPreparedClient(clientOptions)
-    const authClient =
-      preparedClient ?? (await this.authentication.ensureClient(clientOptions))
-
-    if (!authClient) {
-      throw new Error(
-        "Authentication module is missing or failed to initialize. To request identity attributes, please install @icp-sdk/auth (v8 or v10), or provide a compatible authClient."
-      )
-    }
-
-    this.authentication.setAuthenticating()
-    // Replaced by anything else that changes auth state while this request
-    // runs; see where the result is committed.
-    const pendingState = this.authentication.authState
-
-    let signInPromise: Promise<Identity> | undefined
-    let committed = false
-    try {
-      // `signIn` first: it opens the transport channel synchronously, and the
-      // attribute request then reuses that same channel and window.
-      signInPromise = signIn
-        ? this.authentication.signInOrRecoverIdentity({
-            maxTimeToLive,
-            maxTimeToIdle,
-            targets,
-          })
-        : undefined
-      const identityPromise =
-        signInPromise ?? Promise.resolve(authClient.getIdentity())
-      const requestPromise = authClient.requestAttributes({
-        keys,
-        nonce: toAuthClientNonce(nonce),
-      })
-
-      const [signedAttributes, identity] = await Promise.all([
-        requestPromise,
-        identityPromise,
-      ])
-
-      const finalIdentity = identity ?? (await authClient.getIdentity())
-      // A v8 client can say it is authenticated for a delegation that lapsed
-      // in this tab, or while it holds no session, once another tab has
-      // signed in; see `AuthenticationManager.vouchesFor`.
-      const isAuthenticated = this.authentication.vouchesFor(
-        finalIdentity,
-        await authClient.isAuthenticated()
-      )
-      committed = true
-      // A sign-out, or another account's sign-in, can finish while the
-      // attribute side is still pending: neither ends it. `finalIdentity` then
-      // belongs to a session the client has left, and committing it put the
-      // signed-out user's delegation back on the agent while the app showed
-      // them signed out. So commit only what the client still holds and
-      // vouches for, the rule `authenticate()` applies. Whatever moved the
-      // client through the manager has published its own state.
-      //
-      // When nothing has published since this request began, the session
-      // changed under the manager and this request is the first to find out.
-      // A client that vouches for no session any more has lost it, as when
-      // another tab signed out, while it still hands out the identity it held:
-      // the manager signs out too, or it goes on reporting the user signed in
-      // with their delegation on the agent. A client that still vouches for a
-      // session gives no grounds to sign anyone out, so only the
-      // `isAuthenticating` this request started is ended.
-      if (await clientHolds(authClient, finalIdentity, isAuthenticated)) {
-        await this.authentication.commitIdentity(finalIdentity, isAuthenticated)
-      } else if (this.authentication.authState === pendingState) {
-        if (isAuthenticated) {
-          this.authentication.settleAuthenticating()
-        } else {
-          this.authentication.commitSignedOut()
-        }
-      }
-
-      const normalizedSignedAttributes =
-        normalizeSignedIdentityAttributes(signedAttributes)
-
-      return {
-        principal: finalIdentity.getPrincipal().toText(),
-        requestedKeys: keys,
-        signedAttributes: normalizedSignedAttributes,
-        decodedAttributes: decodeIdentityAttributeValues(
-          normalizedSignedAttributes.data,
-          keys
-        ),
-        completedAt: new Date().toISOString(),
-      }
-    } catch (error) {
-      // The sign-in and the attribute request share one provider window and
-      // can end differently. When the attribute side failed (the app's nonce
-      // call rejected, or the provider could not certify a key) but the user
-      // went on to finish signing in, the client held a session nothing had
-      // committed: the app showed the user signed out until a reload restored
-      // it. So a sign-in this request started is waited for, and kept when the
-      // client vouches for it, before the failure is reported.
-      if (signInPromise && !committed) {
-        await this.keepCompletedSignIn(signInPromise, authClient)
-      }
-      this.authentication.setAuthenticationError(error as Error)
-      throw error
-    }
-  }
-
-  private async keepCompletedSignIn(
-    signInPromise: Promise<Identity>,
-    authClient: AuthClientLike
-  ) {
-    const identity = await signInPromise.catch(() => undefined)
-    if (!identity) return
-    const isAuthenticated = await Promise.resolve()
-      .then(() => authClient.isAuthenticated())
-      .catch(() => false)
-    if (!isAuthenticated) return
-    // The session the client holds now must be the one this request opened.
-    // Another login can switch the shared client to a different account while
-    // the attribute side is still pending, and committing this identity then
-    // would put back the account the user switched away from.
-    const current = await Promise.resolve()
-      .then(() => authClient.getIdentity())
-      .catch(() => undefined)
-    if (current?.getPrincipal().toText() !== identity.getPrincipal().toText()) {
-      return
-    }
-    // The attribute failure is the one to report, so a failure here is not.
-    await this.authentication
-      .commitIdentity(identity, true)
-      .catch(() => undefined)
-  }
-
-  public requestOpenId = ({
-    keys,
-    openIdProvider,
-    ...rest
-  }: RequestOpenIdIdentityAttributesParameters): Promise<IdentityAttributeResult> => {
-    // Called (not awaited) synchronously so the user gesture is preserved.
-    return this.request({
-      ...rest,
-      openIdProvider,
-      keys: identityAttributeKeys({ openIdProvider, keys }),
-    })
-  }
-}
-
-/**
- * Whether `identity` is the session `authClient` holds now, and one it still
- * vouches for. The anonymous identity needs no vouching: it signs no one in.
- */
-async function clientHolds(
-  authClient: AuthClientLike,
-  identity: Identity,
-  isAuthenticated: boolean
-): Promise<boolean> {
-  const held = await Promise.resolve()
-    .then(() => authClient.getIdentity())
-    .catch(() => undefined)
-  const principal = identity.getPrincipal()
-  if (held?.getPrincipal().toText() !== principal.toText()) return false
-  return isAuthenticated || principal.isAnonymous()
-}
-
-/**
- * Adapts our nonce input to the `@icp-sdk/auth` nonce contract.
- *
- * v8 takes `() => Promise<Uint8Array>` — a thunk, so it can journal the value
- * and replay the same bytes through a redirect flow. The thunk form also opens
- * the transport channel synchronously, which is what preserves the user
- * gesture.
- *
- * Until 3.12.0 this probed `typeof authClient.memoize === "function"` to detect
- * v8 and fell back to a bare promise for v7. The peer range is now `^8.0.0`, so
- * the probe would only ever take one branch.
- */
-function toAuthClientNonce(
-  nonce: IdentityAttributeNonce
-): () => Promise<Uint8Array> {
-  return () => Promise.resolve(typeof nonce === "function" ? nonce() : nonce)
-}