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

package/dist/index.mjs

@@ -1,8 +1,12 @@
 // src/providers/injected/index.ts
 import { AddressType } from "@phantom/client";
-import { createPhantom, createExtensionPlugin } from "@phantom/browser-injected-sdk";
+import {
+  createPhantom,
+  createExtensionPlugin
+} from "@phantom/browser-injected-sdk";
 import { createSolanaPlugin } from "@phantom/browser-injected-sdk/solana";
 import { createEthereumPlugin } from "@phantom/browser-injected-sdk/ethereum";
+import { createAutoConfirmPlugin } from "@phantom/browser-injected-sdk/auto-confirm";
 
 // src/debug.ts
 var DebugLevel = /* @__PURE__ */ ((DebugLevel2) => {
@@ -78,10 +82,116 @@ var DebugCategory = {
   SESSION: "Session"
 };
 
+// src/providers/injected/chains/SolanaChain.ts
+import { getExplorerUrl, NetworkId } from "@phantom/constants";
+import { Buffer } from "buffer";
+var InjectedSolanaChain = class {
+  constructor(phantom) {
+    this.phantom = phantom;
+  }
+  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 ? Buffer.from(result.signature).toString("base64") : result.signature;
+    return {
+      signature,
+      rawSignature: signature
+    };
+  }
+  signTransaction(_transaction) {
+    throw new Error("signTransaction not available in browser-injected-sdk, use signAndSendTransaction instead");
+  }
+  async signAndSendTransaction(transaction) {
+    const result = await this.phantom.solana.signAndSendTransaction(transaction);
+    return {
+      hash: result.signature,
+      rawTransaction: result.signature,
+      blockExplorer: getExplorerUrl(NetworkId.SOLANA_MAINNET, "transaction", 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 };
+  }
+  async disconnect() {
+    return await this.phantom.solana.disconnect();
+  }
+  async switchNetwork(_network) {
+  }
+  async getPublicKey() {
+    try {
+      const address = await this.phantom.solana.getAccount();
+      return address || null;
+    } catch {
+      return null;
+    }
+  }
+  isConnected() {
+    try {
+      return !!this.phantom.extension?.isInstalled();
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/providers/injected/chains/EthereumChain.ts
+import { getExplorerUrl as getExplorerUrl2, NetworkId as NetworkId2, chainIdToNetworkId } from "@phantom/constants";
+var InjectedEthereumChain = class {
+  constructor(phantom) {
+    this.phantom = phantom;
+  }
+  async request(args) {
+    const provider = await this.phantom.ethereum.getProvider();
+    return await provider.request(args);
+  }
+  async signPersonalMessage(message, address) {
+    const signature = await this.phantom.ethereum.signPersonalMessage(message, address);
+    return {
+      signature,
+      rawSignature: signature
+    };
+  }
+  async signTypedData(typedData, address) {
+    const signature = await this.phantom.ethereum.signTypedData(typedData, address);
+    return {
+      signature,
+      rawSignature: signature
+    };
+  }
+  async sendTransaction(transaction) {
+    const hash = await this.phantom.ethereum.sendTransaction(transaction);
+    const chainId = await this.getChainId();
+    const networkId = chainIdToNetworkId(chainId) || NetworkId2.ETHEREUM_MAINNET;
+    return {
+      hash,
+      rawTransaction: hash,
+      blockExplorer: getExplorerUrl2(networkId, "transaction", hash)
+    };
+  }
+  async switchChain(chainId) {
+    return await this.phantom.ethereum.switchChain(`0x${chainId.toString(16)}`);
+  }
+  async getChainId() {
+    const chainId = await this.phantom.ethereum.getChainId();
+    return parseInt(chainId, 16);
+  }
+  async getAccounts() {
+    return await this.phantom.ethereum.getAccounts();
+  }
+  isConnected() {
+    try {
+      return !!this.phantom.extension?.isInstalled();
+    } catch {
+      return false;
+    }
+  }
+};
+
 // 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;
@@ -102,12 +212,38 @@ var InjectedProvider = class {
       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 });
     debug.info(DebugCategory.INJECTED_PROVIDER, "InjectedProvider initialized");
   }
+  /**
+   * Access to Solana chain operations
+   */
+  get solana() {
+    if (!this.addressTypes.includes(AddressType.solana)) {
+      throw new Error("Solana not enabled for this provider");
+    }
+    if (!this._solanaChain) {
+      this._solanaChain = new InjectedSolanaChain(this.phantom);
+    }
+    return this._solanaChain;
+  }
+  /**
+   * Access to Ethereum chain operations
+   */
+  get ethereum() {
+    if (!this.addressTypes.includes(AddressType.ethereum)) {
+      throw new Error("Ethereum not enabled for this provider");
+    }
+    if (!this._ethereumChain) {
+      this._ethereumChain = new InjectedEthereumChain(this.phantom);
+    }
+    return this._ethereumChain;
+  }
   async connect(authOptions) {
     debug.info(DebugCategory.INJECTED_PROVIDER, "Starting injected provider connect", {
       addressTypes: this.addressTypes,
@@ -119,7 +255,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", {
@@ -133,13 +269,13 @@ var InjectedProvider = class {
       if (this.addressTypes.includes(AddressType.solana)) {
         debug.log(DebugCategory.INJECTED_PROVIDER, "Attempting Solana connection");
         try {
-          const publicKey = await this.phantom.solana.connect();
-          if (publicKey) {
+          const result2 = await this.solana.connect();
+          if (result2.publicKey) {
             connectedAddresses.push({
               addressType: AddressType.solana,
-              address: publicKey
+              address: result2.publicKey
             });
-            debug.info(DebugCategory.INJECTED_PROVIDER, "Solana connected successfully", { address: publicKey });
+            debug.info(DebugCategory.INJECTED_PROVIDER, "Solana connected successfully", { address: result2.publicKey });
           }
         } catch (err) {
           debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to connect Solana", { error: err });
@@ -147,7 +283,7 @@ var InjectedProvider = class {
       }
       if (this.addressTypes.includes(AddressType.ethereum)) {
         try {
-          const accounts = await this.phantom.ethereum.connect();
+          const accounts = await this.ethereum.getAccounts();
           if (accounts && accounts.length > 0) {
             connectedAddresses.push(
               ...accounts.map((address) => ({
@@ -155,6 +291,7 @@ var InjectedProvider = class {
                 address
               }))
             );
+            debug.info(DebugCategory.INJECTED_PROVIDER, "Ethereum connected successfully", { addresses: accounts });
           }
         } catch (err) {
           debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to connect Ethereum", { error: err });
@@ -194,20 +331,17 @@ var InjectedProvider = class {
     debug.info(DebugCategory.INJECTED_PROVIDER, "Starting injected provider disconnect");
     if (this.addressTypes.includes(AddressType.solana)) {
       try {
-        await this.phantom.solana.disconnect();
+        await this.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(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 });
-      }
+      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;
@@ -217,77 +351,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,16 +414,16 @@ 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(AddressType.solana)) {
       this.setupSolanaEvents();
     }
-    if (this.addressTypes.includes(AddressType.ethereum) && this.phantom.ethereum) {
+    if (this.addressTypes.includes(AddressType.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)) {
@@ -348,16 +434,16 @@ 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.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);
       if (solanaIndex >= 0) {
@@ -369,16 +455,19 @@ var InjectedProvider = class {
         addresses: this.addresses,
         source: "injected-extension-account-change"
       });
-    });
+    };
+    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(
-      solanaConnectCleanup,
-      solanaDisconnectCleanup,
-      solanaAccountChangedCleanup
+      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);
       if (accounts && accounts.length > 0) {
@@ -392,17 +481,17 @@ var InjectedProvider = class {
         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.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 });
+    };
+    const handleEthereumAccountsChanged = (accounts) => {
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum accounts changed event received", { accounts });
       this.addresses = this.addresses.filter((addr) => addr.addressType !== AddressType.ethereum);
       if (accounts && accounts.length > 0) {
         this.addresses.push(...accounts.map((address) => ({
@@ -414,11 +503,14 @@ var InjectedProvider = class {
         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(
-      ethConnectCleanup,
-      ethDisconnectCleanup,
-      ethAccountChangedCleanup
+      cleanupConnect,
+      cleanupDisconnect,
+      cleanupAccountsChanged
     );
   }
 };
@@ -882,24 +974,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
    */
@@ -1098,145 +1172,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);
-  }
-  /**
-   * Get current provider information
-   */
-  getCurrentProviderInfo() {
-    return this.providerManager.getCurrentProviderInfo();
+    return currentProvider.ethereum;
   }
+  // ===== CONNECTION MANAGEMENT =====
   /**
-   * Wait for Phantom extension to become available
+   * Connect to the wallet
    */
-  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 isPhantomInstalled() {
+    return isPhantomExtensionInstalled();
+  }
   /**
    * Add event listener for provider events (connect, connect_start, connect_error, disconnect, error)
    * Works with both embedded and injected providers
@@ -1318,13 +1356,101 @@ 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";
 
 // src/index.ts
-import { NetworkId } from "@phantom/constants";
+import { NetworkId as NetworkId3 } from "@phantom/constants";
 import { AddressType as AddressType3 } from "@phantom/client";
 export {
   AddressType3 as AddressType,
@@ -1333,7 +1459,7 @@ export {
   DEFAULT_WALLET_API_URL,
   DebugCategory,
   DebugLevel,
-  NetworkId,
+  NetworkId3 as NetworkId,
   debug,
   detectBrowser,
   getBrowserDisplayName,