Authentication state

authenticated: boolean;

import { useRouter } from "next/router";

import { usePrivy } from "@privy-io/react-auth";

export default function MyComponent() {
const { ready, authenticated, user } = usePrivy();
const router = useRouter();

if (!ready) {
    // Do nothing while the PrivyProvider initializes with updated user state
    return <></>;
}

if (ready && !authenticated) {
    // Replace this code with however you'd like to handle an unauthenticated user
    // As an example, you might redirect them to a login page
    router.push("/login");
}

if (ready && authenticated) {
    // Replace this code with however you'd like to handle an authenticated user
    return <p>User {user?.id} is logged in.</p>;
}
}

user: User | null;

import { useRouter } from "expo-router";
import { usePrivy } from "@privy-io/expo";
import { useEffect } from "react";
import { Text, View } from "react-native";

export default function MyComponent() {
  const { isReady, user } = usePrivy();
  const router = useRouter();

  useEffect(() => {
    if (isReady && !user) {
      // Replace this code with however you'd like to handle an unauthenticated user
      // As an example, you might redirect them to a login page
      router.replace("/login");
    }
  }, [isReady, user, router]);

  if (!isReady) {
    // Do nothing while the PrivyProvider initializes with updated user state
    return null;
  }

  if (isReady && !user) {
    // You could show a loading state or handle this differently
    return <Text>Not authenticated</Text>;
  }

  if (isReady && user) {
    // Replace this code with however you'd like to handle an authenticated user
    return (
      <View>
        <Text>User {user.id} is logged in.</Text>
      </View>
    );
  }
}

public enum AuthState {
  /// AuthState has not been determined yet, show loading
  case notReady
  /// User is unauthenticated
  case unauthenticated
  // User is authenticated and has an associated PrivyUser object
  case authenticated(PrivyUser)
}

public protocol Privy {
  /// A publisher that emits auth state changes.
  var authStatePublisher: AnyPublisher<AuthState, Never> { get }
}

let privyUser = privy.user

if (privyUser != null) {
  // User is authenticated
  let linkedAccounts = privyUser.linkedAccounts
}

public protocol Privy {
  /// The user's current auth state.
  var authState: AuthState { get }
}

// Grab current auth state
if case .authenticated(let user) = privy.authState {
  // User is authenticated. Grab the user's linked accounts
  let linkedAccounts = user.linkedAccounts
}

privy.authStatePublisher
  .receive(on: RunLoop.main)
  .sink { authState in
    switch authState {
    case .authenticated(let user):
      // User is authenticated. Grab the user's linked accounts
      let linkedAccounts = user.linkedAccounts
    case .notReady:
      // Privy not yet ready. Call privy.awaitReady()
    case .unauthenticated:
      // User in not authenticated. Perhaps show login screen.
    }
  }

public sealed interface AuthState {
  // AuthState has not been determined yet, show loading
  public data object NotReady : AuthState

  // User is unauthenticated
  public data object Unauthenticated : AuthState

  // User is authenticated and has an associated PrivyUser object
  public data class Authenticated(val user: PrivyUser) : AuthState
}

public interface Privy {
 // A state flow that can be subscribed to for auth state updates
 public val authState: StateFlow<AuthState>
}

val privyUser = privy.user

if (privyUser != null) {
  // User is authenticated
  val linkedAccounts = privyUser.linkedAccounts
}

// Grab current auth state
val currentAuthState = privy.authState.value
if (currentAuthState is AuthState.Authenticated) {
    // User is authenticated. Grab the user's linked accounts
    val privyUser = currentAuthState.user
    val linkedAccount = privyUser.linkedAccounts
}

coroutineScope.launch {
    privy.authState.collectLatest { authState ->
        when(authState) {
            is AuthState.Authenticated -> {
                // User is authenticated. Grab the user's linked accounts
                val privyUser = authState.user
                val userId = privyUser.linkedAccounts
            }
            AuthState.NotReady -> {
                // Privy not yet ready. Call privy.awaitReady()
            }
            AuthState.Unauthenticated -> {
                // User in not authenticated. Perhaps show login screen.
            }
        }
    }
}

public enum AuthState
{
    NotReady, // Privy has not yet finished initializing
    Unauthenticated, // User is unauthenticated
    Authenticated // User is authenticated
}

Debug.Log(PrivyManager.Instance.AuthState);

PrivyManager.Instance.SetAuthStateChangeCallback(state =>
{
    // User's AuthState has updated
    Debug.Log(state);
});

// User will be null if no user is authenticated
PrivyUser user = PrivyManager.Instance.User;

/// Base class representing different authentication states.
sealed class AuthState {
  const AuthState();
}

/// Represents the initial state before authentication status is determined.
class NotReady extends AuthState {
  const NotReady();
}

/// Represents the state when the user is not authenticated.
class Unauthenticated extends AuthState {
  const Unauthenticated();
}

/// Represents the state when the user is authenticated.
class Authenticated extends AuthState {
  final PrivyUser user;

  /// Constructor accepting the authenticated user's details.
  const Authenticated(this.user);
}

abstract interface class Privy {
  // Get the current authentication state.
  AuthState get currentAuthState;

  // A stream for auth state updates.
  Stream<AuthState> get authStateStream;
}

final privyUser = privy.user;

if (privyUser != null) {
  // User is authenticated
  final linkedAccounts = privyUser.linkedAccounts;
}

// Grab current auth state
final currentAuthState = privy.currentAuthState;

if (currentAuthState is Authenticated) {
  // User is authenticated. Retrieve the associated user from the auth state.
  final privyUser = currentAuthState.user;
  final linkedAccounts = privyUser.linkedAccounts;
}

privy.authStateStream.listen((authState) {
  switch (authState) {
    case Authenticated():
      // User is authenticated. Retrieve the user.
      final privyUser = authState.user;
      final userId = privyUser.linkedAccounts;
      break;
    case NotReady():
      // Privy is not yet ready. Ensure Privy is initialized first.
      break;
    case Unauthenticated():
      // User is not authenticated. You may want to show the login screen.
      break;
  }
});