@phantom/browser-sdk 0.3.9 → 1.0.0-beta.1

package/dist/index.mjs

@@ -1,8 +1,11 @@
 // src/providers/injected/index.ts
-import { AddressType } from "@phantom/client";
+import { AddressType as AddressType3 } 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";
 
 // src/debug.ts
 var DebugLevel = /* @__PURE__ */ ((DebugLevel2) => {
@@ -78,10 +81,236 @@ var DebugCategory = {
   SESSION: "Session"
 };
 
+// src/providers/injected/chains/SolanaChain.ts
+import { EventEmitter } from "eventemitter3";
+import { AddressType } from "@phantom/client";
+import { Buffer } from "buffer";
+var InjectedSolanaChain = class {
+  constructor(phantom, callbacks) {
+    this._connected = false;
+    this._publicKey = null;
+    this.eventEmitter = new 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 === 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);
+    return {
+      signature: result.signature instanceof Uint8Array ? result.signature : new Uint8Array(Buffer.from(result.signature, "base64")),
+      publicKey: this._publicKey || ""
+    };
+  }
+  signTransaction(_transaction) {
+    return Promise.reject(
+      new Error("Sign-only transactions not supported by injected provider. Use signAndSendTransaction instead.")
+    );
+  }
+  async signAndSendTransaction(transaction) {
+    const result = await this.phantom.solana.signAndSendTransaction(transaction);
+    return { signature: result.signature };
+  }
+  signAllTransactions(_transactions) {
+    return Promise.reject(new Error("Sign-only transactions not supported by injected provider"));
+  }
+  switchNetwork(_network) {
+    return Promise.resolve();
+  }
+  // Legacy methods
+  getPublicKey() {
+    return Promise.resolve(this._publicKey);
+  }
+  isConnected() {
+    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 === 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 === 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
+import { EventEmitter as EventEmitter2 } from "eventemitter3";
+import { AddressType as AddressType2 } from "@phantom/client";
+var InjectedEthereumChain = class {
+  constructor(phantom, callbacks) {
+    this._connected = false;
+    this._chainId = "0x1";
+    this._accounts = [];
+    this.eventEmitter = new EventEmitter2();
+    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 - unchanged, already compliant!
+  async request(args) {
+    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 === AddressType2.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) {
+    return await this.phantom.ethereum.signPersonalMessage(message, address);
+  }
+  async signTypedData(typedData, address) {
+    return await this.phantom.ethereum.signTypedData(typedData, address);
+  }
+  async sendTransaction(transaction) {
+    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)}`;
+    this.eventEmitter.emit("chainChanged", this._chainId);
+  }
+  async getChainId() {
+    const chainId = await this.phantom.ethereum.getChainId();
+    return parseInt(chainId, 16);
+  }
+  async getAccounts() {
+    return await this.phantom.ethereum.getAccounts();
+  }
+  isConnected() {
+    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 === AddressType2.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 === AddressType2.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
-import { base64urlEncode } from "@phantom/base64url";
-import { getExplorerUrl } from "@phantom/constants";
-import bs58 from "bs58";
 var InjectedProvider = class {
   constructor(config) {
     this.connected = false;
@@ -94,20 +323,53 @@ var InjectedProvider = class {
     this.addressTypes = config.addressTypes;
     debug.log(DebugCategory.INJECTED_PROVIDER, "Address types configured", { addressTypes: this.addressTypes });
     const plugins = [createExtensionPlugin()];
-    if (this.addressTypes.includes(AddressType.solana)) {
+    if (this.addressTypes.includes(AddressType3.solana)) {
       plugins.push(createSolanaPlugin());
       debug.log(DebugCategory.INJECTED_PROVIDER, "Solana plugin added");
     }
-    if (this.addressTypes.includes(AddressType.ethereum)) {
+    if (this.addressTypes.includes(AddressType3.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.phantom = createPhantom({ plugins });
+    const callbacks = this.createCallbacks();
+    if (this.addressTypes.includes(AddressType3.solana)) {
+      this._solanaChain = new InjectedSolanaChain(this.phantom, callbacks);
+    }
+    if (this.addressTypes.includes(AddressType3.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(AddressType3.solana)) {
+      throw new Error("Solana not enabled for this provider");
+    }
+    if (!this._solanaChain) {
+      throw new Error("Solana chain not initialized");
+    }
+    return this._solanaChain;
+  }
+  /**
+   * Access to Ethereum chain operations
+   */
+  get ethereum() {
+    if (!this.addressTypes.includes(AddressType3.ethereum)) {
+      throw new Error("Ethereum not enabled for this provider");
+    }
+    if (!this._ethereumChain) {
+      throw new Error("Ethereum chain not initialized");
+    }
+    return this._ethereumChain;
+  }
   async connect(authOptions) {
     debug.info(DebugCategory.INJECTED_PROVIDER, "Starting injected provider connect", {
       addressTypes: this.addressTypes,
@@ -119,7 +381,7 @@ var InjectedProvider = class {
       providerType: "injected"
     });
     try {
-      if (!this.phantom.extension.isInstalled()) {
+      if (!this.phantom.extension?.isInstalled?.()) {
         debug.error(DebugCategory.INJECTED_PROVIDER, "Phantom wallet extension not found");
         const error = new Error("Phantom wallet not found");
         this.emit("connect_error", {
@@ -130,13 +392,13 @@ var InjectedProvider = class {
       }
       debug.log(DebugCategory.INJECTED_PROVIDER, "Phantom extension detected");
       const connectedAddresses = [];
-      if (this.addressTypes.includes(AddressType.solana)) {
+      if (this.addressTypes.includes(AddressType3.solana)) {
         debug.log(DebugCategory.INJECTED_PROVIDER, "Attempting Solana connection");
         try {
           const publicKey = await this.phantom.solana.connect();
           if (publicKey) {
             connectedAddresses.push({
-              addressType: AddressType.solana,
+              addressType: AddressType3.solana,
               address: publicKey
             });
             debug.info(DebugCategory.INJECTED_PROVIDER, "Solana connected successfully", { address: publicKey });
@@ -145,16 +407,17 @@ var InjectedProvider = class {
           debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to connect Solana", { error: err });
         }
       }
-      if (this.addressTypes.includes(AddressType.ethereum)) {
+      if (this.addressTypes.includes(AddressType3.ethereum)) {
         try {
           const accounts = await this.phantom.ethereum.connect();
           if (accounts && accounts.length > 0) {
             connectedAddresses.push(
               ...accounts.map((address) => ({
-                addressType: AddressType.ethereum,
+                addressType: AddressType3.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 });
@@ -192,7 +455,7 @@ var InjectedProvider = class {
   }
   async disconnect() {
     debug.info(DebugCategory.INJECTED_PROVIDER, "Starting injected provider disconnect");
-    if (this.addressTypes.includes(AddressType.solana)) {
+    if (this.addressTypes.includes(AddressType3.solana)) {
       try {
         await this.phantom.solana.disconnect();
         debug.log(DebugCategory.INJECTED_PROVIDER, "Solana disconnected successfully");
@@ -200,13 +463,8 @@ var InjectedProvider = class {
         debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to disconnect Solana", { error: err });
       }
     }
-    if (this.addressTypes.includes(AddressType.ethereum)) {
-      try {
-        await this.phantom.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(AddressType3.ethereum)) {
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum disconnected (no-op)");
     }
     this.browserInjectedCleanupFunctions.forEach((cleanup) => cleanup());
     this.browserInjectedCleanupFunctions = [];
@@ -217,77 +475,29 @@ var InjectedProvider = class {
     });
     debug.info(DebugCategory.INJECTED_PROVIDER, "Injected provider disconnected successfully");
   }
-  async signMessage(params) {
-    if (!this.connected) {
-      throw new Error("Wallet not connected");
-    }
-    const networkPrefix = params.networkId.split(":")[0].toLowerCase();
-    let signatureResult;
-    if (networkPrefix === "solana") {
-      const { signature } = await this.phantom.solana.signMessage(new TextEncoder().encode(params.message));
-      signatureResult = bs58.encode(signature);
-    } else if (networkPrefix === "ethereum" || networkPrefix === "polygon" || networkPrefix === "eip155") {
-      const address = this.addresses.find((addr) => addr.addressType === AddressType.ethereum)?.address;
-      if (!address) {
-        throw new Error("No address available");
-      }
-      const signature = await this.phantom.ethereum.signPersonalMessage(params.message, address);
-      signatureResult = signature;
-    } else {
-      throw new Error(`Network ${params.networkId} is not supported for injected wallets`);
-    }
-    return {
-      signature: signatureResult,
-      rawSignature: base64urlEncode(signatureResult)
-    };
-  }
-  async signAndSendTransaction(params) {
-    if (!this.connected) {
-      throw new Error("Wallet not connected");
-    }
-    const networkPrefix = params.networkId.split(":")[0].toLowerCase();
-    if (networkPrefix === "solana") {
-      const transaction = params.transaction;
-      const result = await this.phantom.solana.signAndSendTransaction(transaction);
-      return {
-        hash: result.signature,
-        rawTransaction: base64urlEncode(result.signature),
-        blockExplorer: getExplorerUrl(params.networkId, "transaction", result.signature)
-      };
-    } else if (networkPrefix === "ethereum" || networkPrefix === "polygon" || networkPrefix === "eip155") {
-      const toHex = (value) => {
-        if (!value)
-          return void 0;
-        if (typeof value === "string" && value.startsWith("0x"))
-          return value;
-        if (typeof value === "string")
-          return value;
-        return "0x" + value.toString(16);
-      };
-      const txRequest = {
-        to: params.transaction.to,
-        value: params.transaction.value ? toHex(params.transaction.value) : "0x0",
-        gas: toHex(params.transaction.gas),
-        gasPrice: toHex(params.transaction.gasPrice),
-        maxFeePerGas: toHex(params.transaction.maxFeePerGas),
-        maxPriorityFeePerGas: toHex(params.transaction.maxPriorityFeePerGas),
-        data: params.transaction.data || "0x"
-      };
-      const txHash = await this.phantom.ethereum.sendTransaction(txRequest);
-      return {
-        hash: txHash,
-        rawTransaction: base64urlEncode(txHash),
-        blockExplorer: getExplorerUrl(params.networkId, "transaction", txHash)
-      };
-    }
-    throw new Error(`Network ${params.networkId} is not supported for injected wallets`);
-  }
   getAddresses() {
     return this.addresses;
   }
   isConnected() {
     return this.connected;
   }
+  // AutoConfirm methods - only available for injected providers
+  async enableAutoConfirm(params) {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Enabling autoConfirm", { params });
+    return await this.phantom.autoConfirm.autoConfirmEnable(params);
+  }
+  async disableAutoConfirm() {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Disabling autoConfirm");
+    await this.phantom.autoConfirm.autoConfirmDisable();
+  }
+  async getAutoConfirmStatus() {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Getting autoConfirm status");
+    return await this.phantom.autoConfirm.autoConfirmStatus();
+  }
+  async getSupportedAutoConfirmChains() {
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Getting supported autoConfirm chains");
+    return await this.phantom.autoConfirm.autoConfirmSupportedChains();
+  }
   // Event management methods - implementing unified event interface
   on(event, callback) {
     debug.log(DebugCategory.INJECTED_PROVIDER, "Adding event listener", { event });
@@ -328,19 +538,19 @@ var InjectedProvider = class {
   }
   setupBrowserInjectedEvents() {
     debug.log(DebugCategory.INJECTED_PROVIDER, "Setting up browser-injected-sdk event listeners");
-    if (this.addressTypes.includes(AddressType.solana) && this.phantom.solana) {
+    if (this.addressTypes.includes(AddressType3.solana)) {
       this.setupSolanaEvents();
     }
-    if (this.addressTypes.includes(AddressType.ethereum) && this.phantom.ethereum) {
+    if (this.addressTypes.includes(AddressType3.ethereum)) {
       this.setupEthereumEvents();
     }
   }
   setupSolanaEvents() {
     debug.log(DebugCategory.INJECTED_PROVIDER, "Setting up Solana event listeners");
-    const solanaConnectCleanup = this.phantom.solana.addEventListener("connect", (publicKey) => {
+    const handleSolanaConnect = (publicKey) => {
       debug.log(DebugCategory.INJECTED_PROVIDER, "Solana connect event received", { publicKey });
-      const solanaAddress = { addressType: AddressType.solana, address: publicKey };
-      if (!this.addresses.find((addr) => addr.addressType === AddressType.solana)) {
+      const solanaAddress = { addressType: AddressType3.solana, address: publicKey };
+      if (!this.addresses.find((addr) => addr.addressType === AddressType3.solana)) {
         this.addresses.push(solanaAddress);
       }
       this.connected = true;
@@ -348,78 +558,109 @@ var InjectedProvider = class {
         addresses: this.addresses,
         source: "injected-extension"
       });
-    });
-    const solanaDisconnectCleanup = this.phantom.solana.addEventListener("disconnect", () => {
+    };
+    const handleSolanaDisconnect = () => {
       debug.log(DebugCategory.INJECTED_PROVIDER, "Solana disconnect event received");
-      this.addresses = this.addresses.filter((addr) => addr.addressType !== AddressType.solana);
+      this.addresses = this.addresses.filter((addr) => addr.addressType !== AddressType3.solana);
       this.connected = this.addresses.length > 0;
       this.emit("disconnect", {
         source: "injected-extension"
       });
-    });
-    const solanaAccountChangedCleanup = this.phantom.solana.addEventListener("accountChanged", (publicKey) => {
+    };
+    const handleSolanaAccountChanged = (publicKey) => {
       debug.log(DebugCategory.INJECTED_PROVIDER, "Solana account changed event received", { publicKey });
-      const solanaIndex = this.addresses.findIndex((addr) => addr.addressType === AddressType.solana);
+      const solanaIndex = this.addresses.findIndex((addr) => addr.addressType === AddressType3.solana);
       if (solanaIndex >= 0) {
-        this.addresses[solanaIndex] = { addressType: AddressType.solana, address: publicKey };
+        this.addresses[solanaIndex] = { addressType: AddressType3.solana, address: publicKey };
       } else {
-        this.addresses.push({ addressType: AddressType.solana, address: publicKey });
+        this.addresses.push({ addressType: AddressType3.solana, address: publicKey });
       }
       this.emit("connect", {
         addresses: this.addresses,
         source: "injected-extension-account-change"
       });
-    });
-    this.browserInjectedCleanupFunctions.push(
-      solanaConnectCleanup,
-      solanaDisconnectCleanup,
-      solanaAccountChangedCleanup
+    };
+    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);
   }
   setupEthereumEvents() {
     debug.log(DebugCategory.INJECTED_PROVIDER, "Setting up Ethereum event listeners");
-    const ethConnectCleanup = this.phantom.ethereum.addEventListener("connect", (accounts) => {
+    const handleEthereumConnect = (accounts) => {
       debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum connect event received", { accounts });
-      this.addresses = this.addresses.filter((addr) => addr.addressType !== AddressType.ethereum);
+      this.addresses = this.addresses.filter((addr) => addr.addressType !== AddressType3.ethereum);
       if (accounts && accounts.length > 0) {
-        this.addresses.push(...accounts.map((address) => ({
-          addressType: AddressType.ethereum,
-          address
-        })));
+        this.addresses.push(
+          ...accounts.map((address) => ({
+            addressType: AddressType3.ethereum,
+            address
+          }))
+        );
       }
       this.connected = this.addresses.length > 0;
       this.emit("connect", {
         addresses: this.addresses,
         source: "injected-extension"
       });
-    });
-    const ethDisconnectCleanup = this.phantom.ethereum.addEventListener("disconnect", () => {
+    };
+    const handleEthereumDisconnect = () => {
       debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum disconnect event received");
-      this.addresses = this.addresses.filter((addr) => addr.addressType !== AddressType.ethereum);
+      this.addresses = this.addresses.filter((addr) => addr.addressType !== AddressType3.ethereum);
       this.connected = this.addresses.length > 0;
       this.emit("disconnect", {
         source: "injected-extension"
       });
-    });
-    const ethAccountChangedCleanup = this.phantom.ethereum.addEventListener("accountChanged", (accounts) => {
-      debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum account changed event received", { accounts });
-      this.addresses = this.addresses.filter((addr) => addr.addressType !== AddressType.ethereum);
+    };
+    const handleEthereumAccountsChanged = (accounts) => {
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum accounts changed event received", { accounts });
+      this.addresses = this.addresses.filter((addr) => addr.addressType !== AddressType3.ethereum);
       if (accounts && accounts.length > 0) {
-        this.addresses.push(...accounts.map((address) => ({
-          addressType: AddressType.ethereum,
-          address
-        })));
+        this.addresses.push(
+          ...accounts.map((address) => ({
+            addressType: AddressType3.ethereum,
+            address
+          }))
+        );
       }
       this.emit("connect", {
         addresses: this.addresses,
         source: "injected-extension-account-change"
       });
-    });
-    this.browserInjectedCleanupFunctions.push(
-      ethConnectCleanup,
-      ethDisconnectCleanup,
-      ethAccountChangedCleanup
+    };
+    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);
+  }
+  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);
+      }
+    };
   }
 };
 
@@ -535,6 +776,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
@@ -544,13 +786,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", {
@@ -568,6 +807,7 @@ var BrowserAuthProvider = class {
       const authContext = {
         organizationId: phantomOptions.organizationId,
         parentOrganizationId: phantomOptions.parentOrganizationId,
+        appId: phantomOptions.appId,
         provider: phantomOptions.provider,
         sessionId: phantomOptions.sessionId
       };
@@ -882,24 +1122,6 @@ var ProviderManager = class {
     await this.currentProvider.disconnect();
     this.walletId = null;
   }
-  /**
-   * Sign a message using current provider
-   */
-  async signMessage(params) {
-    if (!this.currentProvider) {
-      throw new Error("No provider connected");
-    }
-    return this.currentProvider.signMessage(params);
-  }
-  /**
-   * Sign and send transaction using current provider
-   */
-  async signAndSendTransaction(params) {
-    if (!this.currentProvider) {
-      throw new Error("No provider connected");
-    }
-    return this.currentProvider.signAndSendTransaction(params);
-  }
   /**
    * Get addresses from current provider
    */
@@ -983,7 +1205,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 });
@@ -1017,19 +1245,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);
@@ -1076,8 +1302,32 @@ var ProviderManager = class {
   }*/
 };
 
-// src/BrowserSDK.ts
+// 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
 var BrowserSDK = class {
   constructor(config) {
     debug.info(DebugCategory.BROWSER_SDK, "Initializing BrowserSDK", {
@@ -1098,145 +1348,109 @@ var BrowserSDK = class {
         `Invalid embeddedWalletType: ${config.embeddedWalletType}. Must be "app-wallet" or "user-wallet".`
       );
     }
-    config.embeddedWalletType = embeddedWalletType;
-    debug.log(DebugCategory.BROWSER_SDK, "Creating ProviderManager", { config });
     this.providerManager = new ProviderManager(config);
-    debug.info(DebugCategory.BROWSER_SDK, "BrowserSDK initialized successfully");
   }
+  // ===== CHAIN API =====
   /**
-   * Connect to the wallet with optional provider switching
+   * Access Solana chain operations
    */
-  async connect(options) {
-    debug.info(DebugCategory.BROWSER_SDK, "Starting connect process", { options });
-    if (options?.providerType) {
-      debug.log(DebugCategory.BROWSER_SDK, "Provider switch requested", {
-        providerType: options.providerType,
-        embeddedWalletType: options.embeddedWalletType
-      });
-      if (!["injected", "embedded"].includes(options.providerType)) {
-        debug.error(DebugCategory.BROWSER_SDK, "Invalid providerType in connect options", {
-          providerType: options.providerType
-        });
-        throw new Error(`Invalid providerType: ${options.providerType}. Must be "injected" or "embedded".`);
-      }
-      if (options.embeddedWalletType && !["app-wallet", "user-wallet"].includes(options.embeddedWalletType)) {
-        debug.error(DebugCategory.BROWSER_SDK, "Invalid embeddedWalletType in connect options", {
-          embeddedWalletType: options.embeddedWalletType
-        });
-        throw new Error(
-          `Invalid embeddedWalletType: ${options.embeddedWalletType}. Must be "app-wallet" or "user-wallet".`
-        );
-      }
-      debug.log(DebugCategory.BROWSER_SDK, "Switching provider", {
-        providerType: options.providerType,
-        embeddedWalletType: options.embeddedWalletType
-      });
-      await this.providerManager.switchProvider(options.providerType, {
-        embeddedWalletType: options.embeddedWalletType
-      });
+  get solana() {
+    const currentProvider = this.providerManager.getCurrentProvider();
+    if (!currentProvider) {
+      throw new Error("No provider available. Call connect() first.");
     }
-    debug.log(DebugCategory.BROWSER_SDK, "Delegating to ProviderManager.connect", {
-      authOptions: options?.authOptions
-    });
-    const result = await this.providerManager.connect(options?.authOptions);
-    debug.info(DebugCategory.BROWSER_SDK, "Connect completed successfully", result);
-    return result;
+    return currentProvider.solana;
   }
   /**
-   * Switch to a different provider type
+   * Access Ethereum chain operations
    */
-  async switchProvider(type, options) {
-    if (!["injected", "embedded"].includes(type)) {
-      throw new Error(`Invalid providerType: ${type}. Must be "injected" or "embedded".`);
+  get ethereum() {
+    const currentProvider = this.providerManager.getCurrentProvider();
+    if (!currentProvider) {
+      throw new Error("No provider available. Call connect() first.");
     }
-    await this.providerManager.switchProvider(type, options);
+    return currentProvider.ethereum;
   }
+  // ===== CONNECTION MANAGEMENT =====
   /**
-   * Get current provider information
+   * Connect to the wallet
    */
-  getCurrentProviderInfo() {
-    return this.providerManager.getCurrentProviderInfo();
-  }
-  /**
-   * Wait for Phantom extension to become available
-   */
-  async waitForPhantomExtension(timeoutMs) {
-    const isInstalled = async (retries = 3, timeAccumulated = 0) => {
-      const installed = isPhantomExtensionInstalled();
-      if (installed)
-        return true;
-      if (retries <= 0)
-        return false;
-      if (timeAccumulated >= (timeoutMs || 3e3))
-        return false;
-      return new Promise((resolve) => {
-        setTimeout(async () => {
-          const result = await isInstalled(retries - 1, timeAccumulated + 100);
-          resolve(result);
-        }, 100);
+  async connect(options) {
+    debug.info(DebugCategory.BROWSER_SDK, "Starting connection", options);
+    try {
+      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 isInstalled();
+      return result;
+    } catch (error) {
+      debug.error(DebugCategory.BROWSER_SDK, "Connection failed", { error: error.message });
+      throw error;
+    }
   }
   /**
    * Disconnect from the wallet
    */
   async disconnect() {
-    return this.providerManager.disconnect();
+    debug.info(DebugCategory.BROWSER_SDK, "Disconnecting");
+    try {
+      await this.providerManager.disconnect();
+      debug.info(DebugCategory.BROWSER_SDK, "Disconnection successful");
+    } catch (error) {
+      debug.error(DebugCategory.BROWSER_SDK, "Disconnection failed", { error: error.message });
+      throw error;
+    }
   }
   /**
-   * Sign a message
-   * @param message - Message string to sign
-   * @param networkId - Network identifier
-   * @returns Signature string
+   * Switch between provider types (injected vs embedded)
    */
-  async signMessage(params) {
-    debug.info(DebugCategory.BROWSER_SDK, "Signing message", {
-      message: params.message,
-      networkId: params.networkId
-    });
-    const result = await this.providerManager.signMessage(params);
-    debug.info(DebugCategory.BROWSER_SDK, "Message signed successfully", {
-      message: params.message,
-      networkId: params.networkId,
-      result
-    });
-    return result;
+  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 =====
   /**
-   * Sign and send a transaction
-   * @param params - Transaction parameters with native transaction object
-   * @returns Transaction result
+   * Check if the SDK is connected to a wallet
    */
-  async signAndSendTransaction(params) {
-    debug.info(DebugCategory.BROWSER_SDK, "Signing and sending transaction", {
-      networkId: params.networkId
-    });
-    const result = await this.providerManager.signAndSendTransaction(params);
-    debug.info(DebugCategory.BROWSER_SDK, "Transaction signed and sent successfully", {
-      networkId: params.networkId,
-      result
-    });
-    return result;
+  isConnected() {
+    return this.providerManager.isConnected();
   }
   /**
-   * Get wallet addresses
+   * Get all connected wallet addresses
    */
   getAddresses() {
     return this.providerManager.getAddresses();
   }
   /**
-   * Check if wallet is connected
+   * Get information about the current provider
    */
-  isConnected() {
-    return this.providerManager.isConnected();
+  getCurrentProviderInfo() {
+    return this.providerManager.getCurrentProviderInfo();
   }
   /**
-   * Get the current wallet ID (for embedded wallets)
+   * Get the wallet ID (for embedded wallets)
    */
   getWalletId() {
     return this.providerManager.getWalletId();
   }
+  // ===== 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
@@ -1318,16 +1532,106 @@ var BrowserSDK = class {
       this.setDebugCallback(config.callback);
     }
   }
+  // ===== AUTO-CONFIRM METHODS (Injected Provider Only) =====
+  /**
+   * Enable auto-confirm for transactions
+   * Only available for injected providers
+   */
+  async enableAutoConfirm(params) {
+    debug.info(DebugCategory.BROWSER_SDK, "Enabling auto-confirm", { params });
+    const currentProvider = this.providerManager.getCurrentProvider();
+    if (!currentProvider) {
+      throw new Error("No provider available. Call connect() first.");
+    }
+    if (!("enableAutoConfirm" in currentProvider)) {
+      throw new Error("Auto-confirm is only available for injected providers");
+    }
+    try {
+      const result = await currentProvider.enableAutoConfirm(params);
+      debug.info(DebugCategory.BROWSER_SDK, "Auto-confirm enabled successfully", { result });
+      return result;
+    } catch (error) {
+      debug.error(DebugCategory.BROWSER_SDK, "Failed to enable auto-confirm", { error: error.message });
+      throw error;
+    }
+  }
+  /**
+   * Disable auto-confirm for transactions
+   * Only available for injected providers
+   */
+  async disableAutoConfirm() {
+    debug.info(DebugCategory.BROWSER_SDK, "Disabling auto-confirm");
+    const currentProvider = this.providerManager.getCurrentProvider();
+    if (!currentProvider) {
+      throw new Error("No provider available. Call connect() first.");
+    }
+    if (!("disableAutoConfirm" in currentProvider)) {
+      throw new Error("Auto-confirm is only available for injected providers");
+    }
+    try {
+      await currentProvider.disableAutoConfirm();
+      debug.info(DebugCategory.BROWSER_SDK, "Auto-confirm disabled successfully");
+    } catch (error) {
+      debug.error(DebugCategory.BROWSER_SDK, "Failed to disable auto-confirm", { error: error.message });
+      throw error;
+    }
+  }
+  /**
+   * Get current auto-confirm status
+   * Only available for injected providers
+   */
+  async getAutoConfirmStatus() {
+    debug.info(DebugCategory.BROWSER_SDK, "Getting auto-confirm status");
+    const currentProvider = this.providerManager.getCurrentProvider();
+    if (!currentProvider) {
+      throw new Error("No provider available. Call connect() first.");
+    }
+    if (!("getAutoConfirmStatus" in currentProvider)) {
+      throw new Error("Auto-confirm is only available for injected providers");
+    }
+    try {
+      const result = await currentProvider.getAutoConfirmStatus();
+      debug.info(DebugCategory.BROWSER_SDK, "Got auto-confirm status", { result });
+      return result;
+    } catch (error) {
+      debug.error(DebugCategory.BROWSER_SDK, "Failed to get auto-confirm status", { error: error.message });
+      throw error;
+    }
+  }
+  /**
+   * Get supported chains for auto-confirm
+   * Only available for injected providers
+   */
+  async getSupportedAutoConfirmChains() {
+    debug.info(DebugCategory.BROWSER_SDK, "Getting supported auto-confirm chains");
+    const currentProvider = this.providerManager.getCurrentProvider();
+    if (!currentProvider) {
+      throw new Error("No provider available. Call connect() first.");
+    }
+    if (!("getSupportedAutoConfirmChains" in currentProvider)) {
+      throw new Error("Auto-confirm is only available for injected providers");
+    }
+    try {
+      const result = await currentProvider.getSupportedAutoConfirmChains();
+      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
+      });
+      throw error;
+    }
+  }
 };
 
 // src/types.ts
-import { AddressType as AddressType2 } from "@phantom/client";
+import { AddressType as AddressType4 } from "@phantom/client";
 
 // src/index.ts
 import { NetworkId } from "@phantom/constants";
-import { AddressType as AddressType3 } from "@phantom/client";
+import { AddressType as AddressType5 } from "@phantom/client";
 export {
-  AddressType3 as AddressType,
+  AddressType5 as AddressType,
   BrowserSDK,
   DEFAULT_AUTH_URL,
   DEFAULT_WALLET_API_URL,
@@ -1338,5 +1642,6 @@ export {
   detectBrowser,
   getBrowserDisplayName,
   getPlatformName,
-  parseBrowserFromUserAgent
+  parseBrowserFromUserAgent,
+  waitForPhantomExtension
 };