@openfort/react-native 0.0.3 → 0.1.1

package/dist/types/index.d.ts

@@ -1 +1,18 @@
-export { default as Iframe } from './Iframe';
+/**
+ * Openfort React Native SDK
+ *
+ * A comprehensive React Native SDK for integrating with the Openfort platform.
+ * This SDK provides authentication, embedded wallets, session management, and UI components
+ * for building decentralized applications on React Native.
+ *
+ * @author Openfort
+ * @version 0.1.0
+ */
+export type { AuthPlayerResponse, OpenfortError, ShieldAuthentication, ShieldAuthType, Openfort as OpenfortClient, Provider, OpenfortConfiguration, ShieldConfiguration, EmbeddedState, } from '@openfort/openfort-js';
+export { OAuthProvider, } from '@openfort/openfort-js';
+export * from './types';
+export * from './hooks';
+export * from './components';
+export * from './core';
+export * from './native';
+export * from './constants';

package/dist/types/index.js

@@ -0,0 +1,2 @@
+// Predicate functions (exported directly, not as types)
+export { isConnected, isReconnecting, isConnecting, isDisconnected, isNotCreated, isCreating, hasError, needsRecovery, isLoading, isReady, needsUserAction, isStable, canTransact, getStateDescription, getActionText, } from './predicates';

package/dist/types/lib/hookConsistency.d.ts

@@ -0,0 +1,14 @@
+import { OpenfortHookOptions } from "../types/hookOption";
+import { OpenfortError } from "../types/openfortError";
+export declare const onSuccess: <T>({ hookOptions, options, data, }: {
+    hookOptions?: OpenfortHookOptions<T>;
+    options?: OpenfortHookOptions<T>;
+    data: T;
+}) => T;
+export declare const onError: <T>({ hookOptions, options, error, }: {
+    hookOptions?: OpenfortHookOptions<T>;
+    options?: OpenfortHookOptions<T>;
+    error: OpenfortError;
+}) => {
+    error: OpenfortError;
+};

package/dist/types/native/index.d.ts

@@ -0,0 +1,5 @@
+export { EmbeddedWalletWebView, WebViewUtils } from './webview';
+export { isSecureStorageMessage, handleSecureStorageMessage, NativeStorageUtils, } from './storage';
+export type { SecureStorageMessage, SecureStorageResponse, } from './storage';
+export { openOAuthSession, authenticateWithApple, isAppleSignInAvailable, parseOAuthUrl, createOAuthRedirectUri, OAuthUtils, } from './oauth';
+export type { OAuthResult, AppleAuthResult, OAuthSessionConfig, } from './oauth';

package/dist/types/native/oauth.d.ts

@@ -0,0 +1,91 @@
+import * as AppleAuthentication from 'expo-apple-authentication';
+import { OAuthProvider as OAuthProviderType } from '@openfort/openfort-js';
+/**
+ * OAuth authentication result
+ */
+export interface OAuthResult {
+    type: 'success' | 'cancel' | 'error';
+    url?: string;
+    error?: string;
+}
+/**
+ * Apple Sign-In authentication result
+ */
+export interface AppleAuthResult {
+    authorizationCode: string;
+    state: string;
+    identityToken?: string;
+    email?: string;
+    fullName?: AppleAuthentication.AppleAuthenticationFullName;
+}
+/**
+ * OAuth session configuration
+ */
+export interface OAuthSessionConfig {
+    /** OAuth provider URL */
+    url: string;
+    /** Redirect URI for OAuth flow */
+    redirectUri: string;
+}
+/**
+ * Opens an OAuth authentication session
+ */
+export declare function openOAuthSession(config: OAuthSessionConfig): Promise<OAuthResult>;
+/**
+ * Handles Apple Sign-In authentication for iOS
+ */
+export declare function authenticateWithApple(options: {
+    state: string;
+    isLogin: boolean;
+}): Promise<AppleAuthResult>;
+/**
+ * Checks if Apple Sign-In is available on the current device
+ */
+export declare function isAppleSignInAvailable(): Promise<boolean>;
+/**
+ * Parses OAuth parameters from a URL
+ */
+export declare function parseOAuthUrl(url: string): {
+    access_token?: string;
+    refresh_token?: string;
+    player_id?: string;
+    error?: string;
+    errorDescription?: string;
+};
+/**
+ * Creates a redirect URI for OAuth flows
+ */
+export declare function createOAuthRedirectUri(path?: string): string;
+/**
+ * OAuth provider utilities
+ */
+export declare const OAuthUtils: {
+    /**
+     * Checks if a provider should use native authentication
+     */
+    shouldUseNativeAuth(provider: OAuthProviderType, isLegacyAppleIosBehaviorEnabled?: boolean): boolean;
+    /**
+     * Gets platform-specific OAuth configuration
+     */
+    getPlatformConfig(): {
+        supportsNativeApple: boolean;
+        platform: string;
+        supportsWebBrowser: boolean;
+    };
+    /**
+     * Validates OAuth provider support
+     */
+    isProviderSupported(provider: OAuthProviderType): boolean;
+    /**
+     * Gets the appropriate OAuth URL for a provider
+     */
+    getProviderUrl(provider: OAuthProviderType, baseUrl: string): string;
+    /**
+     * Handles OAuth session timeout
+     */
+    createTimeoutPromise(timeoutMs?: number): Promise<never>;
+    /**
+     * Combines OAuth session with timeout
+     */
+    withTimeout<T>(promise: Promise<T>, timeoutMs?: number): Promise<T>;
+};

package/dist/types/native/storage.d.ts

@@ -0,0 +1,50 @@
+import * as SecureStore from 'expo-secure-store';
+/**
+ * Interface for secure storage message handling in WebView
+ */
+export interface SecureStorageMessage {
+    event: string;
+    id: string;
+    data: Record<string, any>;
+}
+/**
+ * Interface for secure storage response
+ */
+export interface SecureStorageResponse {
+    event: string;
+    id: string;
+    data: Record<string, any>;
+}
+/**
+ * Checks if a message is a secure storage related message
+ */
+export declare function isSecureStorageMessage(message: unknown): message is SecureStorageMessage;
+/**
+ * Handles secure storage operations from WebView messages
+ */
+export declare function handleSecureStorageMessage(message: SecureStorageMessage): Promise<SecureStorageResponse>;
+/**
+ * Native storage utilities for platform-specific operations
+ */
+export declare const NativeStorageUtils: {
+    /**
+     * Checks if secure storage is available on the current platform
+     */
+    isAvailable(): boolean;
+    /**
+     * Gets the platform-specific storage options
+     */
+    getStorageOptions(): SecureStore.SecureStoreOptions;
+    /**
+     * Safely checks if a key exists in secure storage
+     */
+    keyExists(key: string): Promise<boolean>;
+    /**
+     * Gets all available storage information
+     */
+    getStorageInfo(): Promise<{
+        isAvailable: boolean;
+        platform: string;
+        keychainAccessible: number;
+    }>;
+};

package/dist/types/native/webview.d.ts

@@ -0,0 +1,50 @@
+import React from 'react';
+import WebView from 'react-native-webview';
+import type { Openfort as OpenfortClient } from '@openfort/openfort-js';
+/**
+ * Props for the EmbeddedWalletWebView component
+ */
+interface EmbeddedWalletWebViewProps {
+    /** Openfort client instance */
+    client: OpenfortClient;
+    /** Whether the client is ready and initialized */
+    isClientReady: boolean;
+    /** Callback when WebView proxy status changes */
+    onProxyStatusChange?: (status: 'loading' | 'loaded' | 'reloading') => void;
+}
+/**
+ * WebView component for embedded wallet integration
+ * Handles secure communication between React Native and the embedded wallet WebView
+ * This component is hidden and only used for wallet communication
+ */
+export declare const EmbeddedWalletWebView: React.FC<EmbeddedWalletWebViewProps>;
+/**
+ * Utilities for WebView integration
+ */
+export declare const WebViewUtils: {
+    /**
+     * Checks if WebView is supported on the current platform
+     */
+    isSupported(): boolean;
+    /**
+     * Gets platform-specific WebView configuration
+     */
+    getPlatformConfig(): Partial<React.ComponentProps<typeof WebView>>;
+    /**
+     * Creates a secure message for WebView communication
+     */
+    createSecureMessage(data: any): string;
+    /**
+     * Validates a message received from WebView
+     */
+    validateMessage(message: string): {
+        isValid: boolean;
+        data?: any;
+        error?: string;
+    };
+    /**
+     * Gets WebView user agent for the current platform
+     */
+    getUserAgent(): string;
+};
+export {};

package/dist/types/oauth.js

@@ -0,0 +1,8 @@
+export const mapOAuthStatus = (status) => {
+    return {
+        isLoading: status.status === 'loading',
+        isError: status.status === 'error',
+        isSuccess: status.status === 'done',
+        error: status.error
+    };
+};

package/dist/types/openfortError.js

@@ -0,0 +1,27 @@
+export var OpenfortErrorType;
+(function (OpenfortErrorType) {
+    OpenfortErrorType["AUTHENTICATION_ERROR"] = "AUTHENTICATION_ERROR";
+    OpenfortErrorType["WALLET_ERROR"] = "WALLET_ERROR";
+})(OpenfortErrorType || (OpenfortErrorType = {}));
+export class OpenfortError extends Error {
+    type;
+    data;
+    constructor(message, type, data) {
+        if (data?.error instanceof OpenfortError) {
+            super(data.error.message);
+            this.data = data.error.data;
+            this.type = data.error.type;
+            this.name = data.error.name;
+            return;
+        }
+        else if (data?.error instanceof Error) {
+            super(data.error.message);
+        }
+        else {
+            super(message);
+        }
+        this.type = type;
+        this.data = data || {};
+        this.name = 'OpenfortError';
+    }
+}

package/dist/types/predicates.js

@@ -0,0 +1,101 @@
+export function isConnected(s) {
+    return s.status === 'connected';
+}
+export function isReconnecting(s) {
+    return s.status === 'reconnecting';
+}
+export function isConnecting(s) {
+    return s.status === 'connecting';
+}
+export function isDisconnected(s) {
+    return s.status === 'disconnected';
+}
+export function isNotCreated(s) {
+    return s.status === 'disconnected';
+}
+export function isCreating(s) {
+    return s.status === 'creating';
+}
+export function hasError(s) {
+    return s.status === 'error';
+}
+export function needsRecovery(s) {
+    return s.status === 'needs-recovery';
+}
+/**
+ * Additional utility predicates
+ */
+/**
+ * Type guard to check if wallet is in a loading state (connecting, creating, reconnecting)
+ */
+export function isLoading(s) {
+    return s.status === 'connecting' || s.status === 'creating' || s.status === 'reconnecting';
+}
+/**
+ * Type guard to check if wallet is ready for use
+ */
+export function isReady(s) {
+    return s.status === 'connected';
+}
+/**
+ * Type guard to check if wallet needs user action
+ */
+export function needsUserAction(s) {
+    return s.status === 'disconnected' || s.status === 'needs-recovery' || s.status === 'error';
+}
+/**
+ * Type guard to check if wallet state is stable (not in transition)
+ */
+export function isStable(s) {
+    return !isLoading(s);
+}
+/**
+ * Type guard to check if wallet can perform transactions
+ */
+export function canTransact(s) {
+    return s.status === 'connected';
+}
+/**
+ * Gets a human-readable description of the wallet state
+ */
+export function getStateDescription(s) {
+    switch (s.status) {
+        case 'connected':
+            return 'Wallet is connected and ready to use';
+        case 'connecting':
+            return 'Connecting to wallet...';
+        case 'reconnecting':
+            return 'Reconnecting to wallet...';
+        case 'creating':
+            return 'Creating new wallet...';
+        case 'disconnected':
+            return 'Wallet is disconnected';
+        case 'needs-recovery':
+            return 'Wallet needs to be recovered';
+        case 'error':
+            return 'Wallet encountered an error';
+        default:
+            return 'Unknown wallet state';
+    }
+}
+/**
+ * Gets appropriate action text for the current state
+ */
+export function getActionText(s) {
+    switch (s.status) {
+        case 'needs-recovery':
+            return 'Recover Wallet';
+        case 'error':
+            return 'Retry';
+        case 'disconnected':
+            return 'Create Wallet';
+        case 'connecting':
+        case 'creating':
+        case 'reconnecting':
+            return 'Please wait...';
+        case 'connected':
+            return 'Wallet Ready';
+        default:
+            return 'Unknown';
+    }
+}

package/dist/types/state.js

@@ -0,0 +1 @@
+"use strict";

package/dist/types/types/auth.d.ts

@@ -0,0 +1,168 @@
+import type { OpenfortError, AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
+/**
+ * Password authentication flow state
+ */
+export type PasswordFlowState = {
+    status: 'initial';
+} | {
+    status: 'error';
+    error: Error | null;
+} | {
+    status: 'sending-verification-code';
+} | {
+    status: 'awaiting-code-input';
+} | {
+    status: 'submitting-code';
+} | {
+    status: 'done';
+};
+/**
+ * Sign-in with Ethereum (SIWE) flow state
+ */
+export type SiweFlowState = {
+    status: 'initial';
+} | {
+    status: 'error';
+    error: Error | null;
+} | {
+    status: 'generating-message';
+} | {
+    status: 'awaiting-signature';
+} | {
+    status: 'submitting-signature';
+} | {
+    status: 'done';
+};
+/**
+ * Recovery flow state
+ */
+export type RecoveryFlowState = {
+    status: 'initial' | 'creating-wallet' | 'upgrading-recovery' | 'recovering';
+};
+/**
+ * Custom authentication flow state
+ */
+export type CustomAuthFlowState = {
+    status: 'initial';
+} | {
+    status: 'loading';
+} | {
+    status: 'not-enabled';
+} | {
+    status: 'done';
+} | {
+    status: 'error';
+    error: Error | null;
+};
+/**
+ * Authentication success callback
+ */
+export type AuthSuccessCallback = (user: OpenfortUser, isNewUser?: boolean) => void;
+/**
+ * Authentication link success callback
+ */
+export type AuthLinkSuccessCallback = (user: OpenfortUser) => void;
+/**
+ * Error callback
+ */
+export type ErrorCallback = (error: OpenfortError | Error) => void;
+/**
+ * Email login hook options
+ */
+export interface EmailLoginHookOptions {
+    onError?: ErrorCallback;
+    onSuccess?: AuthSuccessCallback;
+}
+/**
+ * Email link hook options
+ */
+export interface EmailLinkHookOptions {
+    onError?: ErrorCallback;
+    onSuccess?: AuthLinkSuccessCallback;
+}
+/**
+ * Email login hook result
+ */
+export interface EmailLoginHookResult {
+    login: (credentials: {
+        email: string;
+        password: string;
+    }) => Promise<OpenfortUser | undefined>;
+    signup: (credentials: {
+        email: string;
+        password: string;
+        name?: string;
+    }) => Promise<OpenfortUser | undefined>;
+    state: PasswordFlowState;
+}
+/**
+ * Email link hook result
+ */
+export interface EmailLinkHookResult {
+    link: (credentials: {
+        email: string;
+        password: string;
+    }) => Promise<OpenfortUser | undefined>;
+    state: PasswordFlowState;
+}
+/**
+ * SIWE message generation response
+ */
+export type GenerateSiweMessageResponse = Promise<string>;
+/**
+ * SIWE message generation function
+ */
+export type GenerateSiweMessage = (opts: {
+    /** Wallet to request a Sign-In With Ethereum signature from */
+    wallet: any;
+    /**
+     * Required fields that describe origin of Sign-In With Ethereum signature request
+     */
+    from: {
+        /** RFC 3986 authority that is requesting the signing */
+        domain: string;
+        /** RFC 3986 URI referring to the resource that is the subject of the signing */
+        uri: string;
+    };
+}) => GenerateSiweMessageResponse;
+/**
+ * SIWE login hook options
+ */
+export interface SiweLoginHookOptions {
+    onError?: ErrorCallback;
+    onSuccess?: AuthSuccessCallback;
+    onGenerateMessage?: (message: string) => void;
+}
+/**
+ * SIWE link hook options
+ */
+export interface SiweLinkHookOptions {
+    onError?: ErrorCallback;
+    onSuccess?: AuthLinkSuccessCallback;
+    onGenerateMessage?: (message: string) => void;
+}
+/**
+ * SIWE login hook result
+ */
+export interface SiweLoginHookResult {
+    generateSiweMessage: GenerateSiweMessage;
+    state: SiweFlowState;
+    loginWithSiwe: (opts: {
+        signature: string;
+        walletAddress: string;
+        messageOverride?: string;
+        disableSignup?: boolean;
+    }) => Promise<OpenfortUser>;
+}
+/**
+ * SIWE link hook result
+ */
+export interface SiweLinkHookResult {
+    generateSiweMessage: GenerateSiweMessage;
+    state: SiweFlowState;
+    linkWithSiwe: (opts: {
+        signature: string;
+        messageOverride?: string;
+        walletAddress: string;
+    }) => Promise<OpenfortUser>;
+}

package/dist/types/types/baseFlowState.d.ts

@@ -0,0 +1,14 @@
+import { OpenfortError } from "./openfortError";
+export type BaseFlowState = {
+    status: "idle" | 'awaiting-input' | 'loading' | 'success';
+    error?: never;
+} | {
+    status: 'error';
+    error: OpenfortError | null;
+};
+export declare const mapStatus: (status: BaseFlowState) => {
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: OpenfortError | null | undefined;
+};

package/dist/types/types/config.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Storage interface
+ */
+export interface Storage {
+    [key: string]: any;
+}
+/**
+ * Chain configuration
+ */
+export interface Chain {
+    [key: string]: any;
+}
+/**
+ * Custom authentication provider configuration
+ */
+export type CustomAuthProviderConfig = {
+    /**
+     * If true, enable custom authentication integration.
+     * This enables a JWT from a custom auth provider to be used to authenticate Openfort embedded wallets.
+     * Defaults to true.
+     */
+    enabled?: boolean;
+    /**
+     * A callback that returns the user's custom auth provider's access token as a string.
+     * Can be left blank if using cookies to store and send access tokens
+     */
+    getCustomAccessToken: () => Promise<string | undefined>;
+    /**
+     * Custom auth providers loading state
+     */
+    isLoading: boolean;
+};
+/**
+ * Create guest account interface
+ */
+export interface UseGuestAuth {
+    create: () => Promise<import('@openfort/openfort-js').AuthPlayerResponse>;
+}
+/**
+ * Embedded wallet state change hook options
+ */
+export interface UseOnEmbeddedWalletStateChange {
+    onStateChange: (state: import('./wallet').EmbeddedWalletStatus) => void;
+}
+/**
+ * Set embedded wallet recovery parameters
+ */
+export type SetRecoveryParams = {
+    recoveryMethod: 'password';
+    password: string;
+} | {
+    recoveryMethod: 'automatic';
+};
+/**
+ * Set embedded wallet recovery result
+ */
+export interface UseSetEmbeddedWalletRecoveryResult {
+    /**
+     * The embedded account with the updated recovery method.
+     */
+    account: import('@openfort/openfort-js').EmbeddedAccount;
+}
+/**
+ * Set embedded wallet recovery interface
+ */
+export interface UseSetEmbeddedWalletRecovery {
+    /**
+     * An async method to update the recovery method of the embedded wallet.
+     */
+    setRecovery: (params: SetRecoveryParams) => Promise<import('@openfort/openfort-js').EmbeddedAccount>;
+}

package/dist/types/types/hex.d.ts

@@ -0,0 +1 @@
+export type Hex = `0x${string}`;

package/dist/types/types/hookOption.d.ts

@@ -0,0 +1,9 @@
+import { OpenfortError } from "./openfortError";
+export type OpenfortHookOptions<T = {
+    error?: OpenfortError;
+}> = {
+    onSuccess?: (data: T) => void;
+    onError?: (error: OpenfortError) => void;
+    onSettled?: (data: T | undefined | null, error: OpenfortError | null) => void;
+    throwOnError?: boolean;
+};

package/dist/types/types/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Core Openfort hook interface
+ */
+export interface UseOpenfort {
+    /** The current authenticated user, or null when unauthenticated */
+    user: import('@openfort/openfort-js').AuthPlayerResponse | null;
+    /** Whether or not the SDK has initialized and is ready for use */
+    isReady: boolean;
+    /** Any error encountered during SDK initialization */
+    error: Error | null;
+    /** A function that logs the current user out and clears any stored tokens */
+    logout: () => Promise<void>;
+    /** A function that gets the current authenticated user's access token */
+    getAccessToken: () => Promise<string | null>;
+}
+export type { PasswordFlowState, SiweFlowState, RecoveryFlowState, CustomAuthFlowState, AuthSuccessCallback, AuthLinkSuccessCallback, ErrorCallback, EmailLoginHookOptions, EmailLinkHookOptions, EmailLoginHookResult, EmailLinkHookResult, SiweLoginHookOptions, SiweLinkHookOptions, SiweLoginHookResult, SiweLinkHookResult, GenerateSiweMessageResponse, GenerateSiweMessage, } from './auth';
+export type { OAuthFlowState, OAuthTokens, UseOAuthTokensOptions, LoginWithOAuthInput, LinkWithOAuthInput, UseLoginWithOAuth, UseLinkWithOAuth, UnlinkOAuthOptions, UnlinkOAuthParams, } from './oauth';
+export type { OpenfortEmbeddedWalletAccount, WalletRecoveryCallbacks, SolanaWalletRecoveryCallbacks, RecoveryMethodOptions, CreateSolanaEmbeddedWalletOpts, RecoverSolanaEmbeddedWalletOpts, EmbeddedEthereumWalletActions, EmbeddedEthereumWalletState, EmbeddedWalletStatus, ConnectedEmbeddedSolanaWallet, EmbeddedSolanaWalletActions, EmbeddedSolanaWalletConnectedState, EmbeddedSolanaWalletConnectingState, EmbeddedSolanaWalletReconnectingState, EmbeddedSolanaWalletDisconnectedState, EmbeddedSolanaWalletNeedsRecoveryState, EmbeddedSolanaWalletCreatingState, EmbeddedSolanaWalletErrorState, EmbeddedSolanaWalletState, EmbeddedSolanaWalletStatus, ConnectedEmbeddedEthereumWallet, UserWallet, } from './wallet';
+export type { CustomAuthProviderConfig, UseGuestAuth, UseOnEmbeddedWalletStateChange, SetRecoveryParams, UseSetEmbeddedWalletRecoveryResult, UseSetEmbeddedWalletRecovery, } from './config';
+export { isConnected, isReconnecting, isConnecting, isDisconnected, isNotCreated, isCreating, hasError, needsRecovery, isLoading, isReady, needsUserAction, isStable, canTransact, getStateDescription, getActionText, } from './predicates';
+/**
+ * Embedded wallet hook options with callbacks
+ */
+export type UseEmbeddedEthereumWallet = {
+    onCreateWalletSuccess?: (provider: import('@openfort/openfort-js').Provider) => void;
+    onCreateWalletError?: (error: Error) => void;
+    onSetWalletRecoverySuccess?: (result: {
+        user: import('@openfort/openfort-js').AuthPlayerResponse;
+    }) => void;
+    onSetWalletRecoveryError?: (error: Error) => void;
+};
+/**
+ * Embedded Solana wallet hook options with callbacks
+ */
+export type UseEmbeddedSolanaWallet = {
+    onCreateWalletSuccess?: (account: import('@openfort/openfort-js').EmbeddedAccount) => void;
+    onCreateWalletError?: (error: Error) => void;
+};