@phantom/browser-sdk 1.0.0-beta.9 → 1.0.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { EmbeddedProviderConfig, AuthOptions, ConnectResult, WalletAddress, EmbeddedProviderEvent, EventCallback } from '@phantom/embedded-provider-core';
-export { AuthOptions, ConnectResult, SignAndSendTransactionParams, SignMessageParams, SignMessageResult, SignedTransaction, WalletAddress } from '@phantom/embedded-provider-core';
-import { ISolanaChain, IEthereumChain } from '@phantom/chain-interfaces';
+import { EmbeddedProviderConfig, EmbeddedProviderAuthType, ConnectResult as ConnectResult$1, WalletAddress, EmbeddedProviderEvent, EventCallback } from '@phantom/embedded-provider-core';
+export { ConnectErrorEventData, ConnectEventData, ConnectStartEventData, DisconnectEventData, EmbeddedProviderEvent, EmbeddedProviderEventMap, EventCallback, SignAndSendTransactionParams, SignMessageParams, SignMessageResult, SignedTransaction, WalletAddress } from '@phantom/embedded-provider-core';
+import { IEthereumChain, ISolanaChain } from '@phantom/chain-interfaces';
 export { EthTransactionRequest, IEthereumChain, ISolanaChain } from '@phantom/chain-interfaces';
 import { AddressType } from '@phantom/client';
 export { AddressType } from '@phantom/client';
@@ -52,51 +52,97 @@ declare const DebugCategory: {
     readonly SESSION: "Session";
 };
 
+interface PhantomAppLoginOptions {
+    publicKey: string;
+    appId: string;
+    sessionId: string;
+}
+interface PhantomAppLoginResult {
+    walletId: string;
+    organizationId: string;
+    accountDerivationIndex?: number;
+    expiresInMs?: number;
+    authUserId?: string;
+}
+interface PhantomApp {
+    login(options: PhantomAppLoginOptions): Promise<PhantomAppLoginResult>;
+    features(): Promise<{
+        features: string[];
+    }>;
+    getUser(): Promise<{
+        authUserId?: string;
+    } | undefined>;
+}
 declare global {
     interface Window {
         phantom?: {
             solana?: unknown;
             ethereum?: unknown;
-        };
+            app?: PhantomApp;
+        } | undefined;
     }
 }
+
 interface InjectedProviderConfig {
     addressTypes: AddressType[];
 }
 
+type InjectedWalletId = string;
+interface WalletProviders {
+    /** EIP-6963 Ethereum provider (window.ethereum-like) */
+    ethereum?: IEthereumChain;
+    /** Wallet Standard Solana wallet object */
+    solana?: ISolanaChain;
+}
+interface InjectedWalletInfo {
+    id: InjectedWalletId;
+    name: string;
+    icon?: string;
+    addressTypes: AddressType[];
+    providers?: WalletProviders;
+    /** Reverse DNS identifier from EIP-6963 (for potential future matching with Wallet Standard) */
+    rdns?: string;
+    discovery?: "standard" | "eip6963" | "phantom";
+}
+
 interface DebugConfig {
     enabled?: boolean;
     level?: DebugLevel;
     callback?: DebugCallback;
 }
-type BrowserSDKConfig = Prettify<(ExtendedEmbeddedProviderConfig | ExtendedInjectedProviderConfig) & {
-    autoConnect?: boolean;
-}>;
-type Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-interface ExtendedEmbeddedProviderConfig extends Omit<EmbeddedProviderConfig, "authOptions" | "apiBaseUrl" | "embeddedWalletType"> {
-    providerType: "embedded";
+type BrowserSDKConfig = Prettify<Omit<EmbeddedProviderConfig, "authOptions" | "apiBaseUrl" | "embeddedWalletType" | "appId"> & InjectedProviderConfig & {
+    providers: AuthProviderType[];
+    appId?: string;
     apiBaseUrl?: string;
     embeddedWalletType?: "app-wallet" | "user-wallet";
     authOptions?: {
         authUrl?: string;
         redirectUrl?: string;
     };
-}
-interface ExtendedInjectedProviderConfig extends InjectedProviderConfig {
-    providerType: "injected";
-    appId?: never;
-    authOptions?: never;
-    embeddedWalletType?: never;
-}
+}>;
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type AuthProviderType = EmbeddedProviderAuthType | "injected" | "deeplink";
+type AuthOptions = {
+    provider: AuthProviderType;
+    walletId?: string;
+    customAuthData?: Record<string, any>;
+};
 
+type ConnectResultWalletInfo = Omit<InjectedWalletInfo, "providers">;
+type ConnectResult = Omit<ConnectResult$1, "authProvider"> & {
+    authProvider?: AuthProviderType | undefined;
+    walletId?: string | undefined;
+    wallet?: ConnectResultWalletInfo | undefined;
+};
 interface Provider {
-    connect(authOptions?: AuthOptions): Promise<ConnectResult>;
+    connect(authOptions: AuthOptions): Promise<ConnectResult>;
     disconnect(): Promise<void>;
     getAddresses(): WalletAddress[];
     isConnected(): boolean;
     autoConnect(): Promise<void>;
+    getEnabledAddressTypes(): AddressType[];
     solana: ISolanaChain;
     ethereum: IEthereumChain;
 }
@@ -105,26 +151,14 @@ interface ProviderPreference {
     type: "injected" | "embedded";
     embeddedWalletType?: "app-wallet" | "user-wallet";
 }
-interface SwitchProviderOptions {
-    embeddedWalletType?: "app-wallet" | "user-wallet" | (string & Record<never, never>);
-}
 
-/**
- * Browser SDK with chain-specific API
- *
- * Usage:
- * ```typescript
- * const sdk = new BrowserSDK({ providerType: 'embedded', appId: 'your-app-id' });
- * await sdk.connect();
- *
- * // Chain-specific operations
- * await sdk.solana.signMessage(message);
- * await sdk.ethereum.signPersonalMessage(message, address);
- * ```
- */
 declare class BrowserSDK {
     private providerManager;
+    private walletRegistry;
+    private config;
+    isLoading: boolean;
     constructor(config: BrowserSDKConfig);
+    discoverWallets(): Promise<void>;
     /**
      * Access Solana chain operations
      */
@@ -136,15 +170,11 @@ declare class BrowserSDK {
     /**
      * Connect to the wallet
      */
-    connect(options?: AuthOptions): Promise<ConnectResult>;
+    connect(options: AuthOptions): Promise<ConnectResult>;
     /**
      * Disconnect from the wallet
      */
     disconnect(): Promise<void>;
-    /**
-     * Switch between provider types (injected vs embedded)
-     */
-    switchProvider(type: "injected" | "embedded", options?: SwitchProviderOptions): Promise<void>;
     /**
      * Check if the SDK is connected to a wallet
      */
@@ -158,13 +188,12 @@ declare class BrowserSDK {
      */
     getCurrentProviderInfo(): ProviderPreference | null;
     /**
-     * Get the wallet ID (for embedded wallets)
+     * Get enabled address types for the current provider
+     * - For embedded provider: returns config.addressTypes
+     * - For Phantom injected: returns config.addressTypes
+     * - For discovered wallets: returns the wallet's addressTypes from registry
      */
-    getWalletId(): string | null;
-    /**
-     * Check if Phantom extension is installed
-     */
-    static isPhantomInstalled(timeoutMs?: number): Promise<boolean>;
+    getEnabledAddressTypes(): AddressType[];
     /**
      * Add event listener for provider events (connect, connect_start, connect_error, disconnect, error)
      * Works with both embedded and injected providers
@@ -178,32 +207,13 @@ declare class BrowserSDK {
     /**
      * Attempt auto-connection using existing session
      * Should be called after setting up event listeners
-     * Only works with embedded providers
+     * Tries embedded provider first, then injected provider as fallback
      */
     autoConnect(): Promise<void>;
-    /**
-     * Debug configuration methods
-     * These allow dynamic debug configuration without SDK reinstantiation
-     */
-    /**
-     * Enable debug logging
-     */
     enableDebug(): void;
-    /**
-     * Disable debug logging
-     */
     disableDebug(): void;
-    /**
-     * Set debug level
-     */
     setDebugLevel(level: DebugLevel): void;
-    /**
-     * Set debug callback function
-     */
     setDebugCallback(callback: DebugCallback): void;
-    /**
-     * Configure debug settings all at once
-     */
     configureDebug(config: {
         enabled?: boolean;
         level?: DebugLevel;
@@ -229,6 +239,7 @@ declare class BrowserSDK {
      * Only available for injected providers
      */
     getSupportedAutoConfirmChains(): Promise<AutoConfirmSupportedChainsResult>;
+    getDiscoveredWallets(): InjectedWalletInfo[];
 }
 
 /**
@@ -289,4 +300,21 @@ declare function getDeeplinkToPhantom(ref?: string): string;
  */
 declare function waitForPhantomExtension(timeoutMs?: number): Promise<boolean>;
 
-export { BrowserInfo, BrowserSDK, BrowserSDKConfig, DebugCallback, DebugCategory, DebugConfig, DebugLevel, DebugMessage, Provider, debug, detectBrowser, getBrowserDisplayName, getDeeplinkToPhantom, getPlatformName, isMobileDevice, parseBrowserFromUserAgent, waitForPhantomExtension };
+/**
+ * Check if Phantom Login is available
+ *
+ * This function checks if:
+ * 1. The Phantom extension is installed
+ * 2. The extension supports the phantom_login feature
+ *
+ * @param timeoutMs - Maximum time to wait for extension in milliseconds (default: 3000)
+ * @returns Promise<boolean> - true if Phantom Login is available, false otherwise
+ *
+ * Usage:
+ * ```typescript
+ * const isAvailable = await isPhantomLoginAvailable();
+ * ```
+ */
+declare function isPhantomLoginAvailable(timeoutMs?: number): Promise<boolean>;
+
+export { AuthOptions, AuthProviderType, BrowserInfo, BrowserSDK, BrowserSDKConfig, ConnectResult, DebugCallback, DebugCategory, DebugConfig, DebugLevel, DebugMessage, InjectedWalletId, InjectedWalletInfo, Provider, debug, detectBrowser, getBrowserDisplayName, getDeeplinkToPhantom, getPlatformName, isMobileDevice, isPhantomLoginAvailable, parseBrowserFromUserAgent, waitForPhantomExtension };