@phantom/browser-sdk 1.0.0-beta.8 → 1.0.0

package/dist/index.mjs

@@ -2,13 +2,7 @@
 import { AddressType } from "@phantom/client";
 
 // src/providers/injected/index.ts
-import { AddressType as AddressType4 } from "@phantom/client";
-import { createPhantom, createExtensionPlugin } from "@phantom/browser-injected-sdk";
-import { createSolanaPlugin } from "@phantom/browser-injected-sdk/solana";
-import { createEthereumPlugin } from "@phantom/browser-injected-sdk/ethereum";
-import {
-  createAutoConfirmPlugin
-} from "@phantom/browser-injected-sdk/auto-confirm";
+import { AddressType as AddressType2 } from "@phantom/client";
 
 // src/debug.ts
 var DebugLevel = /* @__PURE__ */ ((DebugLevel2) => {
@@ -84,135 +78,604 @@ var DebugCategory = {
   SESSION: "Session"
 };
 
-// src/providers/injected/chains/SolanaChain.ts
+// src/wallets/discovery.ts
+import { AddressType as ClientAddressType } from "@phantom/client";
+import { isPhantomExtensionInstalled } from "@phantom/browser-injected-sdk";
+import { createPhantom, createExtensionPlugin } from "@phantom/browser-injected-sdk";
+import { createSolanaPlugin } from "@phantom/browser-injected-sdk/solana";
+import { createEthereumPlugin } from "@phantom/browser-injected-sdk/ethereum";
+import { createAutoConfirmPlugin } from "@phantom/browser-injected-sdk/auto-confirm";
+function generateWalletIdFromEIP6963(info) {
+  if (info.rdns) {
+    return info.rdns.split(".").reverse().join("-");
+  }
+  return info.name.toLowerCase().replace(/\s+/g, "-");
+}
+function generateWalletIdFromName(name) {
+  return name.toLowerCase().replace(/\s+/g, "-");
+}
+function processEIP6963Providers(providers) {
+  const wallets = [];
+  debug.log(DebugCategory.BROWSER_SDK, "Processing EIP-6963 providers", {
+    providerCount: providers.size,
+    providerNames: Array.from(providers.values()).map((d) => d.info.name)
+  });
+  for (const [, detail] of providers) {
+    const { info, provider } = detail;
+    const isPhantom = info.name.toLowerCase().includes("phantom") || info.rdns && (info.rdns.toLowerCase().includes("phantom") || info.rdns.toLowerCase() === "app.phantom");
+    if (isPhantom) {
+      debug.log(DebugCategory.BROWSER_SDK, "Skipping Phantom from EIP-6963", { name: info.name, rdns: info.rdns });
+      continue;
+    }
+    const walletId = generateWalletIdFromEIP6963(info);
+    debug.log(DebugCategory.BROWSER_SDK, "Discovered EIP-6963 wallet", {
+      walletId,
+      walletName: info.name,
+      rdns: info.rdns
+    });
+    wallets.push({
+      id: walletId,
+      name: info.name,
+      icon: info.icon,
+      addressTypes: [ClientAddressType.ethereum],
+      providers: {
+        // EIP-6963 provider implements EIP-1193 interface (IEthereumChain)
+        ethereum: provider
+      },
+      rdns: info.rdns,
+      // Store rdns for potential future matching
+      discovery: "eip6963"
+    });
+  }
+  debug.log(DebugCategory.BROWSER_SDK, "EIP-6963 discovery completed", {
+    discoveredCount: wallets.length,
+    walletIds: wallets.map((w) => w.id)
+  });
+  return wallets;
+}
+function discoverEthereumWallets() {
+  return new Promise((resolve) => {
+    const discoveredProviders = /* @__PURE__ */ new Map();
+    if (typeof window === "undefined") {
+      resolve([]);
+      return;
+    }
+    const handleAnnounce = (event) => {
+      const detail = event.detail;
+      if (detail?.info && detail?.provider) {
+        discoveredProviders.set(detail.info.uuid, detail);
+      }
+    };
+    window.addEventListener("eip6963:announceProvider", handleAnnounce);
+    window.dispatchEvent(new Event("eip6963:requestProvider"));
+    const processProviders = () => {
+      const wallets = processEIP6963Providers(discoveredProviders);
+      window.removeEventListener("eip6963:announceProvider", handleAnnounce);
+      resolve(wallets);
+    };
+    setTimeout(processProviders, 400);
+  });
+}
+async function discoverSolanaWallets() {
+  const wallets = [];
+  if (typeof window === "undefined" || typeof navigator === "undefined") {
+    debug.log(DebugCategory.BROWSER_SDK, "Wallet Standard discovery skipped (not in browser environment)");
+    return wallets;
+  }
+  const registeredWalletsSet = /* @__PURE__ */ new Set();
+  let cachedWalletsArray;
+  function addRegisteredWallet(wallet) {
+    cachedWalletsArray = void 0;
+    registeredWalletsSet.add(wallet);
+    const featureKeys = wallet.features ? Object.keys(wallet.features) : [];
+    debug.log(DebugCategory.BROWSER_SDK, "Wallet registered", {
+      name: wallet.name,
+      chains: wallet.chains,
+      featureKeys,
+      totalWallets: registeredWalletsSet.size
+    });
+  }
+  function removeRegisteredWallet(wallet) {
+    cachedWalletsArray = void 0;
+    registeredWalletsSet.delete(wallet);
+  }
+  function getRegisteredWallets() {
+    if (!cachedWalletsArray) {
+      cachedWalletsArray = [...registeredWalletsSet];
+    }
+    return cachedWalletsArray;
+  }
+  function register(...wallets2) {
+    wallets2 = wallets2.filter((wallet) => !registeredWalletsSet.has(wallet));
+    if (!wallets2.length) {
+      return () => {
+      };
+    }
+    wallets2.forEach((wallet) => addRegisteredWallet(wallet));
+    return function unregister() {
+      wallets2.forEach((wallet) => removeRegisteredWallet(wallet));
+    };
+  }
+  const registerAPI = Object.freeze({ register });
+  const handleRegisterWalletEvent = (event) => {
+    const callback = event.detail;
+    if (typeof callback === "function") {
+      try {
+        callback(registerAPI);
+      } catch (error) {
+        debug.warn(DebugCategory.BROWSER_SDK, "Error calling wallet registration callback", { error });
+      }
+    }
+  };
+  try {
+    window.addEventListener("wallet-standard:register-wallet", handleRegisterWalletEvent);
+  } catch (error) {
+    debug.warn(DebugCategory.BROWSER_SDK, "Could not add register-wallet event listener", { error });
+  }
+  class AppReadyEvent extends Event {
+    constructor(api) {
+      super("wallet-standard:app-ready", {
+        bubbles: false,
+        cancelable: false,
+        composed: false
+      });
+      this.detail = api;
+    }
+  }
+  try {
+    window.dispatchEvent(new AppReadyEvent(registerAPI));
+    debug.log(DebugCategory.BROWSER_SDK, "Dispatched wallet-standard:app-ready event");
+  } catch (error) {
+    debug.warn(DebugCategory.BROWSER_SDK, "Could not dispatch app-ready event", { error });
+  }
+  const walletsAPI = {
+    getWallets: () => {
+      return {
+        get: getRegisteredWallets,
+        on: (_event, _listener) => {
+          return () => {
+          };
+        },
+        register
+      };
+    }
+  };
+  if (!navigator.wallets) {
+    navigator.wallets = walletsAPI;
+  }
+  debug.log(DebugCategory.BROWSER_SDK, "Initialized Wallet Standard registry");
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  const existingWalletsAPI = navigator.wallets || window.wallets;
+  if (!existingWalletsAPI || typeof existingWalletsAPI.getWallets !== "function") {
+    const logData = {
+      hasNavigator: !!navigator,
+      hasWindow: typeof window !== "undefined",
+      note: "Wallet Standard API not properly initialized"
+    };
+    debug.log(DebugCategory.BROWSER_SDK, "Wallet Standard API not available", logData);
+    return wallets;
+  }
+  const walletsGetter = existingWalletsAPI.getWallets();
+  const getWalletsFn = () => Promise.resolve([...walletsGetter.get()]);
+  debug.log(DebugCategory.BROWSER_SDK, "Wallet Standard API detected, starting discovery");
+  try {
+    let registeredWallets = [];
+    let attempts = 0;
+    const maxAttempts = 5;
+    const initialDelay = 100;
+    const eip6963Timeout = 400;
+    await new Promise((resolve) => setTimeout(resolve, initialDelay));
+    while (attempts < maxAttempts) {
+      registeredWallets = await getWalletsFn();
+      const logData = {
+        attempt: attempts + 1,
+        walletCount: registeredWallets.length,
+        walletNames: registeredWallets.map((w) => w.name),
+        chains: registeredWallets.flatMap((w) => w.chains)
+      };
+      debug.log(DebugCategory.BROWSER_SDK, `Wallet Standard getWallets attempt ${attempts + 1}`, logData);
+      if (registeredWallets.length > 0 || attempts === maxAttempts - 1) {
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, initialDelay));
+      attempts++;
+    }
+    const totalWaitTime = initialDelay + attempts * initialDelay;
+    if (totalWaitTime < eip6963Timeout) {
+      const remainingWait = eip6963Timeout - totalWaitTime;
+      await new Promise((resolve) => setTimeout(resolve, remainingWait));
+      registeredWallets = await getWalletsFn();
+    }
+    debug.log(DebugCategory.BROWSER_SDK, "Wallet Standard getWallets final result", {
+      walletCount: registeredWallets.length,
+      walletNames: registeredWallets.map((w) => w.name),
+      attempts: attempts + 1
+    });
+    for (const wallet of registeredWallets) {
+      const supportsSolana = wallet.chains.some((chain) => {
+        const chainLower = chain.toLowerCase();
+        return chainLower.startsWith("solana:") || chainLower === "solana";
+      }) || wallet.features && typeof wallet.features === "object" && Object.keys(wallet.features).some((featureKey) => {
+        const featureLower = featureKey.toLowerCase();
+        return featureLower.includes("solana") || featureLower.includes("standard:connect") || featureLower.includes("standard:signTransaction");
+      });
+      if (!supportsSolana) {
+        const featureKeys = wallet.features ? Object.keys(wallet.features) : [];
+        debug.log(DebugCategory.BROWSER_SDK, "Wallet does not support Solana", {
+          walletName: wallet.name,
+          chains: wallet.chains,
+          featureKeys
+        });
+        continue;
+      }
+      if (wallet.name.toLowerCase().includes("phantom")) {
+        debug.log(DebugCategory.BROWSER_SDK, "Skipping Phantom from Wallet Standard (handled separately)");
+        continue;
+      }
+      const walletId = generateWalletIdFromName(wallet.name);
+      const safeFeatures = wallet.features ? Object.keys(wallet.features) : [];
+      debug.log(DebugCategory.BROWSER_SDK, "Discovered Wallet Standard Solana wallet", {
+        walletId,
+        walletName: wallet.name,
+        chains: wallet.chains,
+        featureKeys: safeFeatures,
+        icon: wallet.icon,
+        version: wallet.version,
+        accountCount: wallet.accounts?.length || 0
+      });
+      wallets.push({
+        id: walletId,
+        name: wallet.name,
+        icon: wallet.icon,
+        addressTypes: [ClientAddressType.solana],
+        providers: {
+          // Cast to ISolanaChain - Wallet Standard wallets have compatible methods
+          // The InjectedWalletSolanaChain wrapper will handle the actual method calls
+          solana: wallet
+        },
+        discovery: "standard"
+      });
+    }
+  } catch (error) {
+    debug.warn(DebugCategory.BROWSER_SDK, "Wallet Standard API error", {
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : void 0
+    });
+  }
+  const finalLogData = {
+    discoveredCount: wallets.length,
+    walletIds: wallets.map((w) => w.id),
+    walletNames: wallets.map((w) => w.name)
+  };
+  debug.log(DebugCategory.BROWSER_SDK, "Wallet Standard Solana discovery completed", finalLogData);
+  return wallets;
+}
+function discoverPhantomWallet(addressTypes) {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  if (!isPhantomExtensionInstalled()) {
+    return null;
+  }
+  const plugins = [createExtensionPlugin()];
+  if (addressTypes.includes(ClientAddressType.solana)) {
+    plugins.push(createSolanaPlugin());
+  }
+  if (addressTypes.includes(ClientAddressType.ethereum)) {
+    plugins.push(createEthereumPlugin());
+  }
+  plugins.push(createAutoConfirmPlugin());
+  const phantomInstance = createPhantom({ plugins });
+  return {
+    id: "phantom",
+    name: "Phantom",
+    icon: void 0,
+    // Icon will be rendered from icons package in UI components
+    addressTypes,
+    providers: {
+      solana: addressTypes.includes(ClientAddressType.solana) ? phantomInstance.solana : void 0,
+      ethereum: addressTypes.includes(ClientAddressType.ethereum) ? phantomInstance.ethereum : void 0
+    },
+    isPhantom: true,
+    phantomInstance,
+    discovery: "phantom"
+  };
+}
+async function discoverWallets(addressTypes) {
+  const requestedAddressTypes = addressTypes || [];
+  debug.log(DebugCategory.BROWSER_SDK, "Starting all wallet discovery methods", {
+    addressTypes: requestedAddressTypes
+  });
+  const [solanaWallets, ethereumWallets] = await Promise.all([discoverSolanaWallets(), discoverEthereumWallets()]);
+  const phantomWallet = discoverPhantomWallet(requestedAddressTypes);
+  debug.log(DebugCategory.BROWSER_SDK, "All wallet discovery methods completed", {
+    phantomFound: !!phantomWallet,
+    solanaWalletsCount: solanaWallets.length,
+    ethereumWalletsCount: ethereumWallets.length,
+    solanaWalletIds: solanaWallets.map((w) => w.id),
+    ethereumWalletIds: ethereumWallets.map((w) => w.id)
+  });
+  const walletMap = /* @__PURE__ */ new Map();
+  if (phantomWallet) {
+    walletMap.set("phantom", phantomWallet);
+  }
+  for (const wallet of [...solanaWallets, ...ethereumWallets]) {
+    const existing = walletMap.get(wallet.id);
+    if (existing) {
+      const mergedAddressTypes = Array.from(/* @__PURE__ */ new Set([...existing.addressTypes, ...wallet.addressTypes]));
+      const mergedProviders = {
+        ...existing.providers,
+        ...wallet.providers
+      };
+      const mergedWallet = {
+        ...existing,
+        addressTypes: mergedAddressTypes,
+        // Prefer icon from the most recent discovery
+        icon: wallet.icon || existing.icon,
+        providers: mergedProviders
+      };
+      walletMap.set(wallet.id, mergedWallet);
+      debug.log(DebugCategory.BROWSER_SDK, "Merged wallet by ID", {
+        walletName: wallet.name,
+        walletId: wallet.id,
+        existingAddressTypes: existing.addressTypes,
+        newAddressTypes: wallet.addressTypes,
+        mergedAddressTypes,
+        existingProviders: Object.keys(existing.providers || {}),
+        newProviders: Object.keys(wallet.providers || {}),
+        mergedProviders: Object.keys(mergedProviders)
+      });
+      debug.log(DebugCategory.BROWSER_SDK, "Merged wallet from multiple discovery methods", {
+        walletId: wallet.id,
+        walletName: wallet.name,
+        existingAddressTypes: existing.addressTypes,
+        newAddressTypes: wallet.addressTypes,
+        mergedAddressTypes
+      });
+    } else {
+      walletMap.set(wallet.id, wallet);
+    }
+  }
+  return Array.from(walletMap.values());
+}
+
+// src/providers/injected/chains/InjectedWalletSolanaChain.ts
 import { EventEmitter } from "eventemitter3";
-import { AddressType as AddressType2 } from "@phantom/client";
-import { Buffer } from "buffer";
-var InjectedSolanaChain = class {
-  constructor(phantom, callbacks) {
+import { Buffer as Buffer2 } from "buffer";
+var InjectedWalletSolanaChain = class {
+  constructor(provider, walletId, walletName) {
+    this.eventEmitter = new EventEmitter();
     this._connected = false;
     this._publicKey = null;
-    this.eventEmitter = new EventEmitter();
-    this.phantom = phantom;
-    this.callbacks = callbacks;
+    this.provider = provider;
+    this.walletId = walletId;
+    this.walletName = walletName;
     this.setupEventListeners();
-    this.syncInitialState();
   }
-  // Wallet adapter compliant properties
   get connected() {
     return this._connected;
   }
   get publicKey() {
     return this._publicKey;
   }
-  // Connection methods - delegate to provider
-  connect(_options) {
-    if (!this.callbacks.isConnected()) {
-      return Promise.reject(new Error("Provider not connected. Call provider connect first."));
-    }
-    const addresses = this.callbacks.getAddresses();
-    const solanaAddress = addresses.find((addr) => addr.addressType === AddressType2.solana);
-    if (!solanaAddress) {
-      return Promise.reject(new Error("Solana not enabled for this provider"));
+  async connect(options) {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "External wallet Solana connect", {
+      walletId: this.walletId,
+      walletName: this.walletName,
+      onlyIfTrusted: options?.onlyIfTrusted
+    });
+    try {
+      const result = await this.provider.connect(options);
+      if (typeof result === "string") {
+        this._connected = true;
+        this._publicKey = result;
+        debug.info(DebugCategory.INJECTED_PROVIDER, "External wallet Solana connected", {
+          walletId: this.walletId,
+          walletName: this.walletName,
+          publicKey: result
+        });
+        return { publicKey: result };
+      }
+      if (typeof result === "object" && result !== null && "publicKey" in result) {
+        this._connected = true;
+        this._publicKey = result.publicKey;
+        debug.info(DebugCategory.INJECTED_PROVIDER, "External wallet Solana connected", {
+          walletId: this.walletId,
+          walletName: this.walletName,
+          publicKey: result.publicKey
+        });
+        return result;
+      }
+      if (Array.isArray(result) && result.length > 0) {
+        const firstAccount = result[0];
+        if (typeof firstAccount === "object" && firstAccount !== null && "address" in firstAccount) {
+          this._connected = true;
+          this._publicKey = firstAccount.address;
+          debug.info(DebugCategory.INJECTED_PROVIDER, "External wallet Solana connected", {
+            walletId: this.walletId,
+            walletName: this.walletName,
+            publicKey: firstAccount.address
+          });
+          return { publicKey: firstAccount.address };
+        }
+      }
+      throw new Error("Unexpected connect result format");
+    } catch (error) {
+      debug.error(DebugCategory.INJECTED_PROVIDER, "External wallet Solana connect failed", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
     }
-    this.updateConnectionState(true, solanaAddress.address);
-    return Promise.resolve({ publicKey: solanaAddress.address });
   }
   async disconnect() {
-    await this.callbacks.disconnect();
+    debug.log(DebugCategory.INJECTED_PROVIDER, "External wallet Solana disconnect", {
+      walletId: this.walletId,
+      walletName: this.walletName
+    });
+    try {
+      await this.provider.disconnect();
+      this._connected = false;
+      this._publicKey = null;
+      debug.info(DebugCategory.INJECTED_PROVIDER, "External wallet Solana disconnected", {
+        walletId: this.walletId,
+        walletName: this.walletName
+      });
+    } catch (error) {
+      debug.error(DebugCategory.INJECTED_PROVIDER, "External wallet Solana disconnect failed", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
   }
-  // Standard wallet adapter methods
   async signMessage(message) {
     const messageBytes = typeof message === "string" ? new TextEncoder().encode(message) : message;
-    const result = await this.phantom.solana.signMessage(messageBytes);
-    return {
-      signature: result.signature instanceof Uint8Array ? result.signature : new Uint8Array(Buffer.from(result.signature, "base64")),
-      publicKey: this._publicKey || ""
-    };
+    const messagePreview = typeof message === "string" ? message.substring(0, 50) : `${messageBytes.length} bytes`;
+    debug.log(DebugCategory.INJECTED_PROVIDER, "External wallet Solana signMessage", {
+      walletId: this.walletId,
+      walletName: this.walletName,
+      messagePreview,
+      messageLength: messageBytes.length
+    });
+    try {
+      const result = await this.provider.signMessage(message);
+      debug.info(DebugCategory.INJECTED_PROVIDER, "External wallet Solana signMessage success", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        signatureLength: result.signature.length
+      });
+      return {
+        signature: result.signature instanceof Uint8Array ? result.signature : new Uint8Array(Buffer2.from(result.signature, "base64")),
+        publicKey: result.publicKey || this._publicKey || ""
+      };
+    } catch (error) {
+      debug.error(DebugCategory.INJECTED_PROVIDER, "External wallet Solana signMessage failed", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
   }
   async signTransaction(transaction) {
-    if (!this.callbacks.isConnected()) {
-      return Promise.reject(new Error("Provider not connected. Call provider connect first."));
-    }
+    debug.log(DebugCategory.INJECTED_PROVIDER, "External wallet Solana signTransaction", {
+      walletId: this.walletId,
+      walletName: this.walletName
+    });
     try {
-      const result = await this.phantom.solana.signTransaction(transaction);
+      const result = await this.provider.signTransaction(transaction);
+      debug.info(DebugCategory.INJECTED_PROVIDER, "External wallet Solana signTransaction success", {
+        walletId: this.walletId,
+        walletName: this.walletName
+      });
       return result;
     } catch (error) {
-      return Promise.reject(error);
+      debug.error(DebugCategory.INJECTED_PROVIDER, "External wallet Solana signTransaction failed", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
     }
   }
   async signAndSendTransaction(transaction) {
-    const result = await this.phantom.solana.signAndSendTransaction(transaction);
-    return { signature: result.signature };
+    debug.log(DebugCategory.INJECTED_PROVIDER, "External wallet Solana signAndSendTransaction", {
+      walletId: this.walletId,
+      walletName: this.walletName
+    });
+    try {
+      const result = await this.provider.signAndSendTransaction(transaction);
+      debug.info(DebugCategory.INJECTED_PROVIDER, "External wallet Solana signAndSendTransaction success", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        signature: result.signature
+      });
+      return result;
+    } catch (error) {
+      debug.error(DebugCategory.INJECTED_PROVIDER, "External wallet Solana signAndSendTransaction failed", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
   }
   async signAllTransactions(transactions) {
-    if (!this.callbacks.isConnected()) {
-      return Promise.reject(new Error("Provider not connected. Call provider connect first."));
-    }
+    debug.log(DebugCategory.INJECTED_PROVIDER, "External wallet Solana signAllTransactions", {
+      walletId: this.walletId,
+      walletName: this.walletName,
+      transactionCount: transactions.length
+    });
     try {
-      const result = await this.phantom.solana.signAllTransactions(transactions);
+      const result = await this.provider.signAllTransactions(transactions);
+      debug.info(DebugCategory.INJECTED_PROVIDER, "External wallet Solana signAllTransactions success", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        signedCount: result.length
+      });
       return result;
     } catch (error) {
-      return Promise.reject(error);
+      debug.error(DebugCategory.INJECTED_PROVIDER, "External wallet Solana signAllTransactions failed", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
     }
   }
   async signAndSendAllTransactions(transactions) {
-    if (!this.callbacks.isConnected()) {
-      return Promise.reject(new Error("Provider not connected. Call provider connect first."));
-    }
+    debug.log(DebugCategory.INJECTED_PROVIDER, "External wallet Solana signAndSendAllTransactions", {
+      walletId: this.walletId,
+      walletName: this.walletName,
+      transactionCount: transactions.length
+    });
     try {
-      const result = await this.phantom.solana.signAndSendAllTransactions(transactions);
-      return { signatures: result.signatures };
+      const result = await this.provider.signAndSendAllTransactions(transactions);
+      debug.info(DebugCategory.INJECTED_PROVIDER, "External wallet Solana signAndSendAllTransactions success", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        signatureCount: result.signatures.length
+      });
+      return result;
     } catch (error) {
-      return Promise.reject(error);
+      debug.error(DebugCategory.INJECTED_PROVIDER, "External wallet Solana signAndSendAllTransactions failed", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
     }
   }
   switchNetwork(_network) {
     return Promise.resolve();
   }
-  // Legacy methods
   getPublicKey() {
     return Promise.resolve(this._publicKey);
   }
   isConnected() {
-    return this._connected && this.callbacks.isConnected();
+    return this._connected;
   }
   setupEventListeners() {
-    this.phantom.solana.addEventListener("connect", (publicKey) => {
-      this.updateConnectionState(true, publicKey);
-      this.eventEmitter.emit("connect", publicKey);
-    });
-    this.phantom.solana.addEventListener("disconnect", () => {
-      this.updateConnectionState(false, null);
-      this.eventEmitter.emit("disconnect");
-    });
-    this.phantom.solana.addEventListener("accountChanged", (publicKey) => {
-      this._publicKey = publicKey;
-      this.eventEmitter.emit("accountChanged", publicKey);
-    });
-    this.callbacks.on("connect", (data) => {
-      const solanaAddress = data.addresses?.find((addr) => addr.addressType === AddressType2.solana);
-      if (solanaAddress) {
-        this.updateConnectionState(true, solanaAddress.address);
-      }
-    });
-    this.callbacks.on("disconnect", () => {
-      this.updateConnectionState(false, null);
-    });
-  }
-  syncInitialState() {
-    if (this.callbacks.isConnected()) {
-      const solanaAddress = this.callbacks.getAddresses().find((addr) => addr.addressType === AddressType2.solana);
-      if (solanaAddress) {
-        this.updateConnectionState(true, solanaAddress.address);
-      }
+    if (typeof this.provider.on === "function") {
+      this.provider.on("connect", (publicKey) => {
+        this._connected = true;
+        this._publicKey = publicKey;
+        this.eventEmitter.emit("connect", publicKey);
+      });
+      this.provider.on("disconnect", () => {
+        this._connected = false;
+        this._publicKey = null;
+        this.eventEmitter.emit("disconnect");
+      });
+      this.provider.on("accountChanged", (publicKey) => {
+        this._publicKey = publicKey;
+        this.eventEmitter.emit("accountChanged", publicKey);
+      });
     }
   }
-  updateConnectionState(connected, publicKey) {
-    this._connected = connected;
-    this._publicKey = publicKey;
-  }
-  // Event methods for interface compliance
   on(event, listener) {
     this.eventEmitter.on(event, listener);
   }
@@ -221,56 +684,855 @@ var InjectedSolanaChain = class {
   }
 };
 
-// src/providers/injected/chains/EthereumChain.ts
-import { EventEmitter as EventEmitter2 } from "eventemitter3";
-import { AddressType as AddressType3 } from "@phantom/client";
-var InjectedEthereumChain = class {
-  constructor(phantom, callbacks) {
+// src/providers/injected/chains/WalletStandardSolanaAdapter.ts
+import { deserializeSolanaTransaction } from "@phantom/parsers";
+import bs58 from "bs58";
+var WalletStandardSolanaAdapter = class {
+  constructor(wallet, walletId, walletName) {
     this._connected = false;
-    this._chainId = "0x1";
-    this._accounts = [];
-    this.eventEmitter = new EventEmitter2();
-    this.phantom = phantom;
-    this.callbacks = callbacks;
-    this.setupEventListeners();
-    this.syncInitialState();
+    this._publicKey = null;
+    this.wallet = wallet;
+    this.walletId = walletId;
+    this.walletName = walletName;
   }
-  // EIP-1193 compliant properties
   get connected() {
     return this._connected;
   }
-  get chainId() {
-    return this._chainId;
-  }
-  get accounts() {
-    return this._accounts;
+  get publicKey() {
+    return this._publicKey;
   }
-  // EIP-1193 core method with eth_signTransaction support
-  async request(args) {
-    if (args.method === "eth_signTransaction") {
-      const [transaction] = args.params;
-      const result = await this.signTransaction(transaction);
-      return result;
+  async connect(_options) {
+    try {
+      const connectFeature = this.wallet.features?.["standard:connect"];
+      if (!connectFeature || typeof connectFeature.connect !== "function") {
+        throw new Error("Wallet Standard connect feature not available");
+      }
+      const connectResult = await connectFeature.connect();
+      let accounts;
+      if (Array.isArray(connectResult) && connectResult.length > 0) {
+        accounts = connectResult;
+      } else if (this.wallet.accounts && this.wallet.accounts.length > 0) {
+        accounts = Array.from(this.wallet.accounts);
+      }
+      if (!accounts || accounts.length === 0) {
+        throw new Error("No accounts available after connecting to wallet");
+      }
+      const firstAccount = accounts[0];
+      if (!firstAccount) {
+        throw new Error("First account is null or undefined");
+      }
+      let address;
+      if (typeof firstAccount === "string") {
+        address = firstAccount;
+      } else if (typeof firstAccount === "object" && firstAccount !== null) {
+        address = firstAccount.address || firstAccount.publicKey?.toString() || (firstAccount.publicKey instanceof Uint8Array ? Buffer.from(firstAccount.publicKey).toString("hex") : void 0);
+      }
+      if (!address) {
+        throw new Error(
+          `Could not extract address from account. Account structure: ${JSON.stringify(firstAccount, null, 2)}`
+        );
+      }
+      this._connected = true;
+      this._publicKey = address;
+      return { publicKey: address };
+    } catch (error) {
+      debug.error(DebugCategory.INJECTED_PROVIDER, "Wallet Standard Solana connect failed", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
     }
-    const provider = await this.phantom.ethereum.getProvider();
-    return await provider.request(args);
   }
-  // Connection methods - delegate to provider
-  connect() {
-    if (!this.callbacks.isConnected()) {
-      return Promise.reject(new Error("Provider not connected. Call provider connect first."));
+  async disconnect() {
+    try {
+      const disconnectFeature = this.wallet.features?.["standard:disconnect"];
+      if (disconnectFeature && typeof disconnectFeature.disconnect === "function") {
+        await disconnectFeature.disconnect();
+      }
+      this._connected = false;
+      this._publicKey = null;
+    } catch (error) {
+      debug.error(DebugCategory.INJECTED_PROVIDER, "Wallet Standard Solana disconnect failed", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
     }
-    const addresses = this.callbacks.getAddresses();
-    const ethAddresses = addresses.filter((addr) => addr.addressType === AddressType3.ethereum).map((addr) => addr.address);
-    this.updateConnectionState(true, ethAddresses);
-    return Promise.resolve(ethAddresses);
   }
-  async disconnect() {
-    await this.callbacks.disconnect();
+  async signMessage(message) {
+    try {
+      const signMessageFeature = this.wallet.features?.["solana:signMessage"];
+      if (!signMessageFeature || typeof signMessageFeature.signMessage !== "function") {
+        throw new Error("Wallet Standard signMessage feature not available");
+      }
+      const messageBytes = typeof message === "string" ? new TextEncoder().encode(message) : message;
+      const result = await signMessageFeature.signMessage({
+        message: messageBytes,
+        account: this.wallet.accounts?.[0]
+      });
+      if (!Array.isArray(result) || result.length === 0) {
+        throw new Error(`Expected array result from signMessage, got: ${typeof result}`);
+      }
+      const signedMessageResult = result[0];
+      if (!signedMessageResult || !signedMessageResult.signature) {
+        throw new Error(`Invalid signMessage result structure: ${JSON.stringify(result)}`);
+      }
+      const signature = this.parseUint8Array(signedMessageResult.signature);
+      if (signature.length === 0) {
+        throw new Error(`Signature is empty`);
+      }
+      const publicKey = signedMessageResult.account?.address || this.wallet.accounts?.[0]?.address || this._publicKey || "";
+      return { signature, publicKey };
+    } catch (error) {
+      debug.error(DebugCategory.INJECTED_PROVIDER, "Wallet Standard Solana signMessage failed", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
   }
-  // Standard compliant methods (return raw values, not wrapped objects)
-  async signPersonalMessage(message, address) {
-    return await this.phantom.ethereum.signPersonalMessage(message, address);
+  async signTransaction(transaction) {
+    try {
+      const signTransactionFeature = this.wallet.features?.["solana:signTransaction"];
+      if (!signTransactionFeature || typeof signTransactionFeature.signTransaction !== "function") {
+        throw new Error("Wallet Standard signTransaction feature not available");
+      }
+      if (!this.wallet.accounts || this.wallet.accounts.length === 0) {
+        throw new Error("No accounts available. Please connect first.");
+      }
+      const account = this.wallet.accounts[0];
+      const serializedTransaction = this.serializeTransaction(transaction);
+      const results = await signTransactionFeature.signTransaction({
+        transaction: serializedTransaction,
+        account
+      });
+      let transactionData;
+      if (Array.isArray(results) && results.length > 0) {
+        const firstItem = results[0];
+        if (firstItem && typeof firstItem === "object") {
+          transactionData = firstItem.signedTransaction || firstItem.transaction;
+        }
+      } else if (results && typeof results === "object" && !Array.isArray(results)) {
+        transactionData = results.transaction || results.signedTransaction;
+      }
+      if (!transactionData) {
+        throw new Error("No transaction data found in Wallet Standard result");
+      }
+      const signedBytes = this.parseUint8Array(transactionData);
+      if (signedBytes.length === 0) {
+        throw new Error("Empty signed transaction returned from Wallet Standard");
+      }
+      const signedTx = deserializeSolanaTransaction(signedBytes);
+      return signedTx;
+    } catch (error) {
+      debug.error(DebugCategory.INJECTED_PROVIDER, "Wallet Standard Solana signTransaction failed", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  async signAndSendTransaction(transaction) {
+    try {
+      const signAndSendTransactionFeature = this.wallet.features?.["solana:signAndSendTransaction"];
+      if (!signAndSendTransactionFeature || typeof signAndSendTransactionFeature.signAndSendTransaction !== "function") {
+        throw new Error("Wallet Standard signAndSendTransaction feature not available");
+      }
+      if (!this.wallet.accounts || this.wallet.accounts.length === 0) {
+        throw new Error("No accounts available. Please connect first.");
+      }
+      const account = this.wallet.accounts[0];
+      const chain = account.chains?.[0] || "solana:mainnet";
+      const serializedTransaction = this.serializeTransaction(transaction);
+      const results = await signAndSendTransactionFeature.signAndSendTransaction({
+        transaction: serializedTransaction,
+        account,
+        chain
+      });
+      let signatureOutput;
+      if (Array.isArray(results) && results.length > 0) {
+        signatureOutput = results[0];
+      } else if (results && typeof results === "object" && !Array.isArray(results)) {
+        signatureOutput = results;
+      } else {
+        throw new Error("Invalid signAndSendTransaction result format");
+      }
+      if (!signatureOutput.signature) {
+        throw new Error("No signature found in signAndSendTransaction result");
+      }
+      const signatureBytes = this.parseUint8Array(signatureOutput.signature);
+      const signature = bs58.encode(signatureBytes);
+      return { signature };
+    } catch (error) {
+      debug.error(DebugCategory.INJECTED_PROVIDER, "Wallet Standard Solana signAndSendTransaction failed", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  async signAllTransactions(transactions) {
+    try {
+      const signedTransactions = [];
+      for (const transaction of transactions) {
+        const signedTx = await this.signTransaction(transaction);
+        signedTransactions.push(signedTx);
+      }
+      return signedTransactions;
+    } catch (error) {
+      debug.error(DebugCategory.INJECTED_PROVIDER, "Wallet Standard Solana signAllTransactions failed", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  async signAndSendAllTransactions(transactions) {
+    try {
+      const signatures = [];
+      for (const transaction of transactions) {
+        const result = await this.signAndSendTransaction(transaction);
+        signatures.push(result.signature);
+      }
+      return { signatures };
+    } catch (error) {
+      debug.error(DebugCategory.INJECTED_PROVIDER, "Wallet Standard Solana signAndSendAllTransactions failed", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  async switchNetwork(network) {
+    try {
+      const switchNetworkFeature = this.wallet.features?.["standard:switchNetwork"];
+      if (switchNetworkFeature && typeof switchNetworkFeature.switchNetwork === "function") {
+        const chainId = network === "mainnet" ? "solana:mainnet" : "solana:devnet";
+        await switchNetworkFeature.switchNetwork({ chain: chainId });
+      }
+    } catch (error) {
+      debug.error(DebugCategory.INJECTED_PROVIDER, "Wallet Standard Solana switchNetwork failed", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        network,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  getPublicKey() {
+    return Promise.resolve(this._publicKey);
+  }
+  isConnected() {
+    return this._connected;
+  }
+  on(_event, _listener) {
+    const eventsFeature = this.wallet.features?.["standard:events"];
+    if (eventsFeature && typeof eventsFeature.on === "function") {
+      eventsFeature.on(_event, _listener);
+    }
+  }
+  off(_event, _listener) {
+    const eventsFeature = this.wallet.features?.["standard:events"];
+    if (eventsFeature && typeof eventsFeature.off === "function") {
+      eventsFeature.off(_event, _listener);
+    }
+  }
+  /**
+   * Serialize a transaction to Uint8Array for Wallet Standard API
+   */
+  serializeTransaction(transaction) {
+    if (typeof transaction.serialize === "function") {
+      return transaction.serialize({
+        requireAllSignatures: false,
+        verifySignatures: false
+      });
+    }
+    if (transaction instanceof Uint8Array) {
+      return transaction;
+    }
+    return new Uint8Array(0);
+  }
+  /**
+   * Parse a Uint8Array from various formats
+   * Handles: Uint8Array, Array, object with numeric keys (JSON-serialized Uint8Array)
+   */
+  parseUint8Array(value) {
+    if (value instanceof Uint8Array) {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      return new Uint8Array(value);
+    }
+    if (typeof value === "object" && value !== null) {
+      const keys = Object.keys(value).map(Number).filter((k) => !isNaN(k) && k >= 0).sort((a, b) => a - b);
+      if (keys.length > 0) {
+        const maxKey = Math.max(...keys);
+        const array = new Uint8Array(maxKey + 1);
+        for (const key of keys) {
+          array[key] = Number(value[key]) || 0;
+        }
+        return array;
+      }
+    }
+    return new Uint8Array(0);
+  }
+};
+
+// src/providers/injected/chains/InjectedWalletEthereumChain.ts
+import { EventEmitter as EventEmitter2 } from "eventemitter3";
+var InjectedWalletEthereumChain = class {
+  constructor(provider, walletId, walletName) {
+    this.eventEmitter = new EventEmitter2();
+    this._connected = false;
+    this._chainId = "0x1";
+    this._accounts = [];
+    this.provider = provider;
+    this.walletId = walletId;
+    this.walletName = walletName;
+    this.setupEventListeners();
+  }
+  get connected() {
+    return this._connected;
+  }
+  get chainId() {
+    return this._chainId;
+  }
+  get accounts() {
+    return this._accounts;
+  }
+  async request(args) {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum request", {
+      walletId: this.walletId,
+      walletName: this.walletName,
+      method: args.method
+    });
+    try {
+      const requiresAuth = [
+        "personal_sign",
+        "eth_sign",
+        "eth_signTypedData",
+        "eth_signTypedData_v4",
+        "eth_sendTransaction",
+        "eth_signTransaction"
+      ].includes(args.method);
+      if (requiresAuth && (!this._connected || this._accounts.length === 0)) {
+        debug.log(DebugCategory.INJECTED_PROVIDER, "Method requires authorization, ensuring connection", {
+          walletId: this.walletId,
+          walletName: this.walletName,
+          method: args.method
+        });
+        await this.connect();
+      }
+      const result = await this.provider.request(args);
+      debug.info(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum request success", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        method: args.method
+      });
+      return result;
+    } catch (error) {
+      if (error?.code === 4100) {
+        debug.log(DebugCategory.INJECTED_PROVIDER, "Got 4100 Unauthorized, attempting to re-authorize", {
+          walletId: this.walletId,
+          walletName: this.walletName,
+          method: args.method
+        });
+        try {
+          await this.provider.request({ method: "eth_requestAccounts" });
+          const result = await this.provider.request(args);
+          debug.info(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum request success (after re-auth)", {
+            walletId: this.walletId,
+            walletName: this.walletName,
+            method: args.method
+          });
+          return result;
+        } catch (retryError) {
+          debug.error(DebugCategory.INJECTED_PROVIDER, "Failed after re-authorization", {
+            walletId: this.walletId,
+            walletName: this.walletName,
+            method: args.method,
+            error: retryError instanceof Error ? retryError.message : String(retryError)
+          });
+          throw retryError;
+        }
+      }
+      debug.error(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum request failed", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        method: args.method,
+        error: error instanceof Error ? error.message : String(error),
+        errorCode: error?.code
+      });
+      throw error;
+    }
+  }
+  async connect() {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum connect", {
+      walletId: this.walletId,
+      walletName: this.walletName
+    });
+    try {
+      const accounts = await this.provider.request({ method: "eth_requestAccounts" });
+      this._connected = accounts.length > 0;
+      this._accounts = accounts;
+      debug.info(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum connected (via eth_requestAccounts)", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        accountCount: accounts.length,
+        accounts
+      });
+      return accounts;
+    } catch (error) {
+      debug.error(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum connect failed", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  async disconnect() {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum disconnect", {
+      walletId: this.walletId,
+      walletName: this.walletName
+    });
+    try {
+      await this.provider.disconnect();
+      this._connected = false;
+      this._accounts = [];
+      debug.info(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum disconnected", {
+        walletId: this.walletId,
+        walletName: this.walletName
+      });
+    } catch (error) {
+      debug.error(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum disconnect failed", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  async signPersonalMessage(message, address) {
+    const messagePreview = message.length > 50 ? message.substring(0, 50) + "..." : message;
+    debug.log(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum signPersonalMessage", {
+      walletId: this.walletId,
+      walletName: this.walletName,
+      messagePreview,
+      messageLength: message.length,
+      address
+    });
+    try {
+      const providerConnected = this.provider.isConnected?.() || this.provider.connected || false;
+      if (!this._connected || this._accounts.length === 0 || !providerConnected) {
+        debug.log(DebugCategory.INJECTED_PROVIDER, "Not connected, attempting to connect before signing", {
+          walletId: this.walletId,
+          walletName: this.walletName,
+          internalConnected: this._connected,
+          accountsLength: this._accounts.length,
+          providerConnected
+        });
+        await this.connect();
+      }
+      const normalizedAddress = address.toLowerCase();
+      const normalizedAccounts = this._accounts.map((acc) => acc.toLowerCase());
+      if (!normalizedAccounts.includes(normalizedAddress)) {
+        debug.warn(DebugCategory.INJECTED_PROVIDER, "Address not in connected accounts, refreshing connection", {
+          walletId: this.walletId,
+          walletName: this.walletName,
+          requestedAddress: address,
+          connectedAccounts: this._accounts
+        });
+        const currentAccounts = await this.getAccounts();
+        const normalizedCurrentAccounts = currentAccounts.map((acc) => acc.toLowerCase());
+        if (!normalizedCurrentAccounts.includes(normalizedAddress)) {
+          throw new Error(`Address ${address} is not connected. Connected accounts: ${currentAccounts.join(", ")}`);
+        }
+        this._accounts = currentAccounts;
+      }
+      if (typeof this.provider.signPersonalMessage === "function") {
+        const result2 = await this.provider.signPersonalMessage(message, address);
+        debug.info(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum signPersonalMessage success", {
+          walletId: this.walletId,
+          walletName: this.walletName,
+          signatureLength: result2.length
+        });
+        return result2;
+      }
+      const result = await this.request({
+        method: "personal_sign",
+        params: [message, address]
+      });
+      debug.info(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum signPersonalMessage success", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        signatureLength: result.length
+      });
+      return result;
+    } catch (error) {
+      debug.error(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum signPersonalMessage failed", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        error: error instanceof Error ? error.message : String(error),
+        errorCode: error?.code
+      });
+      throw error;
+    }
+  }
+  async signTypedData(typedData, address) {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum signTypedData", {
+      walletId: this.walletId,
+      walletName: this.walletName,
+      primaryType: typedData?.primaryType,
+      address
+    });
+    try {
+      if (typeof this.provider.signTypedData === "function") {
+        const result2 = await this.provider.signTypedData(typedData, address);
+        debug.info(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum signTypedData success", {
+          walletId: this.walletId,
+          walletName: this.walletName,
+          signatureLength: result2.length
+        });
+        return result2;
+      }
+      const result = await this.request({
+        method: "eth_signTypedData_v4",
+        params: [address, typedData]
+      });
+      debug.info(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum signTypedData success", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        signatureLength: result.length
+      });
+      return result;
+    } catch (error) {
+      debug.error(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum signTypedData failed", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  async signTransaction(transaction) {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum signTransaction", {
+      walletId: this.walletId,
+      walletName: this.walletName,
+      from: transaction.from,
+      to: transaction.to
+    });
+    try {
+      if (typeof this.provider.signTransaction === "function") {
+        const result2 = await this.provider.signTransaction(transaction);
+        debug.info(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum signTransaction success", {
+          walletId: this.walletId,
+          walletName: this.walletName,
+          signatureLength: result2.length
+        });
+        return result2;
+      }
+      const result = await this.request({
+        method: "eth_signTransaction",
+        params: [transaction]
+      });
+      debug.info(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum signTransaction success", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        signatureLength: result.length
+      });
+      return result;
+    } catch (error) {
+      debug.error(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum signTransaction failed", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  async sendTransaction(transaction) {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum sendTransaction", {
+      walletId: this.walletId,
+      walletName: this.walletName,
+      from: transaction.from,
+      to: transaction.to,
+      value: transaction.value
+    });
+    try {
+      if (typeof this.provider.sendTransaction === "function") {
+        const result2 = await this.provider.sendTransaction(transaction);
+        debug.info(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum sendTransaction success", {
+          walletId: this.walletId,
+          walletName: this.walletName,
+          txHash: result2
+        });
+        return result2;
+      }
+      const result = await this.request({
+        method: "eth_sendTransaction",
+        params: [transaction]
+      });
+      debug.info(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum sendTransaction success", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        txHash: result
+      });
+      return result;
+    } catch (error) {
+      debug.error(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum sendTransaction failed", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  async switchChain(chainId) {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum switchChain", {
+      walletId: this.walletId,
+      walletName: this.walletName,
+      chainId
+    });
+    try {
+      const hexChainId = typeof chainId === "string" ? chainId.toLowerCase().startsWith("0x") ? chainId : `0x${parseInt(chainId, 10).toString(16)}` : `0x${chainId.toString(16)}`;
+      if (typeof this.provider.switchChain === "function") {
+        await this.provider.switchChain(hexChainId);
+      } else {
+        await this.request({ method: "wallet_switchEthereumChain", params: [{ chainId: hexChainId }] });
+      }
+      this._chainId = hexChainId;
+      this.eventEmitter.emit("chainChanged", this._chainId);
+      debug.info(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum switchChain success", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        chainId: hexChainId
+      });
+    } catch (error) {
+      debug.error(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum switchChain failed", {
+        walletId: this.walletId,
+        walletName: this.walletName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  async getChainId() {
+    if (typeof this.provider.getChainId === "function") {
+      const chainId2 = await this.provider.getChainId();
+      this._chainId = `0x${chainId2.toString(16)}`;
+      return chainId2;
+    }
+    const chainId = await this.request({ method: "eth_chainId" });
+    const parsed = parseInt(chainId, 16);
+    this._chainId = chainId;
+    return parsed;
+  }
+  async getAccounts() {
+    if (typeof this.provider.getAccounts === "function") {
+      const accounts2 = await this.provider.getAccounts();
+      this._accounts = accounts2;
+      return accounts2;
+    }
+    const accounts = await this.request({ method: "eth_accounts" });
+    this._accounts = accounts;
+    return accounts;
+  }
+  isConnected() {
+    return this._connected;
+  }
+  setupEventListeners() {
+    if (typeof this.provider.on === "function") {
+      this.provider.on("connect", (info) => {
+        this._connected = true;
+        this._chainId = info.chainId;
+        this.eventEmitter.emit("connect", info);
+      });
+      this.provider.on("disconnect", (error) => {
+        this._connected = false;
+        this._accounts = [];
+        this.eventEmitter.emit("disconnect", error);
+        this.eventEmitter.emit("accountsChanged", []);
+      });
+      this.provider.on("accountsChanged", (accounts) => {
+        this._accounts = accounts;
+        this.eventEmitter.emit("accountsChanged", accounts);
+      });
+      this.provider.on("chainChanged", (chainId) => {
+        this._chainId = chainId;
+        this.eventEmitter.emit("chainChanged", chainId);
+      });
+    }
+  }
+  on(event, listener) {
+    this.eventEmitter.on(event, listener);
+  }
+  off(event, listener) {
+    this.eventEmitter.off(event, listener);
+  }
+};
+
+// src/providers/injected/chains/SolanaChain.ts
+import { EventEmitter as EventEmitter3 } from "eventemitter3";
+import { Buffer as Buffer3 } from "buffer";
+var PhantomSolanaChain = class {
+  constructor(phantom) {
+    this._publicKey = null;
+    this.eventEmitter = new EventEmitter3();
+    this.phantom = phantom;
+    this.setupEventListeners();
+  }
+  // Wallet adapter compliant properties
+  get connected() {
+    return this._publicKey !== null;
+  }
+  get publicKey() {
+    return this._publicKey;
+  }
+  // Connection methods
+  async connect(options) {
+    const result = await this.phantom.solana.connect(options);
+    if (!result) {
+      throw new Error("Failed to connect to Solana wallet");
+    }
+    const publicKey = typeof result === "string" ? result : "";
+    this._publicKey = publicKey;
+    return { publicKey };
+  }
+  async disconnect() {
+    await this.phantom.solana.disconnect();
+    this._publicKey = null;
+  }
+  // Standard wallet adapter methods
+  async signMessage(message) {
+    const messageBytes = typeof message === "string" ? new TextEncoder().encode(message) : message;
+    const result = await this.phantom.solana.signMessage(messageBytes);
+    return {
+      signature: result.signature instanceof Uint8Array ? result.signature : new Uint8Array(Buffer3.from(result.signature, "base64")),
+      publicKey: this._publicKey || ""
+    };
+  }
+  async signTransaction(transaction) {
+    if (!this.connected) {
+      return Promise.reject(new Error("Provider not connected. Call provider connect first."));
+    }
+    try {
+      const result = await this.phantom.solana.signTransaction(transaction);
+      return result;
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+  async signAndSendTransaction(transaction) {
+    const result = await this.phantom.solana.signAndSendTransaction(transaction);
+    return { signature: result.signature };
+  }
+  async signAllTransactions(transactions) {
+    if (!this.connected) {
+      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.connected) {
+      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();
+  }
+  // Legacy methods
+  getPublicKey() {
+    return Promise.resolve(this._publicKey);
+  }
+  isConnected() {
+    return this.connected;
+  }
+  setupEventListeners() {
+    this.phantom.solana.addEventListener("connect", (publicKey) => {
+      this._publicKey = publicKey;
+      this.eventEmitter.emit("connect", publicKey);
+    });
+    this.phantom.solana.addEventListener("disconnect", () => {
+      this._publicKey = null;
+      this.eventEmitter.emit("disconnect");
+    });
+    this.phantom.solana.addEventListener("accountChanged", (publicKey) => {
+      this._publicKey = publicKey;
+      this.eventEmitter.emit("accountChanged", publicKey);
+    });
+  }
+  // Event methods for interface compliance
+  on(event, listener) {
+    this.eventEmitter.on(event, listener);
+  }
+  off(event, listener) {
+    this.eventEmitter.off(event, listener);
+  }
+};
+
+// src/providers/injected/chains/EthereumChain.ts
+import { EventEmitter as EventEmitter4 } from "eventemitter3";
+var PhantomEthereumChain = class {
+  constructor(phantom) {
+    this._chainId = "0x1";
+    this._accounts = [];
+    this.eventEmitter = new EventEmitter4();
+    this.phantom = phantom;
+    this.setupEventListeners();
+  }
+  // EIP-1193 compliant properties
+  get connected() {
+    return this._accounts.length > 0;
+  }
+  get chainId() {
+    return this._chainId;
+  }
+  get accounts() {
+    return this._accounts;
+  }
+  // EIP-1193 core method with eth_signTransaction support
+  async request(args) {
+    if (args.method === "eth_signTransaction") {
+      const [transaction] = args.params;
+      const result = await this.signTransaction(transaction);
+      return result;
+    }
+    const phantomProvider = await this.phantom.ethereum.getProvider();
+    return await phantomProvider.request(args);
+  }
+  // Connection methods
+  async connect() {
+    const accounts = await this.phantom.ethereum.getAccounts();
+    this._accounts = accounts;
+    return accounts;
+  }
+  async disconnect() {
+    await this.phantom.ethereum.disconnect();
+    this._accounts = [];
+  }
+  // Standard compliant methods (return raw values, not wrapped objects)
+  async signPersonalMessage(message, address) {
+    return await this.phantom.ethereum.signPersonalMessage(message, address);
   }
   async signTypedData(typedData, address) {
     return await this.phantom.ethereum.signTypedData(typedData, address);
@@ -282,8 +1544,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() {
@@ -294,16 +1557,16 @@ var InjectedEthereumChain = class {
     return await this.phantom.ethereum.getAccounts();
   }
   isConnected() {
-    return this._connected && this.callbacks.isConnected();
+    return this.connected;
   }
   setupEventListeners() {
     this.phantom.ethereum.addEventListener("connect", (accounts) => {
-      this.updateConnectionState(true, accounts);
+      this._accounts = accounts;
       this.eventEmitter.emit("connect", { chainId: this._chainId });
       this.eventEmitter.emit("accountsChanged", accounts);
     });
     this.phantom.ethereum.addEventListener("disconnect", () => {
-      this.updateConnectionState(false, []);
+      this._accounts = [];
       this.eventEmitter.emit("disconnect", { code: 4900, message: "Provider disconnected" });
       this.eventEmitter.emit("accountsChanged", []);
     });
@@ -315,254 +1578,532 @@ var InjectedEthereumChain = class {
       this._chainId = chainId;
       this.eventEmitter.emit("chainChanged", chainId);
     });
-    this.callbacks.on("connect", (data) => {
-      const ethAddresses = data.addresses?.filter((addr) => addr.addressType === AddressType3.ethereum)?.map((addr) => addr.address) || [];
-      if (ethAddresses.length > 0) {
-        this.updateConnectionState(true, ethAddresses);
-      }
-    });
-    this.callbacks.on("disconnect", () => {
-      this.updateConnectionState(false, []);
-    });
   }
-  syncInitialState() {
-    if (this.callbacks.isConnected()) {
-      const ethAddresses = this.callbacks.getAddresses().filter((addr) => addr.addressType === AddressType3.ethereum).map((addr) => addr.address);
-      if (ethAddresses.length > 0) {
-        this.updateConnectionState(true, ethAddresses);
+  // Event methods for interface compliance
+  on(event, listener) {
+    this.eventEmitter.on(event, listener);
+  }
+  off(event, listener) {
+    this.eventEmitter.off(event, listener);
+  }
+};
+
+// src/wallets/registry.ts
+function isPhantomWallet(wallet) {
+  return wallet !== void 0 && wallet.id === "phantom" && "isPhantom" in wallet && wallet.isPhantom === true;
+}
+var InjectedWalletRegistry = class {
+  constructor() {
+    this.wallets = /* @__PURE__ */ new Map();
+    this.discoveryPromise = null;
+  }
+  register(info) {
+    const wrappedProviders = {};
+    if (info.providers?.solana) {
+      const isWalletStandard = info.providers.solana && typeof info.providers.solana === "object" && "features" in info.providers.solana && typeof info.providers.solana.features === "object";
+      if (isWalletStandard) {
+        wrappedProviders.solana = new WalletStandardSolanaAdapter(info.providers.solana, info.id, info.name);
+        debug.log(DebugCategory.BROWSER_SDK, "Wrapped Wallet Standard Solana wallet with adapter", {
+          walletId: info.id,
+          walletName: info.name
+        });
+      } else {
+        wrappedProviders.solana = new InjectedWalletSolanaChain(info.providers.solana, info.id, info.name);
+        debug.log(DebugCategory.BROWSER_SDK, "Wrapped Solana provider with InjectedWalletSolanaChain", {
+          walletId: info.id,
+          walletName: info.name
+        });
       }
     }
+    if (info.providers?.ethereum) {
+      wrappedProviders.ethereum = new InjectedWalletEthereumChain(info.providers.ethereum, info.id, info.name);
+      debug.log(DebugCategory.BROWSER_SDK, "Wrapped Ethereum provider with InjectedWalletEthereumChain", {
+        walletId: info.id,
+        walletName: info.name
+      });
+    }
+    const wrappedInfo = {
+      ...info,
+      providers: Object.keys(wrappedProviders).length > 0 ? wrappedProviders : info.providers
+    };
+    this.wallets.set(info.id, wrappedInfo);
+  }
+  /**
+   * Register Phantom wallet with its instance
+   * This creates wrapped providers and stores the Phantom instance for auto-confirm access
+   */
+  registerPhantom(phantomInstance, addressTypes) {
+    const wrappedProviders = {};
+    if (addressTypes.includes(AddressType.solana) && phantomInstance.solana) {
+      wrappedProviders.solana = new PhantomSolanaChain(phantomInstance);
+      debug.log(DebugCategory.BROWSER_SDK, "Created PhantomSolanaChain wrapper", {
+        walletId: "phantom"
+      });
+    }
+    if (addressTypes.includes(AddressType.ethereum) && phantomInstance.ethereum) {
+      wrappedProviders.ethereum = new PhantomEthereumChain(phantomInstance);
+      debug.log(DebugCategory.BROWSER_SDK, "Created PhantomEthereumChain wrapper", {
+        walletId: "phantom"
+      });
+    }
+    const phantomWallet = {
+      id: "phantom",
+      name: "Phantom",
+      icon: "",
+      // Icon will be rendered from icons package in UI components
+      addressTypes,
+      providers: wrappedProviders,
+      isPhantom: true,
+      phantomInstance,
+      discovery: "phantom"
+    };
+    this.wallets.set("phantom", phantomWallet);
+    debug.log(DebugCategory.BROWSER_SDK, "Registered Phantom wallet with chain wrappers", {
+      addressTypes,
+      hasSolana: !!wrappedProviders.solana,
+      hasEthereum: !!wrappedProviders.ethereum
+    });
+  }
+  unregister(id) {
+    this.wallets.delete(id);
+  }
+  has(id) {
+    return this.wallets.has(id);
   }
-  updateConnectionState(connected, accounts) {
-    this._connected = connected;
-    this._accounts = accounts;
+  getById(id) {
+    return this.wallets.get(id);
   }
-  // Event methods for interface compliance
-  on(event, listener) {
-    this.eventEmitter.on(event, listener);
+  getAll() {
+    return Array.from(this.wallets.values());
   }
-  off(event, listener) {
-    this.eventEmitter.off(event, listener);
+  getByAddressTypes(addressTypes) {
+    if (addressTypes.length === 0) {
+      return this.getAll();
+    }
+    const allowed = new Set(addressTypes);
+    return this.getAll().filter((wallet) => wallet.addressTypes.some((t) => allowed.has(t)));
+  }
+  discover(addressTypes) {
+    if (this.discoveryPromise) {
+      return this.discoveryPromise;
+    }
+    debug.log(DebugCategory.BROWSER_SDK, "Starting wallet discovery", { addressTypes });
+    this.discoveryPromise = discoverWallets(addressTypes).then((discoveredWallets) => {
+      const relevantWallets = addressTypes ? discoveredWallets.filter((wallet) => wallet.addressTypes.some((type) => addressTypes.includes(type))) : discoveredWallets;
+      for (const wallet of relevantWallets) {
+        if (wallet.id === "phantom" && isPhantomWallet(wallet)) {
+          this.registerPhantom(wallet.phantomInstance, wallet.addressTypes);
+        } else {
+          this.register(wallet);
+        }
+        debug.log(DebugCategory.BROWSER_SDK, "Registered discovered wallet", {
+          id: wallet.id,
+          name: wallet.name,
+          addressTypes: wallet.addressTypes
+        });
+      }
+      debug.info(DebugCategory.BROWSER_SDK, "Wallet discovery completed", {
+        totalDiscovered: discoveredWallets.length,
+        relevantWallets: relevantWallets.length
+      });
+    }).catch((error) => {
+      debug.warn(DebugCategory.BROWSER_SDK, "Wallet discovery failed", { error });
+      this.discoveryPromise = null;
+      throw error;
+    });
+    return this.discoveryPromise;
   }
 };
+var walletRegistry = null;
+function getWalletRegistry() {
+  if (!walletRegistry) {
+    walletRegistry = new InjectedWalletRegistry();
+  }
+  return walletRegistry;
+}
 
 // src/providers/injected/index.ts
+var WAS_CONNECTED_KEY = "phantom-injected-was-connected";
+var WAS_CONNECTED_VALUE = "true";
+var LAST_WALLET_ID_KEY = "phantom-injected-last-wallet-id";
 var InjectedProvider = class {
+  // Track which wallets have event listeners set up
   constructor(config) {
-    this.connected = false;
-    this.addresses = [];
+    this.selectedWalletId = null;
+    this.walletStates = /* @__PURE__ */ new Map();
     // Event management
     this.eventListeners = /* @__PURE__ */ new Map();
     this.browserInjectedCleanupFunctions = [];
     this.eventsInitialized = false;
+    this.externalWalletEventListenersSetup = /* @__PURE__ */ new Set();
     debug.log(DebugCategory.INJECTED_PROVIDER, "Initializing InjectedProvider", { config });
     this.addressTypes = config.addressTypes;
+    this.walletRegistry = getWalletRegistry();
     debug.log(DebugCategory.INJECTED_PROVIDER, "Address types configured", { addressTypes: this.addressTypes });
-    const plugins = [createExtensionPlugin()];
-    if (this.addressTypes.includes(AddressType4.solana)) {
-      plugins.push(createSolanaPlugin());
-      debug.log(DebugCategory.INJECTED_PROVIDER, "Solana plugin added");
-    }
-    if (this.addressTypes.includes(AddressType4.ethereum)) {
-      plugins.push(createEthereumPlugin());
-      debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum plugin added");
-    }
-    plugins.push(createAutoConfirmPlugin());
-    debug.log(DebugCategory.INJECTED_PROVIDER, "AutoConfirm plugin added");
-    debug.log(DebugCategory.INJECTED_PROVIDER, "Creating Phantom instance with plugins", {
-      pluginCount: plugins.length
+    this.walletRegistry.discover(this.addressTypes).catch((error) => {
+      debug.warn(DebugCategory.INJECTED_PROVIDER, "Wallet discovery failed during initialization", { error });
     });
-    this.phantom = createPhantom({ plugins });
-    const callbacks = this.createCallbacks();
-    if (this.addressTypes.includes(AddressType4.solana)) {
-      this._solanaChain = new InjectedSolanaChain(this.phantom, callbacks);
-    }
-    if (this.addressTypes.includes(AddressType4.ethereum)) {
-      this._ethereumChain = new InjectedEthereumChain(this.phantom, callbacks);
-    }
     debug.info(DebugCategory.INJECTED_PROVIDER, "InjectedProvider initialized");
   }
   /**
-   * Access to Solana chain operations
+   * Wait for wallet discovery to complete if the wallet is not yet in the registry
+   * This is needed for auto-connect when the last wallet was an external wallet
    */
+  async waitForWalletDiscovery(walletId) {
+    if (this.walletRegistry.has(walletId)) {
+      return;
+    }
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Wallet not found in registry, waiting for discovery", {
+      walletId
+    });
+    try {
+      await this.walletRegistry.discover(this.addressTypes);
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Wallet discovery completed", { walletId });
+    } catch (error) {
+      debug.warn(DebugCategory.INJECTED_PROVIDER, "Wallet discovery failed", {
+        walletId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
   get solana() {
-    if (!this.addressTypes.includes(AddressType4.solana)) {
+    if (!this.addressTypes.includes(AddressType2.solana)) {
       throw new Error("Solana not enabled for this provider");
     }
-    if (!this._solanaChain) {
-      throw new Error("Solana chain not initialized");
+    const walletId = this.selectedWalletId || "phantom";
+    const walletInfo = this.walletRegistry.getById(walletId);
+    if (!walletInfo) {
+      const registry = this.walletRegistry;
+      if (registry.discoveryPromise) {
+        throw new Error(
+          `Wallet "${walletId}" not found. Wallet discovery is still in progress. Please wait for sdk.discoverWallets() to complete before accessing chain properties.`
+        );
+      }
+      throw new Error(
+        `Wallet "${walletId}" not found. Please ensure wallet discovery has completed. Make sure you call sdk.discoverWallets() and await it before accessing chain properties.`
+      );
+    }
+    if (!walletInfo.providers?.solana) {
+      throw new Error(
+        `Selected wallet "${walletInfo.name}" does not support Solana. This wallet only supports: ${walletInfo.addressTypes.join(", ")}. Make sure your SDK config includes Solana in addressTypes.`
+      );
     }
-    return this._solanaChain;
+    return walletInfo.providers.solana;
   }
   /**
    * Access to Ethereum chain operations
    */
   get ethereum() {
-    if (!this.addressTypes.includes(AddressType4.ethereum)) {
+    if (!this.addressTypes.includes(AddressType2.ethereum)) {
       throw new Error("Ethereum not enabled for this provider");
     }
-    if (!this._ethereumChain) {
-      throw new Error("Ethereum chain not initialized");
+    const walletId = this.selectedWalletId || "phantom";
+    const walletInfo = this.walletRegistry.getById(walletId);
+    if (!walletInfo) {
+      const registry = this.walletRegistry;
+      if (registry.discoveryPromise) {
+        throw new Error(
+          `Wallet "${walletId}" not found. Wallet discovery is still in progress. Please wait for sdk.discoverWallets() to complete before accessing chain properties.`
+        );
+      }
+      throw new Error(
+        `Wallet "${walletId}" not found. Please ensure wallet discovery has completed. Make sure you call sdk.discoverWallets() and await it before accessing chain properties.`
+      );
+    }
+    if (!walletInfo.providers?.ethereum) {
+      throw new Error(
+        `Selected wallet "${walletInfo.name}" does not support Ethereum. This wallet only supports: ${walletInfo.addressTypes.join(", ")}. Make sure your SDK config includes Ethereum in addressTypes.`
+      );
     }
-    return this._ethereumChain;
+    return walletInfo.providers.ethereum;
   }
-  async connect(authOptions) {
-    debug.info(DebugCategory.INJECTED_PROVIDER, "Starting injected provider connect", {
-      addressTypes: this.addressTypes,
-      authOptionsIgnored: !!authOptions
-      // Note: authOptions are ignored for injected provider
+  validateAndSelectWallet(requestedWalletId) {
+    if (!this.walletRegistry.has(requestedWalletId)) {
+      debug.error(DebugCategory.INJECTED_PROVIDER, "Unknown injected wallet id requested", {
+        walletId: requestedWalletId
+      });
+      throw new Error(`Unknown injected wallet id: ${requestedWalletId}`);
+    }
+    const walletInfo = this.walletRegistry.getById(requestedWalletId);
+    if (!walletInfo || !walletInfo.providers) {
+      debug.warn(DebugCategory.INJECTED_PROVIDER, "Wallet not available for connection", {
+        walletId: requestedWalletId
+      });
+      throw new Error(`Wallet not available for connection: ${requestedWalletId}`);
+    }
+    this.selectedWalletId = requestedWalletId;
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Selected injected wallet for connection", {
+      walletId: requestedWalletId
     });
-    this.emit("connect_start", {
-      source: "manual-connect",
-      providerType: "injected"
+    return walletInfo;
+  }
+  async connectToWallet(walletInfo, options) {
+    if (!walletInfo.providers) {
+      const error = new Error(`Wallet adapter not available for wallet: ${this.selectedWalletId}`);
+      debug.error(DebugCategory.INJECTED_PROVIDER, "Wallet adapter not available", { walletId: this.selectedWalletId });
+      this.emit("connect_error", {
+        error: error.message,
+        source: options?.skipEventListeners ? "auto-connect" : "manual-connect"
+      });
+      throw error;
+    }
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Connecting via wallet", {
+      walletId: this.selectedWalletId,
+      walletName: walletInfo.name,
+      options
     });
-    try {
-      if (!this.phantom.extension?.isInstalled?.()) {
-        debug.error(DebugCategory.INJECTED_PROVIDER, "Phantom wallet extension not found");
-        const error = new Error("Phantom wallet not found");
+    if (!options?.skipEventListeners) {
+      this.setupExternalWalletEvents(walletInfo);
+      if (this.selectedWalletId === "phantom" && isPhantomWallet(walletInfo)) {
+        this.browserInjectedCleanupFunctions.forEach((cleanup) => cleanup());
+        this.browserInjectedCleanupFunctions = [];
+        this.setupBrowserInjectedEvents();
+        this.eventsInitialized = true;
+      }
+    }
+    const connectedAddresses = [];
+    if (this.addressTypes.includes(AddressType2.solana) && walletInfo.providers?.solana) {
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Attempting Solana connection", {
+        walletId: this.selectedWalletId,
+        walletName: walletInfo.name,
+        onlyIfTrusted: options?.onlyIfTrusted
+      });
+      try {
+        const result = await walletInfo.providers.solana.connect(
+          options?.onlyIfTrusted ? { onlyIfTrusted: true } : void 0
+        );
+        const address = result.publicKey;
+        connectedAddresses.push({
+          addressType: AddressType2.solana,
+          address
+        });
+        debug.info(DebugCategory.INJECTED_PROVIDER, "Solana connected successfully", {
+          address,
+          walletId: this.selectedWalletId,
+          walletName: walletInfo.name
+        });
+      } catch (err) {
+        debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to connect Solana, stopping", {
+          error: err,
+          walletId: this.selectedWalletId,
+          walletName: walletInfo.name
+        });
         this.emit("connect_error", {
-          error: error.message,
-          source: "manual-connect"
+          error: err instanceof Error ? err.message : "Failed to connect",
+          source: options?.skipEventListeners ? "auto-connect" : "manual-connect"
         });
-        throw error;
+        throw err;
       }
-      debug.log(DebugCategory.INJECTED_PROVIDER, "Phantom extension detected");
-      const connectedAddresses = [];
-      if (this.addressTypes.includes(AddressType4.solana)) {
-        debug.log(DebugCategory.INJECTED_PROVIDER, "Attempting Solana connection");
-        try {
-          const publicKey = await this.phantom.solana.connect();
-          if (publicKey) {
-            connectedAddresses.push({
-              addressType: AddressType4.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 });
+    }
+    if (this.addressTypes.includes(AddressType2.ethereum) && walletInfo.providers?.ethereum) {
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Attempting Ethereum connection", {
+        walletId: this.selectedWalletId,
+        walletName: walletInfo.name,
+        silent: options?.silent
+      });
+      try {
+        let accounts;
+        if (options?.silent) {
+          accounts = await walletInfo.providers.ethereum.request({ method: "eth_accounts" });
+        } else {
+          accounts = await walletInfo.providers.ethereum.connect();
         }
-      }
-      if (this.addressTypes.includes(AddressType4.ethereum)) {
-        try {
-          const accounts = await this.phantom.ethereum.connect();
-          if (accounts && accounts.length > 0) {
-            connectedAddresses.push(
-              ...accounts.map((address) => ({
-                addressType: AddressType4.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 });
+        if (accounts.length > 0) {
+          connectedAddresses.push(
+            ...accounts.map((address) => ({
+              addressType: AddressType2.ethereum,
+              address
+            }))
+          );
+          debug.info(DebugCategory.INJECTED_PROVIDER, "Ethereum connected successfully", {
+            addresses: accounts,
+            walletId: this.selectedWalletId,
+            walletName: walletInfo.name
+          });
         }
-      }
-      if (connectedAddresses.length === 0) {
-        const error = new Error("Failed to connect to any supported wallet provider");
+      } catch (err) {
+        debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to connect Ethereum, stopping", {
+          error: err,
+          walletId: this.selectedWalletId,
+          walletName: walletInfo.name
+        });
         this.emit("connect_error", {
-          error: error.message,
-          source: "manual-connect"
+          error: err instanceof Error ? err.message : "Failed to connect",
+          source: options?.skipEventListeners ? "auto-connect" : "manual-connect"
         });
-        throw error;
+        throw err;
       }
-      this.addresses = connectedAddresses;
-      this.connected = true;
-      const result = {
-        addresses: this.addresses,
-        status: "completed"
-        // walletId is not applicable for injected providers
-      };
-      this.emit("connect", {
-        addresses: this.addresses,
+    }
+    return connectedAddresses;
+  }
+  async finalizeConnection(connectedAddresses, authProvider, walletId) {
+    if (connectedAddresses.length === 0) {
+      const error = new Error("Failed to connect to any supported wallet provider");
+      this.emit("connect_error", {
+        error: error.message,
         source: "manual-connect"
       });
-      return result;
-    } catch (error) {
-      if (error instanceof Error && !error.message.includes("Phantom wallet not found") && !error.message.includes("Failed to connect to any supported wallet provider")) {
-        this.emit("connect_error", {
-          error: error.message,
-          source: "manual-connect"
+      throw error;
+    }
+    if (this.selectedWalletId) {
+      this.setWalletState(this.selectedWalletId, {
+        connected: true,
+        addresses: connectedAddresses
+      });
+    }
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Finalized connection with addresses", {
+      addressCount: connectedAddresses.length,
+      addresses: connectedAddresses.map((addr) => ({
+        type: addr.addressType,
+        address: addr.address.substring(0, 10) + "..."
+      }))
+    });
+    const authUserId = await this.getAuthUserId("manual-connect");
+    try {
+      localStorage.setItem(WAS_CONNECTED_KEY, WAS_CONNECTED_VALUE);
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Set was-connected flag - auto-reconnect enabled");
+      if (this.selectedWalletId) {
+        localStorage.setItem(LAST_WALLET_ID_KEY, this.selectedWalletId);
+        debug.log(DebugCategory.INJECTED_PROVIDER, "Stored last injected wallet id", {
+          walletId: this.selectedWalletId
         });
       }
+    } catch (error) {
+      debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to persist injected provider state", { error });
+    }
+    const walletInfo = walletId ? this.walletRegistry.getById(walletId) : void 0;
+    const wallet = walletInfo ? {
+      id: walletInfo.id,
+      name: walletInfo.name,
+      icon: walletInfo.icon,
+      addressTypes: walletInfo.addressTypes,
+      rdns: walletInfo.rdns,
+      discovery: walletInfo.discovery
+    } : void 0;
+    const result = {
+      addresses: connectedAddresses,
+      status: "completed",
+      authUserId,
+      authProvider,
+      walletId,
+      wallet
+    };
+    this.emit("connect", {
+      addresses: connectedAddresses,
+      source: "manual-connect",
+      authUserId
+    });
+    return result;
+  }
+  async connect(authOptions) {
+    debug.info(DebugCategory.INJECTED_PROVIDER, "Starting injected provider connect", {
+      addressTypes: this.addressTypes,
+      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"
+    });
+    try {
+      const requestedWalletId = authOptions.walletId || "phantom";
+      const walletInfo = this.validateAndSelectWallet(requestedWalletId);
+      const connectedAddresses = await this.connectToWallet(walletInfo);
+      return await this.finalizeConnection(connectedAddresses, "injected", this.selectedWalletId || void 0);
+    } catch (error) {
+      this.emit("connect_error", {
+        error: error instanceof Error ? error.message : "Failed to connect",
+        source: "manual-connect"
+      });
       throw error;
     }
   }
   async disconnect() {
     debug.info(DebugCategory.INJECTED_PROVIDER, "Starting injected provider disconnect");
-    if (this.addressTypes.includes(AddressType4.solana)) {
-      try {
-        await this.phantom.solana.disconnect();
-        debug.log(DebugCategory.INJECTED_PROVIDER, "Solana disconnected successfully");
-      } catch (err) {
-        debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to disconnect Solana", { error: err });
+    const walletInfo = this.walletRegistry.getById(this.selectedWalletId || "phantom");
+    if (walletInfo?.providers) {
+      if (this.addressTypes.includes(AddressType2.solana) && walletInfo.providers.solana) {
+        try {
+          await walletInfo.providers.solana.disconnect();
+          debug.log(DebugCategory.INJECTED_PROVIDER, "Solana disconnected successfully");
+        } catch (err) {
+          debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to disconnect Solana", { error: err });
+        }
+      }
+      if (this.addressTypes.includes(AddressType2.ethereum) && walletInfo.providers.ethereum) {
+        try {
+          await walletInfo.providers.ethereum.disconnect();
+          debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum disconnected successfully");
+        } catch (err) {
+          debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to disconnect Ethereum", { error: err });
+        }
       }
-    }
-    if (this.addressTypes.includes(AddressType4.ethereum)) {
-      debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum disconnected (no-op)");
     }
     this.browserInjectedCleanupFunctions.forEach((cleanup) => cleanup());
     this.browserInjectedCleanupFunctions = [];
-    this.connected = false;
-    this.addresses = [];
+    if (this.selectedWalletId) {
+      this.externalWalletEventListenersSetup.delete(this.selectedWalletId);
+      this.setWalletState(this.selectedWalletId, {
+        connected: false,
+        addresses: []
+      });
+    }
+    try {
+      localStorage.removeItem(WAS_CONNECTED_KEY);
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Cleared was connected flag to prevent auto-reconnect");
+    } catch (error) {
+      debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to clear was-connected 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
+   * Attempt auto-connection if user was previously connected
+   * Only reconnects if the user connected before and didn't explicitly disconnect
    * Should be called after setting up event listeners
    */
   async autoConnect() {
-    debug.log(DebugCategory.INJECTED_PROVIDER, "Attempting auto-connect with onlyIfTrusted=true");
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Attempting auto-connect");
+    let lastWalletId = null;
+    try {
+      const wasConnected = localStorage.getItem(WAS_CONNECTED_KEY);
+      if (wasConnected !== WAS_CONNECTED_VALUE) {
+        debug.log(DebugCategory.INJECTED_PROVIDER, "Skipping auto-connect: user was not previously connected");
+        return;
+      }
+      lastWalletId = localStorage.getItem(LAST_WALLET_ID_KEY);
+      debug.log(DebugCategory.INJECTED_PROVIDER, "User was previously connected, attempting auto-connect", {
+        lastWalletId: lastWalletId || "phantom"
+      });
+    } catch (error) {
+      debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to check was-connected flag", { error });
+      return;
+    }
     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"
+      const walletId = lastWalletId || "phantom";
+      await this.waitForWalletDiscovery(walletId);
+      const walletInfo = this.validateAndSelectWallet(walletId);
+      let connectedAddresses = [];
+      try {
+        connectedAddresses = await this.connectToWallet(walletInfo, {
+          onlyIfTrusted: true,
+          silent: true,
+          skipEventListeners: true
+          // Set up listeners only if connection succeeds
+        });
+      } catch (err) {
+        debug.log(DebugCategory.INJECTED_PROVIDER, "Auto-connect failed (expected if not trusted)", {
+          error: err,
+          walletId: this.selectedWalletId
         });
-        return;
-      }
-      const connectedAddresses = [];
-      if (this.addressTypes.includes(AddressType4.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: AddressType4.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(AddressType4.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: AddressType4.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");
@@ -572,15 +2113,33 @@ var InjectedProvider = class {
         });
         return;
       }
-      this.addresses = connectedAddresses;
-      this.connected = true;
+      this.setupExternalWalletEvents(walletInfo);
+      if (this.selectedWalletId === "phantom" && isPhantomWallet(walletInfo)) {
+        this.browserInjectedCleanupFunctions.forEach((cleanup) => cleanup());
+        this.browserInjectedCleanupFunctions = [];
+        this.setupBrowserInjectedEvents();
+        this.eventsInitialized = true;
+      }
+      if (this.selectedWalletId) {
+        this.setWalletState(this.selectedWalletId, {
+          connected: true,
+          addresses: connectedAddresses
+        });
+      }
+      const authUserId = await this.getAuthUserId("auto-connect");
       this.emit("connect", {
-        addresses: this.addresses,
-        source: "auto-connect"
+        addresses: connectedAddresses,
+        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) + "..." }))
+        addresses: connectedAddresses.map((addr) => ({
+          type: addr.addressType,
+          address: addr.address.substring(0, 8) + "..."
+        })),
+        walletId: this.selectedWalletId,
+        authUserId
       });
     } catch (error) {
       debug.log(DebugCategory.INJECTED_PROVIDER, "Auto-connect failed with error", {
@@ -592,28 +2151,103 @@ var InjectedProvider = class {
       });
     }
   }
+  getWalletState(walletId) {
+    if (!this.walletStates.has(walletId)) {
+      this.walletStates.set(walletId, { connected: false, addresses: [] });
+    }
+    return this.walletStates.get(walletId);
+  }
+  setWalletState(walletId, state) {
+    this.walletStates.set(walletId, state);
+  }
   getAddresses() {
-    return this.addresses;
+    const walletId = this.selectedWalletId || "phantom";
+    return this.getWalletState(walletId).addresses;
+  }
+  /**
+   * Get enabled address types for the current selected wallet
+   * - For Phantom: returns config.addressTypes
+   * - For external wallets: returns the wallet's addressTypes from registry
+   */
+  getEnabledAddressTypes() {
+    if (!this.selectedWalletId || this.selectedWalletId === "phantom") {
+      return this.addressTypes;
+    }
+    const walletInfo = this.walletRegistry.getById(this.selectedWalletId);
+    if (walletInfo) {
+      return walletInfo.addressTypes;
+    }
+    return this.addressTypes;
   }
   isConnected() {
-    return this.connected;
+    const walletId = this.selectedWalletId || "phantom";
+    return this.getWalletState(walletId).connected;
   }
-  // AutoConfirm methods - only available for injected providers
+  // AutoConfirm methods - only available for Phantom wallet
   async enableAutoConfirm(params) {
+    const walletInfo = this.walletRegistry.getById(this.selectedWalletId || "phantom");
+    if (!isPhantomWallet(walletInfo)) {
+      throw new Error("Auto-confirm is only available for Phantom wallet");
+    }
     debug.log(DebugCategory.INJECTED_PROVIDER, "Enabling autoConfirm", { params });
-    return await this.phantom.autoConfirm.autoConfirmEnable(params);
+    return await walletInfo.phantomInstance.autoConfirm.autoConfirmEnable(params);
   }
   async disableAutoConfirm() {
+    const walletInfo = this.walletRegistry.getById(this.selectedWalletId || "phantom");
+    if (!isPhantomWallet(walletInfo)) {
+      throw new Error("Auto-confirm is only available for Phantom wallet");
+    }
     debug.log(DebugCategory.INJECTED_PROVIDER, "Disabling autoConfirm");
-    await this.phantom.autoConfirm.autoConfirmDisable();
+    await walletInfo.phantomInstance.autoConfirm.autoConfirmDisable();
   }
   async getAutoConfirmStatus() {
+    const walletInfo = this.walletRegistry.getById(this.selectedWalletId || "phantom");
+    if (!isPhantomWallet(walletInfo)) {
+      throw new Error("Auto-confirm is only available for Phantom wallet");
+    }
     debug.log(DebugCategory.INJECTED_PROVIDER, "Getting autoConfirm status");
-    return await this.phantom.autoConfirm.autoConfirmStatus();
+    return await walletInfo.phantomInstance.autoConfirm.autoConfirmStatus();
   }
   async getSupportedAutoConfirmChains() {
+    const walletInfo = this.walletRegistry.getById(this.selectedWalletId || "phantom");
+    if (!isPhantomWallet(walletInfo)) {
+      throw new Error("Auto-confirm is only available for Phantom wallet");
+    }
     debug.log(DebugCategory.INJECTED_PROVIDER, "Getting supported autoConfirm chains");
-    return await this.phantom.autoConfirm.autoConfirmSupportedChains();
+    return await walletInfo.phantomInstance.autoConfirm.autoConfirmSupportedChains();
+  }
+  /**
+   * Helper method to get authUserId from window.phantom.app.getUser()
+   * Returns undefined if the method is not available or fails, or if wallet is not Phantom
+   */
+  async getAuthUserId(context) {
+    const walletInfo = this.walletRegistry.getById(this.selectedWalletId || "phantom");
+    if (!isPhantomWallet(walletInfo)) {
+      return void 0;
+    }
+    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) {
@@ -654,132 +2288,245 @@ var InjectedProvider = class {
     }
   }
   setupBrowserInjectedEvents() {
-    debug.log(DebugCategory.INJECTED_PROVIDER, "Setting up browser-injected-sdk event listeners");
-    if (this.addressTypes.includes(AddressType4.solana)) {
-      this.setupSolanaEvents();
+    const walletInfo = this.walletRegistry.getById(this.selectedWalletId || "phantom");
+    if (!isPhantomWallet(walletInfo)) {
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Skipping browser-injected-sdk event setup - not Phantom wallet");
+      return;
     }
-    if (this.addressTypes.includes(AddressType4.ethereum)) {
-      this.setupEthereumEvents();
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Setting up browser-injected-sdk event listeners");
+    if (this.selectedWalletId === "phantom" && isPhantomWallet(walletInfo)) {
+      if (this.addressTypes.includes(AddressType2.solana)) {
+        this.setupSolanaEvents(walletInfo.phantomInstance);
+      }
+      if (this.addressTypes.includes(AddressType2.ethereum)) {
+        this.setupEthereumEvents(walletInfo.phantomInstance);
+      }
     }
   }
-  setupSolanaEvents() {
+  setupSolanaEvents(phantom) {
     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: AddressType4.solana, address: publicKey };
-      if (!this.addresses.find((addr) => addr.addressType === AddressType4.solana)) {
-        this.addresses.push(solanaAddress);
-      }
-      this.connected = true;
+      const walletId = this.selectedWalletId || "phantom";
+      const state = this.getWalletState(walletId);
+      const solanaAddress = { addressType: AddressType2.solana, address: publicKey };
+      const hasSolana = state.addresses.some((addr) => addr.addressType === AddressType2.solana);
+      const newAddresses = hasSolana ? state.addresses.map((addr) => addr.addressType === AddressType2.solana ? solanaAddress : addr) : [...state.addresses, solanaAddress];
+      this.setWalletState(walletId, {
+        connected: true,
+        addresses: newAddresses
+      });
+      const authUserId = await this.getAuthUserId("Solana connect event");
       this.emit("connect", {
-        addresses: this.addresses,
-        source: "injected-extension"
+        addresses: newAddresses,
+        source: "injected-extension",
+        authUserId
       });
     };
     const handleSolanaDisconnect = () => {
       debug.log(DebugCategory.INJECTED_PROVIDER, "Solana disconnect event received");
-      this.addresses = this.addresses.filter((addr) => addr.addressType !== AddressType4.solana);
-      this.connected = false;
+      const walletId = this.selectedWalletId || "phantom";
+      const state = this.getWalletState(walletId);
+      const filteredAddresses = state.addresses.filter((addr) => addr.addressType !== AddressType2.solana);
+      this.setWalletState(walletId, {
+        connected: filteredAddresses.length > 0,
+        addresses: filteredAddresses
+      });
       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 === AddressType4.solana);
-      if (solanaIndex >= 0) {
-        this.addresses[solanaIndex] = { addressType: AddressType4.solana, address: publicKey };
-      } else {
-        this.addresses.push({ addressType: AddressType4.solana, address: publicKey });
-      }
+      const walletId = this.selectedWalletId || "phantom";
+      const state = this.getWalletState(walletId);
+      const solanaIndex = state.addresses.findIndex((addr) => addr.addressType === AddressType2.solana);
+      const newAddresses = solanaIndex >= 0 ? state.addresses.map(
+        (addr, idx) => idx === solanaIndex ? { addressType: AddressType2.solana, address: publicKey } : addr
+      ) : [...state.addresses, { addressType: AddressType2.solana, address: publicKey }];
+      this.setWalletState(walletId, {
+        connected: true,
+        addresses: newAddresses
+      });
+      const authUserId = await this.getAuthUserId("Solana account changed event");
       this.emit("connect", {
-        addresses: this.addresses,
-        source: "injected-extension-account-change"
+        addresses: newAddresses,
+        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 cleanupConnect = phantom.solana.addEventListener("connect", handleSolanaConnect);
+    const cleanupDisconnect = phantom.solana.addEventListener("disconnect", handleSolanaDisconnect);
+    const cleanupAccountChanged = phantom.solana.addEventListener("accountChanged", handleSolanaAccountChanged);
     this.browserInjectedCleanupFunctions.push(cleanupConnect, cleanupDisconnect, cleanupAccountChanged);
   }
-  setupEthereumEvents() {
+  setupEthereumEvents(phantom) {
     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 !== AddressType4.ethereum);
-      if (accounts && accounts.length > 0) {
-        this.addresses.push(
-          ...accounts.map((address) => ({
-            addressType: AddressType4.ethereum,
-            address
-          }))
-        );
-      }
-      this.connected = this.addresses.length > 0;
+      const walletId = this.selectedWalletId || "phantom";
+      const state = this.getWalletState(walletId);
+      const ethAddresses = accounts.map((address) => ({ addressType: AddressType2.ethereum, address }));
+      const otherAddresses = state.addresses.filter((addr) => addr.addressType !== AddressType2.ethereum);
+      const newAddresses = [...otherAddresses, ...ethAddresses];
+      this.setWalletState(walletId, {
+        connected: true,
+        addresses: newAddresses
+      });
+      const authUserId = await this.getAuthUserId("Ethereum connect event");
       this.emit("connect", {
-        addresses: this.addresses,
-        source: "injected-extension"
+        addresses: newAddresses,
+        source: "injected-extension",
+        authUserId
       });
     };
     const handleEthereumDisconnect = () => {
       debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum disconnect event received");
-      this.addresses = this.addresses.filter((addr) => addr.addressType !== AddressType4.ethereum);
-      this.connected = false;
+      const walletId = this.selectedWalletId || "phantom";
+      const state = this.getWalletState(walletId);
+      const filteredAddresses = state.addresses.filter((addr) => addr.addressType !== AddressType2.ethereum);
+      this.setWalletState(walletId, {
+        connected: filteredAddresses.length > 0,
+        addresses: filteredAddresses
+      });
       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 !== AddressType4.ethereum);
+      const walletId = this.selectedWalletId || "phantom";
+      const state = this.getWalletState(walletId);
+      const otherAddresses = state.addresses.filter((addr) => addr.addressType !== AddressType2.ethereum);
       if (accounts && accounts.length > 0) {
-        this.addresses.push(
-          ...accounts.map((address) => ({
-            addressType: AddressType4.ethereum,
-            address
-          }))
-        );
+        const ethAddresses = accounts.map((address) => ({ addressType: AddressType2.ethereum, address }));
+        const newAddresses = [...otherAddresses, ...ethAddresses];
+        this.setWalletState(walletId, {
+          connected: true,
+          addresses: newAddresses
+        });
+        const authUserId = await this.getAuthUserId("Ethereum accounts changed event");
         this.emit("connect", {
-          addresses: this.addresses,
-          source: "injected-extension-account-change"
+          addresses: newAddresses,
+          source: "injected-extension-account-change",
+          authUserId
         });
       } else {
-        this.connected = false;
+        this.setWalletState(walletId, {
+          connected: otherAddresses.length > 0,
+          addresses: otherAddresses
+        });
         this.emit("disconnect", {
           source: "injected-extension-account-change"
         });
       }
     };
-    const cleanupConnect = this.phantom.ethereum.addEventListener("connect", handleEthereumConnect);
-    const cleanupDisconnect = this.phantom.ethereum.addEventListener("disconnect", handleEthereumDisconnect);
-    const cleanupAccountsChanged = this.phantom.ethereum.addEventListener(
-      "accountsChanged",
-      handleEthereumAccountsChanged
-    );
+    const cleanupConnect = phantom.ethereum.addEventListener("connect", handleEthereumConnect);
+    const cleanupDisconnect = phantom.ethereum.addEventListener("disconnect", handleEthereumDisconnect);
+    const cleanupAccountsChanged = phantom.ethereum.addEventListener("accountsChanged", handleEthereumAccountsChanged);
     this.browserInjectedCleanupFunctions.push(cleanupConnect, cleanupDisconnect, cleanupAccountsChanged);
   }
-  createCallbacks() {
-    return {
-      connect: async () => {
-        const result = await this.connect();
-        return result.addresses;
-      },
-      disconnect: async () => {
-        await this.disconnect();
-      },
-      isConnected: () => {
-        return this.isConnected();
-      },
-      getAddresses: () => {
-        return this.getAddresses();
-      },
-      on: (event, callback) => {
-        this.on(event, callback);
-      },
-      off: (event, callback) => {
-        this.off(event, callback);
+  setupExternalWalletEvents(walletInfo) {
+    if (isPhantomWallet(walletInfo)) {
+      return;
+    }
+    if (!this.selectedWalletId || this.externalWalletEventListenersSetup.has(this.selectedWalletId)) {
+      return;
+    }
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Setting up external wallet event listeners", {
+      walletId: this.selectedWalletId
+    });
+    if (walletInfo.providers?.ethereum) {
+      const handleExternalEthereumAccountsChanged = async (accounts) => {
+        debug.log(DebugCategory.INJECTED_PROVIDER, "External wallet Ethereum accounts changed event received", {
+          walletId: this.selectedWalletId,
+          accounts
+        });
+        const walletId = this.selectedWalletId;
+        const state = this.getWalletState(walletId);
+        const otherAddresses = state.addresses.filter((addr) => addr.addressType !== AddressType2.ethereum);
+        if (accounts && accounts.length > 0) {
+          const ethAddresses = accounts.map((address) => ({ addressType: AddressType2.ethereum, address }));
+          const newAddresses = [...otherAddresses, ...ethAddresses];
+          this.setWalletState(walletId, {
+            connected: true,
+            addresses: newAddresses
+          });
+          debug.log(DebugCategory.INJECTED_PROVIDER, "Updated Ethereum addresses after account change", {
+            walletId,
+            oldCount: 0,
+            // We filtered them out
+            newCount: accounts.length,
+            addresses: newAddresses.filter((addr) => addr.addressType === AddressType2.ethereum)
+          });
+          const authUserId = await this.getAuthUserId("External wallet Ethereum accounts changed event");
+          this.emit("connect", {
+            addresses: newAddresses,
+            source: "external-wallet-account-change",
+            authUserId
+          });
+        } else {
+          this.setWalletState(walletId, {
+            connected: otherAddresses.length > 0,
+            addresses: otherAddresses
+          });
+          this.emit("disconnect", {
+            source: "external-wallet-account-change"
+          });
+        }
+      };
+      if (typeof walletInfo.providers.ethereum.on === "function") {
+        walletInfo.providers.ethereum.on("accountsChanged", handleExternalEthereumAccountsChanged);
+        this.browserInjectedCleanupFunctions.push(() => {
+          if (typeof walletInfo.providers?.ethereum?.off === "function") {
+            walletInfo.providers.ethereum.off("accountsChanged", handleExternalEthereumAccountsChanged);
+          }
+        });
       }
-    };
+    }
+    if (walletInfo.providers?.solana) {
+      const handleExternalSolanaAccountChanged = async (publicKey) => {
+        debug.log(DebugCategory.INJECTED_PROVIDER, "External wallet Solana account changed event received", {
+          walletId: this.selectedWalletId,
+          publicKey
+        });
+        const walletId = this.selectedWalletId;
+        const state = this.getWalletState(walletId);
+        const otherAddresses = state.addresses.filter((addr) => addr.addressType !== AddressType2.solana);
+        if (publicKey) {
+          const newAddresses = [...otherAddresses, { addressType: AddressType2.solana, address: publicKey }];
+          this.setWalletState(walletId, {
+            connected: true,
+            addresses: newAddresses
+          });
+          const authUserId = await this.getAuthUserId("External wallet Solana account changed event");
+          this.emit("connect", {
+            addresses: newAddresses,
+            source: "external-wallet-account-change",
+            authUserId
+          });
+        } else {
+          this.setWalletState(walletId, {
+            connected: otherAddresses.length > 0,
+            addresses: otherAddresses
+          });
+          this.emit("disconnect", {
+            source: "external-wallet-account-change"
+          });
+        }
+      };
+      if (typeof walletInfo.providers.solana.on === "function") {
+        walletInfo.providers.solana.on("accountChanged", handleExternalSolanaAccountChanged);
+        this.browserInjectedCleanupFunctions.push(() => {
+          if (typeof walletInfo.providers?.solana?.off === "function") {
+            walletInfo.providers.solana.off("accountChanged", handleExternalSolanaAccountChanged);
+          }
+        });
+      }
+    }
+    if (this.selectedWalletId) {
+      this.externalWalletEventListenersSetup.add(this.selectedWalletId);
+    }
   }
 };
 
@@ -866,6 +2613,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
@@ -879,6 +2667,147 @@ var browserUrlParamsAccessor = new BrowserURLParamsAccessor();
 
 // src/providers/embedded/adapters/auth.ts
 import { DEFAULT_AUTH_URL } from "@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;
@@ -897,21 +2826,24 @@ var BrowserAuthProvider = class {
       }
       const phantomOptions = options;
       debug.info(DebugCategory.PHANTOM_CONNECT_AUTH, "Starting Phantom Connect authentication", {
-        organizationId: phantomOptions.organizationId,
+        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;
       debug.log(DebugCategory.PHANTOM_CONNECT_AUTH, "Using auth URL", { baseUrl });
       const params = new URLSearchParams({
-        organization_id: phantomOptions.organizationId,
+        public_key: phantomOptions.publicKey,
         app_id: phantomOptions.appId,
         redirect_uri: phantomOptions.redirectUrl || (typeof window !== "undefined" ? this.getValidatedCurrentUrl() : ""),
         session_id: phantomOptions.sessionId,
-        clear_previous_session: true.toString(),
-        sdk_version: "1.0.0-beta.8"
+        // 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",
+        sdk_type: "browser",
+        platform: detectBrowser().name
       });
       if (phantomOptions.provider) {
         debug.log(DebugCategory.PHANTOM_CONNECT_AUTH, "Provider specified, will skip selection", {
@@ -922,12 +2854,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,
+        publicKey: phantomOptions.publicKey,
         appId: phantomOptions.appId,
         provider: phantomOptions.provider,
         sessionId: phantomOptions.sessionId
@@ -936,14 +2864,14 @@ 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:")) {
+      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();
     });
   }
-  resumeAuthFromRedirect() {
+  resumeAuthFromRedirect(provider) {
     try {
       const walletId = this.urlParamsAccessor.getParam("wallet_id");
       const sessionId = this.urlParamsAccessor.getParam("session_id");
@@ -994,10 +2922,37 @@ 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,
+        provider
       };
     } catch (error) {
       sessionStorage.removeItem("phantom-auth-context");
@@ -1006,160 +2961,120 @@ var BrowserAuthProvider = class {
   }
 };
 
-// src/providers/embedded/adapters/logger.ts
-var BrowserLogger = class {
-  info(category, message, data) {
-    debug.info(category, message, data);
-  }
-  warn(category, message, data) {
-    debug.warn(category, message, data);
-  }
-  error(category, message, data) {
-    debug.error(category, message, data);
-  }
-  log(category, message, data) {
-    debug.log(category, message, data);
-  }
-};
+// src/providers/embedded/adapters/phantom-app.ts
+import { isPhantomExtensionInstalled as isPhantomExtensionInstalled3 } from "@phantom/browser-injected-sdk";
 
-// 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" };
+// src/isPhantomLoginAvailable.ts
+import { isPhantomExtensionInstalled as isPhantomExtensionInstalled2 } from "@phantom/browser-injected-sdk";
+async function isPhantomLoginAvailable(timeoutMs = 3e3) {
+  const extensionInstalled = await waitForExtension(timeoutMs);
+  if (!extensionInstalled) {
+    return false;
   }
   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 (!window.phantom?.app?.features || typeof window.phantom.app.features !== "function") {
+      return false;
     }
-    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;
+    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 (isPhantomExtensionInstalled2()) {
+          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 isPhantomExtensionInstalled3();
+  }
+  /**
+   * 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)}`);
     }
-  } catch (error) {
   }
-  return { name, version, userAgent };
-}
-function detectBrowser() {
-  if (typeof window === "undefined" || !window.navigator?.userAgent) {
-    return { name: "unknown", version: "unknown", userAgent: "unknown" };
+};
+
+// src/providers/embedded/adapters/logger.ts
+var BrowserLogger = class {
+  info(category, message, data) {
+    debug.info(category, message, data);
   }
-  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;
+  warn(category, message, data) {
+    debug.warn(category, message, data);
   }
-  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;
+  error(category, message, data) {
+    debug.error(category, message, data);
   }
-  let isTouchDevice = false;
-  try {
-    isTouchDevice = "ontouchstart" in window || navigator.maxTouchPoints > 0;
-  } catch (error) {
-    isTouchDevice = false;
+  log(category, message, data) {
+    debug.log(category, message, data);
   }
-  return isMobileUA || isSmallScreen && isTouchDevice;
-}
+};
 
 // src/providers/embedded/index.ts
 import { ANALYTICS_HEADERS } from "@phantom/constants";
@@ -1177,6 +3092,7 @@ var EmbeddedProvider = class extends CoreEmbeddedProvider {
     const platform = {
       storage: new BrowserStorage(),
       authProvider: new BrowserAuthProvider(urlParamsAccessor),
+      phantomAppProvider: new BrowserPhantomAppProvider(),
       urlParamsAccessor,
       stamper,
       name: platformName,
@@ -1189,26 +3105,61 @@ var EmbeddedProvider = class extends CoreEmbeddedProvider {
         // Full user agent for more detailed info
         [ANALYTICS_HEADERS.APP_ID]: config.appId,
         [ANALYTICS_HEADERS.WALLET_TYPE]: config.embeddedWalletType,
-        [ANALYTICS_HEADERS.SDK_VERSION]: "1.0.0-beta.8"
+        [ANALYTICS_HEADERS.SDK_VERSION]: "1.0.0"
         // Replaced at build time
       }
     };
     debug.log(DebugCategory.EMBEDDED_PROVIDER, "Detected platform", { platformName });
     const logger = new BrowserLogger();
     super(config, platform, logger);
+    this.addressTypes = config.addressTypes;
     debug.info(DebugCategory.EMBEDDED_PROVIDER, "Browser EmbeddedProvider initialized");
   }
+  getEnabledAddressTypes() {
+    return this.addressTypes;
+  }
 };
 
 // src/ProviderManager.ts
+import {
+  EMBEDDED_PROVIDER_AUTH_TYPES
+} from "@phantom/embedded-provider-core";
 import { DEFAULT_WALLET_API_URL, DEFAULT_EMBEDDED_WALLET_TYPE, DEFAULT_AUTH_URL as DEFAULT_AUTH_URL2 } from "@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/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/ProviderManager.ts
 var ProviderManager = class {
   // Track which providers have forwarding set up
   constructor(config) {
     this.providers = /* @__PURE__ */ new Map();
     this.currentProvider = null;
     this.currentProviderKey = null;
-    this.walletId = null;
     // Event management for forwarding provider events
     this.eventListeners = /* @__PURE__ */ new Map();
     this.providerForwardingSetup = /* @__PURE__ */ new WeakSet();
@@ -1244,7 +3195,6 @@ var ProviderManager = class {
     }
     this.currentProvider = this.providers.get(key);
     this.currentProviderKey = key;
-    this.walletId = null;
     this.ensureProviderEventForwarding();
     return this.currentProvider;
   }
@@ -1267,29 +3217,78 @@ var ProviderManager = class {
       embeddedWalletType
     };
   }
+  /**
+   * Check if a provider is allowed by the config
+   */
+  isProviderAllowed(provider) {
+    return this.config.providers.includes(provider);
+  }
   /**
    * 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 }
     });
+    if (!this.isProviderAllowed(authOptions.provider)) {
+      const error = `Provider "${authOptions.provider}" is not in the allowed providers list: ${JSON.stringify(this.config.providers)}`;
+      debug.error(DebugCategory.PROVIDER_MANAGER, error);
+      throw new Error(error);
+    }
+    const requestedProvider = authOptions.provider;
+    let targetProviderType = null;
+    if (requestedProvider === "injected") {
+      targetProviderType = "injected";
+    } else if (requestedProvider === "deeplink") {
+      try {
+        const deeplinkUrl = getDeeplinkToPhantom();
+        if (typeof window !== "undefined") {
+          window.location.href = deeplinkUrl;
+        }
+        return {
+          addresses: [],
+          walletId: void 0,
+          authUserId: void 0
+        };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Failed to open deeplink";
+        debug.error(DebugCategory.PROVIDER_MANAGER, "Deeplink error", { error: errorMessage });
+        throw new Error(`Failed to open deeplink: ${errorMessage}`);
+      }
+    } else if (EMBEDDED_PROVIDER_AUTH_TYPES.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;
     debug.log(DebugCategory.PROVIDER_MANAGER, "Connection successful, saving preferences", {
-      walletId: this.walletId,
-      addressCount: result.addresses?.length || 0
+      addressCount: result.addresses?.length || 0,
+      provider: authOptions.provider
     });
     this.saveProviderPreference();
     debug.info(DebugCategory.PROVIDER_MANAGER, "Connect completed", {
-      walletId: this.walletId,
-      addresses: result.addresses
+      addresses: result.addresses,
+      provider: authOptions.provider
     });
     return result;
   }
@@ -1300,7 +3299,6 @@ var ProviderManager = class {
     if (!this.currentProvider)
       return;
     await this.currentProvider.disconnect();
-    this.walletId = null;
   }
   /**
    * Get addresses from current provider
@@ -1318,10 +3316,71 @@ 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 and is allowed, then injected provider if allowed
+   * 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);
+    const embeddedAllowed = this.config.providers.some((p) => p !== "injected");
+    if (embeddedAllowed && 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 injectedAllowed = this.config.providers.includes("injected");
+    const injectedKey = this.getProviderKey("injected");
+    if (injectedAllowed && 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 allowed providers");
+    return false;
   }
   /**
    * Add event listener - stores callback and ensures current provider forwards events to ProviderManager
@@ -1390,7 +3449,8 @@ var ProviderManager = class {
       "connect",
       "connect_error",
       "disconnect",
-      "error"
+      "error",
+      "spending_limit_reached"
     ];
     for (const event of eventsToForward) {
       const forwardingCallback = (data) => {
@@ -1404,12 +3464,33 @@ var ProviderManager = class {
   }
   /**
    * Set default provider based on initial config
+   * Creates providers based on the allowed providers array
    */
   setDefaultProvider() {
-    const defaultType = this.config.providerType || "embedded";
     const defaultEmbeddedType = this.config.embeddedWalletType || "user-wallet";
-    this.createProvider(defaultType, defaultEmbeddedType);
-    this.switchProvider(defaultType, { embeddedWalletType: defaultEmbeddedType });
+    const hasInjected = this.config.providers.includes("injected");
+    const hasEmbedded = this.config.providers.some((p) => p !== "injected" && p !== "deeplink");
+    if (hasInjected) {
+      debug.log(DebugCategory.PROVIDER_MANAGER, "Creating injected provider (allowed by providers array)");
+      this.createProvider("injected");
+    }
+    if (hasEmbedded) {
+      debug.log(DebugCategory.PROVIDER_MANAGER, "Creating embedded provider (allowed by providers array)");
+      this.createProvider("embedded", defaultEmbeddedType);
+    }
+    let defaultType;
+    if (hasEmbedded && this.providers.has(`embedded-${defaultEmbeddedType}`)) {
+      defaultType = "embedded";
+    } else if (hasInjected && this.providers.has("injected")) {
+      defaultType = "injected";
+    } else {
+      throw new Error("No valid providers could be created from the providers array");
+    }
+    const switchOptions = {};
+    if (defaultType === "embedded") {
+      switchOptions.embeddedWalletType = defaultEmbeddedType;
+    }
+    this.switchProvider(defaultType, switchOptions);
   }
   /**
    * Create a provider instance
@@ -1469,66 +3550,48 @@ 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
-import { isPhantomExtensionInstalled } from "@phantom/browser-injected-sdk";
-async function waitForPhantomExtension(timeoutMs = 3e3) {
-  return new Promise((resolve) => {
-    const startTime = Date.now();
-    const checkInterval = 100;
-    const checkForExtension = () => {
-      try {
-        if (isPhantomExtensionInstalled()) {
-          resolve(true);
-          return;
-        }
-      } catch (error) {
-      }
-      const elapsed = Date.now() - startTime;
-      if (elapsed >= timeoutMs) {
-        resolve(false);
-        return;
-      }
-      setTimeout(checkForExtension, checkInterval);
-    };
-    checkForExtension();
-  });
-}
-
 // src/BrowserSDK.ts
+import { EMBEDDED_PROVIDER_AUTH_TYPES as EMBEDDED_PROVIDER_AUTH_TYPES2 } from "@phantom/embedded-provider-core";
 import { DEFAULT_EMBEDDED_WALLET_TYPE as DEFAULT_EMBEDDED_WALLET_TYPE2 } from "@phantom/constants";
+var BROWSER_SDK_PROVIDER_TYPES = [
+  ...EMBEDDED_PROVIDER_AUTH_TYPES2,
+  "injected",
+  "deeplink"
+];
 var BrowserSDK = class {
   constructor(config) {
+    this.walletRegistry = getWalletRegistry();
+    this.isLoading = true;
     debug.info(DebugCategory.BROWSER_SDK, "Initializing BrowserSDK", {
-      providerType: config.providerType,
+      providers: config.providers,
       embeddedWalletType: config.embeddedWalletType,
       addressTypes: config.addressTypes
     });
-    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".`);
+    if (!Array.isArray(config.providers) || config.providers.length === 0) {
+      debug.error(DebugCategory.BROWSER_SDK, "Invalid providers array", { providers: config.providers });
+      throw new Error("providers must be a non-empty array of AuthProviderType");
+    }
+    const invalidProviders = config.providers.filter((p) => !BROWSER_SDK_PROVIDER_TYPES.includes(p));
+    if (invalidProviders.length > 0) {
+      debug.error(DebugCategory.BROWSER_SDK, "Invalid provider types", {
+        invalidProviders,
+        validProviders: BROWSER_SDK_PROVIDER_TYPES
+      });
+      throw new Error(
+        `Invalid provider type(s): ${invalidProviders.join(", ")}. Valid providers are: ${BROWSER_SDK_PROVIDER_TYPES.join(", ")}`
+      );
+    }
+    const hasEmbeddedProviders = config.providers.some((p) => p !== "injected");
+    if (hasEmbeddedProviders && !config.appId) {
+      debug.error(DebugCategory.BROWSER_SDK, "appId required for embedded providers", {
+        providers: config.providers
+      });
+      throw new Error("appId is required when using embedded providers (google, apple, phantom, etc.)");
     }
     const embeddedWalletType = config.embeddedWalletType || DEFAULT_EMBEDDED_WALLET_TYPE2;
-    if (config.providerType === "embedded" && !["app-wallet", "user-wallet"].includes(embeddedWalletType)) {
+    if (!["app-wallet", "user-wallet"].includes(embeddedWalletType)) {
       debug.error(DebugCategory.BROWSER_SDK, "Invalid embeddedWalletType", {
         embeddedWalletType: config.embeddedWalletType
       });
@@ -1536,7 +3599,14 @@ var BrowserSDK = class {
         `Invalid embeddedWalletType: ${config.embeddedWalletType}. Must be "app-wallet" or "user-wallet".`
       );
     }
+    this.config = config;
     this.providerManager = new ProviderManager(config);
+    void this.discoverWallets();
+  }
+  discoverWallets() {
+    return this.walletRegistry.discover(this.config.addressTypes).finally(() => {
+      this.isLoading = false;
+    });
   }
   // ===== CHAIN API =====
   /**
@@ -1569,7 +3639,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;
@@ -1591,22 +3660,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
@@ -1627,18 +3680,19 @@ var BrowserSDK = class {
     return this.providerManager.getCurrentProviderInfo();
   }
   /**
-   * Get the wallet ID (for embedded wallets)
+   * Get enabled address types for the current provider
+   * - For embedded provider: returns config.addressTypes
+   * - For Phantom injected: returns config.addressTypes
+   * - For discovered wallets: returns the wallet's addressTypes from registry
    */
-  getWalletId() {
-    return this.providerManager.getWalletId();
+  getEnabledAddressTypes() {
+    const currentProvider = this.providerManager.getCurrentProvider();
+    if (!currentProvider) {
+      return [];
+    }
+    return currentProvider.getEnabledAddressTypes();
   }
   // ===== UTILITY METHODS =====
-  /**
-   * Check if Phantom extension is installed
-   */
-  static async isPhantomInstalled(timeoutMs) {
-    return waitForPhantomExtension(timeoutMs);
-  }
   /**
    * Add event listener for provider events (connect, connect_start, connect_error, disconnect, error)
    * Works with both embedded and injected providers
@@ -1658,53 +3712,34 @@ 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) {
-      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");
     }
   }
-  /**
-   * Debug configuration methods
-   * These allow dynamic debug configuration without SDK reinstantiation
-   */
-  /**
-   * Enable debug logging
-   */
   enableDebug() {
     debug.enable();
     debug.info(DebugCategory.BROWSER_SDK, "Debug logging enabled");
   }
-  /**
-   * Disable debug logging
-   */
   disableDebug() {
     debug.disable();
   }
-  /**
-   * Set debug level
-   */
   setDebugLevel(level) {
     debug.setLevel(level);
     debug.info(DebugCategory.BROWSER_SDK, "Debug level updated", { level });
   }
-  /**
-   * Set debug callback function
-   */
   setDebugCallback(callback) {
     debug.setCallback(callback);
     debug.info(DebugCategory.BROWSER_SDK, "Debug callback updated");
   }
-  /**
-   * Configure debug settings all at once
-   */
   configureDebug(config) {
     if (config.enabled !== void 0) {
       if (config.enabled) {
@@ -1810,23 +3845,54 @@ var BrowserSDK = class {
       throw error;
     }
   }
+  getDiscoveredWallets() {
+    debug.log(DebugCategory.BROWSER_SDK, "Getting discovered wallets");
+    try {
+      const allWallets = this.walletRegistry.getByAddressTypes(this.config.addressTypes);
+      debug.log(DebugCategory.BROWSER_SDK, "Retrieved discovered wallets", {
+        count: allWallets.length,
+        walletIds: allWallets.map((w) => w.id)
+      });
+      return allWallets;
+    } catch (error) {
+      debug.error(DebugCategory.BROWSER_SDK, "Failed to get discovered wallets", {
+        error: error.message
+      });
+      return [];
+    }
+  }
 };
 
-// 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/waitForPhantomExtension.ts
+import { isPhantomExtensionInstalled as isPhantomExtensionInstalled4 } from "@phantom/browser-injected-sdk";
+async function waitForPhantomExtension(timeoutMs = 3e3) {
+  return new Promise((resolve) => {
+    const startTime = Date.now();
+    const checkInterval = 100;
+    const checkForExtension = () => {
+      try {
+        if (isPhantomExtensionInstalled4()) {
+          resolve(true);
+          return;
+        }
+      } catch (error) {
+      }
+      const elapsed = Date.now() - startTime;
+      if (elapsed >= timeoutMs) {
+        resolve(false);
+        return;
+      }
+      setTimeout(checkForExtension, checkInterval);
+    };
+    checkForExtension();
+  });
 }
 
 // src/index.ts
 import { NetworkId } from "@phantom/constants";
-import { AddressType as AddressType5 } from "@phantom/client";
+import { AddressType as AddressType3 } from "@phantom/client";
 export {
-  AddressType5 as AddressType,
+  AddressType3 as AddressType,
   BrowserSDK,
   DebugCategory,
   DebugLevel,
@@ -1837,6 +3903,7 @@ export {
   getDeeplinkToPhantom,
   getPlatformName,
   isMobileDevice,
+  isPhantomLoginAvailable,
   parseBrowserFromUserAgent,
   waitForPhantomExtension
 };