@phantom/browser-sdk 1.0.0-beta.22 → 1.0.0-beta.24

package/README.md

@@ -620,6 +620,84 @@ Attempt auto-connection using existing session. Should be called after setting u
 await sdk.autoConnect();
 ```
 
+### Wallet Discovery Methods
+
+The SDK can discover multiple injected wallets using Wallet Standard for Solana and EIP-6963 for Ethereum. This allows users to choose from any installed wallet that supports the configured address types.
+
+#### discoverWallets()
+
+Asynchronously discover all available injected wallets that support the configured address types. This method uses Wallet Standard (`navigator.wallets.getWallets()`) for Solana wallets and EIP-6963 events for Ethereum wallets.
+
+**Returns:** `Promise<InjectedWalletInfo[]>` - Array of discovered wallet information
+
+```typescript
+// Discover wallets asynchronously
+const wallets = await sdk.discoverWallets();
+
+console.log("Discovered wallets:", wallets);
+// Example output:
+// [
+//   {
+//     id: "backpack",
+//     name: "Backpack",
+//     icon: "https://backpack.app/icon.png",
+//     addressTypes: [AddressType.solana],
+//     chains: ["solana:mainnet", "solana:devnet"]
+//   },
+//   {
+//     id: "metamask-io",
+//     name: "MetaMask",
+//     icon: "https://metamask.io/icon.png",
+//     addressTypes: [AddressType.ethereum],
+//     chains: ["eip155:1", "eip155:5", "eip155:11155111"]
+//   }
+// ]
+```
+
+**Behavior:**
+
+- Automatically filters wallets based on `config.addressTypes`
+- If `addressTypes` is undefined or empty, discovers all wallets regardless of chain support
+- Registers discovered wallets in the internal registry for later retrieval
+- Discovery typically takes ~400ms (EIP-6963 timeout)
+- Returns empty array on error (errors are logged but not thrown)
+
+**Note:** Discovery happens automatically when the SDK is instantiated. This method is useful for manually triggering discovery or refreshing the wallet list.
+
+#### getDiscoveredWallets()
+
+Get all currently discovered wallets from the internal registry. This is a synchronous method that returns wallets that have already been discovered.
+
+**Returns:** `InjectedWalletInfo[]` - Array of discovered wallet information
+
+```typescript
+// Get already discovered wallets (synchronous)
+const wallets = sdk.getDiscoveredWallets();
+
+console.log("Available wallets:", wallets);
+// Returns wallets that match the configured addressTypes
+// Also includes Phantom if available and matches addressTypes
+```
+
+**Behavior:**
+
+- Returns wallets from the internal registry that match `config.addressTypes`
+- Includes Phantom wallet if `window.phantom` is available and matches configured address types
+- Returns empty array if no wallets are discovered or if an error occurs
+- This is a synchronous read operation - it does not trigger new discovery
+
+**Wallet Information Structure:**
+
+```typescript
+interface InjectedWalletInfo {
+  id: string; // Unique wallet identifier (e.g., "backpack", "metamask-io")
+  name: string; // Human-readable wallet name (e.g., "Backpack", "MetaMask")
+  icon?: string; // Wallet icon URL (optional)
+  addressTypes: AddressType[]; // Supported address types (e.g., [AddressType.solana])
+  chains?: string[]; // Supported chains in CAIP-2 format (e.g., ["solana:mainnet"])
+}
+```
+
 ### Event Handlers
 
 The SDK provides typed event handlers that allow you to listen for connection state changes. This is especially useful for `autoConnect()` flows where you need to track the connection result.

package/dist/index.d.ts

@@ -108,10 +108,12 @@ type Prettify<T> = {
 type AuthProviderType = EmbeddedProviderAuthType | "injected";
 type AuthOptions = {
     provider: AuthProviderType;
+    walletId?: string;
     customAuthData?: Record<string, any>;
 };
 type ConnectResult = Omit<ConnectResult$1, "authProvider"> & {
     authProvider?: AuthProviderType | undefined;
+    walletId?: string | undefined;
 };
 
 interface Provider {
@@ -120,6 +122,7 @@ interface Provider {
     getAddresses(): WalletAddress[];
     isConnected(): boolean;
     autoConnect(): Promise<void>;
+    getEnabledAddressTypes(): AddressType[];
     solana: ISolanaChain;
     ethereum: IEthereumChain;
 }
@@ -129,9 +132,30 @@ interface ProviderPreference {
     embeddedWalletType?: "app-wallet" | "user-wallet";
 }
 
+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;
+}
+
 declare class BrowserSDK {
     private providerManager;
+    private walletRegistry;
+    private config;
+    isLoading: boolean;
     constructor(config: BrowserSDKConfig);
+    discoverWallets(): Promise<void>;
     /**
      * Access Solana chain operations
      */
@@ -161,9 +185,12 @@ declare class BrowserSDK {
      */
     getCurrentProviderInfo(): ProviderPreference | null;
     /**
-     * Check if Phantom extension is installed
+     * 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
      */
-    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
@@ -180,29 +207,10 @@ declare class BrowserSDK {
      * 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;
@@ -228,6 +236,7 @@ declare class BrowserSDK {
      * Only available for injected providers
      */
     getSupportedAutoConfirmChains(): Promise<AutoConfirmSupportedChainsResult>;
+    getDiscoveredWallets(): InjectedWalletInfo[];
 }
 
 /**
@@ -301,13 +310,8 @@ declare function waitForPhantomExtension(timeoutMs?: number): Promise<boolean>;
  * Usage:
  * ```typescript
  * const isAvailable = await isPhantomLoginAvailable();
- * if (isAvailable) {
- *   console.log("Phantom Login is available!");
- * } else {
- *   console.log("Phantom Login is not available");
- * }
  * ```
  */
 declare function isPhantomLoginAvailable(timeoutMs?: number): Promise<boolean>;
 
-export { AuthOptions, AuthProviderType, BrowserInfo, BrowserSDK, BrowserSDKConfig, ConnectResult, DebugCallback, DebugCategory, DebugConfig, DebugLevel, DebugMessage, Provider, debug, detectBrowser, getBrowserDisplayName, getDeeplinkToPhantom, getPlatformName, isMobileDevice, isPhantomLoginAvailable, parseBrowserFromUserAgent, waitForPhantomExtension };
+export { AuthOptions, AuthProviderType, BrowserInfo, BrowserSDK, BrowserSDKConfig, ConnectResult, DebugCallback, DebugCategory, DebugConfig, DebugLevel, DebugMessage, InjectedWalletId, InjectedWalletInfo, Provider, debug, detectBrowser, getBrowserDisplayName, getDeeplinkToPhantom, getPlatformName, isMobileDevice, isPhantomLoginAvailable, parseBrowserFromUserAgent, waitForPhantomExtension };