@phantom/browser-sdk 1.0.0-beta.0 → 1.0.0-beta.10

package/dist/index.js

@@ -20,23 +20,27 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  AddressType: () => import_client3.AddressType,
+  AddressType: () => import_client5.AddressType,
   BrowserSDK: () => BrowserSDK,
-  DEFAULT_AUTH_URL: () => DEFAULT_AUTH_URL,
-  DEFAULT_WALLET_API_URL: () => DEFAULT_WALLET_API_URL,
   DebugCategory: () => DebugCategory,
   DebugLevel: () => DebugLevel,
-  NetworkId: () => import_constants4.NetworkId,
+  NetworkId: () => import_constants5.NetworkId,
   debug: () => debug,
   detectBrowser: () => detectBrowser,
   getBrowserDisplayName: () => getBrowserDisplayName,
+  getDeeplinkToPhantom: () => getDeeplinkToPhantom,
   getPlatformName: () => getPlatformName,
-  parseBrowserFromUserAgent: () => parseBrowserFromUserAgent
+  isMobileDevice: () => isMobileDevice,
+  parseBrowserFromUserAgent: () => parseBrowserFromUserAgent,
+  waitForPhantomExtension: () => waitForPhantomExtension
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/providers/injected/index.ts
+// src/types.ts
 var import_client = require("@phantom/client");
+
+// src/providers/injected/index.ts
+var import_client4 = require("@phantom/client");
 var import_browser_injected_sdk = require("@phantom/browser-injected-sdk");
 var import_solana = require("@phantom/browser-injected-sdk/solana");
 var import_ethereum = require("@phantom/browser-injected-sdk/ethereum");
@@ -117,97 +121,206 @@ var DebugCategory = {
 };
 
 // src/providers/injected/chains/SolanaChain.ts
-var import_constants = require("@phantom/constants");
+var import_eventemitter3 = require("eventemitter3");
+var import_client2 = require("@phantom/client");
 var import_buffer = require("buffer");
 var InjectedSolanaChain = class {
-  constructor(phantom) {
+  constructor(phantom, callbacks) {
+    this._connected = false;
+    this._publicKey = null;
+    this.eventEmitter = new import_eventemitter3.EventEmitter();
     this.phantom = phantom;
+    this.callbacks = callbacks;
+    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 === import_client2.AddressType.solana);
+    if (!solanaAddress) {
+      return Promise.reject(new Error("Solana not enabled for this provider"));
+    }
+    this.updateConnectionState(true, solanaAddress.address);
+    return Promise.resolve({ publicKey: solanaAddress.address });
   }
+  async disconnect() {
+    await this.callbacks.disconnect();
+  }
+  // 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);
-    const signature = result.signature instanceof Uint8Array ? import_buffer.Buffer.from(result.signature).toString("base64") : result.signature;
     return {
-      signature,
-      rawSignature: signature
+      signature: result.signature instanceof Uint8Array ? result.signature : new Uint8Array(import_buffer.Buffer.from(result.signature, "base64")),
+      publicKey: this._publicKey || ""
     };
   }
-  signTransaction(_transaction) {
-    throw new Error("signTransaction not available in browser-injected-sdk, use signAndSendTransaction instead");
+  async signTransaction(transaction) {
+    if (!this.callbacks.isConnected()) {
+      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 {
-      hash: result.signature,
-      rawTransaction: result.signature,
-      blockExplorer: (0, import_constants.getExplorerUrl)(import_constants.NetworkId.SOLANA_MAINNET, "transaction", result.signature)
-    };
+    return { signature: result.signature };
   }
-  async connect(_options) {
-    const address = await this.phantom.solana.connect();
-    if (!address) {
-      throw new Error("Failed to connect to Solana wallet");
+  async signAllTransactions(transactions) {
+    if (!this.callbacks.isConnected()) {
+      return Promise.reject(new Error("Provider not connected. Call provider connect first."));
+    }
+    try {
+      const result = await this.phantom.solana.signAllTransactions(transactions);
+      return result;
+    } catch (error) {
+      return Promise.reject(error);
     }
-    return { publicKey: address };
-  }
-  async disconnect() {
-    return await this.phantom.solana.disconnect();
-  }
-  async switchNetwork(_network) {
   }
-  async getPublicKey() {
+  async signAndSendAllTransactions(transactions) {
+    if (!this.callbacks.isConnected()) {
+      return Promise.reject(new Error("Provider not connected. Call provider connect first."));
+    }
     try {
-      const address = await this.phantom.solana.getAccount();
-      return address || null;
-    } catch {
-      return null;
+      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() {
-    try {
-      return !!this.phantom.extension?.isInstalled();
-    } catch {
-      return false;
+    return this._connected && this.callbacks.isConnected();
+  }
+  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 === import_client2.AddressType.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 === import_client2.AddressType.solana);
+      if (solanaAddress) {
+        this.updateConnectionState(true, solanaAddress.address);
+      }
     }
   }
+  updateConnectionState(connected, publicKey) {
+    this._connected = connected;
+    this._publicKey = 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
-var import_constants2 = require("@phantom/constants");
+var import_eventemitter32 = require("eventemitter3");
+var import_client3 = require("@phantom/client");
 var InjectedEthereumChain = class {
-  constructor(phantom) {
+  constructor(phantom, callbacks) {
+    this._connected = false;
+    this._chainId = "0x1";
+    this._accounts = [];
+    this.eventEmitter = new import_eventemitter32.EventEmitter();
     this.phantom = phantom;
+    this.callbacks = callbacks;
+    this.setupEventListeners();
+    this.syncInitialState();
+  }
+  // EIP-1193 compliant properties
+  get connected() {
+    return this._connected;
+  }
+  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 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."));
+    }
+    const addresses = this.callbacks.getAddresses();
+    const ethAddresses = addresses.filter((addr) => addr.addressType === import_client3.AddressType.ethereum).map((addr) => addr.address);
+    this.updateConnectionState(true, ethAddresses);
+    return Promise.resolve(ethAddresses);
+  }
+  async disconnect() {
+    await this.callbacks.disconnect();
+  }
+  // Standard compliant methods (return raw values, not wrapped objects)
   async signPersonalMessage(message, address) {
-    const signature = await this.phantom.ethereum.signPersonalMessage(message, address);
-    return {
-      signature,
-      rawSignature: signature
-    };
+    return await this.phantom.ethereum.signPersonalMessage(message, address);
   }
   async signTypedData(typedData, address) {
-    const signature = await this.phantom.ethereum.signTypedData(typedData, address);
-    return {
-      signature,
-      rawSignature: signature
-    };
+    return await this.phantom.ethereum.signTypedData(typedData, address);
+  }
+  async signTransaction(transaction) {
+    return await this.phantom.ethereum.signTransaction(transaction);
   }
   async sendTransaction(transaction) {
-    const hash = await this.phantom.ethereum.sendTransaction(transaction);
-    const chainId = await this.getChainId();
-    const networkId = (0, import_constants2.chainIdToNetworkId)(chainId) || import_constants2.NetworkId.ETHEREUM_MAINNET;
-    return {
-      hash,
-      rawTransaction: hash,
-      blockExplorer: (0, import_constants2.getExplorerUrl)(networkId, "transaction", hash)
-    };
+    return await this.phantom.ethereum.sendTransaction(transaction);
   }
   async switchChain(chainId) {
-    return await this.phantom.ethereum.switchChain(`0x${chainId.toString(16)}`);
+    await this.phantom.ethereum.switchChain(`0x${chainId.toString(16)}`);
+    this._chainId = `0x${chainId.toString(16)}`;
+    this.eventEmitter.emit("chainChanged", this._chainId);
   }
   async getChainId() {
     const chainId = await this.phantom.ethereum.getChainId();
@@ -217,12 +330,56 @@ var InjectedEthereumChain = class {
     return await this.phantom.ethereum.getAccounts();
   }
   isConnected() {
-    try {
-      return !!this.phantom.extension?.isInstalled();
-    } catch {
-      return false;
+    return this._connected && this.callbacks.isConnected();
+  }
+  setupEventListeners() {
+    this.phantom.ethereum.addEventListener("connect", (accounts) => {
+      this.updateConnectionState(true, accounts);
+      this.eventEmitter.emit("connect", { chainId: this._chainId });
+      this.eventEmitter.emit("accountsChanged", accounts);
+    });
+    this.phantom.ethereum.addEventListener("disconnect", () => {
+      this.updateConnectionState(false, []);
+      this.eventEmitter.emit("disconnect", { code: 4900, message: "Provider disconnected" });
+      this.eventEmitter.emit("accountsChanged", []);
+    });
+    this.phantom.ethereum.addEventListener("accountsChanged", (accounts) => {
+      this._accounts = accounts;
+      this.eventEmitter.emit("accountsChanged", accounts);
+    });
+    this.phantom.ethereum.addEventListener("chainChanged", (chainId) => {
+      this._chainId = chainId;
+      this.eventEmitter.emit("chainChanged", chainId);
+    });
+    this.callbacks.on("connect", (data) => {
+      const ethAddresses = data.addresses?.filter((addr) => addr.addressType === import_client3.AddressType.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 === import_client3.AddressType.ethereum).map((addr) => addr.address);
+      if (ethAddresses.length > 0) {
+        this.updateConnectionState(true, ethAddresses);
+      }
     }
   }
+  updateConnectionState(connected, accounts) {
+    this._connected = connected;
+    this._accounts = accounts;
+  }
+  // Event methods for interface compliance
+  on(event, listener) {
+    this.eventEmitter.on(event, listener);
+  }
+  off(event, listener) {
+    this.eventEmitter.off(event, listener);
+  }
 };
 
 // src/providers/injected/index.ts
@@ -238,11 +395,11 @@ var InjectedProvider = class {
     this.addressTypes = config.addressTypes;
     debug.log(DebugCategory.INJECTED_PROVIDER, "Address types configured", { addressTypes: this.addressTypes });
     const plugins = [(0, import_browser_injected_sdk.createExtensionPlugin)()];
-    if (this.addressTypes.includes(import_client.AddressType.solana)) {
+    if (this.addressTypes.includes(import_client4.AddressType.solana)) {
       plugins.push((0, import_solana.createSolanaPlugin)());
       debug.log(DebugCategory.INJECTED_PROVIDER, "Solana plugin added");
     }
-    if (this.addressTypes.includes(import_client.AddressType.ethereum)) {
+    if (this.addressTypes.includes(import_client4.AddressType.ethereum)) {
       plugins.push((0, import_ethereum.createEthereumPlugin)());
       debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum plugin added");
     }
@@ -252,17 +409,24 @@ var InjectedProvider = class {
       pluginCount: plugins.length
     });
     this.phantom = (0, import_browser_injected_sdk.createPhantom)({ plugins });
+    const callbacks = this.createCallbacks();
+    if (this.addressTypes.includes(import_client4.AddressType.solana)) {
+      this._solanaChain = new InjectedSolanaChain(this.phantom, callbacks);
+    }
+    if (this.addressTypes.includes(import_client4.AddressType.ethereum)) {
+      this._ethereumChain = new InjectedEthereumChain(this.phantom, callbacks);
+    }
     debug.info(DebugCategory.INJECTED_PROVIDER, "InjectedProvider initialized");
   }
   /**
    * Access to Solana chain operations
    */
   get solana() {
-    if (!this.addressTypes.includes(import_client.AddressType.solana)) {
+    if (!this.addressTypes.includes(import_client4.AddressType.solana)) {
       throw new Error("Solana not enabled for this provider");
     }
     if (!this._solanaChain) {
-      this._solanaChain = new InjectedSolanaChain(this.phantom);
+      throw new Error("Solana chain not initialized");
     }
     return this._solanaChain;
   }
@@ -270,11 +434,11 @@ var InjectedProvider = class {
    * Access to Ethereum chain operations
    */
   get ethereum() {
-    if (!this.addressTypes.includes(import_client.AddressType.ethereum)) {
+    if (!this.addressTypes.includes(import_client4.AddressType.ethereum)) {
       throw new Error("Ethereum not enabled for this provider");
     }
     if (!this._ethereumChain) {
-      this._ethereumChain = new InjectedEthereumChain(this.phantom);
+      throw new Error("Ethereum chain not initialized");
     }
     return this._ethereumChain;
   }
@@ -300,28 +464,28 @@ var InjectedProvider = class {
       }
       debug.log(DebugCategory.INJECTED_PROVIDER, "Phantom extension detected");
       const connectedAddresses = [];
-      if (this.addressTypes.includes(import_client.AddressType.solana)) {
+      if (this.addressTypes.includes(import_client4.AddressType.solana)) {
         debug.log(DebugCategory.INJECTED_PROVIDER, "Attempting Solana connection");
         try {
-          const result2 = await this.solana.connect();
-          if (result2.publicKey) {
+          const publicKey = await this.phantom.solana.connect();
+          if (publicKey) {
             connectedAddresses.push({
-              addressType: import_client.AddressType.solana,
-              address: result2.publicKey
+              addressType: import_client4.AddressType.solana,
+              address: publicKey
             });
-            debug.info(DebugCategory.INJECTED_PROVIDER, "Solana connected successfully", { address: result2.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(import_client.AddressType.ethereum)) {
+      if (this.addressTypes.includes(import_client4.AddressType.ethereum)) {
         try {
-          const accounts = await this.ethereum.getAccounts();
+          const accounts = await this.phantom.ethereum.connect();
           if (accounts && accounts.length > 0) {
             connectedAddresses.push(
               ...accounts.map((address) => ({
-                addressType: import_client.AddressType.ethereum,
+                addressType: import_client4.AddressType.ethereum,
                 address
               }))
             );
@@ -363,19 +527,17 @@ var InjectedProvider = class {
   }
   async disconnect() {
     debug.info(DebugCategory.INJECTED_PROVIDER, "Starting injected provider disconnect");
-    if (this.addressTypes.includes(import_client.AddressType.solana)) {
+    if (this.addressTypes.includes(import_client4.AddressType.solana)) {
       try {
-        await this.solana.disconnect();
+        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 });
       }
     }
-    if (this.addressTypes.includes(import_client.AddressType.ethereum)) {
+    if (this.addressTypes.includes(import_client4.AddressType.ethereum)) {
       debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum disconnected (no-op)");
     }
-    this._solanaChain = void 0;
-    this._ethereumChain = void 0;
     this.browserInjectedCleanupFunctions.forEach((cleanup) => cleanup());
     this.browserInjectedCleanupFunctions = [];
     this.connected = false;
@@ -385,6 +547,87 @@ var InjectedProvider = class {
     });
     debug.info(DebugCategory.INJECTED_PROVIDER, "Injected provider disconnected successfully");
   }
+  /**
+   * Attempt auto-connection using onlyIfTrusted parameter
+   * This will only connect if the dApp is already trusted by the user
+   * Should be called after setting up event listeners
+   */
+  async autoConnect() {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Attempting auto-connect with onlyIfTrusted=true");
+    this.emit("connect_start", {
+      source: "auto-connect",
+      providerType: "injected"
+    });
+    try {
+      if (!this.phantom.extension?.isInstalled?.()) {
+        debug.warn(DebugCategory.INJECTED_PROVIDER, "Phantom wallet extension not found for auto-connect");
+        this.emit("connect_error", {
+          error: "Phantom wallet not found",
+          source: "auto-connect"
+        });
+        return;
+      }
+      const connectedAddresses = [];
+      if (this.addressTypes.includes(import_client4.AddressType.solana)) {
+        debug.log(DebugCategory.INJECTED_PROVIDER, "Attempting Solana auto-connect");
+        try {
+          const publicKey = await this.phantom.solana.connect({ onlyIfTrusted: true });
+          if (publicKey) {
+            connectedAddresses.push({
+              addressType: import_client4.AddressType.solana,
+              address: publicKey
+            });
+            debug.info(DebugCategory.INJECTED_PROVIDER, "Solana auto-connected successfully", { address: publicKey });
+          }
+        } catch (err) {
+          debug.log(DebugCategory.INJECTED_PROVIDER, "Solana auto-connect failed (expected if not trusted)", { error: err });
+        }
+      }
+      if (this.addressTypes.includes(import_client4.AddressType.ethereum)) {
+        debug.log(DebugCategory.INJECTED_PROVIDER, "Attempting Ethereum auto-connect");
+        try {
+          const accounts = await this.phantom.ethereum.connect({ onlyIfTrusted: true });
+          if (accounts && accounts.length > 0) {
+            connectedAddresses.push(
+              ...accounts.map((address) => ({
+                addressType: import_client4.AddressType.ethereum,
+                address
+              }))
+            );
+            debug.info(DebugCategory.INJECTED_PROVIDER, "Ethereum auto-connected successfully", { addresses: accounts });
+          }
+        } catch (err) {
+          debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum auto-connect failed (expected if not trusted)", { error: err });
+        }
+      }
+      if (connectedAddresses.length === 0) {
+        debug.log(DebugCategory.INJECTED_PROVIDER, "Auto-connect failed: no trusted connections available");
+        this.emit("connect_error", {
+          error: "No trusted connections available",
+          source: "auto-connect"
+        });
+        return;
+      }
+      this.addresses = connectedAddresses;
+      this.connected = true;
+      this.emit("connect", {
+        addresses: this.addresses,
+        source: "auto-connect"
+      });
+      debug.info(DebugCategory.INJECTED_PROVIDER, "Auto-connect successful", {
+        addressCount: connectedAddresses.length,
+        addresses: connectedAddresses.map((addr) => ({ type: addr.addressType, address: addr.address.substring(0, 8) + "..." }))
+      });
+    } catch (error) {
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Auto-connect failed with error", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      this.emit("connect_error", {
+        error: error instanceof Error ? error.message : "Auto-connect failed",
+        source: "auto-connect"
+      });
+    }
+  }
   getAddresses() {
     return this.addresses;
   }
@@ -448,10 +691,10 @@ var InjectedProvider = class {
   }
   setupBrowserInjectedEvents() {
     debug.log(DebugCategory.INJECTED_PROVIDER, "Setting up browser-injected-sdk event listeners");
-    if (this.addressTypes.includes(import_client.AddressType.solana)) {
+    if (this.addressTypes.includes(import_client4.AddressType.solana)) {
       this.setupSolanaEvents();
     }
-    if (this.addressTypes.includes(import_client.AddressType.ethereum)) {
+    if (this.addressTypes.includes(import_client4.AddressType.ethereum)) {
       this.setupEthereumEvents();
     }
   }
@@ -459,8 +702,8 @@ var InjectedProvider = class {
     debug.log(DebugCategory.INJECTED_PROVIDER, "Setting up Solana event listeners");
     const handleSolanaConnect = (publicKey) => {
       debug.log(DebugCategory.INJECTED_PROVIDER, "Solana connect event received", { publicKey });
-      const solanaAddress = { addressType: import_client.AddressType.solana, address: publicKey };
-      if (!this.addresses.find((addr) => addr.addressType === import_client.AddressType.solana)) {
+      const solanaAddress = { addressType: import_client4.AddressType.solana, address: publicKey };
+      if (!this.addresses.find((addr) => addr.addressType === import_client4.AddressType.solana)) {
         this.addresses.push(solanaAddress);
       }
       this.connected = true;
@@ -471,19 +714,19 @@ var InjectedProvider = class {
     };
     const handleSolanaDisconnect = () => {
       debug.log(DebugCategory.INJECTED_PROVIDER, "Solana disconnect event received");
-      this.addresses = this.addresses.filter((addr) => addr.addressType !== import_client.AddressType.solana);
-      this.connected = this.addresses.length > 0;
+      this.addresses = this.addresses.filter((addr) => addr.addressType !== import_client4.AddressType.solana);
+      this.connected = false;
       this.emit("disconnect", {
         source: "injected-extension"
       });
     };
     const handleSolanaAccountChanged = (publicKey) => {
       debug.log(DebugCategory.INJECTED_PROVIDER, "Solana account changed event received", { publicKey });
-      const solanaIndex = this.addresses.findIndex((addr) => addr.addressType === import_client.AddressType.solana);
+      const solanaIndex = this.addresses.findIndex((addr) => addr.addressType === import_client4.AddressType.solana);
       if (solanaIndex >= 0) {
-        this.addresses[solanaIndex] = { addressType: import_client.AddressType.solana, address: publicKey };
+        this.addresses[solanaIndex] = { addressType: import_client4.AddressType.solana, address: publicKey };
       } else {
-        this.addresses.push({ addressType: import_client.AddressType.solana, address: publicKey });
+        this.addresses.push({ addressType: import_client4.AddressType.solana, address: publicKey });
       }
       this.emit("connect", {
         addresses: this.addresses,
@@ -493,22 +736,20 @@ var InjectedProvider = class {
     const cleanupConnect = this.phantom.solana.addEventListener("connect", handleSolanaConnect);
     const cleanupDisconnect = this.phantom.solana.addEventListener("disconnect", handleSolanaDisconnect);
     const cleanupAccountChanged = this.phantom.solana.addEventListener("accountChanged", handleSolanaAccountChanged);
-    this.browserInjectedCleanupFunctions.push(
-      cleanupConnect,
-      cleanupDisconnect,
-      cleanupAccountChanged
-    );
+    this.browserInjectedCleanupFunctions.push(cleanupConnect, cleanupDisconnect, cleanupAccountChanged);
   }
   setupEthereumEvents() {
     debug.log(DebugCategory.INJECTED_PROVIDER, "Setting up Ethereum event listeners");
     const handleEthereumConnect = (accounts) => {
       debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum connect event received", { accounts });
-      this.addresses = this.addresses.filter((addr) => addr.addressType !== import_client.AddressType.ethereum);
+      this.addresses = this.addresses.filter((addr) => addr.addressType !== import_client4.AddressType.ethereum);
       if (accounts && accounts.length > 0) {
-        this.addresses.push(...accounts.map((address) => ({
-          addressType: import_client.AddressType.ethereum,
-          address
-        })));
+        this.addresses.push(
+          ...accounts.map((address) => ({
+            addressType: import_client4.AddressType.ethereum,
+            address
+          }))
+        );
       }
       this.connected = this.addresses.length > 0;
       this.emit("connect", {
@@ -518,34 +759,63 @@ var InjectedProvider = class {
     };
     const handleEthereumDisconnect = () => {
       debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum disconnect event received");
-      this.addresses = this.addresses.filter((addr) => addr.addressType !== import_client.AddressType.ethereum);
-      this.connected = this.addresses.length > 0;
+      this.addresses = this.addresses.filter((addr) => addr.addressType !== import_client4.AddressType.ethereum);
+      this.connected = false;
       this.emit("disconnect", {
         source: "injected-extension"
       });
     };
     const handleEthereumAccountsChanged = (accounts) => {
       debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum accounts changed event received", { accounts });
-      this.addresses = this.addresses.filter((addr) => addr.addressType !== import_client.AddressType.ethereum);
+      this.addresses = this.addresses.filter((addr) => addr.addressType !== import_client4.AddressType.ethereum);
       if (accounts && accounts.length > 0) {
-        this.addresses.push(...accounts.map((address) => ({
-          addressType: import_client.AddressType.ethereum,
-          address
-        })));
+        this.addresses.push(
+          ...accounts.map((address) => ({
+            addressType: import_client4.AddressType.ethereum,
+            address
+          }))
+        );
+        this.emit("connect", {
+          addresses: this.addresses,
+          source: "injected-extension-account-change"
+        });
+      } else {
+        this.connected = false;
+        this.emit("disconnect", {
+          source: "injected-extension-account-change"
+        });
       }
-      this.emit("connect", {
-        addresses: this.addresses,
-        source: "injected-extension-account-change"
-      });
     };
     const cleanupConnect = this.phantom.ethereum.addEventListener("connect", handleEthereumConnect);
     const cleanupDisconnect = this.phantom.ethereum.addEventListener("disconnect", handleEthereumDisconnect);
-    const cleanupAccountsChanged = this.phantom.ethereum.addEventListener("accountsChanged", handleEthereumAccountsChanged);
-    this.browserInjectedCleanupFunctions.push(
-      cleanupConnect,
-      cleanupDisconnect,
-      cleanupAccountsChanged
+    const cleanupAccountsChanged = this.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);
+      }
+    };
   }
 };
 
@@ -643,15 +913,19 @@ var BrowserURLParamsAccessor = class {
 };
 var browserUrlParamsAccessor = new BrowserURLParamsAccessor();
 
-// src/constants.ts
-var DEFAULT_AUTH_URL = "https://connect.phantom.app";
-var DEFAULT_WALLET_API_URL = "https://api.phantom.app/v1/wallets";
-
 // src/providers/embedded/adapters/auth.ts
+var import_constants = require("@phantom/constants");
 var BrowserAuthProvider = class {
   constructor(urlParamsAccessor) {
     this.urlParamsAccessor = urlParamsAccessor;
   }
+  getValidatedCurrentUrl() {
+    const currentUrl = window.location.href;
+    if (!currentUrl.startsWith("http:") && !currentUrl.startsWith("https:")) {
+      throw new Error("Invalid URL protocol - only HTTP/HTTPS URLs are supported");
+    }
+    return currentUrl;
+  }
   authenticate(options) {
     return new Promise((resolve) => {
       if ("jwtToken" in options) {
@@ -660,23 +934,20 @@ var BrowserAuthProvider = class {
       const phantomOptions = options;
       debug.info(DebugCategory.PHANTOM_CONNECT_AUTH, "Starting Phantom Connect authentication", {
         organizationId: phantomOptions.organizationId,
-        parentOrganizationId: phantomOptions.parentOrganizationId,
+        appId: phantomOptions.appId,
         provider: phantomOptions.provider,
         authUrl: phantomOptions.authUrl,
         hasCustomData: !!phantomOptions.customAuthData
       });
-      const baseUrl = phantomOptions.authUrl || DEFAULT_AUTH_URL;
+      const baseUrl = phantomOptions.authUrl || import_constants.DEFAULT_AUTH_URL;
       debug.log(DebugCategory.PHANTOM_CONNECT_AUTH, "Using auth URL", { baseUrl });
       const params = new URLSearchParams({
         organization_id: phantomOptions.organizationId,
-        parent_organization_id: phantomOptions.parentOrganizationId,
-        redirect_uri: phantomOptions.redirectUrl || (typeof window !== "undefined" ? window.location.href : ""),
+        app_id: phantomOptions.appId,
+        redirect_uri: phantomOptions.redirectUrl || (typeof window !== "undefined" ? this.getValidatedCurrentUrl() : ""),
         session_id: phantomOptions.sessionId,
         clear_previous_session: true.toString(),
-        app_name: phantomOptions.appName || "",
-        // Optional app name
-        app_logo: phantomOptions.appLogo || ""
-        // Optional app logo URL
+        sdk_version: "1.0.0-beta.10"
       });
       if (phantomOptions.provider) {
         debug.log(DebugCategory.PHANTOM_CONNECT_AUTH, "Provider specified, will skip selection", {
@@ -693,7 +964,7 @@ var BrowserAuthProvider = class {
       }
       const authContext = {
         organizationId: phantomOptions.organizationId,
-        parentOrganizationId: phantomOptions.parentOrganizationId,
+        appId: phantomOptions.appId,
         provider: phantomOptions.provider,
         sessionId: phantomOptions.sessionId
       };
@@ -701,6 +972,9 @@ var BrowserAuthProvider = class {
       debug.log(DebugCategory.PHANTOM_CONNECT_AUTH, "Stored auth context in session storage", { authContext });
       const authUrl = `${baseUrl}?${params.toString()}`;
       debug.info(DebugCategory.PHANTOM_CONNECT_AUTH, "Redirecting to Phantom Connect", { authUrl });
+      if (!authUrl.startsWith("https:")) {
+        throw new Error("Invalid auth URL - only HTTPS URLs are allowed for authentication");
+      }
       window.location.href = authUrl;
       resolve();
     });
@@ -789,7 +1063,7 @@ function parseBrowserFromUserAgent(userAgent, hasBraveAPI) {
   let name = "unknown";
   let version = "unknown";
   if (!userAgent || typeof userAgent !== "string") {
-    return { name, version };
+    return { name, version, userAgent: "unknown" };
   }
   try {
     if (userAgent.includes("Edg/")) {
@@ -871,11 +1145,11 @@ function parseBrowserFromUserAgent(userAgent, hasBraveAPI) {
     }
   } catch (error) {
   }
-  return { name, version };
+  return { name, version, userAgent };
 }
 function detectBrowser() {
   if (typeof window === "undefined" || !window.navigator?.userAgent) {
-    return { name: "unknown", version: "unknown" };
+    return { name: "unknown", version: "unknown", userAgent: "unknown" };
   }
   const userAgent = window.navigator.userAgent;
   const hasBraveAPI = !!navigator.brave;
@@ -890,25 +1164,70 @@ function getBrowserDisplayName() {
   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/index.ts
+var import_constants2 = require("@phantom/constants");
 var EmbeddedProvider = class extends import_embedded_provider_core.EmbeddedProvider {
   constructor(config) {
     debug.log(DebugCategory.EMBEDDED_PROVIDER, "Initializing Browser EmbeddedProvider", { config });
     const urlParamsAccessor = new BrowserURLParamsAccessor();
     const stamper = new import_indexed_db_stamper.IndexedDbStamper({
-      dbName: `phantom-embedded-sdk-${config.organizationId}`,
+      dbName: `phantom-embedded-sdk-${config.appId}`,
       storeName: "crypto-keys",
       keyName: "signing-key"
     });
     const platformName = getPlatformName();
+    const { name: browserName, version } = detectBrowser();
     const platform = {
       storage: new BrowserStorage(),
       authProvider: new BrowserAuthProvider(urlParamsAccessor),
       urlParamsAccessor,
       stamper,
-      name: platformName
+      name: platformName,
       // Use detected browser name and version for identification
+      analyticsHeaders: {
+        [import_constants2.ANALYTICS_HEADERS.SDK_TYPE]: "browser",
+        [import_constants2.ANALYTICS_HEADERS.PLATFORM]: browserName,
+        // firefox, chrome, safari, etc.
+        [import_constants2.ANALYTICS_HEADERS.PLATFORM_VERSION]: version,
+        // Full user agent for more detailed info
+        [import_constants2.ANALYTICS_HEADERS.APP_ID]: config.appId,
+        [import_constants2.ANALYTICS_HEADERS.WALLET_TYPE]: config.embeddedWalletType,
+        [import_constants2.ANALYTICS_HEADERS.SDK_VERSION]: "1.0.0-beta.10"
+        // Replaced at build time
+      }
     };
     debug.log(DebugCategory.EMBEDDED_PROVIDER, "Detected platform", { platformName });
     const logger = new BrowserLogger();
@@ -918,6 +1237,7 @@ var EmbeddedProvider = class extends import_embedded_provider_core.EmbeddedProvi
 };
 
 // src/ProviderManager.ts
+var import_constants3 = require("@phantom/constants");
 var ProviderManager = class {
   // Track which providers have forwarding set up
   constructor(config) {
@@ -936,6 +1256,15 @@ var ProviderManager = class {
       currentProviderKey: this.currentProviderKey
     });
   }
+  getValidatedCurrentUrl() {
+    if (typeof window === "undefined")
+      return "";
+    const currentUrl = window.location.href;
+    if (!currentUrl.startsWith("http:") && !currentUrl.startsWith("https:")) {
+      throw new Error("Invalid URL protocol - only HTTP/HTTPS URLs are supported");
+    }
+    return currentUrl;
+  }
   /**
    * Switch to a different provider type
    */
@@ -967,7 +1296,8 @@ var ProviderManager = class {
   getCurrentProviderInfo() {
     if (!this.currentProviderKey)
       return null;
-    const [type, embeddedWalletType] = this.currentProviderKey.split("-");
+    const parts = this.currentProviderKey.split("-");
+    const [type, embeddedWalletType] = parts;
     return {
       type,
       embeddedWalletType
@@ -1091,7 +1421,13 @@ var ProviderManager = class {
       return;
     }
     debug.log(DebugCategory.PROVIDER_MANAGER, "Setting up event forwarding from current provider");
-    const eventsToForward = ["connect_start", "connect", "connect_error", "disconnect", "error"];
+    const eventsToForward = [
+      "connect_start",
+      "connect",
+      "connect_error",
+      "disconnect",
+      "error"
+    ];
     for (const event of eventsToForward) {
       const forwardingCallback = (data) => {
         debug.log(DebugCategory.PROVIDER_MANAGER, "Forwarding event from provider", { event, data });
@@ -1107,7 +1443,7 @@ var ProviderManager = class {
    */
   setDefaultProvider() {
     const defaultType = this.config.providerType || "embedded";
-    const defaultEmbeddedType = this.config.embeddedWalletType || "app-wallet";
+    const defaultEmbeddedType = this.config.embeddedWalletType || "user-wallet";
     this.createProvider(defaultType, defaultEmbeddedType);
     this.switchProvider(defaultType, { embeddedWalletType: defaultEmbeddedType });
   }
@@ -1121,24 +1457,27 @@ var ProviderManager = class {
     let provider;
     if (type === "injected") {
       provider = new InjectedProvider({
-        solanaProvider: this.config.solanaProvider || "web3js",
-        addressTypes: this.config.addressTypes
+        addressTypes: this.config.addressTypes || [import_client.AddressType.solana]
       });
-    } else {
-      if (!this.config.apiBaseUrl || !this.config.organizationId) {
-        throw new Error("apiBaseUrl and organizationId are required for embedded provider");
+    } else if (type === "embedded") {
+      if (!this.config.appId) {
+        throw new Error("appId is required for embedded provider");
       }
+      const apiBaseUrl = this.config.apiBaseUrl || import_constants3.DEFAULT_WALLET_API_URL;
+      const authUrl = this.config.authOptions?.authUrl || import_constants3.DEFAULT_AUTH_URL;
       provider = new EmbeddedProvider({
-        apiBaseUrl: this.config.apiBaseUrl,
-        organizationId: this.config.organizationId,
-        authOptions: this.config.authOptions,
-        embeddedWalletType: embeddedWalletType || "app-wallet",
-        addressTypes: this.config.addressTypes,
-        solanaProvider: this.config.solanaProvider || "web3js",
-        appLogo: this.config.appLogo,
-        // Optional app logo URL
-        appName: this.config.appName
+        apiBaseUrl,
+        appId: this.config.appId,
+        authOptions: {
+          ...this.config.authOptions || {},
+          authUrl,
+          redirectUrl: this.config.authOptions?.redirectUrl || this.getValidatedCurrentUrl()
+        },
+        embeddedWalletType: embeddedWalletType || import_constants3.DEFAULT_EMBEDDED_WALLET_TYPE,
+        addressTypes: this.config.addressTypes || [import_client.AddressType.solana]
       });
+    } else {
+      throw new Error(`Unsupported provider type: ${type}`);
     }
     this.providers.set(key, provider);
   }
@@ -1148,8 +1487,10 @@ var ProviderManager = class {
   getProviderKey(type, embeddedWalletType) {
     if (type === "injected") {
       return "injected";
+    } else if (type === "embedded") {
+      return `embedded-${embeddedWalletType || "app-wallet"}`;
     }
-    return `embedded-${embeddedWalletType || "app-wallet"}`;
+    throw new Error(`Unsupported provider type: ${type}`);
   }
   /**
    * Save provider preference to localStorage
@@ -1184,8 +1525,33 @@ var ProviderManager = class {
   }*/
 };
 
-// src/BrowserSDK.ts
+// src/waitForPhantomExtension.ts
 var import_browser_injected_sdk2 = require("@phantom/browser-injected-sdk");
+async function waitForPhantomExtension(timeoutMs = 3e3) {
+  return new Promise((resolve) => {
+    const startTime = Date.now();
+    const checkInterval = 100;
+    const checkForExtension = () => {
+      try {
+        if ((0, import_browser_injected_sdk2.isPhantomExtensionInstalled)()) {
+          resolve(true);
+          return;
+        }
+      } catch (error) {
+      }
+      const elapsed = Date.now() - startTime;
+      if (elapsed >= timeoutMs) {
+        resolve(false);
+        return;
+      }
+      setTimeout(checkForExtension, checkInterval);
+    };
+    checkForExtension();
+  });
+}
+
+// src/BrowserSDK.ts
+var import_constants4 = require("@phantom/constants");
 var BrowserSDK = class {
   constructor(config) {
     debug.info(DebugCategory.BROWSER_SDK, "Initializing BrowserSDK", {
@@ -1197,7 +1563,7 @@ var BrowserSDK = class {
       debug.error(DebugCategory.BROWSER_SDK, "Invalid providerType", { providerType: config.providerType });
       throw new Error(`Invalid providerType: ${config.providerType}. Must be "injected" or "embedded".`);
     }
-    const embeddedWalletType = config.embeddedWalletType || "app-wallet";
+    const embeddedWalletType = config.embeddedWalletType || import_constants4.DEFAULT_EMBEDDED_WALLET_TYPE;
     if (config.providerType === "embedded" && !["app-wallet", "user-wallet"].includes(embeddedWalletType)) {
       debug.error(DebugCategory.BROWSER_SDK, "Invalid embeddedWalletType", {
         embeddedWalletType: config.embeddedWalletType
@@ -1306,8 +1672,8 @@ var BrowserSDK = class {
   /**
    * Check if Phantom extension is installed
    */
-  static isPhantomInstalled() {
-    return (0, import_browser_injected_sdk2.isPhantomExtensionInstalled)();
+  static async isPhantomInstalled(timeoutMs) {
+    return waitForPhantomExtension(timeoutMs);
   }
   /**
    * Add event listener for provider events (connect, connect_start, connect_error, disconnect, error)
@@ -1333,7 +1699,7 @@ var BrowserSDK = class {
   async autoConnect() {
     debug.log(DebugCategory.BROWSER_SDK, "Attempting auto-connect");
     const currentProvider = this.providerManager.getCurrentProvider();
-    if (currentProvider && "autoConnect" in currentProvider) {
+    if (currentProvider) {
       await currentProvider.autoConnect();
     } else {
       debug.warn(DebugCategory.BROWSER_SDK, "Current provider does not support auto-connect", {
@@ -1474,15 +1840,24 @@ var BrowserSDK = class {
       debug.info(DebugCategory.BROWSER_SDK, "Got supported auto-confirm chains", { result });
       return result;
     } catch (error) {
-      debug.error(DebugCategory.BROWSER_SDK, "Failed to get supported auto-confirm chains", { error: error.message });
+      debug.error(DebugCategory.BROWSER_SDK, "Failed to get supported auto-confirm chains", {
+        error: error.message
+      });
       throw error;
     }
   }
 };
 
-// src/types.ts
-var import_client2 = require("@phantom/client");
+// src/utils/deeplink.ts
+function getDeeplinkToPhantom(ref) {
+  if (!window.location.href.startsWith("http:") && !window.location.href.startsWith("https:")) {
+    throw new Error("Invalid URL protocol - only HTTP/HTTPS URLs are supported for deeplinks");
+  }
+  const currentUrl = encodeURIComponent(window.location.href);
+  const refParam = ref ? `?ref=${encodeURIComponent(ref)}` : "";
+  return `https://phantom.app/ul/browse/${currentUrl}${refParam}`;
+}
 
 // src/index.ts
-var import_constants4 = require("@phantom/constants");
-var import_client3 = require("@phantom/client");
+var import_constants5 = require("@phantom/constants");
+var import_client5 = require("@phantom/client");