@privy-io/react-auth 1.12.0-beta.1 → 1.12.0-beta.2

package/dist/index.d.ts

@@ -1,10 +1,13 @@
 import React from 'react';
-import { Web3Provider } from '@ethersproject/providers';
+import { ExternalProvider, Web3Provider } from '@ethersproject/providers';
 import { AbstractProvider } from 'web3-core';
+import { AxiosResponse, AxiosRequestConfig } from 'axios';
 
+declare const SUPPORTED_OAUTH_PROVIDERS: readonly ["google", "discord", "twitter"];
+type OAuthProviderType = typeof SUPPORTED_OAUTH_PROVIDERS[number];
 declare const SUPPORTED_WALLET_TYPES: readonly ["metamask", "coinbase_wallet", "wallet_connect"];
-declare type WalletType = typeof SUPPORTED_WALLET_TYPES[number];
-declare type LinkedAccountType = 'wallet' | 'email' | 'phone' | 'google_oauth' | 'twitter_oauth' | 'discord_oauth';
+type WalletType = typeof SUPPORTED_WALLET_TYPES[number];
+type LinkedAccountType = 'wallet' | 'email' | 'phone' | 'google_oauth' | 'twitter_oauth' | 'discord_oauth';
 /** @ignore */
 interface LinkMetadata {
     /** Account type, most commonly useful when filtering through linkedAccounts */
@@ -105,7 +108,7 @@ interface DiscordOAuthWithMetadata extends LinkMetadata, Discord {
     /** Denotes that this is a Discord account. */
     type: 'discord_oauth';
 }
-declare type LinkedAccountWithMetadata = WalletWithMetadata | EmailWithMetadata | PhoneWithMetadata | GoogleOAuthWithMetadata | TwitterOAuthWithMetadata | DiscordOAuthWithMetadata;
+type LinkedAccountWithMetadata = WalletWithMetadata | EmailWithMetadata | PhoneWithMetadata | GoogleOAuthWithMetadata | TwitterOAuthWithMetadata | DiscordOAuthWithMetadata;
 interface User {
     /** The Privy-issued DID for the user. If you need to store additional information
      * about a user, you can use this DID to reference them. */
@@ -132,6 +135,24 @@ interface User {
      * that may be helpful for advanced use cases. */
     linkedAccounts: Array<LinkedAccountWithMetadata>;
 }
+interface AppSettings {
+    id?: string;
+    name?: string;
+    verificationKey?: string;
+    logoUrl?: string;
+    theme?: 'System' | 'Light' | 'Dark' | string;
+    accentColor?: string;
+    walletAuth?: boolean;
+    emailAuth?: boolean;
+    smsAuth?: boolean;
+    googleOAuth?: boolean;
+    twitterOAuth?: boolean;
+    discordOAuth?: boolean;
+    termsAndConditionsUrl: string | null;
+    privacyPolicyUrl: string | null;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
 
 declare function getAccessToken(): Promise<string | null>;
 /**
@@ -192,6 +213,66 @@ interface EIP1193Provider {
     on: (eventName: string, listener: (...args: unknown[]) => void) => any;
     removeListener: (eventName: string | symbol, listener: (...args: any[]) => void) => any;
 }
+declare class PrivyProxyProvider implements EIP1193Provider {
+    walletProvider?: EIP1193Provider;
+    private _subscriptions;
+    constructor(provider?: EIP1193Provider);
+    on(eventName: string, listener: (...args: any[]) => void): any;
+    request(request: {
+        method: string;
+        params?: any[] | undefined;
+    }): Promise<any>;
+    removeListener: (eventName: string | symbol, listener: (...args: any[]) => void) => any;
+    setProvider: (provider: EIP1193Provider) => void;
+}
+declare class AsExternalProvider extends PrivyProxyProvider implements ExternalProvider {
+    constructor(provider: EIP1193Provider);
+    isMetaMask?: boolean;
+    isStatus?: boolean;
+    host?: string;
+    path?: string;
+    sendAsync?: (request: {
+        method: string;
+        params?: Array<any>;
+    }, callback: (error: any, response: any) => void) => void;
+    send?: (request: {
+        method: string;
+        params?: Array<any>;
+    }, callback: (error: any, response: any) => void) => void;
+}
+
+declare class PrivyConnector {
+    private ethProvider;
+    walletType: WalletType | null;
+    constructor();
+    getEthereumProvider: () => EIP1193Provider;
+    initialize(): void;
+    destroy(): void;
+    getConnectedWallet(): Promise<Wallet | null>;
+    /**
+     * Connects to the wallet.
+     *
+     * @param options.showPrompt if true, prompts the user for a connection when no connection can be automatically re-established.
+     * @returns {string | null} EIP-55 mixed-case checksum-encoded address of connected wallet or null if user does not connect.
+     */
+    connect(options: {
+        showPrompt: boolean;
+    }): Promise<Wallet | null>;
+    private isConnected;
+    private promptConnection;
+    /**
+     * The currently connected EIP-155 chain id. E.g., `1` for Ethereum mainnet.
+     *
+     * @returns {string} The EIP-155 chain id.
+     */
+    chainId(): Promise<string>;
+    /**
+     * The currently connected address.
+     *
+     * @returns {string | null} EIP-55 mixed-case checksum-encoded address or null if not connected.
+     */
+    address(): Promise<string | null>;
+}
 
 /**
  * Allows you to manage the user's current authentication state and access their linked accounts.
@@ -279,6 +360,11 @@ interface PrivyInterface {
      * Get a [web3.js](https://web3js.readthedocs.io/en/v1.8.0/)-compatible provider from the user's wallet, if the user has connected one.
      */
     getWeb3jsProvider: () => AbstractProvider;
+    /**
+     * Get the PrivyConnector object
+     * This shouldn't need to be used directly unless creating a plugin, like a WAGMI plugin
+     */
+    walletConnector: PrivyConnector | null;
     /**
      * Unlink an email account from a user, by passing the email address. Note that you can only unlink an email account if the user has at least one other account.
      */
@@ -328,4 +414,262 @@ declare const usePrivy: () => PrivyInterface;
 
 declare const VERSION: string;
 
-export { Discord, DiscordOAuthWithMetadata, Email, EmailWithMetadata, Google, GoogleOAuthWithMetadata, Phone, PhoneWithMetadata, PrivyInterface, PrivyProvider, PrivyProviderProps, Twitter, TwitterOAuthWithMetadata, User, VERSION, Wallet, WalletWithMetadata, getAccessToken, usePrivy };
+interface DefaultsType {
+    baseURL: string;
+    timeout: number;
+}
+/**
+ * A raw http handler for making requests to the Privy API. It requires a Session
+ * object, which is used for fetching and including any tokens that are required
+ * for requests.
+ */
+declare class Http {
+    private appId;
+    private session;
+    private defaults;
+    private sdkVersion;
+    constructor(appId: string, session: Session, defaults: DefaultsType);
+    get<T = any, R = AxiosResponse<T>, D = any>(path: string, config?: AxiosRequestConfig<D>): Promise<R>;
+    post<T = any, R = AxiosResponse<T>, D = any>(path: string, data?: D, config?: AxiosRequestConfig<D>): Promise<R>;
+    delete<T = any, R = AxiosResponse<T>, D = any>(path: string, config?: AxiosRequestConfig<D>): Promise<R>;
+    private buildConfig;
+}
+
+interface ResponseEmailAccount {
+    type: 'email';
+    address: string;
+    verified_at: number;
+}
+interface ResponsePhoneAccount {
+    type: 'phone';
+    phoneNumber: string;
+    verified_at: number;
+}
+interface ResponseEthereumAccount {
+    type: 'wallet';
+    address: string;
+    chain_type: 'ethereum';
+    verified_at: number;
+}
+interface ResponseOAuthGoogle {
+    type: 'google_oauth';
+    subject: string;
+    email: string;
+    name: string | null;
+    verified_at: number;
+}
+interface ResponseOAuthTwitter {
+    type: 'twitter_oauth';
+    subject: string;
+    username: string | null;
+    name: string | null;
+    verified_at: number;
+}
+interface ResponseOAuthDiscord {
+    type: 'discord_oauth';
+    subject: string;
+    username: string | null;
+    email: string | null;
+    verified_at: number;
+}
+type LinkedAccountsType = Array<ResponseEmailAccount | ResponsePhoneAccount | ResponseEthereumAccount | ResponseOAuthGoogle | ResponseOAuthTwitter | ResponseOAuthDiscord>;
+interface GetCurrentUserResponse {
+    id: string;
+    created_at: number;
+    linked_accounts: LinkedAccountsType;
+}
+
+/**
+ * Valid /session and <>/authenticate calls will respond with a token
+ * as well as a valid user object for streamlining.
+ */
+interface ValidSessionResponse {
+    user: GetCurrentUserResponse;
+    token: string;
+    refresh_token: string | null;
+    is_new_user?: boolean;
+}
+/**
+ * `Session` represents the session lifecycle of the login. It manages token
+ * storage, refresh, and deletion.
+ */
+declare class Session {
+    private destroyOnce;
+    private refreshOnce;
+    private authenticateOnce;
+    private linkOnce;
+    private forkSessionOnce;
+    api?: Http;
+    constructor();
+    get token(): string | null;
+    get refreshToken(): string | null;
+    /**
+     * Checks to see if locally we have refresh credentials. Refresh
+     * credentials consist of:
+     *
+     *     1. Access token
+     *     2. Refresh token
+     *
+     * @returns true if we have what appear to be valid credentials, false otherwise.
+     */
+    hasRefreshCredentials(): boolean;
+    /**
+     * Checks if the session contains a valid token that is not
+     * expired or expiring soon.
+     *
+     * @returns true if token is considered active, false otherwise.
+     */
+    hasActiveToken(): boolean;
+    /**
+     * Checks if the session contains a valid token (correct signature, issuer, and app ID).
+     * Accepts an optional clockTolerance for checking the expiration claim on the session's JWT.
+     *
+     * @returns true if token is valid, false otherwise.
+     */
+    hasValidToken(verificationKey: string, appId: string, clockTolerance?: number): Promise<boolean>;
+    /**
+     * Authenticate the session.
+     * @returns Promise<User>
+     */
+    authenticate(authFlow: AuthFlow): Promise<{
+        user: User | null;
+        isNewUser?: boolean;
+    }>;
+    /**
+     * Link's a new account for a user.
+     * @returns Promise<User>
+     */
+    link(authFlow: AuthFlow): Promise<User | null>;
+    /**
+     * Renews the auth token using the refresh token.
+     * @return Promise<User> if successful with a logged-in user, Promise<null> otherwise.
+     */
+    refresh(): Promise<User | null>;
+    /**
+     * Creates a new session from the current session using the refresh token.
+     * @return Promise<string> if successful.
+     */
+    forkSession(): Promise<string>;
+    /**
+     * Destroy the session.
+     */
+    destroy(): Promise<void>;
+    private _authenticate;
+    private _link;
+    private _refresh;
+    private _destroy;
+    private _forkSession;
+    private destroyLocalState;
+    private storeToken;
+    private storeRefreshToken;
+}
+
+type AuthMeta = {
+    [key: string]: any;
+};
+/**
+ * An auth flow is an encapsulation of the business logic required for a given
+ * authentication process. It requires at least one definitive `authenticate`
+ * method that does the final token handshaking with the API, but may also
+ * include any number of methods/API calls necessary to set up the state (e.g.
+ * sending an email before being able to do a passwordless code login)
+ */
+interface AuthFlow {
+    api?: Http;
+    /**
+     * Any meta information necessary for the auth flow, that may also need to be
+     * shared out to things like frontend components for displaying state of the
+     * auth flow
+     */
+    meta: AuthMeta;
+    /**
+     * Handles the API authentication call(s) to log users in.
+     * Any preconditions must be addressed prior to calling
+     */
+    authenticate(): Promise<ValidSessionResponse>;
+    /**
+     * Handles the API link call(s) to link new user accounts.
+     * Requires user to already be logged in when called.
+     * Any preconditions must be addressed prior to calling
+     */
+    link(): Promise<GetCurrentUserResponse>;
+}
+
+/**
+ * This should not be directly used by developers at the moment,
+ * so we doc-ignore it.
+ * @ignore
+ *
+ */
+declare class PrivyClient {
+    private api;
+    private appId;
+    private session;
+    authFlow?: AuthFlow;
+    connector: PrivyConnector;
+    /**
+     * Creates a new Privy client.
+     * @param options Initialization options.
+     */
+    constructor(options: {
+        /**
+         * The URL of the Privy API. Defaults to `https://api.privy.io/v0`.
+         */
+        apiURL?: string;
+        /**
+         * The app id from your console
+         */
+        appId: string;
+        /**
+         * Time in milliseconds after which to timeout requests to the API and KMS. Defaults to `10000` (10 seconds).
+         */
+        timeout?: number;
+    });
+    authenticate(): Promise<{
+        user: User | null;
+        isNewUser?: boolean | undefined;
+    }>;
+    link(): Promise<User | null>;
+    logout(): Promise<void>;
+    startAuthFlow(authFlow: AuthFlow): void;
+    unlinkEmail(address: string): Promise<User>;
+    unlinkPhone(phoneNumber: string): Promise<User>;
+    unlinkWallet(address: string): Promise<User>;
+    unlinkOAuth(provider: OAuthProviderType, subject: string): Promise<User>;
+    /** DATA METHODS */
+    /**
+     * Fetches the currently authenticed user from the API or
+     * returns null if the user is not authenticated.
+     *
+     * This will refresh the user's access token and rotate
+     * the refresh token if needed.
+     *
+     * @returns Promise<User | null>
+     */
+    getAuthenticatedUser(): Promise<User | null>;
+    /**
+     * Grab the Privy access token for the currently logged in user. Verifies that the
+     * token has a valid signature, was issued by 'privy.io', and corresponds to the
+     * current app ID. If no valid token is found, this method will force a logout and return null.
+     *
+     * If the token is expired or expiring soon, this will attempt to
+     * first refresh the access token to ensure that the token is active.
+     *
+     * @returns Promise<string | null>
+     */
+    getAccessToken(): Promise<string | null>;
+    getAppSettings(): Promise<AppSettings>;
+    setActiveWallet(address: string, user: User): User;
+    /**
+     * Get a short-lived token to start a new Privy session from the existing authenticated session.
+     *
+     * Rotates the access token and refresh token.
+     * Raises an exception if the current session was already forked from a previous session,
+     * or if the current session is not authenticated.
+     *
+     * @returns Promise<string>
+     */
+    forkSession(): Promise<string>;
+}
+
+export { AsExternalProvider, Discord, DiscordOAuthWithMetadata, Email, EmailWithMetadata, Google, GoogleOAuthWithMetadata, Phone, PhoneWithMetadata, PrivyClient, PrivyConnector, PrivyInterface, PrivyProvider, PrivyProviderProps, PrivyProxyProvider, Twitter, TwitterOAuthWithMetadata, User, VERSION, Wallet, WalletWithMetadata, getAccessToken, usePrivy };