@phantom/browser-sdk 1.0.0-beta.20 → 1.0.0-beta.22

package/dist/index.js

@@ -319,8 +319,9 @@ var InjectedEthereumChain = class {
     return await this.phantom.ethereum.sendTransaction(transaction);
   }
   async switchChain(chainId) {
-    await this.phantom.ethereum.switchChain(`0x${chainId.toString(16)}`);
-    this._chainId = `0x${chainId.toString(16)}`;
+    const hexChainId = typeof chainId === "string" ? chainId.toLowerCase().startsWith("0x") ? chainId : `0x${parseInt(chainId, 10).toString(16)}` : `0x${chainId.toString(16)}`;
+    await this.phantom.ethereum.switchChain(hexChainId);
+    this._chainId = hexChainId;
     this.eventEmitter.emit("chainChanged", this._chainId);
   }
   async getChainId() {
@@ -384,8 +385,8 @@ var InjectedEthereumChain = class {
 };
 
 // src/providers/injected/index.ts
-var MANUAL_DISCONNECT_KEY = "phantom-injected-manual-disconnect";
-var MANUAL_DISCONNECT_VALUE = "true";
+var WAS_CONNECTED_KEY = "phantom-injected-was-connected";
+var WAS_CONNECTED_VALUE = "true";
 var InjectedProvider = class {
   constructor(config) {
     this.connected = false;
@@ -421,9 +422,6 @@ var InjectedProvider = class {
     }
     debug.info(DebugCategory.INJECTED_PROVIDER, "InjectedProvider initialized");
   }
-  /**
-   * Access to Solana chain operations
-   */
   get solana() {
     if (!this.addressTypes.includes(import_client4.AddressType.solana)) {
       throw new Error("Solana not enabled for this provider");
@@ -522,10 +520,10 @@ var InjectedProvider = class {
       this.connected = true;
       const authUserId = await this.getAuthUserId("manual-connect");
       try {
-        localStorage.removeItem(MANUAL_DISCONNECT_KEY);
-        debug.log(DebugCategory.INJECTED_PROVIDER, "Cleared manual disconnect flag - auto-reconnect enabled");
+        localStorage.setItem(WAS_CONNECTED_KEY, WAS_CONNECTED_VALUE);
+        debug.log(DebugCategory.INJECTED_PROVIDER, "Set was-connected flag - auto-reconnect enabled");
       } catch (error) {
-        debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to clear manual disconnect flag", { error });
+        debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to set was-connected flag", { error });
       }
       const result = {
         addresses: this.addresses,
@@ -558,18 +556,15 @@ var InjectedProvider = class {
         debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to disconnect Solana", { error: err });
       }
     }
-    if (this.addressTypes.includes(import_client4.AddressType.ethereum)) {
-      debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum disconnected (no-op)");
-    }
     this.browserInjectedCleanupFunctions.forEach((cleanup) => cleanup());
     this.browserInjectedCleanupFunctions = [];
     this.connected = false;
     this.addresses = [];
     try {
-      localStorage.setItem(MANUAL_DISCONNECT_KEY, MANUAL_DISCONNECT_VALUE);
-      debug.log(DebugCategory.INJECTED_PROVIDER, "Set manual disconnect flag to prevent auto-reconnect");
+      localStorage.removeItem(WAS_CONNECTED_KEY);
+      debug.log(DebugCategory.INJECTED_PROVIDER, "Cleared was connected flag to prevent auto-reconnect");
     } catch (error) {
-      debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to set manual disconnect flag", { error });
+      debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to clear was-connected flag", { error });
     }
     this.emit("disconnect", {
       source: "manual-disconnect"
@@ -577,20 +572,22 @@ var InjectedProvider = class {
     debug.info(DebugCategory.INJECTED_PROVIDER, "Injected provider disconnected successfully");
   }
   /**
-   * Attempt auto-connection using onlyIfTrusted parameter
-   * This will only connect if the dApp is already trusted by the user
+   * Attempt auto-connection if user was previously connected
+   * Only reconnects if the user connected before and didn't explicitly disconnect
    * Should be called after setting up event listeners
    */
   async autoConnect() {
-    debug.log(DebugCategory.INJECTED_PROVIDER, "Attempting auto-connect with onlyIfTrusted=true");
+    debug.log(DebugCategory.INJECTED_PROVIDER, "Attempting auto-connect");
     try {
-      const manualDisconnect = localStorage.getItem(MANUAL_DISCONNECT_KEY);
-      if (manualDisconnect === MANUAL_DISCONNECT_VALUE) {
-        debug.log(DebugCategory.INJECTED_PROVIDER, "Skipping auto-connect: user previously disconnected manually");
+      const wasConnected = localStorage.getItem(WAS_CONNECTED_KEY);
+      if (wasConnected !== WAS_CONNECTED_VALUE) {
+        debug.log(DebugCategory.INJECTED_PROVIDER, "Skipping auto-connect: user was not previously connected");
         return;
       }
+      debug.log(DebugCategory.INJECTED_PROVIDER, "User was previously connected, attempting auto-connect");
     } catch (error) {
-      debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to check manual disconnect flag", { error });
+      debug.warn(DebugCategory.INJECTED_PROVIDER, "Failed to check was-connected flag", { error });
+      return;
     }
     this.emit("connect_start", {
       source: "auto-connect",
@@ -618,7 +615,10 @@ var InjectedProvider = class {
             debug.info(DebugCategory.INJECTED_PROVIDER, "Solana auto-connected successfully", { address: publicKey });
           }
         } catch (err) {
-          debug.log(DebugCategory.INJECTED_PROVIDER, "Solana auto-connect failed (expected if not trusted)", { error: err });
+          debug.log(DebugCategory.INJECTED_PROVIDER, "Solana auto-connect failed (expected if not trusted)", {
+            error: err
+          });
+          throw err;
         }
       }
       if (this.addressTypes.includes(import_client4.AddressType.ethereum)) {
@@ -632,10 +632,14 @@ var InjectedProvider = class {
                 address
               }))
             );
-            debug.info(DebugCategory.INJECTED_PROVIDER, "Ethereum auto-connected successfully", { addresses: accounts });
+            debug.info(DebugCategory.INJECTED_PROVIDER, "Ethereum auto-connected successfully", {
+              addresses: accounts
+            });
           }
         } catch (err) {
-          debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum auto-connect failed (expected if not trusted)", { error: err });
+          debug.log(DebugCategory.INJECTED_PROVIDER, "Ethereum auto-connect failed (expected if not trusted)", {
+            error: err
+          });
         }
       }
       if (connectedAddresses.length === 0) {
@@ -656,7 +660,10 @@ var InjectedProvider = class {
       });
       debug.info(DebugCategory.INJECTED_PROVIDER, "Auto-connect successful", {
         addressCount: connectedAddresses.length,
-        addresses: connectedAddresses.map((addr) => ({ type: addr.addressType, address: addr.address.substring(0, 8) + "..." })),
+        addresses: connectedAddresses.map((addr) => ({
+          type: addr.addressType,
+          address: addr.address.substring(0, 8) + "..."
+        })),
         authUserId
       });
     } catch (error) {
@@ -702,14 +709,22 @@ var InjectedProvider = class {
         const userInfo = await window.phantom.app.getUser();
         const authUserId = userInfo?.authUserId;
         if (authUserId) {
-          debug.log(DebugCategory.INJECTED_PROVIDER, `Retrieved authUserId from window.phantom.app.getUser() during ${context}`, {
-            authUserId
-          });
+          debug.log(
+            DebugCategory.INJECTED_PROVIDER,
+            `Retrieved authUserId from window.phantom.app.getUser() during ${context}`,
+            {
+              authUserId
+            }
+          );
         }
         return authUserId;
       }
     } catch (error) {
-      debug.log(DebugCategory.INJECTED_PROVIDER, `Failed to get user info during ${context} (method may not be supported)`, { error });
+      debug.log(
+        DebugCategory.INJECTED_PROVIDER,
+        `Failed to get user info during ${context} (method may not be supported)`,
+        { error }
+      );
     }
     return void 0;
   }
@@ -1200,7 +1215,7 @@ var BrowserAuthProvider = class {
         // OAuth session management - defaults to allow refresh unless explicitly clearing after logout
         clear_previous_session: (phantomOptions.clearPreviousSession ?? false).toString(),
         allow_refresh: (phantomOptions.allowRefresh ?? true).toString(),
-        sdk_version: "1.0.0-beta.20",
+        sdk_version: "1.0.0-beta.22",
         sdk_type: "browser",
         platform: detectBrowser().name
       });
@@ -1230,7 +1245,7 @@ var BrowserAuthProvider = class {
       resolve();
     });
   }
-  resumeAuthFromRedirect() {
+  resumeAuthFromRedirect(provider) {
     try {
       const walletId = this.urlParamsAccessor.getParam("wallet_id");
       const sessionId = this.urlParamsAccessor.getParam("session_id");
@@ -1297,16 +1312,21 @@ var BrowserAuthProvider = class {
         throw new Error("Missing organization_id in auth response");
       }
       if (organizationId.startsWith("temp-")) {
-        debug.warn(DebugCategory.PHANTOM_CONNECT_AUTH, "Received temporary organization_id, server may not be configured properly", {
-          organizationId
-        });
+        debug.warn(
+          DebugCategory.PHANTOM_CONNECT_AUTH,
+          "Received temporary organization_id, server may not be configured properly",
+          {
+            organizationId
+          }
+        );
       }
       return {
         walletId,
         organizationId,
         accountDerivationIndex: accountDerivationIndex ? parseInt(accountDerivationIndex) : 0,
         expiresInMs: expiresInMs ? parseInt(expiresInMs) : 0,
-        authUserId: authUserId || void 0
+        authUserId: authUserId || void 0,
+        provider
       };
     } catch (error) {
       sessionStorage.removeItem("phantom-auth-context");
@@ -1459,7 +1479,7 @@ var EmbeddedProvider = class extends import_embedded_provider_core.EmbeddedProvi
         // Full user agent for more detailed info
         [import_constants2.ANALYTICS_HEADERS.APP_ID]: config.appId,
         [import_constants2.ANALYTICS_HEADERS.WALLET_TYPE]: config.embeddedWalletType,
-        [import_constants2.ANALYTICS_HEADERS.SDK_VERSION]: "1.0.0-beta.20"
+        [import_constants2.ANALYTICS_HEADERS.SDK_VERSION]: "1.0.0-beta.22"
         // Replaced at build time
       }
     };
@@ -1471,6 +1491,7 @@ var EmbeddedProvider = class extends import_embedded_provider_core.EmbeddedProvi
 };
 
 // src/ProviderManager.ts
+var import_embedded_provider_core2 = require("@phantom/embedded-provider-core");
 var import_constants3 = require("@phantom/constants");
 
 // src/utils/auth-callback.ts
@@ -1554,6 +1575,12 @@ var ProviderManager = class {
       embeddedWalletType
     };
   }
+  /**
+   * Check if a provider is allowed by the config
+   */
+  isProviderAllowed(provider) {
+    return this.config.providers.includes(provider);
+  }
   /**
    * Connect using the current provider
    * Automatically switches provider based on authOptions.provider
@@ -1561,13 +1588,18 @@ var ProviderManager = class {
   async connect(authOptions) {
     debug.info(DebugCategory.PROVIDER_MANAGER, "Starting connection", {
       currentProviderKey: this.currentProviderKey,
-      authOptions: { provider: authOptions.provider, hasJwtToken: !!authOptions.jwtToken }
+      authOptions: { provider: authOptions.provider }
     });
+    if (!this.isProviderAllowed(authOptions.provider)) {
+      const error = `Provider "${authOptions.provider}" is not in the allowed providers list: ${JSON.stringify(this.config.providers)}`;
+      debug.error(DebugCategory.PROVIDER_MANAGER, error);
+      throw new Error(error);
+    }
     const requestedProvider = authOptions.provider;
     let targetProviderType = null;
     if (requestedProvider === "injected") {
       targetProviderType = "injected";
-    } else if (["google", "apple", "jwt", "phantom"].includes(requestedProvider)) {
+    } else if (import_embedded_provider_core2.EMBEDDED_PROVIDER_AUTH_TYPES.includes(requestedProvider)) {
       targetProviderType = "embedded";
     }
     if (targetProviderType) {
@@ -1591,16 +1623,14 @@ var ProviderManager = class {
     }
     debug.log(DebugCategory.PROVIDER_MANAGER, "Delegating to provider connect method");
     const result = await this.currentProvider.connect(authOptions);
-    const providerInfo = this.getCurrentProviderInfo();
-    result.providerType = providerInfo?.type;
     debug.log(DebugCategory.PROVIDER_MANAGER, "Connection successful, saving preferences", {
       addressCount: result.addresses?.length || 0,
-      providerType: result.providerType
+      provider: authOptions.provider
     });
     this.saveProviderPreference();
     debug.info(DebugCategory.PROVIDER_MANAGER, "Connect completed", {
       addresses: result.addresses,
-      providerType: result.providerType
+      provider: authOptions.provider
     });
     return result;
   }
@@ -1629,7 +1659,7 @@ var ProviderManager = class {
   }
   /**
    * Attempt auto-connect with fallback strategy
-   * Tries embedded provider first if it exists, then injected provider
+   * Tries embedded provider first if it exists and is allowed, then injected provider if allowed
    * Returns true if any provider successfully connected
    */
   async autoConnect() {
@@ -1640,7 +1670,8 @@ var ProviderManager = class {
     }
     const embeddedWalletType = this.config.embeddedWalletType || "user-wallet";
     const embeddedKey = this.getProviderKey("embedded", embeddedWalletType);
-    if (this.providers.has(embeddedKey)) {
+    const embeddedAllowed = this.config.providers.some((p) => p !== "injected");
+    if (embeddedAllowed && this.providers.has(embeddedKey)) {
       debug.log(DebugCategory.PROVIDER_MANAGER, "Trying auto-connect with existing embedded provider");
       const embeddedProvider = this.providers.get(embeddedKey);
       try {
@@ -1669,8 +1700,9 @@ var ProviderManager = class {
         }
       }
     }
+    const injectedAllowed = this.config.providers.includes("injected");
     const injectedKey = this.getProviderKey("injected");
-    if (this.providers.has(injectedKey)) {
+    if (injectedAllowed && this.providers.has(injectedKey)) {
       debug.log(DebugCategory.PROVIDER_MANAGER, "Trying auto-connect with existing injected provider");
       const injectedProvider = this.providers.get(injectedKey);
       try {
@@ -1689,7 +1721,7 @@ var ProviderManager = class {
         });
       }
     }
-    debug.log(DebugCategory.PROVIDER_MANAGER, "Auto-connect failed for all existing providers");
+    debug.log(DebugCategory.PROVIDER_MANAGER, "Auto-connect failed for all allowed providers");
     return false;
   }
   /**
@@ -1773,17 +1805,28 @@ var ProviderManager = class {
   }
   /**
    * Set default provider based on initial config
-   * Creates both embedded and injected providers for autoConnect fallback
+   * Creates providers based on the allowed providers array
    */
   setDefaultProvider() {
-    const defaultType = this.config.providerType || "embedded";
     const defaultEmbeddedType = this.config.embeddedWalletType || "user-wallet";
-    if (this.config.appId) {
-      debug.log(DebugCategory.PROVIDER_MANAGER, "Creating embedded provider");
+    const hasInjected = this.config.providers.includes("injected");
+    const hasEmbedded = this.config.providers.some((p) => p !== "injected");
+    if (hasInjected) {
+      debug.log(DebugCategory.PROVIDER_MANAGER, "Creating injected provider (allowed by providers array)");
+      this.createProvider("injected");
+    }
+    if (hasEmbedded) {
+      debug.log(DebugCategory.PROVIDER_MANAGER, "Creating embedded provider (allowed by providers array)");
       this.createProvider("embedded", defaultEmbeddedType);
     }
-    debug.log(DebugCategory.PROVIDER_MANAGER, "Creating injected provider");
-    this.createProvider("injected");
+    let defaultType;
+    if (hasEmbedded && this.providers.has(`embedded-${defaultEmbeddedType}`)) {
+      defaultType = "embedded";
+    } else if (hasInjected && this.providers.has("injected")) {
+      defaultType = "injected";
+    } else {
+      throw new Error("No valid providers could be created from the providers array");
+    }
     const switchOptions = {};
     if (defaultType === "embedded") {
       switchOptions.embeddedWalletType = defaultEmbeddedType;
@@ -1876,20 +1919,39 @@ async function waitForPhantomExtension(timeoutMs = 3e3) {
 }
 
 // src/BrowserSDK.ts
+var import_embedded_provider_core3 = require("@phantom/embedded-provider-core");
 var import_constants4 = require("@phantom/constants");
+var BROWSER_SDK_PROVIDER_TYPES = [...import_embedded_provider_core3.EMBEDDED_PROVIDER_AUTH_TYPES, "injected"];
 var BrowserSDK = class {
   constructor(config) {
     debug.info(DebugCategory.BROWSER_SDK, "Initializing BrowserSDK", {
-      providerType: config.providerType,
+      providers: config.providers,
       embeddedWalletType: config.embeddedWalletType,
       addressTypes: config.addressTypes
     });
-    if (!["injected", "embedded"].includes(config.providerType)) {
-      debug.error(DebugCategory.BROWSER_SDK, "Invalid providerType", { providerType: config.providerType });
-      throw new Error(`Invalid providerType: ${config.providerType}. Must be "injected" or "embedded".`);
+    if (!Array.isArray(config.providers) || config.providers.length === 0) {
+      debug.error(DebugCategory.BROWSER_SDK, "Invalid providers array", { providers: config.providers });
+      throw new Error("providers must be a non-empty array of AuthProviderType");
+    }
+    const invalidProviders = config.providers.filter((p) => !BROWSER_SDK_PROVIDER_TYPES.includes(p));
+    if (invalidProviders.length > 0) {
+      debug.error(DebugCategory.BROWSER_SDK, "Invalid provider types", {
+        invalidProviders,
+        validProviders: BROWSER_SDK_PROVIDER_TYPES
+      });
+      throw new Error(
+        `Invalid provider type(s): ${invalidProviders.join(", ")}. Valid providers are: ${BROWSER_SDK_PROVIDER_TYPES.join(", ")}`
+      );
+    }
+    const hasEmbeddedProviders = config.providers.some((p) => p !== "injected");
+    if (hasEmbeddedProviders && !config.appId) {
+      debug.error(DebugCategory.BROWSER_SDK, "appId required for embedded providers", {
+        providers: config.providers
+      });
+      throw new Error("appId is required when using embedded providers (google, apple, phantom, etc.)");
     }
     const embeddedWalletType = config.embeddedWalletType || import_constants4.DEFAULT_EMBEDDED_WALLET_TYPE;
-    if (config.providerType === "embedded" && !["app-wallet", "user-wallet"].includes(embeddedWalletType)) {
+    if (!["app-wallet", "user-wallet"].includes(embeddedWalletType)) {
       debug.error(DebugCategory.BROWSER_SDK, "Invalid embeddedWalletType", {
         embeddedWalletType: config.embeddedWalletType
       });