@dubsdotapp/expo 0.2.10 → 0.2.12

package/dist/index.mjs

@@ -455,7 +455,8 @@ var DubsClient = class {
 // src/storage.ts
 var STORAGE_KEYS = {
   MWA_AUTH_TOKEN: "dubs_mwa_auth_token",
-  JWT_TOKEN: "dubs_jwt_token"
+  JWT_TOKEN: "dubs_jwt_token",
+  PHANTOM_SESSION: "dubs_phantom_session"
 };
 function createSecureStoreStorage() {
   let SecureStore = null;
@@ -493,6 +494,7 @@ import { Connection } from "@solana/web3.js";
 
 // src/managed-wallet.tsx
 import { createContext, useContext, useState, useEffect, useRef, useCallback } from "react";
+import { Platform } from "react-native";
 
 // src/wallet/mwa-adapter.ts
 import { PublicKey } from "@solana/web3.js";
@@ -592,6 +594,388 @@ var MwaWalletAdapter = class {
   }
 };
 
+// src/wallet/phantom-deeplink/phantom-deeplink-adapter.ts
+import { PublicKey as PublicKey2, Transaction as Transaction2 } from "@solana/web3.js";
+import bs582 from "bs58";
+
+// src/wallet/phantom-deeplink/crypto.ts
+import nacl from "tweetnacl";
+import bs58 from "bs58";
+function generateKeyPair() {
+  const kp = nacl.box.keyPair();
+  return { publicKey: kp.publicKey, secretKey: kp.secretKey };
+}
+function deriveSharedSecret(ourSecretKey, theirPublicKey) {
+  return nacl.box.before(theirPublicKey, ourSecretKey);
+}
+function encryptPayload(payload, sharedSecret) {
+  const nonce = nacl.randomBytes(24);
+  const message = new TextEncoder().encode(JSON.stringify(payload));
+  const encrypted = nacl.box.after(message, nonce, sharedSecret);
+  if (!encrypted) throw new Error("Encryption failed");
+  return {
+    nonce: bs58.encode(nonce),
+    ciphertext: bs58.encode(encrypted)
+  };
+}
+function decryptPayload(ciphertextBase58, nonceBase58, sharedSecret) {
+  const ciphertext = bs58.decode(ciphertextBase58);
+  const nonce = bs58.decode(nonceBase58);
+  const decrypted = nacl.box.open.after(ciphertext, nonce, sharedSecret);
+  if (!decrypted) throw new Error("Decryption failed \u2014 invalid shared secret or corrupted data");
+  return JSON.parse(new TextDecoder().decode(decrypted));
+}
+
+// src/wallet/phantom-deeplink/deeplink-handler.ts
+import { Linking } from "react-native";
+var TAG = "[Dubs:DeeplinkHandler]";
+var DeeplinkHandler = class {
+  constructor(redirectBase) {
+    this.pending = /* @__PURE__ */ new Map();
+    this.subscription = null;
+    this.redirectBase = redirectBase.replace(/\/+$/, "");
+    console.log(TAG, "Created with redirectBase:", this.redirectBase);
+  }
+  /** Start listening for incoming deeplinks. Call once on adapter init. */
+  start() {
+    if (this.subscription) {
+      console.log(TAG, "Already listening, skipping start()");
+      return;
+    }
+    console.log(TAG, "Starting URL listener");
+    this.subscription = Linking.addEventListener("url", ({ url }) => {
+      console.log(TAG, "Received URL event:", url);
+      this.handleUrl(url);
+    });
+    Linking.getInitialURL().then((url) => {
+      if (url) {
+        console.log(TAG, "Cold-start URL found:", url);
+        this.handleUrl(url);
+      } else {
+        console.log(TAG, "No cold-start URL");
+      }
+    });
+  }
+  /** Stop listening and reject all pending requests. */
+  destroy() {
+    console.log(TAG, "Destroying \u2014 pending requests:", this.pending.size);
+    this.subscription?.remove();
+    this.subscription = null;
+    for (const [id, req] of this.pending) {
+      clearTimeout(req.timer);
+      req.reject(new Error("DeeplinkHandler destroyed"));
+      this.pending.delete(id);
+    }
+  }
+  /**
+   * Open a Phantom deeplink and wait for the redirect response.
+   * @param url The full Phantom deeplink URL to open
+   * @param requestId Unique ID embedded in the redirect_link param
+   * @param timeoutMs How long to wait before rejecting (default 120s)
+   */
+  async send(url, requestId, timeoutMs = 12e4) {
+    console.log(TAG, `send() requestId=${requestId} timeout=${timeoutMs}ms`);
+    console.log(TAG, "Opening URL:", url.substring(0, 120) + (url.length > 120 ? "..." : ""));
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        console.log(TAG, `Timeout reached for requestId=${requestId}`);
+        this.pending.delete(requestId);
+        reject(new Error(`Phantom deeplink timed out after ${timeoutMs / 1e3}s`));
+      }, timeoutMs);
+      this.pending.set(requestId, { resolve, reject, timer });
+      Linking.openURL(url).catch((err) => {
+        console.log(TAG, `Failed to open URL: ${err.message}`);
+        this.pending.delete(requestId);
+        clearTimeout(timer);
+        reject(new Error(`Failed to open Phantom: ${err.message}`));
+      });
+    });
+  }
+  handleUrl(url) {
+    if (!url.startsWith(this.redirectBase)) {
+      console.log(TAG, "Ignoring URL (not our redirect base):", url.substring(0, 80));
+      return;
+    }
+    console.log(TAG, "Processing redirect URL:", url.substring(0, 120) + (url.length > 120 ? "..." : ""));
+    const parsed = new URL(url);
+    const params = {};
+    parsed.searchParams.forEach((value, key) => {
+      params[key] = value;
+    });
+    const paramKeys = Object.keys(params);
+    console.log(TAG, "Parsed params keys:", paramKeys.join(", "));
+    if (params.errorCode) {
+      const errorMessage = params.errorMessage ? decodeURIComponent(params.errorMessage) : `Phantom error code: ${params.errorCode}`;
+      console.log(TAG, `Phantom returned error: code=${params.errorCode} message="${errorMessage}"`);
+      const requestId2 = this.extractRequestId(url);
+      if (requestId2 && this.pending.has(requestId2)) {
+        console.log(TAG, `Routing error to requestId=${requestId2}`);
+        const req = this.pending.get(requestId2);
+        clearTimeout(req.timer);
+        this.pending.delete(requestId2);
+        req.reject(new Error(errorMessage));
+        return;
+      }
+      console.log(TAG, `Cannot route error to specific request, rejecting all ${this.pending.size} pending`);
+      for (const [id, req] of this.pending) {
+        clearTimeout(req.timer);
+        req.reject(new Error(errorMessage));
+        this.pending.delete(id);
+      }
+      return;
+    }
+    const requestId = this.extractRequestId(url);
+    console.log(TAG, `Extracted requestId=${requestId}, pending requests: [${[...this.pending.keys()].join(", ")}]`);
+    if (requestId && this.pending.has(requestId)) {
+      console.log(TAG, `Resolving requestId=${requestId}`);
+      const req = this.pending.get(requestId);
+      clearTimeout(req.timer);
+      this.pending.delete(requestId);
+      req.resolve({ params });
+      return;
+    }
+    const first = this.pending.entries().next().value;
+    if (first) {
+      const [id, req] = first;
+      console.log(TAG, `Fallback: resolving first pending requestId=${id}`);
+      clearTimeout(req.timer);
+      this.pending.delete(id);
+      req.resolve({ params });
+    } else {
+      console.log(TAG, "No pending requests to resolve \u2014 redirect may have arrived late");
+    }
+  }
+  /** Try to extract a request ID from the URL path segment after the redirect base. */
+  extractRequestId(url) {
+    const afterBase = url.slice(this.redirectBase.length);
+    const match = afterBase.match(/^\/?([a-zA-Z0-9_-]+)/);
+    return match?.[1] ?? null;
+  }
+};
+
+// src/wallet/phantom-deeplink/phantom-deeplink-adapter.ts
+var TAG2 = "[Dubs:PhantomAdapter]";
+var requestCounter = 0;
+function nextRequestId() {
+  return `req${Date.now()}_${++requestCounter}`;
+}
+var PhantomDeeplinkAdapter = class {
+  constructor(config) {
+    this._publicKey = null;
+    this._connected = false;
+    this._dappKeyPair = null;
+    this._sharedSecret = null;
+    this._sessionToken = null;
+    this._phantomPublicKey = null;
+    console.log(TAG2, "Creating adapter with config:", {
+      redirectUri: config.redirectUri,
+      appUrl: config.appUrl,
+      cluster: config.cluster,
+      timeout: config.timeout
+    });
+    this.config = config;
+    this.timeout = config.timeout ?? 12e4;
+    this.handler = new DeeplinkHandler(config.redirectUri);
+    this.handler.start();
+    console.log(TAG2, "Adapter created and deeplink listener started");
+  }
+  get publicKey() {
+    return this._publicKey;
+  }
+  get connected() {
+    return this._connected;
+  }
+  /**
+   * Restore a previously saved session without opening Phantom.
+   * Call this before connect() if you have persisted session state.
+   */
+  restoreSession(saved) {
+    console.log(TAG2, "Restoring session for wallet:", saved.walletPublicKey);
+    this._dappKeyPair = {
+      publicKey: bs582.decode(saved.dappPublicKey),
+      secretKey: bs582.decode(saved.dappSecretKey)
+    };
+    this._phantomPublicKey = bs582.decode(saved.phantomPublicKey);
+    this._sharedSecret = bs582.decode(saved.sharedSecret);
+    this._sessionToken = saved.sessionToken;
+    this._publicKey = new PublicKey2(saved.walletPublicKey);
+    this._connected = true;
+    console.log(TAG2, "Session restored successfully \u2014 connected:", this._publicKey.toBase58());
+  }
+  /** Serialize the current session for persistence. Returns null if not connected. */
+  getSession() {
+    if (!this._connected || !this._dappKeyPair || !this._phantomPublicKey || !this._sharedSecret || !this._sessionToken || !this._publicKey) {
+      return null;
+    }
+    return {
+      dappPublicKey: bs582.encode(this._dappKeyPair.publicKey),
+      dappSecretKey: bs582.encode(this._dappKeyPair.secretKey),
+      phantomPublicKey: bs582.encode(this._phantomPublicKey),
+      sharedSecret: bs582.encode(this._sharedSecret),
+      sessionToken: this._sessionToken,
+      walletPublicKey: this._publicKey.toBase58()
+    };
+  }
+  async connect() {
+    console.log(TAG2, "connect() \u2014 generating x25519 keypair");
+    this._dappKeyPair = generateKeyPair();
+    const dappPubBase58 = bs582.encode(this._dappKeyPair.publicKey);
+    console.log(TAG2, "Dapp public key:", dappPubBase58);
+    const requestId = nextRequestId();
+    const redirectLink = `${this.config.redirectUri}/${requestId}`;
+    console.log(TAG2, `connect() requestId=${requestId} redirectLink=${redirectLink}`);
+    const appUrl = this.config.appUrl || this.config.redirectUri;
+    console.log(TAG2, "Using app_url:", appUrl);
+    const params = new URLSearchParams({
+      dapp_encryption_public_key: dappPubBase58,
+      cluster: this.config.cluster || "mainnet-beta",
+      redirect_link: redirectLink,
+      app_url: appUrl
+    });
+    const url = `https://phantom.app/ul/v1/connect?${params.toString()}`;
+    console.log(TAG2, "Opening Phantom connect deeplink...");
+    const response = await this.handler.send(url, requestId, this.timeout);
+    console.log(TAG2, "Received connect response, param keys:", Object.keys(response.params).join(", "));
+    const phantomPubBase58 = response.params.phantom_encryption_public_key;
+    if (!phantomPubBase58) {
+      console.log(TAG2, "ERROR: No phantom_encryption_public_key in response");
+      throw new Error("Phantom did not return an encryption public key");
+    }
+    console.log(TAG2, "Phantom public key:", phantomPubBase58);
+    this._phantomPublicKey = bs582.decode(phantomPubBase58);
+    this._sharedSecret = deriveSharedSecret(
+      this._dappKeyPair.secretKey,
+      this._phantomPublicKey
+    );
+    console.log(TAG2, "Shared secret derived, decrypting response...");
+    const data = decryptPayload(
+      response.params.data,
+      response.params.nonce,
+      this._sharedSecret
+    );
+    console.log(TAG2, "Decrypted connect data \u2014 public_key:", data.public_key, "session length:", data.session?.length);
+    this._sessionToken = data.session;
+    this._publicKey = new PublicKey2(data.public_key);
+    this._connected = true;
+    console.log(TAG2, "Connected! Wallet:", this._publicKey.toBase58());
+    this.config.onSessionChange?.(this.getSession());
+  }
+  disconnect() {
+    console.log(TAG2, "disconnect() \u2014 clearing state, was connected:", this._connected, "wallet:", this._publicKey?.toBase58());
+    this._publicKey = null;
+    this._connected = false;
+    this._dappKeyPair = null;
+    this._sharedSecret = null;
+    this._sessionToken = null;
+    this._phantomPublicKey = null;
+    this.config.onSessionChange?.(null);
+    console.log(TAG2, "Disconnected");
+  }
+  async signTransaction(transaction) {
+    this.assertConnected();
+    console.log(TAG2, "signTransaction() \u2014 serializing transaction");
+    const serializedTx = bs582.encode(
+      transaction.serialize({ requireAllSignatures: false, verifySignatures: false })
+    );
+    console.log(TAG2, "Transaction serialized, length:", serializedTx.length);
+    const { nonce, ciphertext } = encryptPayload(
+      { transaction: serializedTx, session: this._sessionToken },
+      this._sharedSecret
+    );
+    const requestId = nextRequestId();
+    const redirectLink = `${this.config.redirectUri}/${requestId}`;
+    console.log(TAG2, `signTransaction() requestId=${requestId}`);
+    const params = new URLSearchParams({
+      dapp_encryption_public_key: bs582.encode(this._dappKeyPair.publicKey),
+      nonce,
+      payload: ciphertext,
+      redirect_link: redirectLink
+    });
+    const url = `https://phantom.app/ul/v1/signTransaction?${params.toString()}`;
+    console.log(TAG2, "Opening Phantom signTransaction deeplink...");
+    const response = await this.handler.send(url, requestId, this.timeout);
+    console.log(TAG2, "Received signTransaction response");
+    const data = decryptPayload(
+      response.params.data,
+      response.params.nonce,
+      this._sharedSecret
+    );
+    console.log(TAG2, "Decrypted signed transaction, length:", data.transaction?.length);
+    return Transaction2.from(bs582.decode(data.transaction));
+  }
+  async signAndSendTransaction(transaction) {
+    this.assertConnected();
+    console.log(TAG2, "signAndSendTransaction() \u2014 serializing transaction");
+    const serializedTx = bs582.encode(
+      transaction.serialize({ requireAllSignatures: false, verifySignatures: false })
+    );
+    console.log(TAG2, "Transaction serialized, length:", serializedTx.length);
+    const { nonce, ciphertext } = encryptPayload(
+      { transaction: serializedTx, session: this._sessionToken },
+      this._sharedSecret
+    );
+    const requestId = nextRequestId();
+    const redirectLink = `${this.config.redirectUri}/${requestId}`;
+    console.log(TAG2, `signAndSendTransaction() requestId=${requestId}`);
+    const params = new URLSearchParams({
+      dapp_encryption_public_key: bs582.encode(this._dappKeyPair.publicKey),
+      nonce,
+      payload: ciphertext,
+      redirect_link: redirectLink
+    });
+    const url = `https://phantom.app/ul/v1/signAndSendTransaction?${params.toString()}`;
+    console.log(TAG2, "Opening Phantom signAndSendTransaction deeplink...");
+    const response = await this.handler.send(url, requestId, this.timeout);
+    console.log(TAG2, "Received signAndSendTransaction response");
+    const data = decryptPayload(
+      response.params.data,
+      response.params.nonce,
+      this._sharedSecret
+    );
+    console.log(TAG2, "Transaction sent! Signature:", data.signature);
+    return data.signature;
+  }
+  async signMessage(message) {
+    this.assertConnected();
+    console.log(TAG2, "signMessage() \u2014 message length:", message.length);
+    const { nonce, ciphertext } = encryptPayload(
+      { message: bs582.encode(message), session: this._sessionToken },
+      this._sharedSecret
+    );
+    const requestId = nextRequestId();
+    const redirectLink = `${this.config.redirectUri}/${requestId}`;
+    console.log(TAG2, `signMessage() requestId=${requestId}`);
+    const params = new URLSearchParams({
+      dapp_encryption_public_key: bs582.encode(this._dappKeyPair.publicKey),
+      nonce,
+      payload: ciphertext,
+      redirect_link: redirectLink
+    });
+    const url = `https://phantom.app/ul/v1/signMessage?${params.toString()}`;
+    console.log(TAG2, "Opening Phantom signMessage deeplink...");
+    const response = await this.handler.send(url, requestId, this.timeout);
+    console.log(TAG2, "Received signMessage response");
+    const data = decryptPayload(
+      response.params.data,
+      response.params.nonce,
+      this._sharedSecret
+    );
+    console.log(TAG2, "Message signed, signature:", data.signature?.substring(0, 20) + "...");
+    return bs582.decode(data.signature);
+  }
+  /** Remove the Linking event listener. Call when the adapter is no longer needed. */
+  destroy() {
+    console.log(TAG2, "destroy() \u2014 cleaning up");
+    this.handler.destroy();
+  }
+  assertConnected() {
+    if (!this._connected || !this._sharedSecret || !this._sessionToken) {
+      console.log(TAG2, "assertConnected FAILED \u2014 connected:", this._connected, "hasSecret:", !!this._sharedSecret, "hasSession:", !!this._sessionToken);
+      throw new Error("Wallet not connected");
+    }
+  }
+};
+
 // src/ui/ConnectWalletScreen.tsx
 import {
   View,
@@ -770,6 +1154,7 @@ var styles = StyleSheet.create({
 
 // src/managed-wallet.tsx
 import { Fragment, jsx as jsx2 } from "react/jsx-runtime";
+var TAG3 = "[Dubs:ManagedWallet]";
 var DisconnectContext = createContext(null);
 function useDisconnect() {
   return useContext(DisconnectContext);
@@ -782,85 +1167,168 @@ function ManagedWalletProvider({
   accentColor,
   appIcon,
   tagline,
+  redirectUri,
+  appUrl,
   children
 }) {
   const [connected, setConnected] = useState(false);
   const [connecting, setConnecting] = useState(false);
   const [isReady, setIsReady] = useState(false);
   const [error, setError] = useState(null);
+  const usePhantom = Platform.OS === "ios" && !!redirectUri;
+  console.log(TAG3, `Platform: ${Platform.OS}, redirectUri: ${redirectUri ? "provided" : "not set"}, usePhantom: ${usePhantom}`);
   const adapterRef = useRef(null);
   const transactRef = useRef(null);
   if (!adapterRef.current) {
-    adapterRef.current = new MwaWalletAdapter({
-      transact: (...args) => {
-        if (!transactRef.current) {
-          throw new Error(
-            "@dubsdotapp/expo: @solana-mobile/mobile-wallet-adapter-protocol-web3js is required. Install it with: npm install @solana-mobile/mobile-wallet-adapter-protocol-web3js"
-          );
+    if (usePhantom) {
+      console.log(TAG3, "Creating PhantomDeeplinkAdapter");
+      adapterRef.current = new PhantomDeeplinkAdapter({
+        redirectUri,
+        appUrl,
+        cluster,
+        onSessionChange: (session) => {
+          if (session) {
+            console.log(TAG3, "Phantom session changed \u2014 saving to storage, wallet:", session.walletPublicKey);
+            storage.setItem(STORAGE_KEYS.PHANTOM_SESSION, JSON.stringify(session)).catch((err) => {
+              console.log(TAG3, "Failed to save Phantom session:", err);
+            });
+          } else {
+            console.log(TAG3, "Phantom session cleared \u2014 removing from storage");
+            storage.deleteItem(STORAGE_KEYS.PHANTOM_SESSION).catch((err) => {
+              console.log(TAG3, "Failed to delete Phantom session:", err);
+            });
+          }
         }
-        return transactRef.current(...args);
-      },
-      appIdentity: { name: appName },
-      cluster,
-      onAuthTokenChange: (token) => {
-        if (token) {
-          storage.setItem(STORAGE_KEYS.MWA_AUTH_TOKEN, token).catch(() => {
-          });
-        } else {
-          storage.deleteItem(STORAGE_KEYS.MWA_AUTH_TOKEN).catch(() => {
-          });
+      });
+    } else {
+      console.log(TAG3, "Creating MwaWalletAdapter");
+      adapterRef.current = new MwaWalletAdapter({
+        transact: (...args) => {
+          if (!transactRef.current) {
+            throw new Error(
+              "@dubsdotapp/expo: @solana-mobile/mobile-wallet-adapter-protocol-web3js is required. Install it with: npm install @solana-mobile/mobile-wallet-adapter-protocol-web3js"
+            );
+          }
+          return transactRef.current(...args);
+        },
+        appIdentity: { name: appName },
+        cluster,
+        onAuthTokenChange: (token) => {
+          if (token) {
+            storage.setItem(STORAGE_KEYS.MWA_AUTH_TOKEN, token).catch(() => {
+            });
+          } else {
+            storage.deleteItem(STORAGE_KEYS.MWA_AUTH_TOKEN).catch(() => {
+            });
+          }
         }
-      }
-    });
+      });
+    }
   }
   const adapter = adapterRef.current;
   useEffect(() => {
     let cancelled = false;
     (async () => {
-      try {
-        const mwa = await import("@solana-mobile/mobile-wallet-adapter-protocol-web3js");
-        if (cancelled) return;
-        transactRef.current = mwa.transact;
-      } catch {
-      }
-      try {
-        const savedToken = await storage.getItem(STORAGE_KEYS.MWA_AUTH_TOKEN);
-        if (savedToken && !cancelled) {
-          adapter.setAuthToken(savedToken);
-          await adapter.connect();
-          if (!cancelled) setConnected(true);
+      if (usePhantom) {
+        console.log(TAG3, "Phantom path \u2014 checking for saved session...");
+        try {
+          const savedJson = await storage.getItem(STORAGE_KEYS.PHANTOM_SESSION);
+          if (savedJson && !cancelled) {
+            console.log(TAG3, "Found saved Phantom session, restoring...");
+            const saved = JSON.parse(savedJson);
+            adapter.restoreSession(saved);
+            if (!cancelled) {
+              console.log(TAG3, "Session restored, marking connected");
+              setConnected(true);
+            }
+          } else {
+            console.log(TAG3, "No saved Phantom session found");
+          }
+        } catch (err) {
+          console.log(TAG3, "Failed to restore Phantom session:", err instanceof Error ? err.message : err);
+        } finally {
+          if (!cancelled) {
+            console.log(TAG3, "Phantom init complete, marking ready");
+            setIsReady(true);
+          }
+        }
+      } else {
+        console.log(TAG3, "MWA path \u2014 dynamic-importing transact...");
+        try {
+          const mwa = await import("@solana-mobile/mobile-wallet-adapter-protocol-web3js");
+          if (cancelled) return;
+          transactRef.current = mwa.transact;
+          console.log(TAG3, "MWA transact loaded");
+        } catch {
+          console.log(TAG3, "MWA not installed \u2014 transact will throw on use");
+        }
+        try {
+          const savedToken = await storage.getItem(STORAGE_KEYS.MWA_AUTH_TOKEN);
+          if (savedToken && !cancelled) {
+            console.log(TAG3, "Found saved MWA auth token, reconnecting...");
+            adapter.setAuthToken(savedToken);
+            await adapter.connect();
+            if (!cancelled) {
+              console.log(TAG3, "MWA reconnected from saved token");
+              setConnected(true);
+            }
+          } else {
+            console.log(TAG3, "No saved MWA auth token");
+          }
+        } catch (err) {
+          console.log(TAG3, "MWA silent reconnect failed:", err instanceof Error ? err.message : err);
+        } finally {
+          if (!cancelled) {
+            console.log(TAG3, "MWA init complete, marking ready");
+            setIsReady(true);
+          }
         }
-      } catch {
-      } finally {
-        if (!cancelled) setIsReady(true);
       }
     })();
     return () => {
       cancelled = true;
     };
-  }, [adapter, storage]);
+  }, [adapter, storage, usePhantom]);
   const handleConnect = useCallback(async () => {
+    console.log(TAG3, "handleConnect() \u2014 user tapped connect");
     setConnecting(true);
     setError(null);
     try {
       await adapter.connect();
+      console.log(TAG3, "handleConnect() \u2014 success, wallet:", adapter.publicKey?.toBase58());
       setConnected(true);
     } catch (err) {
       const message = err instanceof Error ? err.message : "Connection failed";
+      console.log(TAG3, "handleConnect() \u2014 failed:", message);
       setError(message);
     } finally {
       setConnecting(false);
     }
   }, [adapter]);
   const disconnect = useCallback(async () => {
-    adapter.disconnect();
+    console.log(TAG3, "disconnect() \u2014 clearing all state");
+    adapter.disconnect?.();
     await storage.deleteItem(STORAGE_KEYS.MWA_AUTH_TOKEN).catch(() => {
     });
+    await storage.deleteItem(STORAGE_KEYS.PHANTOM_SESSION).catch(() => {
+    });
     await storage.deleteItem(STORAGE_KEYS.JWT_TOKEN).catch(() => {
     });
     setConnected(false);
+    console.log(TAG3, "disconnect() \u2014 done");
   }, [adapter, storage]);
-  if (!isReady) return null;
+  useEffect(() => {
+    return () => {
+      if (usePhantom && adapter && "destroy" in adapter) {
+        console.log(TAG3, "Unmounting \u2014 destroying Phantom adapter");
+        adapter.destroy();
+      }
+    };
+  }, [adapter, usePhantom]);
+  if (!isReady) {
+    console.log(TAG3, "Not ready yet \u2014 rendering null");
+    return null;
+  }
   if (!connected) {
     if (renderConnectScreen === false) {
       return null;
@@ -879,6 +1347,7 @@ function ManagedWalletProvider({
     }
     return /* @__PURE__ */ jsx2(ConnectWalletScreen, { ...connectProps });
   }
+  console.log(TAG3, "Rendering children \u2014 connected with wallet:", adapter.publicKey?.toBase58());
   return /* @__PURE__ */ jsx2(DisconnectContext.Provider, { value: disconnect, children: children(adapter) });
 }
 
@@ -893,7 +1362,7 @@ import {
   StyleSheet as StyleSheet2,
   Keyboard,
   KeyboardAvoidingView,
-  Platform,
+  Platform as Platform2,
   Image as Image2,
   Animated,
   ScrollView
@@ -1007,7 +1476,7 @@ function useNetworkGames(params) {
 import { useState as useState6, useCallback as useCallback6 } from "react";
 
 // src/utils/transaction.ts
-import { Transaction as Transaction2 } from "@solana/web3.js";
+import { Transaction as Transaction3 } from "@solana/web3.js";
 async function signAndSendBase64Transaction(base64Tx, wallet) {
   if (!wallet.publicKey) throw new Error("Wallet not connected");
   const binaryStr = atob(base64Tx);
@@ -1015,7 +1484,7 @@ async function signAndSendBase64Transaction(base64Tx, wallet) {
   for (let i = 0; i < binaryStr.length; i++) {
     bytes[i] = binaryStr.charCodeAt(i);
   }
-  const transaction = Transaction2.from(bytes);
+  const transaction = Transaction3.from(bytes);
   if (wallet.signAndSendTransaction) {
     return wallet.signAndSendTransaction(transaction);
   }
@@ -1256,7 +1725,7 @@ function useCreateCustomGame() {
 
 // src/hooks/useAuth.ts
 import { useState as useState10, useCallback as useCallback10, useRef as useRef2, useContext as useContext2 } from "react";
-import bs58 from "bs58";
+import bs583 from "bs58";
 
 // src/auth-context.ts
 import { createContext as createContext2 } from "react";
@@ -1294,7 +1763,7 @@ function useAuth() {
       setStatus("signing");
       const messageBytes = new TextEncoder().encode(message);
       const signatureBytes = await wallet.signMessage(messageBytes);
-      const signature = bs58.encode(signatureBytes);
+      const signature = bs583.encode(signatureBytes);
       setStatus("verifying");
       const result = await client.authenticate({ walletAddress, signature, nonce });
       if (result.needsRegistration) {
@@ -1795,7 +2264,7 @@ function DefaultRegistrationScreen({
     KeyboardAvoidingView,
     {
       style: [s.container, { backgroundColor: t.background }],
-      behavior: Platform.OS === "ios" ? "padding" : void 0,
+      behavior: Platform2.OS === "ios" ? "padding" : void 0,
       children: /* @__PURE__ */ jsx3(
         ScrollView,
         {
@@ -1896,7 +2365,9 @@ function DubsProvider({
   renderLoading,
   renderError,
   renderRegistration,
-  managed = true
+  managed = true,
+  redirectUri,
+  appUrl
 }) {
   const config = NETWORK_CONFIG[network];
   const baseUrl = baseUrlOverride || config.baseUrl;
@@ -1946,6 +2417,8 @@ function DubsProvider({
       accentColor: uiConfig.accentColor,
       appIcon: uiConfig.appIcon,
       tagline: uiConfig.tagline,
+      redirectUri,
+      appUrl,
       children: (adapter) => /* @__PURE__ */ jsx4(
         ManagedInner,
         {
@@ -2765,7 +3238,7 @@ import {
   Animated as Animated2,
   StyleSheet as StyleSheet10,
   KeyboardAvoidingView as KeyboardAvoidingView2,
-  Platform as Platform2
+  Platform as Platform3
 } from "react-native";
 import { jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
 var STATUS_LABELS2 = {
@@ -2877,7 +3350,7 @@ function CreateCustomGameSheet({
           KeyboardAvoidingView2,
           {
             style: styles9.keyboardView,
-            behavior: Platform2.OS === "ios" ? "padding" : void 0,
+            behavior: Platform3.OS === "ios" ? "padding" : void 0,
             children: /* @__PURE__ */ jsx12(View10, { style: styles9.sheetPositioner, children: /* @__PURE__ */ jsxs10(View10, { style: [styles9.sheet, { backgroundColor: t.background }], children: [
               /* @__PURE__ */ jsx12(View10, { style: styles9.handleRow, children: /* @__PURE__ */ jsx12(View10, { style: [styles9.handle, { backgroundColor: t.textMuted }] }) }),
               /* @__PURE__ */ jsxs10(View10, { style: styles9.header, children: [
@@ -3129,6 +3602,7 @@ export {
   LivePoolsCard,
   MwaWalletAdapter,
   NETWORK_CONFIG,
+  PhantomDeeplinkAdapter,
   PickWinnerCard,
   PlayersCard,
   SOLANA_PROGRAM_ERRORS,