@phantom/browser-sdk 1.0.0-beta.2 → 1.0.0-beta.21

package/dist/index.js

@@ -22,22 +22,26 @@ var src_exports = {};
 __export(src_exports, {
   AddressType: () => import_client5.AddressType,
   BrowserSDK: () => BrowserSDK,
-  DEFAULT_AUTH_URL: () => DEFAULT_AUTH_URL,
-  DEFAULT_WALLET_API_URL: () => DEFAULT_WALLET_API_URL,
   DebugCategory: () => DebugCategory,
   DebugLevel: () => DebugLevel,
-  NetworkId: () => import_constants2.NetworkId,
+  NetworkId: () => import_constants5.NetworkId,
   debug: () => debug,
   detectBrowser: () => detectBrowser,
   getBrowserDisplayName: () => getBrowserDisplayName,
+  getDeeplinkToPhantom: () => getDeeplinkToPhantom,
   getPlatformName: () => getPlatformName,
+  isMobileDevice: () => isMobileDevice,
+  isPhantomLoginAvailable: () => isPhantomLoginAvailable,
   parseBrowserFromUserAgent: () => parseBrowserFromUserAgent,
   waitForPhantomExtension: () => waitForPhantomExtension
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/types.ts
+var import_client = require("@phantom/client");
+
 // src/providers/injected/index.ts
-var import_client3 = require("@phantom/client");
+var import_client4 = 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");
@@ -119,7 +123,7 @@ var DebugCategory = {
 
 // src/providers/injected/chains/SolanaChain.ts
 var import_eventemitter3 = require("eventemitter3");
-var import_client = require("@phantom/client");
+var import_client2 = require("@phantom/client");
 var import_buffer = require("buffer");
 var InjectedSolanaChain = class {
   constructor(phantom, callbacks) {
@@ -144,7 +148,7 @@ var InjectedSolanaChain = class {
       return Promise.reject(new Error("Provider not connected. Call provider connect first."));
     }
     const addresses = this.callbacks.getAddresses();
-    const solanaAddress = addresses.find((addr) => addr.addressType === import_client.AddressType.solana);
+    const solanaAddress = addresses.find((addr) => addr.addressType === import_client2.AddressType.solana);
     if (!solanaAddress) {
       return Promise.reject(new Error("Solana not enabled for this provider"));
     }
@@ -178,8 +182,27 @@ var InjectedSolanaChain = class {
     const result = await this.phantom.solana.signAndSendTransaction(transaction);
     return { signature: result.signature };
   }
-  signAllTransactions(_transactions) {
-    return Promise.reject(new Error("Sign-only transactions not supported by injected provider"));
+  async signAllTransactions(transactions) {
+    if (!this.callbacks.isConnected()) {
+      return Promise.reject(new Error("Provider not connected. Call provider connect first."));
+    }
+    try {
+      const result = await this.phantom.solana.signAllTransactions(transactions);
+      return result;
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+  async signAndSendAllTransactions(transactions) {
+    if (!this.callbacks.isConnected()) {
+      return Promise.reject(new Error("Provider not connected. Call provider connect first."));
+    }
+    try {
+      const result = await this.phantom.solana.signAndSendAllTransactions(transactions);
+      return { signatures: result.signatures };
+    } catch (error) {
+      return Promise.reject(error);
+    }
   }
   switchNetwork(_network) {
     return Promise.resolve();
@@ -205,7 +228,7 @@ var InjectedSolanaChain = class {
       this.eventEmitter.emit("accountChanged", publicKey);
     });
     this.callbacks.on("connect", (data) => {
-      const solanaAddress = data.addresses?.find((addr) => addr.addressType === import_client.AddressType.solana);
+      const solanaAddress = data.addresses?.find((addr) => addr.addressType === import_client2.AddressType.solana);
       if (solanaAddress) {
         this.updateConnectionState(true, solanaAddress.address);
       }
@@ -216,7 +239,7 @@ var InjectedSolanaChain = class {
   }
   syncInitialState() {
     if (this.callbacks.isConnected()) {
-      const solanaAddress = this.callbacks.getAddresses().find((addr) => addr.addressType === import_client.AddressType.solana);
+      const solanaAddress = this.callbacks.getAddresses().find((addr) => addr.addressType === import_client2.AddressType.solana);
       if (solanaAddress) {
         this.updateConnectionState(true, solanaAddress.address);
       }
@@ -237,7 +260,7 @@ var InjectedSolanaChain = class {
 
 // src/providers/injected/chains/EthereumChain.ts
 var import_eventemitter32 = require("eventemitter3");
-var import_client2 = require("@phantom/client");
+var import_client3 = require("@phantom/client");
 var InjectedEthereumChain = class {
   constructor(phantom, callbacks) {
     this._connected = false;
@@ -275,7 +298,7 @@ var InjectedEthereumChain = class {
       return Promise.reject(new Error("Provider not connected. Call provider connect first."));
     }
     const addresses = this.callbacks.getAddresses();
-    const ethAddresses = addresses.filter((addr) => addr.addressType === import_client2.AddressType.ethereum).map((addr) => addr.address);
+    const ethAddresses = addresses.filter((addr) => addr.addressType === import_client3.AddressType.ethereum).map((addr) => addr.address);
     this.updateConnectionState(true, ethAddresses);
     return Promise.resolve(ethAddresses);
   }
@@ -296,8 +319,9 @@ var InjectedEthereumChain = class {
     return await this.phantom.ethereum.sendTransaction(transaction);
   }
   async switchChain(chainId) {
-    await this.phantom.ethereum.switchChain(`0x${chainId.toString(16)}`);
-    this._chainId = `0x${chainId.toString(16)}`;
+    const hexChainId = typeof chainId === "string" ? chainId.toLowerCase().startsWith("0x") ? chainId : `0x${parseInt(chainId, 10).toString(16)}` : `0x${chainId.toString(16)}`;
+    await this.phantom.ethereum.switchChain(hexChainId);
+    this._chainId = hexChainId;
     this.eventEmitter.emit("chainChanged", this._chainId);
   }
   async getChainId() {
@@ -330,7 +354,7 @@ var InjectedEthereumChain = class {
       this.eventEmitter.emit("chainChanged", chainId);
     });
     this.callbacks.on("connect", (data) => {
-      const ethAddresses = data.addresses?.filter((addr) => addr.addressType === import_client2.AddressType.ethereum)?.map((addr) => addr.address) || [];
+      const ethAddresses = data.addresses?.filter((addr) => addr.addressType === import_client3.AddressType.ethereum)?.map((addr) => addr.address) || [];
       if (ethAddresses.length > 0) {
         this.updateConnectionState(true, ethAddresses);
       }
@@ -341,7 +365,7 @@ var InjectedEthereumChain = class {
   }
   syncInitialState() {
     if (this.callbacks.isConnected()) {
-      const ethAddresses = this.callbacks.getAddresses().filter((addr) => addr.addressType === import_client2.AddressType.ethereum).map((addr) => addr.address);
+      const ethAddresses = this.callbacks.getAddresses().filter((addr) => addr.addressType === import_client3.AddressType.ethereum).map((addr) => addr.address);
       if (ethAddresses.length > 0) {
         this.updateConnectionState(true, ethAddresses);
       }
@@ -361,6 +385,8 @@ var InjectedEthereumChain = class {
 };
 
 // src/providers/injected/index.ts
+var MANUAL_DISCONNECT_KEY = "phantom-injected-manual-disconnect";
+var MANUAL_DISCONNECT_VALUE = "true";
 var InjectedProvider = class {
   constructor(config) {
     this.connected = false;
@@ -373,11 +399,11 @@ var InjectedProvider = class {
     this.addressTypes = config.addressTypes;
     debug.log(DebugCategory.INJECTED_PROVIDER, "Address types configured", { addressTypes: this.addressTypes });
     const plugins = [(0, import_browser_injected_sdk.createExtensionPlugin)()];
-    if (this.addressTypes.includes(import_client3.AddressType.solana)) {
+    if (this.addressTypes.includes(import_client4.AddressType.solana)) {
       plugins.push((0, import_solana.createSolanaPlugin)());
       debug.log(DebugCategory.INJECTED_PROVIDER, "Solana plugin added");
     }
-    if (this.addressTypes.includes(import_client3.AddressType.ethereum)) {
+    if (this.addressTypes.includes(import_client4.AddressType.ethereum)) {
       plugins.push((0, import_ethereum.createEthereumPlugin)());
       debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum plugin added");
     }
@@ -388,10 +414,10 @@ var InjectedProvider = class {
     });
     this.phantom = (0, import_browser_injected_sdk.createPhantom)({ plugins });
     const callbacks = this.createCallbacks();
-    if (this.addressTypes.includes(import_client3.AddressType.solana)) {
+    if (this.addressTypes.includes(import_client4.AddressType.solana)) {
       this._solanaChain = new InjectedSolanaChain(this.phantom, callbacks);
     }
-    if (this.addressTypes.includes(import_client3.AddressType.ethereum)) {
+    if (this.addressTypes.includes(import_client4.AddressType.ethereum)) {
       this._ethereumChain = new InjectedEthereumChain(this.phantom, callbacks);
     }
     debug.info(DebugCategory.INJECTED_PROVIDER, "InjectedProvider initialized");
@@ -400,7 +426,7 @@ var InjectedProvider = class {
    * Access to Solana chain operations
    */
   get solana() {
-    if (!this.addressTypes.includes(import_client3.AddressType.solana)) {
+    if (!this.addressTypes.includes(import_client4.AddressType.solana)) {
       throw new Error("Solana not enabled for this provider");
     }
     if (!this._solanaChain) {
@@ -412,7 +438,7 @@ var InjectedProvider = class {
    * Access to Ethereum chain operations
    */
   get ethereum() {
-    if (!this.addressTypes.includes(import_client3.AddressType.ethereum)) {
+    if (!this.addressTypes.includes(import_client4.AddressType.ethereum)) {
       throw new Error("Ethereum not enabled for this provider");
     }
     if (!this._ethereumChain) {
@@ -423,9 +449,11 @@ var InjectedProvider = class {
   async connect(authOptions) {
     debug.info(DebugCategory.INJECTED_PROVIDER, "Starting injected provider connect", {
       addressTypes: this.addressTypes,
-      authOptionsIgnored: !!authOptions
-      // Note: authOptions are ignored for injected provider
+      provider: authOptions.provider
     });
+    if (authOptions.provider !== "injected") {
+      throw new Error(`Invalid provider for injected connection: ${authOptions.provider}. Must be "injected"`);
+    }
     this.emit("connect_start", {
       source: "manual-connect",
       providerType: "injected"
@@ -442,35 +470,45 @@ var InjectedProvider = class {
       }
       debug.log(DebugCategory.INJECTED_PROVIDER, "Phantom extension detected");
       const connectedAddresses = [];
-      if (this.addressTypes.includes(import_client3.AddressType.solana)) {
+      if (this.addressTypes.includes(import_client4.AddressType.solana)) {
         debug.log(DebugCategory.INJECTED_PROVIDER, "Attempting Solana connection");
         try {
           const publicKey = await this.phantom.solana.connect();
           if (publicKey) {
             connectedAddresses.push({
-              addressType: import_client3.AddressType.solana,
+              addressType: import_client4.AddressType.solana,
               address: publicKey
             });
             debug.info(DebugCategory.INJECTED_PROVIDER, "Solana connected successfully", { address: publicKey });
           }
         } catch (err) {
-          debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to connect Solana", { error: err });
+          debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to connect Solana, stopping", { error: err });
+          this.emit("connect_error", {
+            error: err instanceof Error ? err.message : "Failed to connect",
+            source: "manual-connect"
+          });
+          throw err;
         }
       }
-      if (this.addressTypes.includes(import_client3.AddressType.ethereum)) {
+      if (this.addressTypes.includes(import_client4.AddressType.ethereum)) {
         try {
           const accounts = await this.phantom.ethereum.connect();
           if (accounts && accounts.length > 0) {
             connectedAddresses.push(
               ...accounts.map((address) => ({
-                addressType: import_client3.AddressType.ethereum,
+                addressType: import_client4.AddressType.ethereum,
                 address
               }))
             );
             debug.info(DebugCategory.INJECTED_PROVIDER, "Ethereum connected successfully", { addresses: accounts });
           }
         } catch (err) {
-          debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to connect Ethereum", { error: err });
+          debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to connect Ethereum, stopping", { error: err });
+          this.emit("connect_error", {
+            error: err instanceof Error ? err.message : "Failed to connect",
+            source: "manual-connect"
+          });
+          throw err;
         }
       }
       if (connectedAddresses.length === 0) {
@@ -483,14 +521,22 @@ var InjectedProvider = class {
       }
       this.addresses = connectedAddresses;
       this.connected = true;
+      const authUserId = await this.getAuthUserId("manual-connect");
+      try {
+        localStorage.removeItem(MANUAL_DISCONNECT_KEY);
+        debug.log(DebugCategory.INJECTED_PROVIDER, "Cleared manual disconnect flag - auto-reconnect enabled");
+      } catch (error) {
+        debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to clear manual disconnect flag", { error });
+      }
       const result = {
         addresses: this.addresses,
-        status: "completed"
-        // walletId is not applicable for injected providers
+        status: "completed",
+        authUserId
       };
       this.emit("connect", {
         addresses: this.addresses,
-        source: "manual-connect"
+        source: "manual-connect",
+        authUserId
       });
       return result;
     } catch (error) {
@@ -505,7 +551,7 @@ var InjectedProvider = class {
   }
   async disconnect() {
     debug.info(DebugCategory.INJECTED_PROVIDER, "Starting injected provider disconnect");
-    if (this.addressTypes.includes(import_client3.AddressType.solana)) {
+    if (this.addressTypes.includes(import_client4.AddressType.solana)) {
       try {
         await this.phantom.solana.disconnect();
         debug.log(DebugCategory.INJECTED_PROVIDER, "Solana disconnected successfully");
@@ -513,18 +559,117 @@ var InjectedProvider = class {
         debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to disconnect Solana", { error: err });
       }
     }
-    if (this.addressTypes.includes(import_client3.AddressType.ethereum)) {
+    if (this.addressTypes.includes(import_client4.AddressType.ethereum)) {
       debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum disconnected (no-op)");
     }
     this.browserInjectedCleanupFunctions.forEach((cleanup) => cleanup());
     this.browserInjectedCleanupFunctions = [];
     this.connected = false;
     this.addresses = [];
+    try {
+      localStorage.setItem(MANUAL_DISCONNECT_KEY, MANUAL_DISCONNECT_VALUE);
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Set manual disconnect flag to prevent auto-reconnect");
+    } catch (error) {
+      debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to set manual disconnect flag", { error });
+    }
     this.emit("disconnect", {
       source: "manual-disconnect"
     });
     debug.info(DebugCategory.INJECTED_PROVIDER, "Injected provider disconnected successfully");
   }
+  /**
+   * Attempt auto-connection using onlyIfTrusted parameter
+   * This will only connect if the dApp is already trusted by the user
+   * Should be called after setting up event listeners
+   */
+  async autoConnect() {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Attempting auto-connect with onlyIfTrusted=true");
+    try {
+      const manualDisconnect = localStorage.getItem(MANUAL_DISCONNECT_KEY);
+      if (manualDisconnect === MANUAL_DISCONNECT_VALUE) {
+        debug.log(DebugCategory.INJECTED_PROVIDER, "Skipping auto-connect: user previously disconnected manually");
+        return;
+      }
+    } catch (error) {
+      debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to check manual disconnect flag", { error });
+    }
+    this.emit("connect_start", {
+      source: "auto-connect",
+      providerType: "injected"
+    });
+    try {
+      if (!this.phantom.extension?.isInstalled?.()) {
+        debug.warn(DebugCategory.INJECTED_PROVIDER, "Phantom wallet extension not found for auto-connect");
+        this.emit("connect_error", {
+          error: "Phantom wallet not found",
+          source: "auto-connect"
+        });
+        return;
+      }
+      const connectedAddresses = [];
+      if (this.addressTypes.includes(import_client4.AddressType.solana)) {
+        debug.log(DebugCategory.INJECTED_PROVIDER, "Attempting Solana auto-connect");
+        try {
+          const publicKey = await this.phantom.solana.connect({ onlyIfTrusted: true });
+          if (publicKey) {
+            connectedAddresses.push({
+              addressType: import_client4.AddressType.solana,
+              address: publicKey
+            });
+            debug.info(DebugCategory.INJECTED_PROVIDER, "Solana auto-connected successfully", { address: publicKey });
+          }
+        } catch (err) {
+          debug.log(DebugCategory.INJECTED_PROVIDER, "Solana auto-connect failed (expected if not trusted)", { error: err });
+        }
+      }
+      if (this.addressTypes.includes(import_client4.AddressType.ethereum)) {
+        debug.log(DebugCategory.INJECTED_PROVIDER, "Attempting Ethereum auto-connect");
+        try {
+          const accounts = await this.phantom.ethereum.connect({ onlyIfTrusted: true });
+          if (accounts && accounts.length > 0) {
+            connectedAddresses.push(
+              ...accounts.map((address) => ({
+                addressType: import_client4.AddressType.ethereum,
+                address
+              }))
+            );
+            debug.info(DebugCategory.INJECTED_PROVIDER, "Ethereum auto-connected successfully", { addresses: accounts });
+          }
+        } catch (err) {
+          debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum auto-connect failed (expected if not trusted)", { error: err });
+        }
+      }
+      if (connectedAddresses.length === 0) {
+        debug.log(DebugCategory.INJECTED_PROVIDER, "Auto-connect failed: no trusted connections available");
+        this.emit("connect_error", {
+          error: "No trusted connections available",
+          source: "auto-connect"
+        });
+        return;
+      }
+      this.addresses = connectedAddresses;
+      this.connected = true;
+      const authUserId = await this.getAuthUserId("auto-connect");
+      this.emit("connect", {
+        addresses: this.addresses,
+        source: "auto-connect",
+        authUserId
+      });
+      debug.info(DebugCategory.INJECTED_PROVIDER, "Auto-connect successful", {
+        addressCount: connectedAddresses.length,
+        addresses: connectedAddresses.map((addr) => ({ type: addr.addressType, address: addr.address.substring(0, 8) + "..." })),
+        authUserId
+      });
+    } catch (error) {
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Auto-connect failed with error", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      this.emit("connect_error", {
+        error: error instanceof Error ? error.message : "Auto-connect failed",
+        source: "auto-connect"
+      });
+    }
+  }
   getAddresses() {
     return this.addresses;
   }
@@ -548,6 +693,27 @@ var InjectedProvider = class {
     debug.log(DebugCategory.INJECTED_PROVIDER, "Getting supported autoConfirm chains");
     return await this.phantom.autoConfirm.autoConfirmSupportedChains();
   }
+  /**
+   * Helper method to get authUserId from window.phantom.app.getUser()
+   * Returns undefined if the method is not available or fails
+   */
+  async getAuthUserId(context) {
+    try {
+      if (window.phantom?.app?.getUser) {
+        const userInfo = await window.phantom.app.getUser();
+        const authUserId = userInfo?.authUserId;
+        if (authUserId) {
+          debug.log(DebugCategory.INJECTED_PROVIDER, `Retrieved authUserId from window.phantom.app.getUser() during ${context}`, {
+            authUserId
+          });
+        }
+        return authUserId;
+      }
+    } catch (error) {
+      debug.log(DebugCategory.INJECTED_PROVIDER, `Failed to get user info during ${context} (method may not be supported)`, { error });
+    }
+    return void 0;
+  }
   // Event management methods - implementing unified event interface
   on(event, callback) {
     debug.log(DebugCategory.INJECTED_PROVIDER, "Adding event listener", { event });
@@ -588,98 +754,108 @@ var InjectedProvider = class {
   }
   setupBrowserInjectedEvents() {
     debug.log(DebugCategory.INJECTED_PROVIDER, "Setting up browser-injected-sdk event listeners");
-    if (this.addressTypes.includes(import_client3.AddressType.solana)) {
+    if (this.addressTypes.includes(import_client4.AddressType.solana)) {
       this.setupSolanaEvents();
     }
-    if (this.addressTypes.includes(import_client3.AddressType.ethereum)) {
+    if (this.addressTypes.includes(import_client4.AddressType.ethereum)) {
       this.setupEthereumEvents();
     }
   }
   setupSolanaEvents() {
     debug.log(DebugCategory.INJECTED_PROVIDER, "Setting up Solana event listeners");
-    const handleSolanaConnect = (publicKey) => {
+    const handleSolanaConnect = async (publicKey) => {
       debug.log(DebugCategory.INJECTED_PROVIDER, "Solana connect event received", { publicKey });
-      const solanaAddress = { addressType: import_client3.AddressType.solana, address: publicKey };
-      if (!this.addresses.find((addr) => addr.addressType === import_client3.AddressType.solana)) {
+      const solanaAddress = { addressType: import_client4.AddressType.solana, address: publicKey };
+      if (!this.addresses.find((addr) => addr.addressType === import_client4.AddressType.solana)) {
         this.addresses.push(solanaAddress);
       }
       this.connected = true;
+      const authUserId = await this.getAuthUserId("Solana connect event");
       this.emit("connect", {
         addresses: this.addresses,
-        source: "injected-extension"
+        source: "injected-extension",
+        authUserId
       });
     };
     const handleSolanaDisconnect = () => {
       debug.log(DebugCategory.INJECTED_PROVIDER, "Solana disconnect event received");
-      this.addresses = this.addresses.filter((addr) => addr.addressType !== import_client3.AddressType.solana);
-      this.connected = this.addresses.length > 0;
+      this.addresses = this.addresses.filter((addr) => addr.addressType !== import_client4.AddressType.solana);
+      this.connected = false;
       this.emit("disconnect", {
         source: "injected-extension"
       });
     };
-    const handleSolanaAccountChanged = (publicKey) => {
+    const handleSolanaAccountChanged = async (publicKey) => {
       debug.log(DebugCategory.INJECTED_PROVIDER, "Solana account changed event received", { publicKey });
-      const solanaIndex = this.addresses.findIndex((addr) => addr.addressType === import_client3.AddressType.solana);
+      const solanaIndex = this.addresses.findIndex((addr) => addr.addressType === import_client4.AddressType.solana);
       if (solanaIndex >= 0) {
-        this.addresses[solanaIndex] = { addressType: import_client3.AddressType.solana, address: publicKey };
+        this.addresses[solanaIndex] = { addressType: import_client4.AddressType.solana, address: publicKey };
       } else {
-        this.addresses.push({ addressType: import_client3.AddressType.solana, address: publicKey });
+        this.addresses.push({ addressType: import_client4.AddressType.solana, address: publicKey });
       }
+      const authUserId = await this.getAuthUserId("Solana account changed event");
       this.emit("connect", {
         addresses: this.addresses,
-        source: "injected-extension-account-change"
+        source: "injected-extension-account-change",
+        authUserId
       });
     };
     const cleanupConnect = this.phantom.solana.addEventListener("connect", handleSolanaConnect);
     const cleanupDisconnect = this.phantom.solana.addEventListener("disconnect", handleSolanaDisconnect);
-    const cleanupAccountChanged = this.phantom.solana.addEventListener(
-      "accountChanged",
-      handleSolanaAccountChanged
-    );
+    const cleanupAccountChanged = this.phantom.solana.addEventListener("accountChanged", handleSolanaAccountChanged);
     this.browserInjectedCleanupFunctions.push(cleanupConnect, cleanupDisconnect, cleanupAccountChanged);
   }
   setupEthereumEvents() {
     debug.log(DebugCategory.INJECTED_PROVIDER, "Setting up Ethereum event listeners");
-    const handleEthereumConnect = (accounts) => {
+    const handleEthereumConnect = async (accounts) => {
       debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum connect event received", { accounts });
-      this.addresses = this.addresses.filter((addr) => addr.addressType !== import_client3.AddressType.ethereum);
+      this.addresses = this.addresses.filter((addr) => addr.addressType !== import_client4.AddressType.ethereum);
       if (accounts && accounts.length > 0) {
         this.addresses.push(
           ...accounts.map((address) => ({
-            addressType: import_client3.AddressType.ethereum,
+            addressType: import_client4.AddressType.ethereum,
             address
           }))
         );
       }
       this.connected = this.addresses.length > 0;
+      const authUserId = await this.getAuthUserId("Ethereum connect event");
       this.emit("connect", {
         addresses: this.addresses,
-        source: "injected-extension"
+        source: "injected-extension",
+        authUserId
       });
     };
     const handleEthereumDisconnect = () => {
       debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum disconnect event received");
-      this.addresses = this.addresses.filter((addr) => addr.addressType !== import_client3.AddressType.ethereum);
-      this.connected = this.addresses.length > 0;
+      this.addresses = this.addresses.filter((addr) => addr.addressType !== import_client4.AddressType.ethereum);
+      this.connected = false;
       this.emit("disconnect", {
         source: "injected-extension"
       });
     };
-    const handleEthereumAccountsChanged = (accounts) => {
+    const handleEthereumAccountsChanged = async (accounts) => {
       debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum accounts changed event received", { accounts });
-      this.addresses = this.addresses.filter((addr) => addr.addressType !== import_client3.AddressType.ethereum);
+      this.addresses = this.addresses.filter((addr) => addr.addressType !== import_client4.AddressType.ethereum);
       if (accounts && accounts.length > 0) {
         this.addresses.push(
           ...accounts.map((address) => ({
-            addressType: import_client3.AddressType.ethereum,
+            addressType: import_client4.AddressType.ethereum,
             address
           }))
         );
+        const authUserId = await this.getAuthUserId("Ethereum accounts changed event");
+        this.emit("connect", {
+          addresses: this.addresses,
+          source: "injected-extension-account-change",
+          authUserId
+        });
+      } else {
+        this.connected = false;
+        this.emit("disconnect", {
+          source: "injected-extension-account-change"
+        });
       }
-      this.emit("connect", {
-        addresses: this.addresses,
-        source: "injected-extension-account-change"
-      });
     };
     const cleanupConnect = this.phantom.ethereum.addEventListener("connect", handleEthereumConnect);
     const cleanupDisconnect = this.phantom.ethereum.addEventListener("disconnect", handleEthereumDisconnect);
@@ -692,7 +868,7 @@ var InjectedProvider = class {
   createCallbacks() {
     return {
       connect: async () => {
-        const result = await this.connect();
+        const result = await this.connect({ provider: "injected" });
         return result.addresses;
       },
       disconnect: async () => {
@@ -797,6 +973,47 @@ var BrowserStorage = class {
       };
     });
   }
+  async getShouldClearPreviousSession() {
+    debug.log(DebugCategory.STORAGE, "Getting shouldClearPreviousSession flag 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("shouldClearPreviousSession");
+      request.onsuccess = () => {
+        const shouldClear = request.result ?? false;
+        debug.log(DebugCategory.STORAGE, "Retrieved shouldClearPreviousSession flag from IndexedDB", {
+          shouldClear
+        });
+        resolve(shouldClear);
+      };
+      request.onerror = () => {
+        debug.error(DebugCategory.STORAGE, "Failed to get shouldClearPreviousSession flag from IndexedDB", {
+          error: request.error
+        });
+        reject(request.error);
+      };
+    });
+  }
+  async setShouldClearPreviousSession(should) {
+    debug.log(DebugCategory.STORAGE, "Setting shouldClearPreviousSession flag in IndexedDB", { should });
+    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(should, "shouldClearPreviousSession");
+      request.onsuccess = () => {
+        debug.log(DebugCategory.STORAGE, "Successfully set shouldClearPreviousSession flag in IndexedDB");
+        resolve();
+      };
+      request.onerror = () => {
+        debug.error(DebugCategory.STORAGE, "Failed to set shouldClearPreviousSession flag in IndexedDB", {
+          error: request.error
+        });
+        reject(request.error);
+      };
+    });
+  }
 };
 
 // src/providers/embedded/adapters/url-params.ts
@@ -808,15 +1025,160 @@ var BrowserURLParamsAccessor = class {
 };
 var browserUrlParamsAccessor = new BrowserURLParamsAccessor();
 
-// 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 import_constants = require("@phantom/constants");
+
+// src/utils/browser-detection.ts
+function parseBrowserFromUserAgent(userAgent, hasBraveAPI) {
+  let name = "unknown";
+  let version = "unknown";
+  if (!userAgent || typeof userAgent !== "string") {
+    return { name, version, userAgent: "unknown" };
+  }
+  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];
+    }
+    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) {
+  }
+  return { name, version, userAgent };
+}
+function detectBrowser() {
+  if (typeof window === "undefined" || !window.navigator?.userAgent) {
+    return { name: "unknown", version: "unknown", userAgent: "unknown" };
+  }
+  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;
+}
+function isMobileDevice() {
+  if (typeof window === "undefined" || !window.navigator?.userAgent) {
+    return false;
+  }
+  const userAgent = window.navigator.userAgent.toLowerCase();
+  const mobilePatterns = [
+    /android/,
+    /iphone|ipad|ipod/,
+    /blackberry/,
+    /windows phone/,
+    /mobile/,
+    /tablet/,
+    /silk/,
+    /kindle/,
+    /opera mini/,
+    /opera mobi/
+  ];
+  const isMobileUA = mobilePatterns.some((pattern) => pattern.test(userAgent));
+  let isSmallScreen = false;
+  try {
+    isSmallScreen = window.screen.width <= 768 || window.screen.height <= 768;
+  } catch (error) {
+    isSmallScreen = false;
+  }
+  let isTouchDevice = false;
+  try {
+    isTouchDevice = "ontouchstart" in window || navigator.maxTouchPoints > 0;
+  } catch (error) {
+    isTouchDevice = false;
+  }
+  return isMobileUA || isSmallScreen && isTouchDevice;
+}
 
 // src/providers/embedded/adapters/auth.ts
 var BrowserAuthProvider = class {
   constructor(urlParamsAccessor) {
     this.urlParamsAccessor = urlParamsAccessor;
   }
+  getValidatedCurrentUrl() {
+    const currentUrl = window.location.href;
+    if (!currentUrl.startsWith("http:") && !currentUrl.startsWith("https:")) {
+      throw new Error("Invalid URL protocol - only HTTP/HTTPS URLs are supported");
+    }
+    return currentUrl;
+  }
   authenticate(options) {
     return new Promise((resolve) => {
       if ("jwtToken" in options) {
@@ -824,22 +1186,24 @@ var BrowserAuthProvider = class {
       }
       const phantomOptions = options;
       debug.info(DebugCategory.PHANTOM_CONNECT_AUTH, "Starting Phantom Connect authentication", {
-        organizationId: phantomOptions.organizationId,
-        parentOrganizationId: phantomOptions.parentOrganizationId,
+        publicKey: phantomOptions.publicKey,
         appId: phantomOptions.appId,
         provider: phantomOptions.provider,
-        authUrl: phantomOptions.authUrl,
-        hasCustomData: !!phantomOptions.customAuthData
+        authUrl: phantomOptions.authUrl
       });
-      const baseUrl = phantomOptions.authUrl || DEFAULT_AUTH_URL;
+      const baseUrl = phantomOptions.authUrl || import_constants.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,
+        public_key: phantomOptions.publicKey,
         app_id: phantomOptions.appId,
-        redirect_uri: phantomOptions.redirectUrl || (typeof window !== "undefined" ? window.location.href : ""),
+        redirect_uri: phantomOptions.redirectUrl || (typeof window !== "undefined" ? this.getValidatedCurrentUrl() : ""),
         session_id: phantomOptions.sessionId,
-        clear_previous_session: true.toString()
+        // OAuth session management - defaults to allow refresh unless explicitly clearing after logout
+        clear_previous_session: (phantomOptions.clearPreviousSession ?? false).toString(),
+        allow_refresh: (phantomOptions.allowRefresh ?? true).toString(),
+        sdk_version: "1.0.0-beta.21",
+        sdk_type: "browser",
+        platform: detectBrowser().name
       });
       if (phantomOptions.provider) {
         debug.log(DebugCategory.PHANTOM_CONNECT_AUTH, "Provider specified, will skip selection", {
@@ -850,13 +1214,8 @@ var BrowserAuthProvider = class {
         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,
+        publicKey: phantomOptions.publicKey,
         appId: phantomOptions.appId,
         provider: phantomOptions.provider,
         sessionId: phantomOptions.sessionId
@@ -865,6 +1224,9 @@ var BrowserAuthProvider = class {
       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 });
+      if (!authUrl.startsWith("https:") && !authUrl.startsWith("http://localhost")) {
+        throw new Error("Invalid auth URL - only HTTPS URLs are allowed for authentication");
+      }
       window.location.href = authUrl;
       resolve();
     });
@@ -920,10 +1282,32 @@ var BrowserAuthProvider = class {
         sessionId,
         accountDerivationIndex: accountDerivationIndex ? parseInt(accountDerivationIndex) : void 0
       });
+      const organizationId = this.urlParamsAccessor.getParam("organization_id");
+      const expiresInMs = this.urlParamsAccessor.getParam("expires_in_ms");
+      const authUserId = this.urlParamsAccessor.getParam("auth_user_id");
+      debug.log(DebugCategory.PHANTOM_CONNECT_AUTH, "Auth redirect parameters", {
+        walletId,
+        organizationId,
+        sessionId,
+        accountDerivationIndex,
+        expiresInMs,
+        authUserId
+      });
+      if (!organizationId) {
+        debug.error(DebugCategory.PHANTOM_CONNECT_AUTH, "Missing organization_id in auth response");
+        throw new Error("Missing organization_id in auth response");
+      }
+      if (organizationId.startsWith("temp-")) {
+        debug.warn(DebugCategory.PHANTOM_CONNECT_AUTH, "Received temporary organization_id, server may not be configured properly", {
+          organizationId
+        });
+      }
       return {
         walletId,
-        userInfo: context,
-        accountDerivationIndex: accountDerivationIndex ? parseInt(accountDerivationIndex) : void 0
+        organizationId,
+        accountDerivationIndex: accountDerivationIndex ? parseInt(accountDerivationIndex) : 0,
+        expiresInMs: expiresInMs ? parseInt(expiresInMs) : 0,
+        authUserId: authUserId || void 0
       };
     } catch (error) {
       sessionStorage.removeItem("phantom-auth-context");
@@ -932,6 +1316,105 @@ var BrowserAuthProvider = class {
   }
 };
 
+// src/providers/embedded/adapters/phantom-app.ts
+var import_browser_injected_sdk3 = require("@phantom/browser-injected-sdk");
+
+// src/isPhantomLoginAvailable.ts
+var import_browser_injected_sdk2 = require("@phantom/browser-injected-sdk");
+async function isPhantomLoginAvailable(timeoutMs = 3e3) {
+  const extensionInstalled = await waitForExtension(timeoutMs);
+  if (!extensionInstalled) {
+    return false;
+  }
+  try {
+    if (!window.phantom?.app?.features || typeof window.phantom.app.features !== "function") {
+      return false;
+    }
+    const response = await window.phantom.app.features();
+    if (!Array.isArray(response.features)) {
+      return false;
+    }
+    return response.features.includes("phantom_login");
+  } catch (error) {
+    console.error("Error checking Phantom extension features", error);
+    return false;
+  }
+}
+async function waitForExtension(timeoutMs) {
+  return new Promise((resolve) => {
+    const startTime = Date.now();
+    const checkInterval = 100;
+    const checkForExtension = () => {
+      try {
+        if ((0, import_browser_injected_sdk2.isPhantomExtensionInstalled)()) {
+          resolve(true);
+          return;
+        }
+      } catch (error) {
+      }
+      const elapsed = Date.now() - startTime;
+      if (elapsed >= timeoutMs) {
+        resolve(false);
+        return;
+      }
+      setTimeout(checkForExtension, checkInterval);
+    };
+    checkForExtension();
+  });
+}
+
+// src/providers/embedded/adapters/phantom-app.ts
+var BrowserPhantomAppProvider = class {
+  /**
+   * Check if the Phantom extension is installed in the browser
+   */
+  isAvailable() {
+    return (0, import_browser_injected_sdk3.isPhantomExtensionInstalled)();
+  }
+  /**
+   * Authenticate using the Phantom browser extension
+   */
+  async authenticate(options) {
+    if (!this.isAvailable()) {
+      throw new Error(
+        "Phantom extension is not installed. Please install the Phantom browser extension to use this authentication method."
+      );
+    }
+    const loginAvailable = await isPhantomLoginAvailable();
+    if (!loginAvailable) {
+      throw new Error(
+        "Phantom Login is not available. Please update your Phantom extension to use this authentication method."
+      );
+    }
+    try {
+      if (!window.phantom?.app?.login) {
+        throw new Error("Phantom extension login method not found");
+      }
+      const result = await window.phantom.app.login({
+        publicKey: options.publicKey,
+        appId: options.appId,
+        sessionId: options.sessionId
+      });
+      if (!result || !result.walletId || !result.organizationId) {
+        throw new Error("Invalid authentication response from Phantom extension");
+      }
+      return {
+        walletId: result.walletId,
+        organizationId: result.organizationId,
+        provider: "phantom",
+        accountDerivationIndex: result.accountDerivationIndex ?? 0,
+        expiresInMs: result.expiresInMs ?? 0,
+        authUserId: result.authUserId
+      };
+    } catch (error) {
+      if (error instanceof Error) {
+        throw error;
+      }
+      throw new Error(`Phantom extension authentication failed: ${String(error)}`);
+    }
+  }
+};
+
 // src/providers/embedded/adapters/logger.ts
 var BrowserLogger = class {
   info(category, message, data) {
@@ -948,131 +1431,38 @@ var BrowserLogger = class {
   }
 };
 
-// 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];
-    }
-    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) {
-  }
-  return { name, version };
-}
-function detectBrowser() {
-  if (typeof window === "undefined" || !window.navigator?.userAgent) {
-    return { name: "unknown", version: "unknown" };
-  }
-  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 import_constants2 = require("@phantom/constants");
 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}`,
+      dbName: `phantom-embedded-sdk-${config.appId}`,
       storeName: "crypto-keys",
       keyName: "signing-key"
     });
     const platformName = getPlatformName();
+    const { name: browserName, version } = detectBrowser();
     const platform = {
       storage: new BrowserStorage(),
       authProvider: new BrowserAuthProvider(urlParamsAccessor),
+      phantomAppProvider: new BrowserPhantomAppProvider(),
       urlParamsAccessor,
       stamper,
-      name: platformName
+      name: platformName,
       // Use detected browser name and version for identification
+      analyticsHeaders: {
+        [import_constants2.ANALYTICS_HEADERS.SDK_TYPE]: "browser",
+        [import_constants2.ANALYTICS_HEADERS.PLATFORM]: browserName,
+        // firefox, chrome, safari, etc.
+        [import_constants2.ANALYTICS_HEADERS.PLATFORM_VERSION]: version,
+        // Full user agent for more detailed info
+        [import_constants2.ANALYTICS_HEADERS.APP_ID]: config.appId,
+        [import_constants2.ANALYTICS_HEADERS.WALLET_TYPE]: config.embeddedWalletType,
+        [import_constants2.ANALYTICS_HEADERS.SDK_VERSION]: "1.0.0-beta.21"
+        // Replaced at build time
+      }
     };
     debug.log(DebugCategory.EMBEDDED_PROVIDER, "Detected platform", { platformName });
     const logger = new BrowserLogger();
@@ -1081,6 +1471,26 @@ var EmbeddedProvider = class extends import_embedded_provider_core.EmbeddedProvi
   }
 };
 
+// src/ProviderManager.ts
+var import_constants3 = require("@phantom/constants");
+
+// src/utils/auth-callback.ts
+function isAuthFailureCallback(searchParams) {
+  if (typeof window === "undefined" && !searchParams)
+    return false;
+  const params = searchParams || new URLSearchParams(window.location.search);
+  const responseType = params.get("response_type");
+  const sessionId = params.get("session_id");
+  return responseType === "failure" && !!sessionId;
+}
+function isAuthCallbackUrl(searchParams) {
+  if (typeof window === "undefined" && !searchParams)
+    return false;
+  const params = searchParams || new URLSearchParams(window.location.search);
+  const sessionId = params.get("session_id");
+  return !!(sessionId && (params.has("response_type") || params.has("wallet_id")));
+}
+
 // src/ProviderManager.ts
 var ProviderManager = class {
   // Track which providers have forwarding set up
@@ -1088,7 +1498,6 @@ var ProviderManager = class {
     this.providers = /* @__PURE__ */ new Map();
     this.currentProvider = null;
     this.currentProviderKey = null;
-    this.walletId = null;
     // Event management for forwarding provider events
     this.eventListeners = /* @__PURE__ */ new Map();
     this.providerForwardingSetup = /* @__PURE__ */ new WeakSet();
@@ -1100,6 +1509,15 @@ var ProviderManager = class {
       currentProviderKey: this.currentProviderKey
     });
   }
+  getValidatedCurrentUrl() {
+    if (typeof window === "undefined")
+      return "";
+    const currentUrl = window.location.href;
+    if (!currentUrl.startsWith("http:") && !currentUrl.startsWith("https:")) {
+      throw new Error("Invalid URL protocol - only HTTP/HTTPS URLs are supported");
+    }
+    return currentUrl;
+  }
   /**
    * Switch to a different provider type
    */
@@ -1115,7 +1533,6 @@ var ProviderManager = class {
     }
     this.currentProvider = this.providers.get(key);
     this.currentProviderKey = key;
-    this.walletId = null;
     this.ensureProviderEventForwarding();
     return this.currentProvider;
   }
@@ -1131,7 +1548,8 @@ var ProviderManager = class {
   getCurrentProviderInfo() {
     if (!this.currentProviderKey)
       return null;
-    const [type, embeddedWalletType] = this.currentProviderKey.split("-");
+    const parts = this.currentProviderKey.split("-");
+    const [type, embeddedWalletType] = parts;
     return {
       type,
       embeddedWalletType
@@ -1139,27 +1557,51 @@ var ProviderManager = class {
   }
   /**
    * Connect using the current provider
+   * Automatically switches provider based on authOptions.provider
    */
   async connect(authOptions) {
     debug.info(DebugCategory.PROVIDER_MANAGER, "Starting connection", {
       currentProviderKey: this.currentProviderKey,
-      authOptions: authOptions ? { provider: authOptions.provider, hasJwtToken: !!authOptions.jwtToken } : void 0
+      authOptions: { provider: authOptions.provider, hasJwtToken: !!authOptions.jwtToken }
     });
+    const requestedProvider = authOptions.provider;
+    let targetProviderType = null;
+    if (requestedProvider === "injected") {
+      targetProviderType = "injected";
+    } else if (["google", "apple", "jwt", "phantom"].includes(requestedProvider)) {
+      targetProviderType = "embedded";
+    }
+    if (targetProviderType) {
+      const currentInfo = this.getCurrentProviderInfo();
+      if (currentInfo?.type !== targetProviderType) {
+        debug.log(DebugCategory.PROVIDER_MANAGER, "Auto-switching provider based on auth options", {
+          from: currentInfo?.type,
+          to: targetProviderType,
+          requestedProvider
+        });
+        const switchOptions = {};
+        if (targetProviderType === "embedded") {
+          switchOptions.embeddedWalletType = currentInfo?.embeddedWalletType || this.config.embeddedWalletType;
+        }
+        this.switchProvider(targetProviderType, switchOptions);
+      }
+    }
     if (!this.currentProvider) {
       debug.error(DebugCategory.PROVIDER_MANAGER, "No provider selected");
       throw new Error("No provider selected");
     }
     debug.log(DebugCategory.PROVIDER_MANAGER, "Delegating to provider connect method");
     const result = await this.currentProvider.connect(authOptions);
-    this.walletId = result.walletId || null;
+    const providerInfo = this.getCurrentProviderInfo();
+    result.providerType = providerInfo?.type;
     debug.log(DebugCategory.PROVIDER_MANAGER, "Connection successful, saving preferences", {
-      walletId: this.walletId,
-      addressCount: result.addresses?.length || 0
+      addressCount: result.addresses?.length || 0,
+      providerType: result.providerType
     });
     this.saveProviderPreference();
     debug.info(DebugCategory.PROVIDER_MANAGER, "Connect completed", {
-      walletId: this.walletId,
-      addresses: result.addresses
+      addresses: result.addresses,
+      providerType: result.providerType
     });
     return result;
   }
@@ -1170,7 +1612,6 @@ var ProviderManager = class {
     if (!this.currentProvider)
       return;
     await this.currentProvider.disconnect();
-    this.walletId = null;
   }
   /**
    * Get addresses from current provider
@@ -1188,10 +1629,69 @@ var ProviderManager = class {
     return this.currentProvider?.isConnected() ?? false;
   }
   /**
-   * Get current wallet ID
+   * Attempt auto-connect with fallback strategy
+   * Tries embedded provider first if it exists, then injected provider
+   * Returns true if any provider successfully connected
    */
-  getWalletId() {
-    return this.walletId;
+  async autoConnect() {
+    debug.log(DebugCategory.PROVIDER_MANAGER, "Starting auto-connect with fallback strategy");
+    if (isAuthFailureCallback()) {
+      debug.warn(DebugCategory.PROVIDER_MANAGER, "Auth failure detected in URL, skipping autoConnect fallback");
+      return false;
+    }
+    const embeddedWalletType = this.config.embeddedWalletType || "user-wallet";
+    const embeddedKey = this.getProviderKey("embedded", embeddedWalletType);
+    if (this.providers.has(embeddedKey)) {
+      debug.log(DebugCategory.PROVIDER_MANAGER, "Trying auto-connect with existing embedded provider");
+      const embeddedProvider = this.providers.get(embeddedKey);
+      try {
+        const previousProvider = this.currentProvider;
+        const previousKey = this.currentProviderKey;
+        this.currentProvider = embeddedProvider;
+        this.currentProviderKey = embeddedKey;
+        this.ensureProviderEventForwarding();
+        await embeddedProvider.autoConnect();
+        if (embeddedProvider.isConnected()) {
+          debug.info(DebugCategory.PROVIDER_MANAGER, "Embedded auto-connect successful");
+          this.saveProviderPreference();
+          return true;
+        } else {
+          debug.log(DebugCategory.PROVIDER_MANAGER, "Embedded provider did not connect, restoring previous provider");
+          this.currentProvider = previousProvider;
+          this.currentProviderKey = previousKey;
+        }
+      } catch (error) {
+        debug.log(DebugCategory.PROVIDER_MANAGER, "Embedded auto-connect failed", {
+          error: error.message
+        });
+        if (isAuthCallbackUrl()) {
+          debug.log(DebugCategory.PROVIDER_MANAGER, "In auth callback URL, not attempting injected fallback");
+          return false;
+        }
+      }
+    }
+    const injectedKey = this.getProviderKey("injected");
+    if (this.providers.has(injectedKey)) {
+      debug.log(DebugCategory.PROVIDER_MANAGER, "Trying auto-connect with existing injected provider");
+      const injectedProvider = this.providers.get(injectedKey);
+      try {
+        this.currentProvider = injectedProvider;
+        this.currentProviderKey = injectedKey;
+        this.ensureProviderEventForwarding();
+        await injectedProvider.autoConnect();
+        if (injectedProvider.isConnected()) {
+          debug.info(DebugCategory.PROVIDER_MANAGER, "Injected auto-connect successful");
+          this.saveProviderPreference();
+          return true;
+        }
+      } catch (error) {
+        debug.log(DebugCategory.PROVIDER_MANAGER, "Injected auto-connect failed", {
+          error: error.message
+        });
+      }
+    }
+    debug.log(DebugCategory.PROVIDER_MANAGER, "Auto-connect failed for all existing providers");
+    return false;
   }
   /**
    * Add event listener - stores callback and ensures current provider forwards events to ProviderManager
@@ -1274,12 +1774,22 @@ var ProviderManager = class {
   }
   /**
    * Set default provider based on initial config
+   * Creates both embedded and injected providers for autoConnect fallback
    */
   setDefaultProvider() {
     const defaultType = this.config.providerType || "embedded";
-    const defaultEmbeddedType = this.config.embeddedWalletType || "app-wallet";
-    this.createProvider(defaultType, defaultEmbeddedType);
-    this.switchProvider(defaultType, { embeddedWalletType: defaultEmbeddedType });
+    const defaultEmbeddedType = this.config.embeddedWalletType || "user-wallet";
+    if (this.config.appId) {
+      debug.log(DebugCategory.PROVIDER_MANAGER, "Creating embedded provider");
+      this.createProvider("embedded", defaultEmbeddedType);
+    }
+    debug.log(DebugCategory.PROVIDER_MANAGER, "Creating injected provider");
+    this.createProvider("injected");
+    const switchOptions = {};
+    if (defaultType === "embedded") {
+      switchOptions.embeddedWalletType = defaultEmbeddedType;
+    }
+    this.switchProvider(defaultType, switchOptions);
   }
   /**
    * Create a provider instance
@@ -1291,22 +1801,27 @@ var ProviderManager = class {
     let provider;
     if (type === "injected") {
       provider = new InjectedProvider({
-        solanaProvider: this.config.solanaProvider || "web3js",
-        addressTypes: this.config.addressTypes
+        addressTypes: this.config.addressTypes || [import_client.AddressType.solana]
       });
-    } else {
-      if (!this.config.apiBaseUrl || !this.config.appId) {
-        throw new Error("apiBaseUrl and appId are required for embedded provider");
+    } else if (type === "embedded") {
+      if (!this.config.appId) {
+        throw new Error("appId is required for embedded provider");
       }
+      const apiBaseUrl = this.config.apiBaseUrl || import_constants3.DEFAULT_WALLET_API_URL;
+      const authUrl = this.config.authOptions?.authUrl || import_constants3.DEFAULT_AUTH_URL;
       provider = new EmbeddedProvider({
-        apiBaseUrl: this.config.apiBaseUrl,
-        organizationId: this.config.appId,
+        apiBaseUrl,
         appId: this.config.appId,
-        authOptions: this.config.authOptions,
-        embeddedWalletType: embeddedWalletType || "app-wallet",
-        addressTypes: this.config.addressTypes,
-        solanaProvider: this.config.solanaProvider || "web3js"
+        authOptions: {
+          ...this.config.authOptions || {},
+          authUrl,
+          redirectUrl: this.config.authOptions?.redirectUrl || this.getValidatedCurrentUrl()
+        },
+        embeddedWalletType: embeddedWalletType || import_constants3.DEFAULT_EMBEDDED_WALLET_TYPE,
+        addressTypes: this.config.addressTypes || [import_client.AddressType.solana]
       });
+    } else {
+      throw new Error(`Unsupported provider type: ${type}`);
     }
     this.providers.set(key, provider);
   }
@@ -1316,8 +1831,10 @@ var ProviderManager = class {
   getProviderKey(type, embeddedWalletType) {
     if (type === "injected") {
       return "injected";
+    } else if (type === "embedded") {
+      return `embedded-${embeddedWalletType || "app-wallet"}`;
     }
-    return `embedded-${embeddedWalletType || "app-wallet"}`;
+    throw new Error(`Unsupported provider type: ${type}`);
   }
   /**
    * Save provider preference to localStorage
@@ -1332,35 +1849,17 @@ var ProviderManager = class {
       console.error("Failed to save provider preference:", error);
     }
   }
-  /**
-   * Restore provider preference from localStorage
-   */
-  /*
-  private restoreProviderPreference(): void {
-    try {
-      const saved = localStorage.getItem("phantom-provider-preference");
-      if (saved) {
-        const preference: ProviderPreference = JSON.parse(saved);
-        this.switchProvider(preference.type, {
-          embeddedWalletType: preference.embeddedWalletType,
-        });
-      }
-    } catch (error) {
-      // Ignore localStorage errors - just use default provider
-      console.error("Failed to restore provider preference:", error);
-    }
-  }*/
 };
 
 // src/waitForPhantomExtension.ts
-var import_browser_injected_sdk2 = require("@phantom/browser-injected-sdk");
+var import_browser_injected_sdk4 = require("@phantom/browser-injected-sdk");
 async function waitForPhantomExtension(timeoutMs = 3e3) {
   return new Promise((resolve) => {
     const startTime = Date.now();
     const checkInterval = 100;
     const checkForExtension = () => {
       try {
-        if ((0, import_browser_injected_sdk2.isPhantomExtensionInstalled)()) {
+        if ((0, import_browser_injected_sdk4.isPhantomExtensionInstalled)()) {
           resolve(true);
           return;
         }
@@ -1378,6 +1877,7 @@ async function waitForPhantomExtension(timeoutMs = 3e3) {
 }
 
 // src/BrowserSDK.ts
+var import_constants4 = require("@phantom/constants");
 var BrowserSDK = class {
   constructor(config) {
     debug.info(DebugCategory.BROWSER_SDK, "Initializing BrowserSDK", {
@@ -1389,7 +1889,7 @@ var BrowserSDK = class {
       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";
+    const embeddedWalletType = config.embeddedWalletType || import_constants4.DEFAULT_EMBEDDED_WALLET_TYPE;
     if (config.providerType === "embedded" && !["app-wallet", "user-wallet"].includes(embeddedWalletType)) {
       debug.error(DebugCategory.BROWSER_SDK, "Invalid embeddedWalletType", {
         embeddedWalletType: config.embeddedWalletType
@@ -1431,7 +1931,6 @@ var BrowserSDK = class {
       const result = await this.providerManager.connect(options);
       debug.info(DebugCategory.BROWSER_SDK, "Connection successful", {
         addressCount: result.addresses.length,
-        walletId: result.walletId,
         status: result.status
       });
       return result;
@@ -1453,22 +1952,6 @@ var BrowserSDK = class {
       throw error;
     }
   }
-  /**
-   * Switch between provider types (injected vs embedded)
-   */
-  async switchProvider(type, options) {
-    debug.info(DebugCategory.BROWSER_SDK, "Switching provider", { type, options });
-    try {
-      await this.providerManager.switchProvider(type, options);
-      debug.info(DebugCategory.BROWSER_SDK, "Provider switch successful", { type });
-    } catch (error) {
-      debug.error(DebugCategory.BROWSER_SDK, "Provider switch failed", {
-        type,
-        error: error.message
-      });
-      throw error;
-    }
-  }
   // ===== STATE QUERIES =====
   /**
    * Check if the SDK is connected to a wallet
@@ -1488,12 +1971,6 @@ var BrowserSDK = class {
   getCurrentProviderInfo() {
     return this.providerManager.getCurrentProviderInfo();
   }
-  /**
-   * Get the wallet ID (for embedded wallets)
-   */
-  getWalletId() {
-    return this.providerManager.getWalletId();
-  }
   // ===== UTILITY METHODS =====
   /**
    * Check if Phantom extension is installed
@@ -1520,17 +1997,17 @@ var BrowserSDK = class {
   /**
    * Attempt auto-connection using existing session
    * Should be called after setting up event listeners
-   * Only works with embedded providers
+   * Tries embedded provider first, then injected provider as fallback
    */
   async autoConnect() {
-    debug.log(DebugCategory.BROWSER_SDK, "Attempting auto-connect");
-    const currentProvider = this.providerManager.getCurrentProvider();
-    if (currentProvider && "autoConnect" in currentProvider) {
-      await currentProvider.autoConnect();
-    } else {
-      debug.warn(DebugCategory.BROWSER_SDK, "Current provider does not support auto-connect", {
+    debug.log(DebugCategory.BROWSER_SDK, "Attempting auto-connect with fallback strategy");
+    const result = await this.providerManager.autoConnect();
+    if (result) {
+      debug.info(DebugCategory.BROWSER_SDK, "Auto-connect successful", {
         providerType: this.getCurrentProviderInfo()?.type
       });
+    } else {
+      debug.log(DebugCategory.BROWSER_SDK, "Auto-connect failed for all providers");
     }
   }
   /**
@@ -1674,9 +2151,16 @@ var BrowserSDK = class {
   }
 };
 
-// src/types.ts
-var import_client4 = require("@phantom/client");
+// src/utils/deeplink.ts
+function getDeeplinkToPhantom(ref) {
+  if (!window.location.href.startsWith("http:") && !window.location.href.startsWith("https:")) {
+    throw new Error("Invalid URL protocol - only HTTP/HTTPS URLs are supported for deeplinks");
+  }
+  const currentUrl = encodeURIComponent(window.location.href);
+  const refParam = ref ? `?ref=${encodeURIComponent(ref)}` : "";
+  return `https://phantom.app/ul/browse/${currentUrl}${refParam}`;
+}
 
 // src/index.ts
-var import_constants2 = require("@phantom/constants");
+var import_constants5 = require("@phantom/constants");
 var import_client5 = require("@phantom/client");