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

package/dist/index.js

@@ -20,23 +20,24 @@ 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_constants2.NetworkId,
   debug: () => debug,
   detectBrowser: () => detectBrowser,
   getBrowserDisplayName: () => getBrowserDisplayName,
   getPlatformName: () => getPlatformName,
-  parseBrowserFromUserAgent: () => parseBrowserFromUserAgent
+  parseBrowserFromUserAgent: () => parseBrowserFromUserAgent,
+  waitForPhantomExtension: () => waitForPhantomExtension
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/providers/injected/index.ts
-var import_client = require("@phantom/client");
+var import_client3 = 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 +118,187 @@ var DebugCategory = {
 };
 
 // src/providers/injected/chains/SolanaChain.ts
-var import_constants = require("@phantom/constants");
+var import_eventemitter3 = require("eventemitter3");
+var import_client = 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_client.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");
-    }
-    return { publicKey: address };
+  signAllTransactions(_transactions) {
+    return Promise.reject(new Error("Sign-only transactions not supported by injected provider"));
   }
-  async disconnect() {
-    return await this.phantom.solana.disconnect();
-  }
-  async switchNetwork(_network) {
+  switchNetwork(_network) {
+    return Promise.resolve();
   }
-  async getPublicKey() {
-    try {
-      const address = await this.phantom.solana.getAccount();
-      return address || null;
-    } catch {
-      return null;
-    }
+  // 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_client.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_client.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_client2 = 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_client2.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 +308,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_client2.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_client2.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 +373,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_client3.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_client3.AddressType.ethereum)) {
       plugins.push((0, import_ethereum.createEthereumPlugin)());
       debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum plugin added");
     }
@@ -252,17 +387,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_client3.AddressType.solana)) {
+      this._solanaChain = new InjectedSolanaChain(this.phantom, callbacks);
+    }
+    if (this.addressTypes.includes(import_client3.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_client3.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 +412,11 @@ var InjectedProvider = class {
    * Access to Ethereum chain operations
    */
   get ethereum() {
-    if (!this.addressTypes.includes(import_client.AddressType.ethereum)) {
+    if (!this.addressTypes.includes(import_client3.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 +442,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_client3.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_client3.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_client3.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_client3.AddressType.ethereum,
                 address
               }))
             );
@@ -363,19 +505,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_client3.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_client3.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;
@@ -448,10 +588,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_client3.AddressType.solana)) {
       this.setupSolanaEvents();
     }
-    if (this.addressTypes.includes(import_client.AddressType.ethereum)) {
+    if (this.addressTypes.includes(import_client3.AddressType.ethereum)) {
       this.setupEthereumEvents();
     }
   }
@@ -459,8 +599,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_client3.AddressType.solana, address: publicKey };
+      if (!this.addresses.find((addr) => addr.addressType === import_client3.AddressType.solana)) {
         this.addresses.push(solanaAddress);
       }
       this.connected = true;
@@ -471,7 +611,7 @@ 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.addresses = this.addresses.filter((addr) => addr.addressType !== import_client3.AddressType.solana);
       this.connected = this.addresses.length > 0;
       this.emit("disconnect", {
         source: "injected-extension"
@@ -479,11 +619,11 @@ var InjectedProvider = class {
     };
     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_client3.AddressType.solana);
       if (solanaIndex >= 0) {
-        this.addresses[solanaIndex] = { addressType: import_client.AddressType.solana, address: publicKey };
+        this.addresses[solanaIndex] = { addressType: import_client3.AddressType.solana, address: publicKey };
       } else {
-        this.addresses.push({ addressType: import_client.AddressType.solana, address: publicKey });
+        this.addresses.push({ addressType: import_client3.AddressType.solana, address: publicKey });
       }
       this.emit("connect", {
         addresses: this.addresses,
@@ -492,23 +632,24 @@ 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
+    const cleanupAccountChanged = this.phantom.solana.addEventListener(
+      "accountChanged",
+      handleSolanaAccountChanged
     );
+    this.browserInjectedCleanupFunctions.push(cleanupConnect, cleanupDisconnect, cleanupAccountChanged);
   }
   setupEthereumEvents() {
     debug.log(DebugCategory.INJECTED_PROVIDER, "Setting up Ethereum event listeners");
     const handleEthereumConnect = (accounts) => {
       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_client3.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_client3.AddressType.ethereum,
+            address
+          }))
+        );
       }
       this.connected = this.addresses.length > 0;
       this.emit("connect", {
@@ -518,7 +659,7 @@ 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.addresses = this.addresses.filter((addr) => addr.addressType !== import_client3.AddressType.ethereum);
       this.connected = this.addresses.length > 0;
       this.emit("disconnect", {
         source: "injected-extension"
@@ -526,12 +667,14 @@ var InjectedProvider = class {
     };
     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_client3.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_client3.AddressType.ethereum,
+            address
+          }))
+        );
       }
       this.emit("connect", {
         addresses: this.addresses,
@@ -540,12 +683,34 @@ var InjectedProvider = class {
     };
     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);
+      }
+    };
   }
 };
 
@@ -661,6 +826,7 @@ var BrowserAuthProvider = class {
       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
@@ -670,13 +836,10 @@ var BrowserAuthProvider = class {
       const params = new URLSearchParams({
         organization_id: phantomOptions.organizationId,
         parent_organization_id: phantomOptions.parentOrganizationId,
+        app_id: phantomOptions.appId,
         redirect_uri: phantomOptions.redirectUrl || (typeof window !== "undefined" ? window.location.href : ""),
         session_id: phantomOptions.sessionId,
-        clear_previous_session: true.toString(),
-        app_name: phantomOptions.appName || "",
-        // Optional app name
-        app_logo: phantomOptions.appLogo || ""
-        // Optional app logo URL
+        clear_previous_session: true.toString()
       });
       if (phantomOptions.provider) {
         debug.log(DebugCategory.PHANTOM_CONNECT_AUTH, "Provider specified, will skip selection", {
@@ -694,6 +857,7 @@ var BrowserAuthProvider = class {
       const authContext = {
         organizationId: phantomOptions.organizationId,
         parentOrganizationId: phantomOptions.parentOrganizationId,
+        appId: phantomOptions.appId,
         provider: phantomOptions.provider,
         sessionId: phantomOptions.sessionId
       };
@@ -1091,7 +1255,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 });
@@ -1125,19 +1295,17 @@ var ProviderManager = class {
         addressTypes: this.config.addressTypes
       });
     } else {
-      if (!this.config.apiBaseUrl || !this.config.organizationId) {
-        throw new Error("apiBaseUrl and organizationId are required for embedded provider");
+      if (!this.config.apiBaseUrl || !this.config.appId) {
+        throw new Error("apiBaseUrl and appId are required for embedded provider");
       }
       provider = new EmbeddedProvider({
         apiBaseUrl: this.config.apiBaseUrl,
-        organizationId: this.config.organizationId,
+        organizationId: this.config.appId,
+        appId: this.config.appId,
         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
+        solanaProvider: this.config.solanaProvider || "web3js"
       });
     }
     this.providers.set(key, provider);
@@ -1184,8 +1352,32 @@ 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 BrowserSDK = class {
   constructor(config) {
     debug.info(DebugCategory.BROWSER_SDK, "Initializing BrowserSDK", {
@@ -1306,8 +1498,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)
@@ -1474,15 +1666,17 @@ 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");
+var import_client4 = require("@phantom/client");
 
 // src/index.ts
-var import_constants4 = require("@phantom/constants");
-var import_client3 = require("@phantom/client");
+var import_constants2 = require("@phantom/constants");
+var import_client5 = require("@phantom/client");