@dubsdotapp/expo 0.2.21 → 0.2.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dubsdotapp/expo",
-  "version": "0.2.21",
+  "version": "0.2.23",
   "description": "React Native SDK for the Dubs betting platform",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/src/index.ts

@@ -107,5 +107,5 @@ export type {
 
 // Utils
 export { signAndSendBase64Transaction } from './utils/transaction';
-export { getDeviceInfo } from './utils/device';
+export { getDeviceInfo, isSolanaSeeker } from './utils/device';
 export type { DeviceInfo } from './utils/device';

package/src/managed-wallet.tsx

@@ -4,6 +4,7 @@ import { MwaWalletAdapter } from './wallet/mwa-adapter';
 import { PhantomDeeplinkAdapter } from './wallet/phantom-deeplink';
 import type { PhantomSession } from './wallet/phantom-deeplink';
 import type { WalletAdapter } from './wallet/types';
+import { isSolanaSeeker } from './utils/device';
 import { ConnectWalletScreen } from './ui/ConnectWalletScreen';
 import type { ConnectWalletScreenProps } from './ui/ConnectWalletScreen';
 import type { TokenStorage } from './storage';
@@ -28,6 +29,7 @@ function getOrCreatePhantomAdapter(config: {
       redirectUri: config.redirectUri,
       appUrl: config.appUrl,
       cluster: config.cluster,
+      storage: config.storage,
       onSessionChange: (session) => {
         if (session) {
           console.log(TAG, 'Phantom session changed — saving to storage, wallet:', session.walletPublicKey);
@@ -94,11 +96,12 @@ export function ManagedWalletProvider({
   const [error, setError] = useState<string | null>(null);
 
   // Determine which adapter to use:
-  // - iOS always uses Phantom deeplinks
-  // - Android uses MWA (default)
-  const usePhantom = Platform.OS === 'ios' && !!redirectUri;
+  // - Solana Seeker (Android) → MWA (native Mobile Wallet Adapter support)
+  // - Everything else (iOS + regular Android) → Phantom deeplinks
+  const seeker = Platform.OS === 'android' && isSolanaSeeker();
+  const usePhantom = !seeker && !!redirectUri;
 
-  console.log(TAG, `Platform: ${Platform.OS}, redirectUri: ${redirectUri ? 'provided' : 'not set'}, usePhantom: ${usePhantom}`);
+  console.log(TAG, `Platform: ${Platform.OS}, seeker: ${seeker}, redirectUri: ${redirectUri ? 'provided' : 'not set'}, usePhantom: ${usePhantom}`);
 
   const adapterRef = useRef<WalletAdapter | null>(null);
   const transactRef = useRef<any>(null);
@@ -156,6 +159,24 @@ export function ManagedWalletProvider({
           return;
         }
 
+        // Check for cold-start recovery (Android killed the app during connect)
+        const coldStartUrl = phantom.consumeColdStartUrl();
+        if (coldStartUrl) {
+          try {
+            console.log(TAG, 'Cold-start URL detected, attempting recovery');
+            await phantom.completeConnectFromColdStart(coldStartUrl);
+            if (!cancelled) {
+              console.log(TAG, 'Cold-start recovery succeeded');
+              setConnected(true);
+              setIsReady(true);
+            }
+            return;
+          } catch (err) {
+            console.log(TAG, 'Cold-start recovery failed:', err instanceof Error ? err.message : err);
+            // Fall through to normal session restore
+          }
+        }
+
         try {
           const savedSession = await storage.getItem(STORAGE_KEYS.PHANTOM_SESSION);
           if (savedSession && !cancelled) {
@@ -248,6 +269,7 @@ export function ManagedWalletProvider({
     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(() => {});
+    await storage.deleteItem(STORAGE_KEYS.PHANTOM_CONNECT_IN_FLIGHT).catch(() => {});
     setConnected(false);
     console.log(TAG, 'disconnect() — done');
   }, [adapter, storage, usePhantom]);

package/src/storage.ts

@@ -8,6 +8,7 @@ export const STORAGE_KEYS = {
   MWA_AUTH_TOKEN: 'dubs_mwa_auth_token',
   JWT_TOKEN: 'dubs_jwt_token',
   PHANTOM_SESSION: 'dubs_phantom_session',
+  PHANTOM_CONNECT_IN_FLIGHT: 'dubs_phantom_connect_in_flight',
 } as const;
 
 /**

package/src/utils/device.ts

@@ -16,6 +16,19 @@ export interface DeviceInfo {
   isDevice: boolean | null;
 }
 
+/**
+ * Detect Solana Seeker device (synchronous — safe to call during render).
+ * Checks brand from expo-device; returns false if expo-device isn't installed.
+ */
+export function isSolanaSeeker(): boolean {
+  try {
+    const Device = require('expo-device');
+    return Device.brand?.toLowerCase() === 'solanamobile';
+  } catch {
+    return false;
+  }
+}
+
 export async function getDeviceInfo(): Promise<DeviceInfo> {
   try {
     const Device = require('expo-device');

package/src/wallet/phantom-deeplink/deeplink-handler.ts

@@ -23,6 +23,7 @@ export class DeeplinkHandler {
   private readonly redirectBase: string;
   private readonly pending = new Map<string, PendingRequest>();
   private subscription: ReturnType<typeof Linking.addEventListener> | null = null;
+  private _coldStartUrl: string | null = null;
 
   constructor(redirectBase: string) {
     // Strip trailing slashes for consistent matching
@@ -163,10 +164,18 @@ export class DeeplinkHandler {
       this.pending.delete(id);
       req.resolve({ params });
     } else {
-      console.log(TAG, 'No pending requests to resolve — redirect may have arrived late');
+      console.log(TAG, 'No pending requests to resolve — stashing as cold-start URL');
+      this._coldStartUrl = url;
     }
   }
 
+  /** Return and clear the stashed cold-start URL (if any). */
+  getColdStartUrl(): string | null {
+    const url = this._coldStartUrl;
+    this._coldStartUrl = null;
+    return url;
+  }
+
   /** Extract the request ID from the dubs_rid query parameter. */
   private extractRequestId(url: string): string | null {
     try {

package/src/wallet/phantom-deeplink/phantom-deeplink-adapter.ts

@@ -1,6 +1,8 @@
 import { PublicKey, Transaction } from '@solana/web3.js';
 import bs58 from 'bs58';
 import type { WalletAdapter } from '../types';
+import type { TokenStorage } from '../../storage';
+import { STORAGE_KEYS } from '../../storage';
 import {
   generateKeyPair,
   deriveSharedSecret,
@@ -38,6 +40,8 @@ export interface PhantomDeeplinkAdapterConfig {
   timeout?: number;
   /** Called when the Phantom session changes (save/clear for persistence) */
   onSessionChange?: (session: PhantomSession | null) => void;
+  /** Storage for persisting in-flight connect state (cold-start recovery on Android) */
+  storage?: TokenStorage;
 }
 
 let requestCounter = 0;
@@ -147,6 +151,20 @@ export class PhantomDeeplinkAdapter implements WalletAdapter {
       app_url: appUrl,
     });
 
+    // Persist in-flight state so we can recover if the OS kills the app (Android cold-start)
+    if (this.config.storage) {
+      console.log(TAG, 'Saving in-flight connect state to storage');
+      await this.config.storage.setItem(
+        STORAGE_KEYS.PHANTOM_CONNECT_IN_FLIGHT,
+        JSON.stringify({
+          dappPublicKey: dappPubBase58,
+          dappSecretKey: bs58.encode(this._dappKeyPair.secretKey),
+          requestId,
+          createdAt: Date.now(),
+        }),
+      );
+    }
+
     const url = `https://phantom.app/ul/v1/connect?${params.toString()}`;
     console.log(TAG, 'Opening Phantom connect deeplink...');
     const response = await this.handler.send(url, requestId, this.timeout);
@@ -183,6 +201,9 @@ export class PhantomDeeplinkAdapter implements WalletAdapter {
 
     // Notify consumer of new session
     this.config.onSessionChange?.(this.getSession());
+
+    // Clear in-flight state now that connect succeeded
+    this.config.storage?.deleteItem(STORAGE_KEYS.PHANTOM_CONNECT_IN_FLIGHT).catch(() => {});
   }
 
   disconnect(): void {
@@ -197,6 +218,100 @@ export class PhantomDeeplinkAdapter implements WalletAdapter {
     console.log(TAG, 'Disconnected');
   }
 
+  /**
+   * Return and clear the stashed cold-start URL from the deeplink handler.
+   * Used by ManagedWalletProvider to detect an in-flight connect on cold start.
+   */
+  consumeColdStartUrl(): string | null {
+    return this.handler.getColdStartUrl();
+  }
+
+  /**
+   * Complete a connect flow that was interrupted by the OS killing the app (Android).
+   * Loads the saved in-flight keypair from storage, decrypts the Phantom response
+   * from the cold-start URL, and restores the session.
+   */
+  async completeConnectFromColdStart(url: string): Promise<void> {
+    if (!this.config.storage) {
+      throw new Error('Cannot recover cold-start connect: no storage configured');
+    }
+
+    console.log(TAG, 'completeConnectFromColdStart() — attempting recovery');
+
+    const raw = await this.config.storage.getItem(STORAGE_KEYS.PHANTOM_CONNECT_IN_FLIGHT);
+    if (!raw) {
+      throw new Error('No in-flight connect state found in storage');
+    }
+
+    const inFlight = JSON.parse(raw) as {
+      dappPublicKey: string;
+      dappSecretKey: string;
+      requestId: string;
+      createdAt: number;
+    };
+
+    // Check expiry (120s)
+    const age = Date.now() - inFlight.createdAt;
+    if (age > 120_000) {
+      console.log(TAG, `In-flight state expired (${Math.round(age / 1000)}s old), clearing`);
+      await this.config.storage.deleteItem(STORAGE_KEYS.PHANTOM_CONNECT_IN_FLIGHT).catch(() => {});
+      throw new Error('In-flight connect state expired');
+    }
+
+    console.log(TAG, `In-flight state age: ${Math.round(age / 1000)}s, requestId: ${inFlight.requestId}`);
+
+    // Restore keypair from storage
+    this._dappKeyPair = {
+      publicKey: bs58.decode(inFlight.dappPublicKey),
+      secretKey: bs58.decode(inFlight.dappSecretKey),
+    };
+
+    // Parse the Phantom callback URL
+    const parsed = new URL(url);
+    const params: Record<string, string> = {};
+    parsed.searchParams.forEach((value, key) => {
+      params[key] = value;
+    });
+
+    // Check for Phantom error
+    if (params.errorCode) {
+      const errorMessage = params.errorMessage
+        ? decodeURIComponent(params.errorMessage)
+        : `Phantom error code: ${params.errorCode}`;
+      await this.config.storage.deleteItem(STORAGE_KEYS.PHANTOM_CONNECT_IN_FLIGHT).catch(() => {});
+      throw new Error(errorMessage);
+    }
+
+    const phantomPubBase58 = params.phantom_encryption_public_key;
+    if (!phantomPubBase58) {
+      await this.config.storage.deleteItem(STORAGE_KEYS.PHANTOM_CONNECT_IN_FLIGHT).catch(() => {});
+      throw new Error('Phantom did not return an encryption public key');
+    }
+
+    console.log(TAG, 'Cold-start: Phantom public key:', phantomPubBase58);
+
+    this._phantomPublicKey = bs58.decode(phantomPubBase58);
+    this._sharedSecret = deriveSharedSecret(
+      this._dappKeyPair.secretKey,
+      this._phantomPublicKey,
+    );
+
+    const data = decryptPayload(params.data, params.nonce, this._sharedSecret);
+    console.log(TAG, 'Cold-start: Decrypted connect data — public_key:', data.public_key);
+
+    this._sessionToken = data.session;
+    this._publicKey = new PublicKey(data.public_key);
+    this._connected = true;
+
+    console.log(TAG, 'Cold-start recovery complete! Wallet:', this._publicKey.toBase58());
+
+    // Notify consumer of new session
+    this.config.onSessionChange?.(this.getSession());
+
+    // Clear in-flight state
+    await this.config.storage.deleteItem(STORAGE_KEYS.PHANTOM_CONNECT_IN_FLIGHT).catch(() => {});
+  }
+
   async signTransaction(transaction: Transaction): Promise<Transaction> {
     this.assertConnected();
     console.log(TAG, 'signTransaction() — serializing transaction');