@phantom/browser-sdk 0.3.4 → 0.3.5

package/README.md

@@ -41,8 +41,7 @@ const sdk = new BrowserSDK({
   organizationId: "your-org-id",
 });
 
-const { walletId, addresses } = await sdk.connect();
-console.log("Wallet ID:", walletId);
+const { addresses } = await sdk.connect();
 console.log("Addresses:", addresses);
 
 const result = await sdk.signAndSendTransaction({
@@ -89,6 +88,7 @@ const sdk = new BrowserSDK({
   },
   appName: "My DApp", // optional, for branding
   appLogo: "https://myapp.com/logo.png", // optional, for branding
+  autoConnect: true, // optional, auto-connect to existing session (default: true for embedded)
   debug: {
     enabled: true, // optional, enable debug logging
     level: "info", // optional, debug level
@@ -162,6 +162,43 @@ const sdk = new BrowserSDK({
 - **@solana/web3.js**: Better ecosystem compatibility, wider community support
 - **@solana/kit**: Better TypeScript support, modern architecture, smaller bundle size
 
+### Auto-Connect Feature
+
+The SDK can automatically reconnect to existing sessions when instantiated, providing a seamless user experience.
+
+```typescript
+const sdk = new BrowserSDK({
+  providerType: "embedded",
+  // ... other config
+  autoConnect: true, // Default: true for embedded, false for injected
+});
+
+// SDK will automatically check for existing valid session and connect in background
+// No need to call connect() if user already has a session
+
+// Check if already connected
+if (sdk.isConnected()) {
+  console.log("Already connected!");
+  const addresses = await sdk.getAddresses();
+} else {
+  // First time or session expired, need to connect manually
+  await sdk.connect();
+}
+```
+
+**Disabling Auto-Connect:**
+
+```typescript
+const sdk = new BrowserSDK({
+  providerType: "embedded",
+  // ... other config
+  autoConnect: false, // Disable auto-connect
+});
+
+// Now you must manually call connect() every time
+await sdk.connect();
+```
+
 ## API Reference
 
 ### Constructor
@@ -188,6 +225,7 @@ interface BrowserSDKConfig {
   };
   embeddedWalletType?: "app-wallet" | "user-wallet"; // Wallet type
   solanaProvider?: "web3js" | "kit"; // Solana library choice (default: 'web3js')
+  autoConnect?: boolean; // Enable auto-connect to existing sessions (default: true)
 
   // Debug options
   debug?: {
@@ -316,6 +354,14 @@ Disconnect from wallet and clear session.
 await sdk.disconnect();
 ```
 
+#### autoConnect()
+
+Attempt auto-connection using existing session. Should be called after setting up event listeners to avoid race conditions. Only works with embedded providers.
+
+```typescript
+await sdk.autoConnect();
+```
+
 ## Transaction Examples
 
 ### Solana Transactions

package/dist/index.d.ts

@@ -1,8 +1,7 @@
-import { AddressType } from '@phantom/client';
-export { AddressType } from '@phantom/client';
-import { AuthOptions, ConnectResult, SignMessageParams, SignMessageResult, SignAndSendTransactionParams, SignedTransaction, WalletAddress } from '@phantom/embedded-provider-core';
+import { EmbeddedProviderConfig, AuthOptions, ConnectResult, SignMessageParams, SignMessageResult, SignAndSendTransactionParams, SignedTransaction, WalletAddress, EmbeddedProviderEvent, EventCallback } from '@phantom/embedded-provider-core';
 export { AuthOptions, ConnectResult, SignAndSendTransactionParams, SignMessageParams, SignMessageResult, SignedTransaction, WalletAddress } from '@phantom/embedded-provider-core';
 export { NetworkId } from '@phantom/constants';
+export { AddressType } from '@phantom/client';
 
 declare enum DebugLevel {
     ERROR = 0,
@@ -48,19 +47,12 @@ declare const DebugCategory: {
     readonly SESSION: "Session";
 };
 
-interface BrowserSDKConfig {
+interface BrowserSDKConfig extends Partial<EmbeddedProviderConfig> {
     providerType: "injected" | "embedded" | (string & Record<never, never>);
-    appName?: string;
-    appLogo?: string;
-    addressTypes?: AddressType[];
     apiBaseUrl?: string;
     organizationId?: string;
-    authOptions?: {
-        authUrl?: string;
-        redirectUrl?: string;
-    };
     embeddedWalletType?: "app-wallet" | "user-wallet" | (string & Record<never, never>);
-    solanaProvider?: "web3js" | "kit";
+    autoConnect?: boolean;
     debug?: {
         enabled?: boolean;
         level?: DebugLevel;
@@ -137,6 +129,22 @@ declare class BrowserSDK {
      * Get the current wallet ID (for embedded wallets)
      */
     getWalletId(): string | null;
+    /**
+     * Add event listener for provider events (connect, connect_start, connect_error, disconnect, error)
+     * Works with both embedded and injected providers
+     */
+    on(event: EmbeddedProviderEvent, callback: EventCallback): void;
+    /**
+     * Remove event listener for provider events
+     * Works with both embedded and injected providers
+     */
+    off(event: EmbeddedProviderEvent, callback: EventCallback): void;
+    /**
+     * Attempt auto-connection using existing session
+     * Should be called after setting up event listeners
+     * Only works with embedded providers
+     */
+    autoConnect(): Promise<void>;
 }
 
 /**

package/dist/index.js

@@ -133,6 +133,10 @@ var InjectedProvider = class {
   constructor(config) {
     this.connected = false;
     this.addresses = [];
+    // Event management
+    this.eventListeners = /* @__PURE__ */ new Map();
+    this.browserInjectedCleanupFunctions = [];
+    this.eventsInitialized = false;
     debug.log(DebugCategory.INJECTED_PROVIDER, "Initializing InjectedProvider", { config });
     this.addressTypes = config.addressTypes || [import_client.AddressType.solana, import_client.AddressType.ethereum];
     debug.log(DebugCategory.INJECTED_PROVIDER, "Address types configured", { addressTypes: this.addressTypes });
@@ -157,70 +161,108 @@ var InjectedProvider = class {
       authOptionsIgnored: !!authOptions
       // Note: authOptions are ignored for injected provider
     });
-    if (!this.phantom.extension.isInstalled()) {
-      debug.error(DebugCategory.INJECTED_PROVIDER, "Phantom wallet extension not found");
-      throw new Error("Phantom wallet not found");
-    }
-    debug.log(DebugCategory.INJECTED_PROVIDER, "Phantom extension detected");
-    const connectedAddresses = [];
-    if (this.addressTypes.includes(import_client.AddressType.solana)) {
-      debug.log(DebugCategory.INJECTED_PROVIDER, "Attempting Solana connection");
-      try {
-        const publicKey = await this.phantom.solana.connect();
-        if (publicKey) {
-          connectedAddresses.push({
-            addressType: import_client.AddressType.solana,
-            address: publicKey
-          });
-          debug.info(DebugCategory.INJECTED_PROVIDER, "Solana connected successfully", { address: publicKey });
+    this.emit("connect_start", {
+      source: "manual-connect",
+      providerType: "injected"
+    });
+    try {
+      if (!this.phantom.extension.isInstalled()) {
+        debug.error(DebugCategory.INJECTED_PROVIDER, "Phantom wallet extension not found");
+        const error = new Error("Phantom wallet not found");
+        this.emit("connect_error", {
+          error: error.message,
+          source: "manual-connect"
+        });
+        throw error;
+      }
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Phantom extension detected");
+      const connectedAddresses = [];
+      if (this.addressTypes.includes(import_client.AddressType.solana)) {
+        debug.log(DebugCategory.INJECTED_PROVIDER, "Attempting Solana connection");
+        try {
+          const publicKey = await this.phantom.solana.connect();
+          if (publicKey) {
+            connectedAddresses.push({
+              addressType: import_client.AddressType.solana,
+              address: publicKey
+            });
+            debug.info(DebugCategory.INJECTED_PROVIDER, "Solana connected successfully", { address: publicKey });
+          }
+        } catch (err) {
+          debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to connect Solana", { error: err });
         }
-      } catch (err) {
-        debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to connect Solana", { error: err });
       }
-    }
-    if (this.addressTypes.includes(import_client.AddressType.ethereum)) {
-      try {
-        const accounts = await this.phantom.ethereum.connect();
-        if (accounts && accounts.length > 0) {
-          connectedAddresses.push(
-            ...accounts.map((address) => ({
-              addressType: import_client.AddressType.ethereum,
-              address
-            }))
-          );
+      if (this.addressTypes.includes(import_client.AddressType.ethereum)) {
+        try {
+          const accounts = await this.phantom.ethereum.connect();
+          if (accounts && accounts.length > 0) {
+            connectedAddresses.push(
+              ...accounts.map((address) => ({
+                addressType: import_client.AddressType.ethereum,
+                address
+              }))
+            );
+          }
+        } catch (err) {
+          debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to connect Ethereum", { error: err });
         }
-      } catch (err) {
-        debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to connect Ethereum", { error: err });
       }
+      if (connectedAddresses.length === 0) {
+        const error = new Error("Failed to connect to any supported wallet provider");
+        this.emit("connect_error", {
+          error: error.message,
+          source: "manual-connect"
+        });
+        throw error;
+      }
+      this.addresses = connectedAddresses;
+      this.connected = true;
+      const result = {
+        addresses: this.addresses,
+        status: "completed"
+        // walletId is not applicable for injected providers
+      };
+      this.emit("connect", {
+        addresses: this.addresses,
+        source: "manual-connect"
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof Error && !error.message.includes("Phantom wallet not found") && !error.message.includes("Failed to connect to any supported wallet provider")) {
+        this.emit("connect_error", {
+          error: error.message,
+          source: "manual-connect"
+        });
+      }
+      throw error;
     }
-    if (connectedAddresses.length === 0) {
-      throw new Error("Failed to connect to any supported wallet provider");
-    }
-    this.addresses = connectedAddresses;
-    this.connected = true;
-    return {
-      addresses: this.addresses,
-      status: "completed"
-      // walletId is not applicable for injected providers
-    };
   }
   async disconnect() {
+    debug.info(DebugCategory.INJECTED_PROVIDER, "Starting injected provider disconnect");
     if (this.addressTypes.includes(import_client.AddressType.solana)) {
       try {
         await this.phantom.solana.disconnect();
+        debug.log(DebugCategory.INJECTED_PROVIDER, "Solana disconnected successfully");
       } catch (err) {
-        console.error("Failed to disconnect Solana:", err);
+        debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to disconnect Solana", { error: err });
       }
     }
     if (this.addressTypes.includes(import_client.AddressType.ethereum)) {
       try {
         await this.phantom.ethereum.disconnect();
+        debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum disconnected successfully");
       } catch (err) {
-        console.error("Failed to disconnect Ethereum:", err);
+        debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to disconnect Ethereum", { error: err });
       }
     }
+    this.browserInjectedCleanupFunctions.forEach((cleanup) => cleanup());
+    this.browserInjectedCleanupFunctions = [];
     this.connected = false;
     this.addresses = [];
+    this.emit("disconnect", {
+      source: "manual-disconnect"
+    });
+    debug.info(DebugCategory.INJECTED_PROVIDER, "Injected provider disconnected successfully");
   }
   async signMessage(params) {
     if (!this.connected) {
@@ -293,6 +335,139 @@ var InjectedProvider = class {
   isConnected() {
     return this.connected;
   }
+  // Event management methods - implementing unified event interface
+  on(event, callback) {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Adding event listener", { event });
+    if (!this.eventsInitialized) {
+      this.setupBrowserInjectedEvents();
+      this.eventsInitialized = true;
+    }
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventListeners.get(event).add(callback);
+  }
+  off(event, callback) {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Removing event listener", { event });
+    if (this.eventListeners.has(event)) {
+      this.eventListeners.get(event).delete(callback);
+      if (this.eventListeners.get(event).size === 0) {
+        this.eventListeners.delete(event);
+      }
+    }
+  }
+  emit(event, data) {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Emitting event", {
+      event,
+      listenerCount: this.eventListeners.get(event)?.size || 0,
+      data
+    });
+    const listeners = this.eventListeners.get(event);
+    if (listeners && listeners.size > 0) {
+      listeners.forEach((callback) => {
+        try {
+          callback(data);
+        } catch (error) {
+          debug.error(DebugCategory.INJECTED_PROVIDER, "Event callback error", { event, error });
+        }
+      });
+    }
+  }
+  setupBrowserInjectedEvents() {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Setting up browser-injected-sdk event listeners");
+    if (this.addressTypes.includes(import_client.AddressType.solana) && this.phantom.solana) {
+      this.setupSolanaEvents();
+    }
+    if (this.addressTypes.includes(import_client.AddressType.ethereum) && this.phantom.ethereum) {
+      this.setupEthereumEvents();
+    }
+  }
+  setupSolanaEvents() {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Setting up Solana event listeners");
+    const solanaConnectCleanup = this.phantom.solana.addEventListener("connect", (publicKey) => {
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Solana connect event received", { publicKey });
+      const solanaAddress = { addressType: import_client.AddressType.solana, address: publicKey };
+      if (!this.addresses.find((addr) => addr.addressType === import_client.AddressType.solana)) {
+        this.addresses.push(solanaAddress);
+      }
+      this.connected = true;
+      this.emit("connect", {
+        addresses: this.addresses,
+        source: "injected-extension"
+      });
+    });
+    const solanaDisconnectCleanup = this.phantom.solana.addEventListener("disconnect", () => {
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Solana disconnect event received");
+      this.addresses = this.addresses.filter((addr) => addr.addressType !== import_client.AddressType.solana);
+      this.connected = this.addresses.length > 0;
+      this.emit("disconnect", {
+        source: "injected-extension"
+      });
+    });
+    const solanaAccountChangedCleanup = this.phantom.solana.addEventListener("accountChanged", (publicKey) => {
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Solana account changed event received", { publicKey });
+      const solanaIndex = this.addresses.findIndex((addr) => addr.addressType === import_client.AddressType.solana);
+      if (solanaIndex >= 0) {
+        this.addresses[solanaIndex] = { addressType: import_client.AddressType.solana, address: publicKey };
+      } else {
+        this.addresses.push({ addressType: import_client.AddressType.solana, address: publicKey });
+      }
+      this.emit("connect", {
+        addresses: this.addresses,
+        source: "injected-extension-account-change"
+      });
+    });
+    this.browserInjectedCleanupFunctions.push(
+      solanaConnectCleanup,
+      solanaDisconnectCleanup,
+      solanaAccountChangedCleanup
+    );
+  }
+  setupEthereumEvents() {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Setting up Ethereum event listeners");
+    const ethConnectCleanup = this.phantom.ethereum.addEventListener("connect", (accounts) => {
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum connect event received", { accounts });
+      this.addresses = this.addresses.filter((addr) => addr.addressType !== import_client.AddressType.ethereum);
+      if (accounts && accounts.length > 0) {
+        this.addresses.push(...accounts.map((address) => ({
+          addressType: import_client.AddressType.ethereum,
+          address
+        })));
+      }
+      this.connected = this.addresses.length > 0;
+      this.emit("connect", {
+        addresses: this.addresses,
+        source: "injected-extension"
+      });
+    });
+    const ethDisconnectCleanup = this.phantom.ethereum.addEventListener("disconnect", () => {
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum disconnect event received");
+      this.addresses = this.addresses.filter((addr) => addr.addressType !== import_client.AddressType.ethereum);
+      this.connected = this.addresses.length > 0;
+      this.emit("disconnect", {
+        source: "injected-extension"
+      });
+    });
+    const ethAccountChangedCleanup = this.phantom.ethereum.addEventListener("accountChanged", (accounts) => {
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum account changed event received", { accounts });
+      this.addresses = this.addresses.filter((addr) => addr.addressType !== import_client.AddressType.ethereum);
+      if (accounts && accounts.length > 0) {
+        this.addresses.push(...accounts.map((address) => ({
+          addressType: import_client.AddressType.ethereum,
+          address
+        })));
+      }
+      this.emit("connect", {
+        addresses: this.addresses,
+        source: "injected-extension-account-change"
+      });
+    });
+    this.browserInjectedCleanupFunctions.push(
+      ethConnectCleanup,
+      ethDisconnectCleanup,
+      ethAccountChangedCleanup
+    );
+  }
 };
 
 // src/providers/embedded/index.ts
@@ -662,11 +837,15 @@ var EmbeddedProvider = class extends import_embedded_provider_core.EmbeddedProvi
 
 // src/ProviderManager.ts
 var ProviderManager = class {
+  // Track which providers have forwarding set up
   constructor(config) {
     this.providers = /* @__PURE__ */ new Map();
     this.currentProvider = null;
     this.currentProviderKey = null;
     this.walletId = null;
+    // Event management for forwarding provider events
+    this.eventListeners = /* @__PURE__ */ new Map();
+    this.providerForwardingSetup = /* @__PURE__ */ new WeakSet();
     debug.log(DebugCategory.PROVIDER_MANAGER, "Initializing ProviderManager", { config });
     this.config = config;
     debug.log(DebugCategory.PROVIDER_MANAGER, "Setting default provider");
@@ -691,6 +870,7 @@ var ProviderManager = class {
     this.currentProvider = this.providers.get(key);
     this.currentProviderKey = key;
     this.walletId = null;
+    this.ensureProviderEventForwarding();
     return this.currentProvider;
   }
   /**
@@ -785,6 +965,79 @@ var ProviderManager = class {
   getWalletId() {
     return this.walletId;
   }
+  /**
+   * Add event listener - stores callback and ensures current provider forwards events to ProviderManager
+   */
+  on(event, callback) {
+    debug.log(DebugCategory.PROVIDER_MANAGER, "Adding event listener", { event });
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventListeners.get(event).add(callback);
+    this.ensureProviderEventForwarding();
+  }
+  /**
+   * Remove event listener
+   */
+  off(event, callback) {
+    debug.log(DebugCategory.PROVIDER_MANAGER, "Removing event listener", { event });
+    if (this.eventListeners.has(event)) {
+      this.eventListeners.get(event).delete(callback);
+      if (this.eventListeners.get(event).size === 0) {
+        this.eventListeners.delete(event);
+      }
+    }
+  }
+  /**
+   * Emit event to all registered callbacks
+   */
+  emit(event, data) {
+    debug.log(DebugCategory.PROVIDER_MANAGER, "Emitting event to stored callbacks", {
+      event,
+      listenerCount: this.eventListeners.get(event)?.size || 0,
+      data
+    });
+    const listeners = this.eventListeners.get(event);
+    if (listeners && listeners.size > 0) {
+      listeners.forEach((callback) => {
+        try {
+          debug.log(DebugCategory.PROVIDER_MANAGER, "Calling stored callback for event", { event });
+          callback(data);
+        } catch (error) {
+          debug.error(DebugCategory.PROVIDER_MANAGER, "Event callback error", { event, error });
+        }
+      });
+    } else {
+      debug.warn(DebugCategory.PROVIDER_MANAGER, "No stored callbacks for event", { event });
+    }
+  }
+  /**
+   * Ensure current provider forwards its events to this ProviderManager
+   * Only sets up forwarding once per provider instance to avoid accumulation
+   */
+  ensureProviderEventForwarding() {
+    if (!this.currentProvider || !("on" in this.currentProvider)) {
+      debug.warn(DebugCategory.PROVIDER_MANAGER, "Current provider does not support events", {
+        providerType: this.getCurrentProviderInfo()?.type
+      });
+      return;
+    }
+    if (this.providerForwardingSetup.has(this.currentProvider)) {
+      debug.log(DebugCategory.PROVIDER_MANAGER, "Event forwarding already set up for current provider");
+      return;
+    }
+    debug.log(DebugCategory.PROVIDER_MANAGER, "Setting up event forwarding from current provider");
+    const eventsToForward = ["connect_start", "connect", "connect_error", "disconnect", "error"];
+    for (const event of eventsToForward) {
+      const forwardingCallback = (data) => {
+        debug.log(DebugCategory.PROVIDER_MANAGER, "Forwarding event from provider", { event, data });
+        this.emit(event, data);
+      };
+      debug.log(DebugCategory.PROVIDER_MANAGER, "Attaching forwarding callback for event", { event });
+      this.currentProvider.on(event, forwardingCallback);
+    }
+    this.providerForwardingSetup.add(this.currentProvider);
+  }
   /**
    * Set default provider based on initial config
    */
@@ -1038,6 +1291,38 @@ var BrowserSDK = class {
   getWalletId() {
     return this.providerManager.getWalletId();
   }
+  /**
+   * Add event listener for provider events (connect, connect_start, connect_error, disconnect, error)
+   * Works with both embedded and injected providers
+   */
+  on(event, callback) {
+    debug.log(DebugCategory.BROWSER_SDK, "Adding event listener", { event });
+    this.providerManager.on(event, callback);
+  }
+  /**
+   * Remove event listener for provider events
+   * Works with both embedded and injected providers
+   */
+  off(event, callback) {
+    debug.log(DebugCategory.BROWSER_SDK, "Removing event listener", { event });
+    this.providerManager.off(event, callback);
+  }
+  /**
+   * Attempt auto-connection using existing session
+   * Should be called after setting up event listeners
+   * Only works with embedded providers
+   */
+  async autoConnect() {
+    debug.log(DebugCategory.BROWSER_SDK, "Attempting auto-connect");
+    const currentProvider = this.providerManager.getCurrentProvider();
+    if (currentProvider && "autoConnect" in currentProvider) {
+      await currentProvider.autoConnect();
+    } else {
+      debug.warn(DebugCategory.BROWSER_SDK, "Current provider does not support auto-connect", {
+        providerType: this.getCurrentProviderInfo()?.type
+      });
+    }
+  }
 };
 
 // src/index.ts

package/dist/index.mjs

@@ -86,6 +86,10 @@ var InjectedProvider = class {
   constructor(config) {
     this.connected = false;
     this.addresses = [];
+    // Event management
+    this.eventListeners = /* @__PURE__ */ new Map();
+    this.browserInjectedCleanupFunctions = [];
+    this.eventsInitialized = false;
     debug.log(DebugCategory.INJECTED_PROVIDER, "Initializing InjectedProvider", { config });
     this.addressTypes = config.addressTypes || [AddressType.solana, AddressType.ethereum];
     debug.log(DebugCategory.INJECTED_PROVIDER, "Address types configured", { addressTypes: this.addressTypes });
@@ -110,70 +114,108 @@ var InjectedProvider = class {
       authOptionsIgnored: !!authOptions
       // Note: authOptions are ignored for injected provider
     });
-    if (!this.phantom.extension.isInstalled()) {
-      debug.error(DebugCategory.INJECTED_PROVIDER, "Phantom wallet extension not found");
-      throw new Error("Phantom wallet not found");
-    }
-    debug.log(DebugCategory.INJECTED_PROVIDER, "Phantom extension detected");
-    const connectedAddresses = [];
-    if (this.addressTypes.includes(AddressType.solana)) {
-      debug.log(DebugCategory.INJECTED_PROVIDER, "Attempting Solana connection");
-      try {
-        const publicKey = await this.phantom.solana.connect();
-        if (publicKey) {
-          connectedAddresses.push({
-            addressType: AddressType.solana,
-            address: publicKey
-          });
-          debug.info(DebugCategory.INJECTED_PROVIDER, "Solana connected successfully", { address: publicKey });
+    this.emit("connect_start", {
+      source: "manual-connect",
+      providerType: "injected"
+    });
+    try {
+      if (!this.phantom.extension.isInstalled()) {
+        debug.error(DebugCategory.INJECTED_PROVIDER, "Phantom wallet extension not found");
+        const error = new Error("Phantom wallet not found");
+        this.emit("connect_error", {
+          error: error.message,
+          source: "manual-connect"
+        });
+        throw error;
+      }
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Phantom extension detected");
+      const connectedAddresses = [];
+      if (this.addressTypes.includes(AddressType.solana)) {
+        debug.log(DebugCategory.INJECTED_PROVIDER, "Attempting Solana connection");
+        try {
+          const publicKey = await this.phantom.solana.connect();
+          if (publicKey) {
+            connectedAddresses.push({
+              addressType: AddressType.solana,
+              address: publicKey
+            });
+            debug.info(DebugCategory.INJECTED_PROVIDER, "Solana connected successfully", { address: publicKey });
+          }
+        } catch (err) {
+          debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to connect Solana", { error: err });
         }
-      } catch (err) {
-        debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to connect Solana", { error: err });
       }
-    }
-    if (this.addressTypes.includes(AddressType.ethereum)) {
-      try {
-        const accounts = await this.phantom.ethereum.connect();
-        if (accounts && accounts.length > 0) {
-          connectedAddresses.push(
-            ...accounts.map((address) => ({
-              addressType: AddressType.ethereum,
-              address
-            }))
-          );
+      if (this.addressTypes.includes(AddressType.ethereum)) {
+        try {
+          const accounts = await this.phantom.ethereum.connect();
+          if (accounts && accounts.length > 0) {
+            connectedAddresses.push(
+              ...accounts.map((address) => ({
+                addressType: AddressType.ethereum,
+                address
+              }))
+            );
+          }
+        } catch (err) {
+          debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to connect Ethereum", { error: err });
         }
-      } catch (err) {
-        debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to connect Ethereum", { error: err });
       }
+      if (connectedAddresses.length === 0) {
+        const error = new Error("Failed to connect to any supported wallet provider");
+        this.emit("connect_error", {
+          error: error.message,
+          source: "manual-connect"
+        });
+        throw error;
+      }
+      this.addresses = connectedAddresses;
+      this.connected = true;
+      const result = {
+        addresses: this.addresses,
+        status: "completed"
+        // walletId is not applicable for injected providers
+      };
+      this.emit("connect", {
+        addresses: this.addresses,
+        source: "manual-connect"
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof Error && !error.message.includes("Phantom wallet not found") && !error.message.includes("Failed to connect to any supported wallet provider")) {
+        this.emit("connect_error", {
+          error: error.message,
+          source: "manual-connect"
+        });
+      }
+      throw error;
     }
-    if (connectedAddresses.length === 0) {
-      throw new Error("Failed to connect to any supported wallet provider");
-    }
-    this.addresses = connectedAddresses;
-    this.connected = true;
-    return {
-      addresses: this.addresses,
-      status: "completed"
-      // walletId is not applicable for injected providers
-    };
   }
   async disconnect() {
+    debug.info(DebugCategory.INJECTED_PROVIDER, "Starting injected provider disconnect");
     if (this.addressTypes.includes(AddressType.solana)) {
       try {
         await this.phantom.solana.disconnect();
+        debug.log(DebugCategory.INJECTED_PROVIDER, "Solana disconnected successfully");
       } catch (err) {
-        console.error("Failed to disconnect Solana:", err);
+        debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to disconnect Solana", { error: err });
       }
     }
     if (this.addressTypes.includes(AddressType.ethereum)) {
       try {
         await this.phantom.ethereum.disconnect();
+        debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum disconnected successfully");
       } catch (err) {
-        console.error("Failed to disconnect Ethereum:", err);
+        debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to disconnect Ethereum", { error: err });
       }
     }
+    this.browserInjectedCleanupFunctions.forEach((cleanup) => cleanup());
+    this.browserInjectedCleanupFunctions = [];
     this.connected = false;
     this.addresses = [];
+    this.emit("disconnect", {
+      source: "manual-disconnect"
+    });
+    debug.info(DebugCategory.INJECTED_PROVIDER, "Injected provider disconnected successfully");
   }
   async signMessage(params) {
     if (!this.connected) {
@@ -246,6 +288,139 @@ var InjectedProvider = class {
   isConnected() {
     return this.connected;
   }
+  // Event management methods - implementing unified event interface
+  on(event, callback) {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Adding event listener", { event });
+    if (!this.eventsInitialized) {
+      this.setupBrowserInjectedEvents();
+      this.eventsInitialized = true;
+    }
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventListeners.get(event).add(callback);
+  }
+  off(event, callback) {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Removing event listener", { event });
+    if (this.eventListeners.has(event)) {
+      this.eventListeners.get(event).delete(callback);
+      if (this.eventListeners.get(event).size === 0) {
+        this.eventListeners.delete(event);
+      }
+    }
+  }
+  emit(event, data) {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Emitting event", {
+      event,
+      listenerCount: this.eventListeners.get(event)?.size || 0,
+      data
+    });
+    const listeners = this.eventListeners.get(event);
+    if (listeners && listeners.size > 0) {
+      listeners.forEach((callback) => {
+        try {
+          callback(data);
+        } catch (error) {
+          debug.error(DebugCategory.INJECTED_PROVIDER, "Event callback error", { event, error });
+        }
+      });
+    }
+  }
+  setupBrowserInjectedEvents() {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Setting up browser-injected-sdk event listeners");
+    if (this.addressTypes.includes(AddressType.solana) && this.phantom.solana) {
+      this.setupSolanaEvents();
+    }
+    if (this.addressTypes.includes(AddressType.ethereum) && this.phantom.ethereum) {
+      this.setupEthereumEvents();
+    }
+  }
+  setupSolanaEvents() {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Setting up Solana event listeners");
+    const solanaConnectCleanup = this.phantom.solana.addEventListener("connect", (publicKey) => {
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Solana connect event received", { publicKey });
+      const solanaAddress = { addressType: AddressType.solana, address: publicKey };
+      if (!this.addresses.find((addr) => addr.addressType === AddressType.solana)) {
+        this.addresses.push(solanaAddress);
+      }
+      this.connected = true;
+      this.emit("connect", {
+        addresses: this.addresses,
+        source: "injected-extension"
+      });
+    });
+    const solanaDisconnectCleanup = this.phantom.solana.addEventListener("disconnect", () => {
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Solana disconnect event received");
+      this.addresses = this.addresses.filter((addr) => addr.addressType !== AddressType.solana);
+      this.connected = this.addresses.length > 0;
+      this.emit("disconnect", {
+        source: "injected-extension"
+      });
+    });
+    const solanaAccountChangedCleanup = this.phantom.solana.addEventListener("accountChanged", (publicKey) => {
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Solana account changed event received", { publicKey });
+      const solanaIndex = this.addresses.findIndex((addr) => addr.addressType === AddressType.solana);
+      if (solanaIndex >= 0) {
+        this.addresses[solanaIndex] = { addressType: AddressType.solana, address: publicKey };
+      } else {
+        this.addresses.push({ addressType: AddressType.solana, address: publicKey });
+      }
+      this.emit("connect", {
+        addresses: this.addresses,
+        source: "injected-extension-account-change"
+      });
+    });
+    this.browserInjectedCleanupFunctions.push(
+      solanaConnectCleanup,
+      solanaDisconnectCleanup,
+      solanaAccountChangedCleanup
+    );
+  }
+  setupEthereumEvents() {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Setting up Ethereum event listeners");
+    const ethConnectCleanup = this.phantom.ethereum.addEventListener("connect", (accounts) => {
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum connect event received", { accounts });
+      this.addresses = this.addresses.filter((addr) => addr.addressType !== AddressType.ethereum);
+      if (accounts && accounts.length > 0) {
+        this.addresses.push(...accounts.map((address) => ({
+          addressType: AddressType.ethereum,
+          address
+        })));
+      }
+      this.connected = this.addresses.length > 0;
+      this.emit("connect", {
+        addresses: this.addresses,
+        source: "injected-extension"
+      });
+    });
+    const ethDisconnectCleanup = this.phantom.ethereum.addEventListener("disconnect", () => {
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum disconnect event received");
+      this.addresses = this.addresses.filter((addr) => addr.addressType !== AddressType.ethereum);
+      this.connected = this.addresses.length > 0;
+      this.emit("disconnect", {
+        source: "injected-extension"
+      });
+    });
+    const ethAccountChangedCleanup = this.phantom.ethereum.addEventListener("accountChanged", (accounts) => {
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum account changed event received", { accounts });
+      this.addresses = this.addresses.filter((addr) => addr.addressType !== AddressType.ethereum);
+      if (accounts && accounts.length > 0) {
+        this.addresses.push(...accounts.map((address) => ({
+          addressType: AddressType.ethereum,
+          address
+        })));
+      }
+      this.emit("connect", {
+        addresses: this.addresses,
+        source: "injected-extension-account-change"
+      });
+    });
+    this.browserInjectedCleanupFunctions.push(
+      ethConnectCleanup,
+      ethDisconnectCleanup,
+      ethAccountChangedCleanup
+    );
+  }
 };
 
 // src/providers/embedded/index.ts
@@ -615,11 +790,15 @@ var EmbeddedProvider = class extends CoreEmbeddedProvider {
 
 // src/ProviderManager.ts
 var ProviderManager = class {
+  // Track which providers have forwarding set up
   constructor(config) {
     this.providers = /* @__PURE__ */ new Map();
     this.currentProvider = null;
     this.currentProviderKey = null;
     this.walletId = null;
+    // Event management for forwarding provider events
+    this.eventListeners = /* @__PURE__ */ new Map();
+    this.providerForwardingSetup = /* @__PURE__ */ new WeakSet();
     debug.log(DebugCategory.PROVIDER_MANAGER, "Initializing ProviderManager", { config });
     this.config = config;
     debug.log(DebugCategory.PROVIDER_MANAGER, "Setting default provider");
@@ -644,6 +823,7 @@ var ProviderManager = class {
     this.currentProvider = this.providers.get(key);
     this.currentProviderKey = key;
     this.walletId = null;
+    this.ensureProviderEventForwarding();
     return this.currentProvider;
   }
   /**
@@ -738,6 +918,79 @@ var ProviderManager = class {
   getWalletId() {
     return this.walletId;
   }
+  /**
+   * Add event listener - stores callback and ensures current provider forwards events to ProviderManager
+   */
+  on(event, callback) {
+    debug.log(DebugCategory.PROVIDER_MANAGER, "Adding event listener", { event });
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventListeners.get(event).add(callback);
+    this.ensureProviderEventForwarding();
+  }
+  /**
+   * Remove event listener
+   */
+  off(event, callback) {
+    debug.log(DebugCategory.PROVIDER_MANAGER, "Removing event listener", { event });
+    if (this.eventListeners.has(event)) {
+      this.eventListeners.get(event).delete(callback);
+      if (this.eventListeners.get(event).size === 0) {
+        this.eventListeners.delete(event);
+      }
+    }
+  }
+  /**
+   * Emit event to all registered callbacks
+   */
+  emit(event, data) {
+    debug.log(DebugCategory.PROVIDER_MANAGER, "Emitting event to stored callbacks", {
+      event,
+      listenerCount: this.eventListeners.get(event)?.size || 0,
+      data
+    });
+    const listeners = this.eventListeners.get(event);
+    if (listeners && listeners.size > 0) {
+      listeners.forEach((callback) => {
+        try {
+          debug.log(DebugCategory.PROVIDER_MANAGER, "Calling stored callback for event", { event });
+          callback(data);
+        } catch (error) {
+          debug.error(DebugCategory.PROVIDER_MANAGER, "Event callback error", { event, error });
+        }
+      });
+    } else {
+      debug.warn(DebugCategory.PROVIDER_MANAGER, "No stored callbacks for event", { event });
+    }
+  }
+  /**
+   * Ensure current provider forwards its events to this ProviderManager
+   * Only sets up forwarding once per provider instance to avoid accumulation
+   */
+  ensureProviderEventForwarding() {
+    if (!this.currentProvider || !("on" in this.currentProvider)) {
+      debug.warn(DebugCategory.PROVIDER_MANAGER, "Current provider does not support events", {
+        providerType: this.getCurrentProviderInfo()?.type
+      });
+      return;
+    }
+    if (this.providerForwardingSetup.has(this.currentProvider)) {
+      debug.log(DebugCategory.PROVIDER_MANAGER, "Event forwarding already set up for current provider");
+      return;
+    }
+    debug.log(DebugCategory.PROVIDER_MANAGER, "Setting up event forwarding from current provider");
+    const eventsToForward = ["connect_start", "connect", "connect_error", "disconnect", "error"];
+    for (const event of eventsToForward) {
+      const forwardingCallback = (data) => {
+        debug.log(DebugCategory.PROVIDER_MANAGER, "Forwarding event from provider", { event, data });
+        this.emit(event, data);
+      };
+      debug.log(DebugCategory.PROVIDER_MANAGER, "Attaching forwarding callback for event", { event });
+      this.currentProvider.on(event, forwardingCallback);
+    }
+    this.providerForwardingSetup.add(this.currentProvider);
+  }
   /**
    * Set default provider based on initial config
    */
@@ -991,6 +1244,38 @@ var BrowserSDK = class {
   getWalletId() {
     return this.providerManager.getWalletId();
   }
+  /**
+   * Add event listener for provider events (connect, connect_start, connect_error, disconnect, error)
+   * Works with both embedded and injected providers
+   */
+  on(event, callback) {
+    debug.log(DebugCategory.BROWSER_SDK, "Adding event listener", { event });
+    this.providerManager.on(event, callback);
+  }
+  /**
+   * Remove event listener for provider events
+   * Works with both embedded and injected providers
+   */
+  off(event, callback) {
+    debug.log(DebugCategory.BROWSER_SDK, "Removing event listener", { event });
+    this.providerManager.off(event, callback);
+  }
+  /**
+   * Attempt auto-connection using existing session
+   * Should be called after setting up event listeners
+   * Only works with embedded providers
+   */
+  async autoConnect() {
+    debug.log(DebugCategory.BROWSER_SDK, "Attempting auto-connect");
+    const currentProvider = this.providerManager.getCurrentProvider();
+    if (currentProvider && "autoConnect" in currentProvider) {
+      await currentProvider.autoConnect();
+    } else {
+      debug.warn(DebugCategory.BROWSER_SDK, "Current provider does not support auto-connect", {
+        providerType: this.getCurrentProviderInfo()?.type
+      });
+    }
+  }
 };
 
 // src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phantom/browser-sdk",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "Browser SDK for Phantom Wallet with unified interface",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -32,7 +32,7 @@
     "@phantom/browser-injected-sdk": "^0.0.9",
     "@phantom/client": "^0.1.8",
     "@phantom/constants": "^0.0.3",
-    "@phantom/embedded-provider-core": "^0.1.5",
+    "@phantom/embedded-provider-core": "^0.1.6",
     "@phantom/indexed-db-stamper": "^0.1.4",
     "@phantom/parsers": "^0.0.7",
     "axios": "^1.10.0",