@phantom/browser-sdk 0.2.1 → 0.2.3

package/dist/index.mjs

@@ -3,26 +3,118 @@ import { AddressType } from "@phantom/client";
 import { createPhantom, createExtensionPlugin } from "@phantom/browser-injected-sdk";
 import { createSolanaPlugin } from "@phantom/browser-injected-sdk/solana";
 import { createEthereumPlugin } from "@phantom/browser-injected-sdk/ethereum";
+
+// src/debug.ts
+var DebugLevel = /* @__PURE__ */ ((DebugLevel2) => {
+  DebugLevel2[DebugLevel2["ERROR"] = 0] = "ERROR";
+  DebugLevel2[DebugLevel2["WARN"] = 1] = "WARN";
+  DebugLevel2[DebugLevel2["INFO"] = 2] = "INFO";
+  DebugLevel2[DebugLevel2["DEBUG"] = 3] = "DEBUG";
+  return DebugLevel2;
+})(DebugLevel || {});
+var Debug = class {
+  constructor() {
+    this.level = 0 /* ERROR */;
+    this.enabled = false;
+  }
+  static getInstance() {
+    if (!Debug.instance) {
+      Debug.instance = new Debug();
+    }
+    return Debug.instance;
+  }
+  setCallback(callback) {
+    this.callback = callback;
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  enable() {
+    this.enabled = true;
+  }
+  disable() {
+    this.enabled = false;
+  }
+  writeLog(level, category, message, data) {
+    if (!this.enabled || level > this.level) {
+      return;
+    }
+    const debugMessage = {
+      timestamp: Date.now(),
+      level,
+      category,
+      message,
+      data
+    };
+    if (this.callback) {
+      this.callback(debugMessage);
+    }
+  }
+  error(category, message, data) {
+    this.writeLog(0 /* ERROR */, category, message, data);
+  }
+  warn(category, message, data) {
+    this.writeLog(1 /* WARN */, category, message, data);
+  }
+  info(category, message, data) {
+    this.writeLog(2 /* INFO */, category, message, data);
+  }
+  debug(category, message, data) {
+    this.writeLog(3 /* DEBUG */, category, message, data);
+  }
+  log(category, message, data) {
+    this.writeLog(3 /* DEBUG */, category, message, data);
+  }
+};
+var debug = Debug.getInstance();
+var DebugCategory = {
+  BROWSER_SDK: "BrowserSDK",
+  PROVIDER_MANAGER: "ProviderManager",
+  EMBEDDED_PROVIDER: "EmbeddedProvider",
+  INJECTED_PROVIDER: "InjectedProvider",
+  PHANTOM_CONNECT_AUTH: "PhantomConnectAuth",
+  JWT_AUTH: "JWTAuth",
+  STORAGE: "Storage",
+  SESSION: "Session"
+};
+
+// src/providers/injected/index.ts
 var InjectedProvider = class {
   constructor(config) {
     this.connected = false;
     this.addresses = [];
+    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 });
     const plugins = [createExtensionPlugin()];
     if (this.addressTypes.includes(AddressType.solana)) {
       plugins.push(createSolanaPlugin());
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Solana plugin added");
     }
     if (this.addressTypes.includes(AddressType.ethereum)) {
       plugins.push(createEthereumPlugin());
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum plugin added");
     }
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Creating Phantom instance with plugins", {
+      pluginCount: plugins.length
+    });
     this.phantom = createPhantom({ plugins });
+    debug.info(DebugCategory.INJECTED_PROVIDER, "InjectedProvider initialized");
   }
-  async connect() {
+  async connect(authOptions) {
+    debug.info(DebugCategory.INJECTED_PROVIDER, "Starting injected provider connect", {
+      addressTypes: this.addressTypes,
+      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) {
@@ -30,9 +122,10 @@ var InjectedProvider = class {
             addressType: AddressType.solana,
             address: publicKey
           });
+          debug.info(DebugCategory.INJECTED_PROVIDER, "Solana connected successfully", { address: publicKey });
         }
       } catch (err) {
-        console.error("Failed to connect Solana:", err);
+        debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to connect Solana", { error: err });
       }
     }
     if (this.addressTypes.includes(AddressType.ethereum)) {
@@ -47,7 +140,7 @@ var InjectedProvider = class {
           );
         }
       } catch (err) {
-        console.error("Failed to connect Ethereum:", err);
+        debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to connect Ethereum", { error: err });
       }
     }
     if (connectedAddresses.length === 0) {
@@ -56,7 +149,8 @@ var InjectedProvider = class {
     this.addresses = connectedAddresses;
     this.connected = true;
     return {
-      addresses: this.addresses
+      addresses: this.addresses,
+      status: "completed"
       // walletId is not applicable for injected providers
     };
   }
@@ -142,11 +236,10 @@ var InjectedProvider = class {
 };
 
 // src/providers/embedded/index.ts
-import { PhantomClient, generateKeyPair } from "@phantom/client";
-import { ApiKeyStamper } from "@phantom/api-key-stamper";
+import { EmbeddedProvider as CoreEmbeddedProvider } from "@phantom/embedded-provider-core";
 
-// src/providers/embedded/storage.ts
-var IndexedDBStorage = class {
+// src/providers/embedded/adapters/storage.ts
+var BrowserStorage = class {
   constructor() {
     this.dbName = "phantom-browser-sdk";
     this.storeName = "sessions";
@@ -166,149 +259,222 @@ var IndexedDBStorage = class {
     });
   }
   async getSession() {
+    debug.log(DebugCategory.STORAGE, "Getting session from IndexedDB");
     const db = await this.getDB();
     return new Promise((resolve, reject) => {
       const transaction = db.transaction([this.storeName], "readonly");
       const store = transaction.objectStore(this.storeName);
       const request = store.get("currentSession");
-      request.onsuccess = () => resolve(request.result || null);
-      request.onerror = () => reject(request.error);
+      request.onsuccess = () => {
+        const session = request.result || null;
+        debug.log(DebugCategory.STORAGE, "Retrieved session from IndexedDB", {
+          hasSession: !!session,
+          sessionId: session?.sessionId
+        });
+        resolve(session);
+      };
+      request.onerror = () => {
+        debug.error(DebugCategory.STORAGE, "Failed to get session from IndexedDB", { error: request.error });
+        reject(request.error);
+      };
     });
   }
   async saveSession(session) {
+    debug.log(DebugCategory.STORAGE, "Saving session to IndexedDB", {
+      sessionId: session.sessionId,
+      walletId: session.walletId,
+      status: session.status
+    });
     const db = await this.getDB();
     return new Promise((resolve, reject) => {
       const transaction = db.transaction([this.storeName], "readwrite");
       const store = transaction.objectStore(this.storeName);
       const request = store.put(session, "currentSession");
-      request.onsuccess = () => resolve();
-      request.onerror = () => reject(request.error);
+      request.onsuccess = () => {
+        debug.log(DebugCategory.STORAGE, "Successfully saved session to IndexedDB");
+        resolve();
+      };
+      request.onerror = () => {
+        debug.error(DebugCategory.STORAGE, "Failed to save session to IndexedDB", { error: request.error });
+        reject(request.error);
+      };
     });
   }
   async clearSession() {
+    debug.log(DebugCategory.STORAGE, "Clearing session from IndexedDB");
     const db = await this.getDB();
     return new Promise((resolve, reject) => {
       const transaction = db.transaction([this.storeName], "readwrite");
       const store = transaction.objectStore(this.storeName);
       const request = store.delete("currentSession");
-      request.onsuccess = () => resolve();
-      request.onerror = () => reject(request.error);
+      request.onsuccess = () => {
+        debug.log(DebugCategory.STORAGE, "Successfully cleared session from IndexedDB");
+        resolve();
+      };
+      request.onerror = () => {
+        debug.error(DebugCategory.STORAGE, "Failed to clear session from IndexedDB", { error: request.error });
+        reject(request.error);
+      };
     });
   }
 };
 
-// src/providers/embedded/auth.ts
-var IframeAuth = class {
-  async authenticate(_options) {
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    return {
-      walletId: `wallet-${Date.now()}`
-    };
+// src/providers/embedded/adapters/url-params.ts
+var BrowserURLParamsAccessor = class {
+  getParam(key) {
+    const urlParams = new URLSearchParams(window.location.search);
+    return urlParams.get(key);
   }
 };
+var browserUrlParamsAccessor = new BrowserURLParamsAccessor();
 
-// src/providers/embedded/index.ts
-import { parseMessage, parseTransaction } from "@phantom/parsers";
-var EmbeddedProvider = class {
-  constructor(config) {
-    this.client = null;
-    this.walletId = null;
-    this.addresses = [];
-    this.config = config;
-    this.storage = new IndexedDBStorage();
-    config.solanaProvider;
-  }
-  async connect() {
-    let session = await this.storage.getSession();
-    if (!session) {
-      const keypair = generateKeyPair();
-      const stamper2 = new ApiKeyStamper({
-        apiSecretKey: keypair.secretKey
+// src/constants.ts
+var DEFAULT_AUTH_URL = "https://connect.phantom.app";
+var DEFAULT_WALLET_API_URL = "https://api.phantom.app/v1/wallets";
+
+// src/providers/embedded/adapters/auth.ts
+var BrowserAuthProvider = class {
+  constructor(urlParamsAccessor) {
+    this.urlParamsAccessor = urlParamsAccessor;
+  }
+  authenticate(options) {
+    return new Promise((resolve) => {
+      if ("jwtToken" in options) {
+        throw new Error("JWT authentication should be handled by the core JWTAuth class");
+      }
+      const phantomOptions = options;
+      debug.info(DebugCategory.PHANTOM_CONNECT_AUTH, "Starting Phantom Connect authentication", {
+        organizationId: phantomOptions.organizationId,
+        parentOrganizationId: phantomOptions.parentOrganizationId,
+        provider: phantomOptions.provider,
+        authUrl: phantomOptions.authUrl,
+        hasCustomData: !!phantomOptions.customAuthData
       });
-      const tempClient = new PhantomClient(
-        {
-          apiBaseUrl: this.config.apiBaseUrl
-        },
-        stamper2
-      );
-      const uid = Date.now();
-      const organizationName = `${this.config.organizationId}-${uid}`;
-      const { organizationId } = await tempClient.createOrganization(organizationName, keypair);
-      let walletId;
-      if (this.config.embeddedWalletType === "user-wallet") {
-        const auth = new IframeAuth();
-        const authResult = await auth.authenticate({
-          iframeUrl: this.config.authUrl || "https://auth-flow.phantom.app",
-          organizationId,
-          parentOrganizationId: this.config.organizationId,
-          embeddedWalletType: this.config.embeddedWalletType
+      const baseUrl = phantomOptions.authUrl || DEFAULT_AUTH_URL;
+      debug.log(DebugCategory.PHANTOM_CONNECT_AUTH, "Using auth URL", { baseUrl });
+      const params = new URLSearchParams({
+        organization_id: phantomOptions.organizationId,
+        parent_organization_id: phantomOptions.parentOrganizationId,
+        redirect_uri: phantomOptions.redirectUrl || (typeof window !== "undefined" ? window.location.href : ""),
+        session_id: phantomOptions.sessionId,
+        clear_previous_session: true.toString()
+      });
+      if (phantomOptions.provider) {
+        debug.log(DebugCategory.PHANTOM_CONNECT_AUTH, "Provider specified, will skip selection", {
+          provider: phantomOptions.provider
         });
-        walletId = authResult.walletId;
+        params.append("provider", phantomOptions.provider);
       } else {
-        const wallet = await tempClient.createWallet(`Wallet ${Date.now()}`);
-        walletId = wallet.walletId;
+        debug.log(DebugCategory.PHANTOM_CONNECT_AUTH, "No provider specified, defaulting to Google");
+        params.append("provider", "google");
+      }
+      if (phantomOptions.customAuthData) {
+        debug.log(DebugCategory.PHANTOM_CONNECT_AUTH, "Adding custom auth data");
+        params.append("authData", JSON.stringify(phantomOptions.customAuthData));
       }
-      session = {
+      const authContext = {
+        organizationId: phantomOptions.organizationId,
+        parentOrganizationId: phantomOptions.parentOrganizationId,
+        provider: phantomOptions.provider,
+        sessionId: phantomOptions.sessionId
+      };
+      sessionStorage.setItem("phantom-auth-context", JSON.stringify(authContext));
+      debug.log(DebugCategory.PHANTOM_CONNECT_AUTH, "Stored auth context in session storage", { authContext });
+      const authUrl = `${baseUrl}?${params.toString()}`;
+      debug.info(DebugCategory.PHANTOM_CONNECT_AUTH, "Redirecting to Phantom Connect", { authUrl });
+      window.location.href = authUrl;
+      resolve();
+    });
+  }
+  resumeAuthFromRedirect() {
+    try {
+      const walletId = this.urlParamsAccessor.getParam("wallet_id");
+      const sessionId = this.urlParamsAccessor.getParam("session_id");
+      const error = this.urlParamsAccessor.getParam("error");
+      const errorDescription = this.urlParamsAccessor.getParam("error_description");
+      if (error) {
+        const errorMsg = errorDescription || error;
+        switch (error) {
+          case "access_denied":
+            throw new Error(`Authentication cancelled: ${errorMsg}`);
+          case "invalid_request":
+            throw new Error(`Invalid authentication request: ${errorMsg}`);
+          case "server_error":
+            throw new Error(`Authentication server error: ${errorMsg}`);
+          case "temporarily_unavailable":
+            throw new Error(`Authentication service temporarily unavailable: ${errorMsg}`);
+          default:
+            throw new Error(`Authentication failed: ${errorMsg}`);
+        }
+      }
+      if (!walletId || !sessionId) {
+        debug.log(DebugCategory.PHANTOM_CONNECT_AUTH, "Missing auth parameters in URL", {
+          hasWalletId: !!walletId,
+          hasSessionId: !!sessionId
+        });
+        return null;
+      }
+      const contextStr = sessionStorage.getItem("phantom-auth-context");
+      let context = {};
+      if (contextStr) {
+        try {
+          context = JSON.parse(contextStr);
+        } catch (parseError) {
+          debug.warn(DebugCategory.PHANTOM_CONNECT_AUTH, "Failed to parse stored auth context", { error: parseError });
+        }
+      }
+      if (context.sessionId && sessionId !== context.sessionId) {
+        debug.error(DebugCategory.PHANTOM_CONNECT_AUTH, "Session ID mismatch", {
+          urlSessionId: sessionId,
+          storedSessionId: context.sessionId
+        });
+        throw new Error("Session ID mismatch - possible session corruption or replay attack");
+      }
+      sessionStorage.removeItem("phantom-auth-context");
+      debug.info(DebugCategory.PHANTOM_CONNECT_AUTH, "Successfully resumed auth from redirect", {
         walletId,
-        organizationId: this.config.organizationId,
-        keypair
+        sessionId
+      });
+      return {
+        walletId,
+        userInfo: context
       };
-      await this.storage.saveSession(session);
+    } catch (error) {
+      sessionStorage.removeItem("phantom-auth-context");
+      throw error;
     }
-    const stamper = new ApiKeyStamper({
-      apiSecretKey: session.keypair.secretKey
-    });
-    this.client = new PhantomClient(
-      {
-        apiBaseUrl: this.config.apiBaseUrl,
-        organizationId: session.organizationId
-      },
-      stamper
-    );
-    this.walletId = session.walletId;
-    const addresses = await this.client.getWalletAddresses(session.walletId);
-    this.addresses = addresses.filter((addr) => this.config.addressTypes.some((type) => type === addr.addressType)).map((addr) => ({
-      addressType: addr.addressType,
-      address: addr.address
-    }));
-    return {
-      walletId: this.walletId,
-      addresses: this.addresses
-    };
   }
-  async disconnect() {
-    await this.storage.clearSession();
-    this.client = null;
-    this.walletId = null;
-    this.addresses = [];
+};
+
+// src/providers/embedded/adapters/logger.ts
+var BrowserLogger = class {
+  info(category, message, data) {
+    debug.info(category, message, data);
   }
-  async signMessage(params) {
-    if (!this.client || !this.walletId) {
-      throw new Error("Not connected");
-    }
-    const parsedMessage = parseMessage(params.message);
-    return await this.client.signMessage({
-      walletId: this.walletId,
-      message: parsedMessage.base64url,
-      networkId: params.networkId
-    });
+  warn(category, message, data) {
+    debug.warn(category, message, data);
   }
-  async signAndSendTransaction(params) {
-    if (!this.client || !this.walletId) {
-      throw new Error("Not connected");
-    }
-    const parsedTransaction = await parseTransaction(params.transaction, params.networkId);
-    return await this.client.signAndSendTransaction({
-      walletId: this.walletId,
-      transaction: parsedTransaction.base64url,
-      networkId: params.networkId
-    });
+  error(category, message, data) {
+    debug.error(category, message, data);
   }
-  getAddresses() {
-    return this.addresses;
+  log(category, message, data) {
+    debug.log(category, message, data);
   }
-  isConnected() {
-    return this.client !== null && this.walletId !== null;
+};
+
+// src/providers/embedded/index.ts
+var EmbeddedProvider = class extends CoreEmbeddedProvider {
+  constructor(config) {
+    debug.log(DebugCategory.EMBEDDED_PROVIDER, "Initializing Browser EmbeddedProvider", { config });
+    const urlParamsAccessor = new BrowserURLParamsAccessor();
+    const platform = {
+      storage: new BrowserStorage(),
+      authProvider: new BrowserAuthProvider(urlParamsAccessor),
+      urlParamsAccessor
+    };
+    const logger = new BrowserLogger();
+    super(config, platform, logger);
+    debug.info(DebugCategory.EMBEDDED_PROVIDER, "Browser EmbeddedProvider initialized");
   }
 };
 
@@ -319,8 +485,13 @@ var ProviderManager = class {
     this.currentProvider = null;
     this.currentProviderKey = null;
     this.walletId = null;
+    debug.log(DebugCategory.PROVIDER_MANAGER, "Initializing ProviderManager", { config });
     this.config = config;
+    debug.log(DebugCategory.PROVIDER_MANAGER, "Setting default provider");
     this.setDefaultProvider();
+    debug.info(DebugCategory.PROVIDER_MANAGER, "ProviderManager initialized", {
+      currentProviderKey: this.currentProviderKey
+    });
   }
   /**
    * Switch to a different provider type
@@ -361,13 +532,27 @@ var ProviderManager = class {
   /**
    * Connect using the current provider
    */
-  async connect() {
+  async connect(authOptions) {
+    debug.info(DebugCategory.PROVIDER_MANAGER, "Starting connection", {
+      currentProviderKey: this.currentProviderKey,
+      authOptions: authOptions ? { provider: authOptions.provider, hasJwtToken: !!authOptions.jwtToken } : void 0
+    });
     if (!this.currentProvider) {
+      debug.error(DebugCategory.PROVIDER_MANAGER, "No provider selected");
       throw new Error("No provider selected");
     }
-    const result = await this.currentProvider.connect();
+    debug.log(DebugCategory.PROVIDER_MANAGER, "Delegating to provider connect method");
+    const result = await this.currentProvider.connect(authOptions);
     this.walletId = result.walletId || null;
+    debug.log(DebugCategory.PROVIDER_MANAGER, "Connection successful, saving preferences", {
+      walletId: this.walletId,
+      addressCount: result.addresses?.length || 0
+    });
     this.saveProviderPreference();
+    debug.info(DebugCategory.PROVIDER_MANAGER, "Connect completed", {
+      walletId: this.walletId,
+      addresses: result.addresses
+    });
     return result;
   }
   /**
@@ -447,7 +632,7 @@ var ProviderManager = class {
       provider = new EmbeddedProvider({
         apiBaseUrl: this.config.apiBaseUrl,
         organizationId: this.config.organizationId,
-        authUrl: this.config.authUrl,
+        authOptions: this.config.authOptions,
         embeddedWalletType: embeddedWalletType || "app-wallet",
         addressTypes: this.config.addressTypes || [],
         solanaProvider: this.config.solanaProvider || "web3js"
@@ -501,37 +686,78 @@ 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
+    });
     if (!["injected", "embedded"].includes(config.providerType)) {
+      debug.error(DebugCategory.BROWSER_SDK, "Invalid providerType", { providerType: config.providerType });
       throw new Error(`Invalid providerType: ${config.providerType}. Must be "injected" or "embedded".`);
     }
     const embeddedWalletType = config.embeddedWalletType || "app-wallet";
     if (config.providerType === "embedded" && !["app-wallet", "user-wallet"].includes(embeddedWalletType)) {
+      debug.error(DebugCategory.BROWSER_SDK, "Invalid embeddedWalletType", {
+        embeddedWalletType: config.embeddedWalletType
+      });
       throw new Error(
         `Invalid embeddedWalletType: ${config.embeddedWalletType}. Must be "app-wallet" or "user-wallet".`
       );
     }
     config.embeddedWalletType = embeddedWalletType;
     this.config = config;
+    debug.log(DebugCategory.BROWSER_SDK, "Creating ProviderManager", { config });
     this.providerManager = new ProviderManager(config);
+    debug.info(DebugCategory.BROWSER_SDK, "BrowserSDK initialized successfully");
   }
   /**
    * Connect to the wallet with optional provider switching
    */
   async connect(options) {
+    debug.info(DebugCategory.BROWSER_SDK, "Starting connect process", { options });
     if (options?.providerType) {
+      debug.log(DebugCategory.BROWSER_SDK, "Provider switch requested", {
+        providerType: options.providerType,
+        embeddedWalletType: options.embeddedWalletType
+      });
       if (!["injected", "embedded"].includes(options.providerType)) {
+        debug.error(DebugCategory.BROWSER_SDK, "Invalid providerType in connect options", {
+          providerType: options.providerType
+        });
         throw new Error(`Invalid providerType: ${options.providerType}. Must be "injected" or "embedded".`);
       }
       if (options.embeddedWalletType && !["app-wallet", "user-wallet"].includes(options.embeddedWalletType)) {
+        debug.error(DebugCategory.BROWSER_SDK, "Invalid embeddedWalletType in connect options", {
+          embeddedWalletType: options.embeddedWalletType
+        });
         throw new Error(
           `Invalid embeddedWalletType: ${options.embeddedWalletType}. Must be "app-wallet" or "user-wallet".`
         );
       }
+      debug.log(DebugCategory.BROWSER_SDK, "Switching provider", {
+        providerType: options.providerType,
+        embeddedWalletType: options.embeddedWalletType
+      });
       await this.providerManager.switchProvider(options.providerType, {
         embeddedWalletType: options.embeddedWalletType
       });
     }
-    return this.providerManager.connect();
+    debug.log(DebugCategory.BROWSER_SDK, "Delegating to ProviderManager.connect", {
+      authOptions: options?.authOptions
+    });
+    const result = await this.providerManager.connect(options?.authOptions);
+    debug.info(DebugCategory.BROWSER_SDK, "Connect completed successfully", result);
+    return result;
   }
   /**
    * Switch to a different provider type
@@ -643,5 +869,10 @@ import { NetworkId, AddressType as AddressType2 } from "@phantom/client";
 export {
   AddressType2 as AddressType,
   BrowserSDK,
-  NetworkId
+  DEFAULT_AUTH_URL,
+  DEFAULT_WALLET_API_URL,
+  DebugCategory,
+  DebugLevel,
+  NetworkId,
+  debug
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phantom/browser-sdk",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Browser SDK for Phantom Wallet with unified interface",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -30,8 +30,9 @@
     "@phantom/api-key-stamper": "^0.1.1",
     "@phantom/base64url": "^0.1.0",
     "@phantom/browser-injected-sdk": "^0.0.9",
-    "@phantom/client": "^0.1.1",
-    "@phantom/parsers": "^0.0.2",
+    "@phantom/client": "^0.1.3",
+    "@phantom/embedded-provider-core": "^0.1.1",
+    "@phantom/parsers": "^0.0.4",
     "axios": "^1.10.0",
     "bs58": "^6.0.0",
     "buffer": "^6.0.3",