Solana Mobile

Solana Mobile Development Skill

Expert knowledge for building mobile dApps on Solana with Mobile Wallet Adapter, Seeker device integration, and SeedVault support.

Overview

This skill provides comprehensive guidance for developing mobile applications on the Solana blockchain, with focus on:

• Mobile Wallet Adapter (MWA) - Protocol for connecting mobile dApps to wallets
• Solana Mobile Seeker - Detecting and optimizing for Seeker devices
• SeedVault - Secure key storage on Solana Mobile devices
• React Native Integration - Building cross-platform mobile dApps
• dApp Store Publishing - Submitting apps to Solana dApp Store

When to Use This Skill

Activate this skill when:

• Building React Native dApps for Solana
• Implementing Mobile Wallet Adapter
• Detecting Solana Mobile Seeker users
• Integrating with SeedVault for secure key storage
• Publishing to Solana dApp Store
• Optimizing mobile user experience
• Implementing Sign-In With Solana (SIWS)

Core Concepts

Mobile Wallet Adapter (MWA)

MWA is a protocol that enables secure communication between mobile dApps and wallet apps.

Key Features:

• Secure WebSocket-based communication
• Session-based authorization
• Transaction signing
• Message signing
• Multi-wallet support

Protocol Flow:

1. Association - Establish connection via URI scheme
2. Session Establishment - ECDH key exchange
3. Authorization - Request wallet access
4. Privileged Methods - Sign transactions/messages

Solana Mobile Seeker

Seeker is Solana's flagship mobile device with built-in crypto features.

Detection Methods:

1. Platform Constants (Client-side, spoofable)
2. Genesis Token Verification (On-chain, guaranteed)

Seeker Features:

• SeedVault secure storage
• Optimized Solana performance
• Seeker Genesis Token (SGT)
• Native dApp Store integration

SeedVault

Secure enclave for storing private keys on Solana Mobile devices.

Benefits:

• Hardware-backed security
• Biometric authentication
• Secure key derivation
• Isolated from app memory

Implementation Patterns

1. Mobile Wallet Adapter Setup

Install Dependencies

npm install @solana-mobile/mobile-wallet-adapter-protocol \
  @solana-mobile/mobile-wallet-adapter-protocol-web3js \
  @solana/web3.js \
  react-native-quick-crypto

Configure Polyfills

Create polyfill.js:

import { install } from 'react-native-quick-crypto';
install();

Create index.js:

import './polyfill';
import 'expo-router/entry';

Update package.json:

{
  "main": "./index.js"
}

MWA Provider Setup

import {
  ConnectionProvider,
  RPC_ENDPOINT,
} from '@solana/web3.js';
import {
  SolanaMobileWalletAdapter,
} from '@solana-mobile/mobile-wallet-adapter-protocol-web3js';

export function MobileWalletProvider({ children }) {
  return (
    <ConnectionProvider endpoint={RPC_ENDPOINT}>
      <SolanaMobileWalletAdapter
        cluster="mainnet-beta"
        appIdentity={{
          name: 'Your dApp',
          uri: 'https://yourdapp.com',
          icon: 'favicon.ico',
        }}
      >
        {children}
      </SolanaMobileWalletAdapter>
    </ConnectionProvider>
  );
}

2. Authorization Flow

import { transact } from '@solana-mobile/mobile-wallet-adapter-protocol-web3js';

async function authorizeWallet() {
  const result = await transact(async (wallet) => {
    const authResult = await wallet.authorize({
      cluster: 'solana:mainnet',
      identity: {
        name: 'Obscura DEX',
        uri: 'https://obscura.finance',
        icon: 'icon.png',
      },
      features: [
        'solana:signMessages',
        'solana:signAndSendTransaction',
      ],
    });

    return {
      accounts: authResult.accounts,
      authToken: authResult.auth_token,
      walletUriBase: authResult.wallet_uri_base,
    };
  });

  return result;
}

3. Sign and Send Transaction

import { Transaction } from '@solana/web3.js';
import { transact } from '@solana-mobile/mobile-wallet-adapter-protocol-web3js';

async function signAndSendTransaction(transaction: Transaction) {
  const result = await transact(async (wallet) => {
    // Authorize if needed
    const authResult = await wallet.authorize({
      cluster: 'solana:mainnet',
      identity: APP_IDENTITY,
    });

    // Get latest blockhash
    const { blockhash } = await connection.getLatestBlockhash();
    transaction.recentBlockhash = blockhash;
    transaction.feePayer = authResult.accounts[0].publicKey;

    // Sign and send
    const signedTxs = await wallet.signAndSendTransactions({
      transactions: [transaction],
    });

    return signedTxs[0];
  });

  return result;
}

4. Sign Message

async function signMessage(message: string) {
  const result = await transact(async (wallet) => {
    const authResult = await wallet.authorize({
      cluster: 'solana:mainnet',
      identity: APP_IDENTITY,
    });

    const encodedMessage = new TextEncoder().encode(message);
    
    const signedMessages = await wallet.signMessages({
      addresses: [authResult.accounts[0].address],
      payloads: [encodedMessage],
    });

    return {
      signature: signedMessages.signed_payloads[0],
      address: authResult.accounts[0].address,
    };
  });

  return result;
}

5. Seeker Detection (Platform Constants)

import { Platform } from 'react-native';

function isSeekerDevice(): boolean {
  return Platform.constants?.Model === 'Seeker';
}

function getSeekerInfo() {
  if (!isSeekerDevice()) {
    return null;
  }

  return {
    model: Platform.constants.Model,
    brand: Platform.constants.Brand,
    manufacturer: Platform.constants.Manufacturer,
    fingerprint: Platform.constants.Fingerprint,
  };
}

// Usage
if (isSeekerDevice()) {
  console.log('Running on Seeker device!');
  // Show Seeker-specific UI
}

6. Seeker Genesis Token Verification

Client-Side: Sign-In With Solana (SIWS)

async function signInWithSolana() {
  const result = await transact(async (wallet) => {
    const authResult = await wallet.authorize({
      cluster: 'solana:mainnet',
      identity: APP_IDENTITY,
      sign_in_payload: {
        domain: 'obscura.finance',
        statement: 'Sign in to verify Seeker ownership',
        uri: 'https://obscura.finance',
        version: '1',
        chainId: 'solana:mainnet',
        nonce: generateNonce(),
        issuedAt: new Date().toISOString(),
      },
    });

    return {
      walletAddress: authResult.accounts[0].address,
      signInResult: authResult.sign_in_result,
    };
  });

  // Send to backend for verification
  const isVerified = await verifyOnBackend(result);
  return isVerified;
}

Server-Side: Verify SIWS + Check SGT

import { verifySignIn } from '@solana/wallet-standard-util';
import { Connection, PublicKey } from '@solana/web3.js';

// Step 1: Verify SIWS signature
async function verifySIWS(signInPayload, signInResult): Promise<boolean> {
  const serializedOutput = {
    account: {
      publicKey: new Uint8Array(signInResult.account.publicKey),
      ...signInResult.account,
    },
    signature: new Uint8Array(signInResult.signature),
    signedMessage: new Uint8Array(signInResult.signedMessage),
  };
  
  return verifySignIn(signInPayload, serializedOutput);
}

// Step 2: Check for Seeker Genesis Token
async function checkSeekerGenesisToken(
  walletAddress: string,
  heliusApiKey: string
): Promise<boolean> {
  const response = await fetch(
    `https://api.helius.xyz/v0/addresses/${walletAddress}/balances?api-key=${heliusApiKey}`
  );
  
  const data = await response.json();
  
  // Check for Seeker Genesis Token
  // SGT Collection: https://solscan.io/collection/...
  const hasSGT = data.tokens?.some(
    (token) => token.mint === 'SEEKER_GENESIS_TOKEN_MINT'
  );
  
  return hasSGT;
}

// Step 3: Combined verification
async function verifySeekerUser(signInResult, heliusApiKey): Promise<boolean> {
  // Verify SIWS signature
  const siwsVerified = await verifySIWS(
    signInResult.payload,
    signInResult.result
  );
  
  if (!siwsVerified) {
    return false;
  }
  
  // Check SGT ownership
  const hasSGT = await checkSeekerGenesisToken(
    signInResult.walletAddress,
    heliusApiKey
  );
  
  return hasSGT;
}

7. SeedVault Integration

// SeedVault is automatically used by MWA-compatible wallets
// No additional code needed - keys are stored securely

// To leverage SeedVault features:
async function requestBiometricAuth() {
  // Wallet apps handle biometric auth automatically
  // when accessing SeedVault keys
  
  const result = await transact(async (wallet) => {
    // This will trigger biometric prompt if enabled
    const authResult = await wallet.authorize({
      cluster: 'solana:mainnet',
      identity: APP_IDENTITY,
    });
    
    return authResult;
  });
  
  return result;
}

8. Reauthorization (Persistent Sessions)

// Store auth token securely
import AsyncStorage from '@react-native-async-storage/async-storage';

async function saveAuthToken(authToken: string) {
  await AsyncStorage.setItem('mwa_auth_token', authToken);
}

async function getAuthToken(): Promise<string | null> {
  return await AsyncStorage.getItem('mwa_auth_token');
}

// Reauthorize with stored token
async function reauthorize() {
  const authToken = await getAuthToken();
  
  if (!authToken) {
    return authorizeWallet(); // First time auth
  }
  
  try {
    const result = await transact(async (wallet) => {
      const authResult = await wallet.authorize({
        cluster: 'solana:mainnet',
        identity: APP_IDENTITY,
        auth_token: authToken, // Reuse token
      });
      
      // Save new token if updated
      await saveAuthToken(authResult.auth_token);
      
      return authResult;
    });
    
    return result;
  } catch (error) {
    // Token expired, request new auth
    await AsyncStorage.removeItem('mwa_auth_token');
    return authorizeWallet();
  }
}

Best Practices

Security

1. Never Request Private Keys

   • Always use MWA signing methods
   • Never ask users for seed phrases
   • Trust wallet apps for key management

2. Verify Signatures

   • Always verify SIWS signatures on backend
   • Use on-chain verification for critical features
   • Don't trust client-side checks alone

3. Secure Token Storage

   • Use AsyncStorage for auth tokens
   • Encrypt sensitive data
   • Clear tokens on logout

User Experience

1. Handle Wallet Not Installed

   try {
     await transact(async (wallet) => {
       // ... wallet operations
     });
   } catch (error) {
     if (error.message.includes('No wallet found')) {
       // Show wallet installation prompt
       showInstallWalletDialog();
     }
   }
   

2. Loading States

   const [isConnecting, setIsConnecting] = useState(false);
   
   async function connect() {
     setIsConnecting(true);
     try {
       await authorizeWallet();
     } finally {
       setIsConnecting(false);
     }
   }
   

3. Error Handling

   try {
     await signAndSendTransaction(tx);
   } catch (error) {
     if (error.message.includes('User rejected')) {
       showToast('Transaction cancelled');
     } else if (error.message.includes('Insufficient funds')) {
       showToast('Insufficient SOL balance');
     } else {
       showToast('Transaction failed');
     }
   }
   

Performance

1. Reuse Connections

   • Store auth tokens
   • Reauthorize instead of fresh auth
   • Use wallet_uri_base for faster connections

2. Batch Transactions

   await wallet.signAndSendTransactions({
     transactions: [tx1, tx2, tx3], // Batch multiple
   });
   

3. Optimize for Seeker

   if (isSeekerDevice()) {
     // Use optimized settings for Seeker
     connection.commitment = 'confirmed'; // Faster
   }
   

Common Patterns

Pattern 1: Connect Button

function ConnectWalletButton() {
  const [wallet, setWallet] = useState(null);
  const [loading, setLoading] = useState(false);
  
  async function handleConnect() {
    setLoading(true);
    try {
      const result = await reauthorize();
      setWallet(result.accounts[0]);
    } catch (error) {
      console.error('Connection failed:', error);
    } finally {
      setLoading(false);
    }
  }
  
  if (wallet) {
    return (
      <View>
        <Text>Connected: {wallet.address.slice(0, 8)}...</Text>
      </View>
    );
  }
  
  return (
    <Button
      title={loading ? 'Connecting...' : 'Connect Wallet'}
     
      disabled={loading}
    />
  );
}

Pattern 2: Seeker-Specific UI

function SeekerBanner() {
  const isSeeker = isSeekerDevice();
  const [hasGenesisToken, setHasGenesisToken] = useState(false);
  
  useEffect(() => {
    if (isSeeker) {
      verifyGenesisToken().then(setHasGenesisToken);
    }
  }, [isSeeker]);
  
  if (!isSeeker) return null;
  
  return (
    <View style={styles.seekerBanner}>
      <Text>🎉 Seeker Device Detected!</Text>
      {hasGenesisToken && (
        <Text>✅ Genesis Token Verified</Text>
      )}
    </View>
  );
}

Pattern 3: Transaction with Confirmation

async function sendTransactionWithConfirmation(transaction: Transaction) {
  // Sign and send
  const signature = await signAndSendTransaction(transaction);
  
  // Wait for confirmation
  const confirmation = await connection.confirmTransaction(
    signature,
    'confirmed'
  );
  
  if (confirmation.value.err) {
    throw new Error('Transaction failed');
  }
  
  return signature;
}

Publishing to dApp Store

1. Build APK

# For Expo
eas build --platform android --profile production

# For React Native
cd android
./gradlew assembleRelease

2. Sign APK

# Generate keystore
keytool -genkey -v -keystore my-release-key.keystore \
  -alias my-key-alias -keyalg RSA -keysize 2048 -validity 10000

# Sign APK
jarsigner -verbose -sigalg SHA256withRSA -digestalg SHA-256 \
  -keystore my-release-key.keystore \
  app-release-unsigned.apk my-key-alias

3. Submit to dApp Store

# Install publishing CLI
npm install -g @solana-mobile/dapp-store-cli

# Login
dapp-store login

# Create app NFT (first time only)
dapp-store create

# Submit release
dapp-store publish \
  --apk ./app-release.apk \
  --requestor-is-authorized \
  --complies-with-solana-dapp-store-policies

Troubleshooting

Issue: Wallet Not Connecting

Solutions:

1. Check if wallet app is installed
2. Verify network (devnet/mainnet)
3. Clear app cache
4. Reinstall wallet app

Issue: Transaction Fails

Solutions:

1. Check SOL balance for fees
2. Verify recent blockhash
3. Check transaction size
4. Ensure correct cluster

Issue: Seeker Not Detected

Solutions:

1. Verify Platform.constants.Model
2. Check device fingerprint
3. Use Genesis Token verification
4. Test on actual Seeker device

Issue: Auth Token Expired

Solutions:

1. Clear stored token
2. Request fresh authorization
3. Implement token refresh logic
4. Handle ERROR_AUTHORIZATION_FAILED

Resources

Documentation

• Solana Mobile Docs
• MWA Specification
• React Native Guide
• dApp Store Guide

Tools

• MWA Protocol
• Solana Mobile SDK
• dApp Store CLI

Example Apps

• Solana Mobile Sample Apps
• Anchor Counter dApp

Integration with Obscura DEX

Mobile-Specific Features

1. Seeker Rewards

   • Detect Seeker users
   • Offer reduced trading fees
   • Exclusive features for SGT holders

2. Mobile-Optimized UI

   • Touch-friendly controls
   • Simplified trading interface
   • Biometric authentication

3. Push Notifications

   • Price alerts
   • Order fills
   • Market updates

4. Offline Capabilities

   • Cache market data
   • Queue transactions
   • Sync when online

Last Updated: February 18, 2026

Converted and distributed by TomeVault — claim your Tome and manage your conversions.