@phantom/browser-sdk 0.3.4 → 0.3.6

package/dist/index.mjs

@@ -86,8 +86,12 @@ 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];
+    this.addressTypes = config.addressTypes;
     debug.log(DebugCategory.INJECTED_PROVIDER, "Address types configured", { addressTypes: this.addressTypes });
     const plugins = [createExtensionPlugin()];
     if (this.addressTypes.includes(AddressType.solana)) {
@@ -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
    */
@@ -758,7 +1011,7 @@ var ProviderManager = class {
     if (type === "injected") {
       provider = new InjectedProvider({
         solanaProvider: this.config.solanaProvider || "web3js",
-        addressTypes: this.config.addressTypes || []
+        addressTypes: this.config.addressTypes
       });
     } else {
       if (!this.config.apiBaseUrl || !this.config.organizationId) {
@@ -769,7 +1022,7 @@ var ProviderManager = class {
         organizationId: this.config.organizationId,
         authOptions: this.config.authOptions,
         embeddedWalletType: embeddedWalletType || "app-wallet",
-        addressTypes: this.config.addressTypes || [],
+        addressTypes: this.config.addressTypes,
         solanaProvider: this.config.solanaProvider || "web3js",
         appLogo: this.config.appLogo,
         // Optional app logo URL
@@ -824,20 +1077,10 @@ var ProviderManager = class {
 import { isPhantomExtensionInstalled } from "@phantom/browser-injected-sdk";
 var BrowserSDK = class {
   constructor(config) {
-    if (config.debug?.enabled) {
-      debug.enable();
-      if (config.debug.level !== void 0) {
-        debug.setLevel(config.debug.level);
-      }
-      if (config.debug.callback) {
-        debug.setCallback(config.debug.callback);
-      }
-    }
     debug.info(DebugCategory.BROWSER_SDK, "Initializing BrowserSDK", {
       providerType: config.providerType,
       embeddedWalletType: config.embeddedWalletType,
-      addressTypes: config.addressTypes,
-      debugEnabled: config.debug?.enabled
+      addressTypes: config.addressTypes
     });
     if (!["injected", "embedded"].includes(config.providerType)) {
       debug.error(DebugCategory.BROWSER_SDK, "Invalid providerType", { providerType: config.providerType });
@@ -991,13 +1234,97 @@ 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
+      });
+    }
+  }
+  /**
+   * Debug configuration methods
+   * These allow dynamic debug configuration without SDK reinstantiation
+   */
+  /**
+   * Enable debug logging
+   */
+  enableDebug() {
+    debug.enable();
+    debug.info(DebugCategory.BROWSER_SDK, "Debug logging enabled");
+  }
+  /**
+   * Disable debug logging
+   */
+  disableDebug() {
+    debug.disable();
+  }
+  /**
+   * Set debug level
+   */
+  setDebugLevel(level) {
+    debug.setLevel(level);
+    debug.info(DebugCategory.BROWSER_SDK, "Debug level updated", { level });
+  }
+  /**
+   * Set debug callback function
+   */
+  setDebugCallback(callback) {
+    debug.setCallback(callback);
+    debug.info(DebugCategory.BROWSER_SDK, "Debug callback updated");
+  }
+  /**
+   * Configure debug settings all at once
+   */
+  configureDebug(config) {
+    if (config.enabled !== void 0) {
+      if (config.enabled) {
+        this.enableDebug();
+      } else {
+        this.disableDebug();
+      }
+    }
+    if (config.level !== void 0) {
+      this.setDebugLevel(config.level);
+    }
+    if (config.callback !== void 0) {
+      this.setDebugCallback(config.callback);
+    }
+  }
 };
 
+// src/types.ts
+import { AddressType as AddressType2 } from "@phantom/client";
+
 // src/index.ts
 import { NetworkId } from "@phantom/constants";
-import { AddressType as AddressType2 } from "@phantom/client";
+import { AddressType as AddressType3 } from "@phantom/client";
 export {
-  AddressType2 as AddressType,
+  AddressType3 as AddressType,
   BrowserSDK,
   DEFAULT_AUTH_URL,
   DEFAULT_WALLET_API_URL,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phantom/browser-sdk",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "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.7",
     "@phantom/indexed-db-stamper": "^0.1.4",
     "@phantom/parsers": "^0.0.7",
     "axios": "^1.10.0",