@phantom/browser-sdk 0.2.2 → 0.3.1

package/dist/index.mjs

@@ -3,26 +3,121 @@ 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
+import { base64urlEncode } from "@phantom/base64url";
+import { getExplorerUrl } from "@phantom/constants";
+import bs58 from "bs58";
 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 +125,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 +143,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 +152,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
     };
   }
@@ -83,18 +180,24 @@ var InjectedProvider = class {
       throw new Error("Wallet not connected");
     }
     const networkPrefix = params.networkId.split(":")[0].toLowerCase();
+    let signatureResult;
     if (networkPrefix === "solana") {
       const { signature } = await this.phantom.solana.signMessage(new TextEncoder().encode(params.message));
-      return Array.from(signature).map((b) => b.toString(16).padStart(2, "0")).join("");
+      signatureResult = bs58.encode(signature);
     } else if (networkPrefix === "ethereum" || networkPrefix === "polygon" || networkPrefix === "eip155") {
       const address = this.addresses.find((addr) => addr.addressType === AddressType.ethereum)?.address;
       if (!address) {
         throw new Error("No address available");
       }
       const signature = await this.phantom.ethereum.signPersonalMessage(params.message, address);
-      return signature;
+      signatureResult = signature;
+    } else {
+      throw new Error(`Network ${params.networkId} is not supported for injected wallets`);
     }
-    throw new Error(`Network ${params.networkId} is not supported for injected wallets`);
+    return {
+      signature: signatureResult,
+      rawSignature: base64urlEncode(signatureResult)
+    };
   }
   async signAndSendTransaction(params) {
     if (!this.connected) {
@@ -105,7 +208,9 @@ var InjectedProvider = class {
       const transaction = params.transaction;
       const result = await this.phantom.solana.signAndSendTransaction(transaction);
       return {
-        rawTransaction: result.signature
+        hash: result.signature,
+        rawTransaction: base64urlEncode(result.signature),
+        blockExplorer: getExplorerUrl(params.networkId, "transaction", result.signature)
       };
     } else if (networkPrefix === "ethereum" || networkPrefix === "polygon" || networkPrefix === "eip155") {
       const toHex = (value) => {
@@ -128,7 +233,9 @@ var InjectedProvider = class {
       };
       const txHash = await this.phantom.ethereum.sendTransaction(txRequest);
       return {
-        rawTransaction: txHash
+        hash: txHash,
+        rawTransaction: base64urlEncode(txHash),
+        blockExplorer: getExplorerUrl(params.networkId, "transaction", txHash)
       };
     }
     throw new Error(`Network ${params.networkId} is not supported for injected wallets`);
@@ -142,11 +249,11 @@ 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";
+import { IndexedDbStamper } from "@phantom/indexed-db-stamper";
 
-// 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 +273,339 @@ 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));
+      }
+      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}`);
+        }
       }
-      session = {
+      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");
+  error(category, message, data) {
+    debug.error(category, message, data);
+  }
+  log(category, message, data) {
+    debug.log(category, message, data);
+  }
+};
+
+// src/utils/browser-detection.ts
+function parseBrowserFromUserAgent(userAgent, hasBraveAPI) {
+  let name = "unknown";
+  let version = "unknown";
+  if (!userAgent || typeof userAgent !== "string") {
+    return { name, version };
+  }
+  try {
+    if (userAgent.includes("Edg/")) {
+      name = "edge";
+      const match = userAgent.match(/Edg\/([0-9]+(?:\.[0-9]+)*)/);
+      if (match)
+        version = match[1].split(".")[0];
+    } else if (userAgent.includes("OPR/") || userAgent.includes("Opera/")) {
+      name = "opera";
+      const match = userAgent.match(/(?:OPR|Opera)\/([0-9]+(?:\.[0-9]+)*)/);
+      if (match)
+        version = match[1].split(".")[0];
+    } else if (userAgent.includes("SamsungBrowser/")) {
+      name = "samsung";
+      const match = userAgent.match(/SamsungBrowser\/([0-9]+(?:\.[0-9]+)*)/);
+      if (match)
+        version = match[1].split(".")[0];
+    } else if (userAgent.includes("DuckDuckGo/")) {
+      name = "duckduckgo";
+      const match = userAgent.match(/DuckDuckGo\/([0-9]+(?:\.[0-9]+)*)/);
+      if (match)
+        version = match[1].split(".")[0];
+    } else if (userAgent.includes("Chrome/") && hasBraveAPI) {
+      name = "brave";
+      const match = userAgent.match(/Chrome\/([0-9]+(?:\.[0-9]+)*)/);
+      if (match)
+        version = match[1].split(".")[0];
+    } else if (userAgent.includes("Mobile/") || userAgent.includes("Android")) {
+      if (userAgent.includes("Chrome/")) {
+        name = "chrome-mobile";
+        const match = userAgent.match(/Chrome\/([0-9]+(?:\.[0-9]+)*)/);
+        if (match)
+          version = match[1].split(".")[0];
+      } else if (userAgent.includes("Firefox/")) {
+        name = "firefox-mobile";
+        const match = userAgent.match(/Firefox\/([0-9]+(?:\.[0-9]+)*)/);
+        if (match)
+          version = match[1].split(".")[0];
+      } else if (userAgent.includes("Safari/") && userAgent.includes("Mobile/")) {
+        name = "safari-mobile";
+        const match = userAgent.match(/Version\/([0-9]+(?:\.[0-9]+)*)/);
+        if (match)
+          version = match[1].split(".")[0];
+      } else {
+        name = "mobile";
+      }
+    } else if (userAgent.includes("Chrome/")) {
+      name = "chrome";
+      const match = userAgent.match(/Chrome\/([0-9]+(?:\.[0-9]+)*)/);
+      if (match)
+        version = match[1].split(".")[0];
+    } else if (userAgent.includes("Firefox/")) {
+      name = "firefox";
+      const match = userAgent.match(/Firefox\/([0-9]+(?:\.[0-9]+)*)/);
+      if (match)
+        version = match[1].split(".")[0];
+    } else if (userAgent.includes("Safari/") && !userAgent.includes("Chrome/")) {
+      name = "safari";
+      const match = userAgent.match(/Version\/([0-9]+(?:\.[0-9]+)*)/);
+      if (match)
+        version = match[1].split(".")[0];
     }
-    const parsedTransaction = await parseTransaction(params.transaction, params.networkId);
-    return await this.client.signAndSendTransaction({
-      walletId: this.walletId,
-      transaction: parsedTransaction.base64url,
-      networkId: params.networkId
-    });
+    if (name === "unknown") {
+      const patterns = [
+        { regex: /Chrome\/([0-9]+)/, name: "chrome" },
+        { regex: /Firefox\/([0-9]+)/, name: "firefox" },
+        { regex: /Safari\/([0-9]+)/, name: "safari" },
+        { regex: /Edge\/([0-9]+)/, name: "edge" },
+        { regex: /Opera\/([0-9]+)/, name: "opera" }
+      ];
+      for (const pattern of patterns) {
+        const match = userAgent.match(pattern.regex);
+        if (match) {
+          name = pattern.name;
+          version = match[1];
+          break;
+        }
+      }
+    }
+  } catch (error) {
   }
-  getAddresses() {
-    return this.addresses;
+  return { name, version };
+}
+function detectBrowser() {
+  if (typeof window === "undefined" || !window.navigator?.userAgent) {
+    return { name: "unknown", version: "unknown" };
   }
-  isConnected() {
-    return this.client !== null && this.walletId !== null;
+  const userAgent = window.navigator.userAgent;
+  const hasBraveAPI = !!navigator.brave;
+  return parseBrowserFromUserAgent(userAgent, hasBraveAPI);
+}
+function getPlatformName() {
+  const { name, version } = detectBrowser();
+  return version !== "unknown" ? `${name}-v${version}` : name;
+}
+function getBrowserDisplayName() {
+  const { name, version } = detectBrowser();
+  const capitalizedName = name.charAt(0).toUpperCase() + name.slice(1);
+  return version !== "unknown" ? `${capitalizedName} ${version}` : capitalizedName;
+}
+
+// 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 stamper = new IndexedDbStamper({
+      dbName: `phantom-embedded-sdk-${config.organizationId}`,
+      storeName: "crypto-keys",
+      keyName: "signing-key"
+    });
+    const platformName = getPlatformName();
+    const platform = {
+      storage: new BrowserStorage(),
+      authProvider: new BrowserAuthProvider(urlParamsAccessor),
+      urlParamsAccessor,
+      stamper,
+      name: platformName
+      // Use detected browser name and version for identification
+    };
+    debug.log(DebugCategory.EMBEDDED_PROVIDER, "Detected platform", { platformName });
+    const logger = new BrowserLogger();
+    super(config, platform, logger);
+    debug.info(DebugCategory.EMBEDDED_PROVIDER, "Browser EmbeddedProvider initialized");
   }
 };
 
@@ -319,8 +616,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 +663,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 +763,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 +817,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
@@ -582,7 +939,17 @@ var BrowserSDK = class {
    * @returns Signature string
    */
   async signMessage(params) {
-    return this.providerManager.signMessage(params);
+    debug.info(DebugCategory.BROWSER_SDK, "Signing message", {
+      message: params.message,
+      networkId: params.networkId
+    });
+    const result = await this.providerManager.signMessage(params);
+    debug.info(DebugCategory.BROWSER_SDK, "Message signed successfully", {
+      message: params.message,
+      networkId: params.networkId,
+      result
+    });
+    return result;
   }
   /**
    * Sign and send a transaction
@@ -590,7 +957,15 @@ var BrowserSDK = class {
    * @returns Transaction result
    */
   async signAndSendTransaction(params) {
-    return this.providerManager.signAndSendTransaction(params);
+    debug.info(DebugCategory.BROWSER_SDK, "Signing and sending transaction", {
+      networkId: params.networkId
+    });
+    const result = await this.providerManager.signAndSendTransaction(params);
+    debug.info(DebugCategory.BROWSER_SDK, "Transaction signed and sent successfully", {
+      networkId: params.networkId,
+      result
+    });
+    return result;
   }
   /**
    * Get wallet addresses
@@ -639,9 +1014,19 @@ var BrowserSDK = class {
 };
 
 // src/index.ts
-import { NetworkId, AddressType as AddressType2 } from "@phantom/client";
+import { NetworkId } from "@phantom/constants";
+import { AddressType as AddressType2 } from "@phantom/client";
 export {
   AddressType2 as AddressType,
   BrowserSDK,
-  NetworkId
+  DEFAULT_AUTH_URL,
+  DEFAULT_WALLET_API_URL,
+  DebugCategory,
+  DebugLevel,
+  NetworkId,
+  debug,
+  detectBrowser,
+  getBrowserDisplayName,
+  getPlatformName,
+  parseBrowserFromUserAgent
 };