@0xkey-io/react-native-wallet-kit 0.1.0

package/dist/providers/Types.d.ts

@@ -0,0 +1,275 @@
+/// <reference types="react" />
+import type { ZeroXKeySDKClientBase, ZeroXKeyClientMethods, Wallet, StamperType, ExportBundle } from "@0xkey-io/core";
+import type { Session, v1User } from "@0xkey-io/sdk-types";
+import type { ZeroXKeyProviderConfig, AuthState, ClientState } from "../types/base";
+import type { ExportWalletParams, ExportPrivateKeyParams, ExportWalletAccountParams, ImportWalletParams, ImportPrivateKeyParams, HandleDiscordOauthParams, HandleXOauthParams, HandleGoogleOauthParams, HandleAppleOauthParams, HandleFacebookOauthParams } from "../types/method-types";
+export interface ClientContextType extends Omit<ZeroXKeyClientMethods, "connectWalletAccount" | "fetchWalletProviders" | "disconnectWalletAccount" | "switchWalletAccountChain" | "loginWithWallet" | "signUpWithWallet" | "loginOrSignupWithWallet" | "exportWallet" | "exportPrivateKey" | "exportWalletAccount" | "importWallet" | "importPrivateKey" | "buildWalletLoginRequest"> {
+    /** @internal */
+    httpClient: ZeroXKeySDKClientBase | undefined;
+    /** @internal */
+    session: Session | undefined;
+    /** @internal */
+    allSessions?: Record<string, Session> | undefined;
+    /** @internal */
+    clientState: ClientState | undefined;
+    /** @internal */
+    authState: AuthState;
+    /** @internal */
+    config?: ZeroXKeyProviderConfig | undefined;
+    /** @internal */
+    user: v1User | undefined;
+    /** @internal */
+    wallets: Wallet[];
+    /**
+     * Export a wallet. Optionally decrypt and return the mnemonic directly.
+     *
+     * - By default, this function DECRYPTS and returns the mnemonic for convenience.
+     * - If `decrypt` is set to false, it returns the encrypted export bundle string instead.
+     * - When decrypting, this function generates a P-256 keypair internally,
+     *   exports the wallet encrypted to the generated public key, then decrypts the bundle
+     *   using the generated private key and returns the mnemonic string.
+     * - When `decrypt` is true, the provided `targetPublicKey` (if any) is ignored.
+     *
+     * @param params.walletId - The wallet ID to export.
+     * @param params.targetPublicKey - Optional; used only when `decrypt` is not set.
+     * @param params.organizationId - Optional organization ID override.
+     * @param params.stampWith - Optional stamper override.
+     * @param params.decrypt - Defaults to true. Set to false to receive the encrypted bundle.
+     */
+    exportWallet(params: ExportWalletParams): Promise<ExportBundle>;
+    /**
+     * Export a private key. Optionally decrypt and return the raw private key.
+     *
+     * - By default, this function DECRYPTS and returns the raw private key (hex for EVM, base58 for Solana when `keyFormat` is "SOLANA").
+     * - If `decrypt` is false, the provider returns the encrypted export bundle string.
+     * - When decrypting, the provider generates a P-256 keypair, exports to the generated public key,
+     *   decrypts locally, and returns the raw private key (hex for EVM, or base58 for Solana when `keyFormat` is "SOLANA").
+     *
+     * @param params.privateKeyId - The private key ID to export.
+     * @param params.targetPublicKey - Optional; used only when `decrypt` is not set.
+     * @param params.organizationId - Optional organization ID override.
+     * @param params.stampWith - Optional stamper override.
+     * @param params.decrypt - Defaults to true. Set to false to receive the encrypted bundle.
+     * @returns Raw private key (default) or encrypted bundle (when decrypt is false).
+     */
+    exportPrivateKey(params: ExportPrivateKeyParams): Promise<ExportBundle>;
+    /**
+     * Export a wallet account. Optionally decrypt and return the raw private key.
+     *
+     * - By default, this function DECRYPTS and returns the raw private key (hex for EVM, base58 for Solana when `keyFormat` is "SOLANA").
+     * - If `decrypt` is false, the provider returns the encrypted export bundle string.
+     * - When decrypting, the provider generates a P-256 keypair, exports to the generated public key,
+     *   decrypts locally, and returns the raw private key (hex for EVM, or base58 for Solana when `keyFormat` is "SOLANA").
+     *
+     * @param params.address - The account address to export.
+     * @param params.targetPublicKey - Optional; used only when `decrypt` is not set.
+     * @param params.organizationId - Optional organization ID override.
+     * @param params.stampWith - Optional stamper override.
+     * @param params.decrypt - Defaults to true. Set to false to receive the encrypted bundle.
+     * @returns Raw private key (default) or encrypted bundle (when decrypt is false).
+     */
+    exportWalletAccount(params: ExportWalletAccountParams): Promise<ExportBundle>;
+    /**
+     * Import a wallet using a mnemonic.
+     *
+     * - The provider internally calls `initImportWallet` to retrieve an import bundle.
+     * - It encrypts the provided `mnemonic` to that bundle using HPKE and calls `client.importWallet`.
+     * - Optionally accepts `accounts` to pre-create wallet accounts; otherwise defaults may apply.
+     *
+     * @param params.mnemonic - Mnemonic phrase to import.
+     * @param params.walletName - Name for the new wallet.
+     * @param params.accounts - Optional accounts to pre-create.
+     * @param params.organizationId - Optional organization ID.
+     * @param params.userId - Optional user ID.
+     * @param params.stampWith - Optional stamper override.
+     * @returns The new wallet ID.
+     */
+    importWallet(params: ImportWalletParams): Promise<string>;
+    /**
+     * Import a private key by encrypting it to an import bundle internally.
+     *
+     * - The provider internally calls `initImportPrivateKey` to retrieve an import bundle.
+     * - It encrypts the provided `privateKey` to that bundle using HPKE and calls `client.importPrivateKey`.
+     * - `addressFormats` is required and determines the curve by default; `curve` can be provided to override.
+     *
+     * @param params.privateKey - The private key material to import (hex for EVM; base58 for Solana when `keyFormat` is "SOLANA").
+     * @param params.privateKeyName - A display name for the imported key.
+     * @param params.addressFormats - Address formats to derive and register.
+     * @param params.curve - Optional curve override.
+     * @param params.keyFormat - Optional source key encoding (default "HEXADECIMAL").
+     * @param params.organizationId - Optional organization ID.
+     * @param params.userId - Optional user ID.
+     * @param params.stampWith - Optional stamper override.
+     * @returns The new private key ID.
+     */
+    importPrivateKey(params: ImportPrivateKeyParams): Promise<string>;
+    /**
+     * Refreshes the user details.
+     *
+     * - This function fetches the latest user details for the current session (or optionally for a specific user/organization if provided)
+     *   and updates the `user` state variable in the provider.
+     * - If a `stampWith` parameter is provided, it will use that stamper to fetch the user details (supports Passkey, ApiKey, or Wallet stampers).
+     * - Automatically handles error reporting via the configured callbacks.
+     * - Typically used after authentication, user profile updates, or linking/unlinking authenticators to ensure the provider state is up to date.
+     * - If no user is found, the state will not be updated.
+     *
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @returns A promise that resolves when the user details are successfully refreshed and state is updated.
+     * @throws {ZeroXKeyError} If the client is not initialized or if there is an error refreshing the user details.
+     */
+    refreshUser: (params?: {
+        stampWith?: StamperType | undefined;
+    }) => Promise<void>;
+    /**
+     * Refreshes the wallets state for the current user session.
+     *
+     * - This function fetches the latest list of wallets associated with the current session or user,
+     *   and updates the `wallets` state variable in the provider.
+     * - If a `stampWith` parameter is provided, it will use that stamper to fetch the wallets
+     *   (supports Passkey, ApiKey, or Wallet stampers for granular authentication control).
+     * - Automatically handles error reporting via the configured callbacks.
+     * - Typically used after wallet creation, import, export, account changes, or authentication
+     *   to ensure the provider state is up to date.
+     * - If no wallets are found, the state will be set to an empty array.
+     *
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @returns A promise that resolves when the wallets are successfully refreshed and state is updated.
+     * @throws {ZeroXKeyError} If the client is not initialized or if there is an error refreshing the wallets.
+     */
+    refreshWallets: (params?: {
+        stampWith?: StamperType | undefined;
+    }) => Promise<Wallet[]>;
+    /**
+     * Handles the Discord OAuth 2.0 flow.
+     *
+     * - This function initiates the OAuth 2.0 PKCE flow with Discord by opening the in-app browser and deep-linking back to the app.
+     * - On React Native, the flow always uses the in-app browser.
+     * - Generates a new ephemeral API key pair and uses its public key as part of the state and a cryptographic nonce to bind the OAuth session.
+     * - Creates a PKCE verifier/challenge pair, storing the verifier in `AsyncStorage` for later use in the token exchange.
+     * - Constructs the Discord OAuth URL with all required parameters, including client ID, redirect URI, response type, scope, PKCE code challenge, nonce, and state.
+     * - The `state` parameter encodes the provider name, flow type, ephemeral public key, and any additional key-value pairs provided in `additionalState`.
+     * - The flow resolves when the app is deep-linked back; it rejects if the in-app browser is closed or times out.
+     * - On receiving an authorization code, the function exchanges it for an OIDC token via the ZeroXKey proxy (`proxyOAuth2Authenticate`) using the PKCE verifier, redirect URI, and nonce.
+     * - On successful authentication, the function either calls the provided `onOauthSuccess` callback, triggers the `onOauthRedirect` callback from provider callbacks, or completes the OAuth flow internally by calling `completeOauth`.
+     * - Handles error cases such as missing configuration, in-app browser failures, missing PKCE verifier, or ZeroXKey proxy failures, throwing a `ZeroXKeyError` with appropriate error codes.
+     *
+     * @param params.clientId - The Discord Client ID to use (defaults to the client ID from configuration).
+     * @param params.additionalState - Additional key-value pairs to include in the OAuth state parameter for tracking or custom logic.
+     * @param params.onOauthSuccess - Callback function to handle the successful OAuth response (receives `{ oidcToken, providerName, publicKey }`).
+     *
+     * onOauthSuccess params:
+     * - oidcToken: The OIDC token issued by ZeroXKey after exchanging the auth code.
+     * - providerName: The name of the OAuth provider ("discord").
+     * - publicKey: The public key used for the OAuth flow.
+     *
+     * @returns A promise that resolves when the OAuth flow is successfully initiated and completed, or rejects on error or timeout.
+     * @throws {ZeroXKeyError} If the configuration is not ready, required parameters are missing, or if there is an error initiating or completing the OAuth flow.
+     */
+    handleDiscordOauth: (params?: HandleDiscordOauthParams) => Promise<void>;
+    /**
+     * Handles the Twitter (X) OAuth 2.0 flow.
+     *
+     * - This function initiates the OAuth 2.0 PKCE flow with Twitter (X) by opening the in-app browser and deep-linking back to the app.
+     * - On React Native, the flow always uses the in-app browser.
+     * - Generates a new ephemeral API key pair and uses its public key as part of the state and a cryptographic nonce to bind the OAuth session.
+     * - Creates a PKCE verifier/challenge pair, storing the verifier in `AsyncStorage` for later use in the token exchange.
+     * - Constructs the Twitter (X) OAuth URL with all required parameters, including client ID, redirect URI, response type, scope, PKCE code challenge, nonce, and state.
+     * - The `state` parameter encodes the provider name, flow type, ephemeral public key, and any additional key-value pairs provided in `additionalState`.
+     * - The flow resolves when the app is deep-linked back; it rejects if the in-app browser is closed or times out.
+     * - On receiving an authorization code, the function exchanges it for an OIDC token via the ZeroXKey proxy (`proxyOAuth2Authenticate`) using the PKCE verifier, redirect URI, and nonce.
+     * - On successful authentication, the function either calls the provided `onOauthSuccess` callback, triggers the `onOauthRedirect` callback from provider callbacks, or completes the OAuth flow internally by calling `completeOauth`.
+     * - Handles error cases such as missing configuration, in-app browser failures, missing PKCE verifier, or ZeroXKey proxy failures, throwing a `ZeroXKeyError` with appropriate error codes.
+     *
+     * @param params.clientId - The Twitter (X) Client ID to use (defaults to the client ID from configuration).
+     * @param params.additionalState - Additional key-value pairs to include in the OAuth state parameter for tracking or custom logic.
+     * @param params.onOauthSuccess - Callback function to handle the successful OAuth response (receives `{ oidcToken, providerName, publicKey }`).
+     *
+     * onOauthSuccess params:
+     * - oidcToken: The OIDC token issued by ZeroXKey after exchanging the auth code.
+     * - providerName: The name of the OAuth provider ("twitter").
+     * - publicKey: The public key used for the OAuth flow.
+     *
+     * @returns A promise that resolves when the OAuth flow is successfully initiated and completed, or rejects on error or timeout.
+     * @throws {ZeroXKeyError} If the configuration is not ready, required parameters are missing, or if there is an error initiating or completing the OAuth flow.
+     */
+    handleXOauth: (params?: HandleXOauthParams) => Promise<void>;
+    /**
+     * Handles the Google OAuth flow.
+     *
+     * - This function initiates the Google OAuth flow by opening the in-app browser and deep-linking back to the app.
+     * - On React Native, the flow always uses the in-app browser.
+     * - Generates a new ephemeral API key pair and uses its public key as the nonce for the OAuth request, ensuring cryptographic binding of the session.
+     * - Constructs the Google OAuth URL with all required parameters, including client ID, redirect URI, response type, scope, nonce, and state.
+     * - The `state` parameter includes the provider, flow type, public key, and any additional state parameters for tracking or custom logic.
+     * - The flow resolves when the app is deep-linked back; it rejects if the in-app browser is closed or times out.
+     * - On successful authentication, the function either calls the provided `onOauthSuccess` callback, triggers the `onOauthRedirect` callback from provider callbacks, or completes the OAuth flow internally by calling `completeOauth`.
+     * - Handles all error cases, including missing configuration, in-app browser failures, and timeouts, and throws a `ZeroXKeyError` with appropriate error codes.
+     *
+     * @param params.clientId - The Google Client ID to use (defaults to the client ID from configuration).
+     * @param params.additionalState - Additional key-value pairs to include in the OAuth state parameter for custom tracking or logic.
+     * @param params.onOauthSuccess - Callback function to handle the successful OAuth response (receives `{ oidcToken, providerName, publicKey }`).
+     *
+     * onOauthSuccess params:
+     * - oidcToken: The OIDC token received from the OAuth flow.
+     * - providerName: The name of the OAuth provider ("google").
+     * - publicKey: The public key used for the OAuth flow.
+     *
+     * @returns A promise that resolves when the OAuth flow is successfully initiated and completed, or rejects on error or timeout.
+     * @throws {ZeroXKeyError} If the configuration is not ready, required parameters are missing, or if there is an error initiating or completing the OAuth flow.
+     */
+    handleGoogleOauth: (params?: HandleGoogleOauthParams) => Promise<void>;
+    /**
+     * Handles the Apple OAuth flow.
+     *
+     * - This function initiates the Apple OAuth flow by opening the in-app browser and deep-linking back to the app.
+     * - On React Native, the flow always uses the in-app browser.
+     * - Generates a new ephemeral API key pair and uses its public key as the nonce for the OAuth request, ensuring cryptographic binding of the session.
+     * - Constructs the Apple OAuth URL with all required parameters, including client ID, redirect URI, response type, response mode, nonce, and state.
+     * - The `state` parameter includes the provider, flow type, public key, and any additional state parameters for tracking or custom logic.
+     * - The flow resolves when the app is deep-linked back; it rejects if the in-app browser is closed or times out.
+     * - On successful authentication, the function either calls the provided `onOauthSuccess` callback, triggers the `onOauthRedirect` callback from provider callbacks, or completes the OAuth flow internally by calling `completeOauth`.
+     * - Handles all error cases, including missing configuration, in-app browser failures, and timeouts, and throws a `ZeroXKeyError` with appropriate error codes.
+     *
+     * @param params.clientId - The Apple Client ID to use (defaults to the client ID from configuration).
+     * @param params.additionalState - Additional key-value pairs to include in the OAuth state parameter for custom tracking or logic.
+     * @param params.onOauthSuccess - Callback function to handle the successful OAuth response (receives `{ oidcToken, providerName, publicKey }`).
+     *
+     * onOauthSuccess params:
+     * - oidcToken: The OIDC token received from the OAuth flow.
+     * - providerName: The name of the OAuth provider ("apple").
+     * - publicKey: The public key used for the OAuth flow.
+     *
+     * @returns A promise that resolves when the OAuth flow is successfully initiated and completed, or rejects on error or timeout.
+     * @throws {ZeroXKeyError} If the configuration is not ready, required parameters are missing, or if there is an error initiating or completing the OAuth flow.
+     */
+    handleAppleOauth: (params?: HandleAppleOauthParams) => Promise<void>;
+    /**
+     * Handles the Facebook OAuth flow.
+     *
+     * - This function initiates the Facebook OAuth flow by opening the in-app browser and deep-linking back to the app.
+     * - On React Native, the flow always uses the in-app browser.
+     * - Generates a new ephemeral API key pair and uses its public key as the nonce for the OAuth request, ensuring cryptographic binding of the session.
+     * - Uses PKCE (Proof Key for Code Exchange) for enhanced security, generating a code verifier and challenge for the Facebook OAuth flow.
+     * - Constructs the Facebook OAuth URL with all required parameters, including client ID, redirect URI, response type, code challenge, nonce, and state.
+     * - The `state` parameter includes the provider, flow type, public key, and any additional state parameters for tracking or custom logic.
+     * - The flow resolves when the app is deep-linked back; it rejects if the in-app browser is closed or times out.
+     * - On successful authentication, the function either calls the provided `onOauthSuccess` callback, triggers the `onOauthRedirect` callback from provider callbacks, or completes the OAuth flow internally by calling `completeOauth`.
+     * - Handles all error cases, including missing configuration, in-app browser failures, and timeouts, and throws a `ZeroXKeyError` with appropriate error codes.
+     *
+     * @param params.clientId - The Facebook Client ID to use (defaults to the client ID from configuration).
+     * @param params.additionalState - Additional key-value pairs to include in the OAuth state parameter for custom tracking or logic.
+     * @param params.onOauthSuccess - Callback function to handle the successful OAuth response (receives `{ oidcToken, providerName, publicKey }`).
+     *
+     * onOauthSuccess params:
+     * - oidcToken: The OIDC token received from the OAuth flow.
+     * - providerName: The name of the OAuth provider ("facebook").
+     * - publicKey: The public key used for the OAuth flow.
+     *
+     * @returns A promise that resolves when the OAuth flow is successfully initiated and completed, or rejects on error or timeout.
+     * @throws {ZeroXKeyError} If the configuration is not ready, required parameters are missing, or if there is an error initiating or completing the OAuth flow.
+     */
+    handleFacebookOauth: (params?: HandleFacebookOauthParams) => Promise<void>;
+}
+/** @internal */
+export declare const ClientContext: import("react").Context<ClientContextType | undefined>;
+//# sourceMappingURL=Types.d.ts.map

package/dist/providers/Types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Types.d.ts","sourceRoot":"","sources":["../../src/providers/Types.tsx"],"names":[],"mappings":"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"}

package/dist/providers/Types.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var react = require('react');
+
+/** @internal */
+const ClientContext = react.createContext(undefined);
+
+exports.ClientContext = ClientContext;
+//# sourceMappingURL=Types.js.map

package/dist/providers/Types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Types.js","sources":["../../src/providers/Types.tsx"],"sourcesContent":[null],"names":["createContext"],"mappings":";;;;AAgVA;MACa,aAAa,GAAGA,mBAAa,CACxC,SAAS;;;;"}

package/dist/providers/Types.mjs

@@ -0,0 +1,7 @@
+import { createContext } from 'react';
+
+/** @internal */
+const ClientContext = createContext(undefined);
+
+export { ClientContext };
+//# sourceMappingURL=Types.mjs.map

package/dist/providers/Types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Types.mjs","sources":["../../src/providers/Types.tsx"],"sourcesContent":[null],"names":[],"mappings":";;AAgVA;MACa,aAAa,GAAG,aAAa,CACxC,SAAS;;;;"}

package/dist/providers/ZeroXKeyProvider.d.ts

@@ -0,0 +1,39 @@
+import { ReactNode } from "react";
+import { type ZeroXKeyCallbacks, type ZeroXKeyProviderConfig } from "../types/base";
+/**
+ * @inline
+ */
+interface ZeroXKeyProviderProps {
+    children: ReactNode;
+    config: ZeroXKeyProviderConfig;
+    callbacks?: ZeroXKeyCallbacks | undefined;
+}
+/**
+ * Provides ZeroXKey client authentication, session management, wallet operations, and user profile management
+ * for the React Native Wallet Kit SDK. This context provider encapsulates all core authentication flows (Passkey, OTP, OAuth),
+ * session lifecycle (creation, expiration, refresh), wallet import/export, and user profile updates (email, phone, name).
+ *
+ * The provider automatically initializes the ZeroXKey client, fetches configuration (including proxy auth config if needed),
+ * and synchronizes session and authentication state. It exposes a comprehensive set of methods for authentication flows,
+ * wallet management, and user profile operations, as well as UI handlers for modal-driven flows.
+ *
+ * Features:
+ * - Passkey, OTP (Email/SMS), and OAuth (Google, Apple, Facebook, Discord, X) authentication and sign-up flows.
+ * - React Native-specific OAuth: opens an in-app browser (Custom Tabs/Safari View Controller) and deep-links back via the configured app scheme.
+ * - Session management: creation, expiration scheduling, refresh, and clearing.
+ * - Wallet management: fetch, import, export, account management.
+ * - User profile management: email, phone, name, OAuth provider, and passkey linking/removal.
+ * - Error handling and callback integration for custom error and event responses.
+ *
+ * Usage:
+ * Wrap your application with `ZeroXKeyProvider` to enable authentication and wallet features via context.
+ *
+ * @param config - The ZeroXKey provider configuration object.
+ * @param children - React children to be rendered within the provider.
+ * @param callbacks - Optional callbacks for error handling and session events.
+ *
+ * @returns A React context provider exposing authentication, wallet, and user management methods and state.
+ */
+export declare const ZeroXKeyProvider: React.FC<ZeroXKeyProviderProps>;
+export {};
+//# sourceMappingURL=ZeroXKeyProvider.d.ts.map

package/dist/providers/ZeroXKeyProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ZeroXKeyProvider.d.ts","sourceRoot":"","sources":["../../src/providers/ZeroXKeyProvider.tsx"],"names":[],"mappings":"AAgFA,OAAO,EAAE,SAAS,EAA4C,MAAM,OAAO,CAAC;AA0B5E,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,EAI5B,MAAM,eAAe,CAAC;AAuBvB;;GAEG;AACH,UAAU,qBAAqB;IAC7B,QAAQ,EAAE,SAAS,CAAC;IACpB,MAAM,EAAE,sBAAsB,CAAC;IAC/B,SAAS,CAAC,EAAE,iBAAiB,GAAG,SAAS,CAAC;CAC3C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,gBAAgB,EAAE,KAAK,CAAC,EAAE,CAAC,qBAAqB,CAk/F5D,CAAC"}