@phantom/browser-sdk 0.2.2 → 0.3.1

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,14 +17,31 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  AddressType: () => import_client3.AddressType,
+  AddressType: () => import_client2.AddressType,
   BrowserSDK: () => BrowserSDK,
-  NetworkId: () => import_client3.NetworkId
+  DEFAULT_AUTH_URL: () => DEFAULT_AUTH_URL,
+  DEFAULT_WALLET_API_URL: () => DEFAULT_WALLET_API_URL,
+  DebugCategory: () => DebugCategory,
+  DebugLevel: () => DebugLevel,
+  NetworkId: () => import_constants3.NetworkId,
+  debug: () => debug,
+  detectBrowser: () => detectBrowser,
+  getBrowserDisplayName: () => getBrowserDisplayName,
+  getPlatformName: () => getPlatformName,
+  parseBrowserFromUserAgent: () => parseBrowserFromUserAgent
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -31,26 +50,121 @@ var import_client = require("@phantom/client");
 var import_browser_injected_sdk = require("@phantom/browser-injected-sdk");
 var import_solana = require("@phantom/browser-injected-sdk/solana");
 var import_ethereum = require("@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 import_base64url = require("@phantom/base64url");
+var import_constants = require("@phantom/constants");
+var import_bs58 = __toESM(require("bs58"));
 var InjectedProvider = class {
   constructor(config) {
     this.connected = false;
     this.addresses = [];
+    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 });
     const plugins = [(0, import_browser_injected_sdk.createExtensionPlugin)()];
     if (this.addressTypes.includes(import_client.AddressType.solana)) {
       plugins.push((0, import_solana.createSolanaPlugin)());
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Solana plugin added");
     }
     if (this.addressTypes.includes(import_client.AddressType.ethereum)) {
       plugins.push((0, import_ethereum.createEthereumPlugin)());
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum plugin added");
     }
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Creating Phantom instance with plugins", {
+      pluginCount: plugins.length
+    });
     this.phantom = (0, import_browser_injected_sdk.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(import_client.AddressType.solana)) {
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Attempting Solana connection");
       try {
         const publicKey = await this.phantom.solana.connect();
         if (publicKey) {
@@ -58,9 +172,10 @@ var InjectedProvider = class {
             addressType: import_client.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(import_client.AddressType.ethereum)) {
@@ -75,7 +190,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) {
@@ -84,7 +199,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
     };
   }
@@ -111,18 +227,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 = import_bs58.default.encode(signature);
     } else if (networkPrefix === "ethereum" || networkPrefix === "polygon" || networkPrefix === "eip155") {
       const address = this.addresses.find((addr) => addr.addressType === import_client.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: (0, import_base64url.base64urlEncode)(signatureResult)
+    };
   }
   async signAndSendTransaction(params) {
     if (!this.connected) {
@@ -133,7 +255,9 @@ var InjectedProvider = class {
       const transaction = params.transaction;
       const result = await this.phantom.solana.signAndSendTransaction(transaction);
       return {
-        rawTransaction: result.signature
+        hash: result.signature,
+        rawTransaction: (0, import_base64url.base64urlEncode)(result.signature),
+        blockExplorer: (0, import_constants.getExplorerUrl)(params.networkId, "transaction", result.signature)
       };
     } else if (networkPrefix === "ethereum" || networkPrefix === "polygon" || networkPrefix === "eip155") {
       const toHex = (value) => {
@@ -156,7 +280,9 @@ var InjectedProvider = class {
       };
       const txHash = await this.phantom.ethereum.sendTransaction(txRequest);
       return {
-        rawTransaction: txHash
+        hash: txHash,
+        rawTransaction: (0, import_base64url.base64urlEncode)(txHash),
+        blockExplorer: (0, import_constants.getExplorerUrl)(params.networkId, "transaction", txHash)
       };
     }
     throw new Error(`Network ${params.networkId} is not supported for injected wallets`);
@@ -170,11 +296,11 @@ var InjectedProvider = class {
 };
 
 // src/providers/embedded/index.ts
-var import_client2 = require("@phantom/client");
-var import_api_key_stamper = require("@phantom/api-key-stamper");
+var import_embedded_provider_core = require("@phantom/embedded-provider-core");
+var import_indexed_db_stamper = require("@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";
@@ -194,149 +320,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
-var import_parsers = require("@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 = (0, import_client2.generateKeyPair)();
-      const stamper2 = new import_api_key_stamper.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 import_client2.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 import_api_key_stamper.ApiKeyStamper({
-      apiSecretKey: session.keypair.secretKey
-    });
-    this.client = new import_client2.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 = (0, import_parsers.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 (0, import_parsers.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 import_embedded_provider_core.EmbeddedProvider {
+  constructor(config) {
+    debug.log(DebugCategory.EMBEDDED_PROVIDER, "Initializing Browser EmbeddedProvider", { config });
+    const urlParamsAccessor = new BrowserURLParamsAccessor();
+    const stamper = new import_indexed_db_stamper.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");
   }
 };
 
@@ -347,8 +663,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
@@ -389,13 +710,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;
   }
   /**
@@ -475,7 +810,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"
@@ -529,37 +864,78 @@ var ProviderManager = class {
 var import_browser_injected_sdk2 = require("@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
@@ -610,7 +986,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
@@ -618,7 +1004,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
@@ -667,4 +1061,5 @@ var BrowserSDK = class {
 };
 
 // src/index.ts
-var import_client3 = require("@phantom/client");
+var import_constants3 = require("@phantom/constants");
+var import_client2 = require("@phantom/client");