@dubsdotapp/expo 0.3.0 → 0.3.2

package/package.json

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

package/src/client.ts

@@ -37,8 +37,12 @@ import type {
   UiConfig,
   UFCEvent,
   UFCFighterDetail,
-  DeveloperCommissionsResult,
-  DeveloperCommissionsSummary,
+  ArcadePool,
+  ArcadeEntry,
+  ArcadeLeaderboardEntry,
+  ArcadePoolStats,
+  StartAttemptResult,
+  SubmitScoreResult,
 } from './types';
 
 export interface DubsClientConfig {
@@ -473,43 +477,85 @@ export class DubsClient {
     return { ...SOLANA_PROGRAM_ERRORS };
   }
 
-  // ── App Config ──
+  // ── Arcade Pools ──
 
-  /** Fetch the app's UI customization config (accent color, icon, tagline, environment) */
-  async getAppConfig(): Promise<UiConfig> {
-    const res = await this.request<{ data: { environment?: string; uiConfig: UiConfig } }>('GET', '/apps/config');
-    const config = res.data?.uiConfig || {};
-    if (res.data?.environment) {
-      config.environment = res.data.environment as UiConfig['environment'];
-    }
-    return config;
+  async getArcadePools(params?: { gameSlug?: string; status?: string }): Promise<ArcadePool[]> {
+    const qs = new URLSearchParams();
+    if (params?.gameSlug) qs.set('gameSlug', params.gameSlug);
+    if (params?.status) qs.set('status', params.status);
+    const query = qs.toString();
+    const res = await this.request<{ success: true; pools: ArcadePool[] }>(
+      'GET',
+      `/arcade/pools${query ? `?${query}` : ''}`,
+    );
+    return res.pools;
+  }
+
+  async getArcadePool(poolId: number): Promise<{ pool: ArcadePool; stats: ArcadePoolStats }> {
+    const res = await this.request<{ success: true; pool: ArcadePool; stats: ArcadePoolStats }>(
+      'GET',
+      `/arcade/pools/${poolId}`,
+    );
+    return { pool: res.pool, stats: res.stats };
   }
 
-  // ── Developer Commissions ──
+  async enterArcadePool(poolId: number, params: { walletAddress: string; txSignature: string }): Promise<ArcadeEntry> {
+    const res = await this.request<{ success: true; entry: ArcadeEntry }>(
+      'POST',
+      `/arcade/pools/${poolId}/enter`,
+      params,
+    );
+    return res.entry;
+  }
 
-  /** Fetch paginated list of commission earnings for this app */
-  async getCommissions(params?: { limit?: number; offset?: number }): Promise<DeveloperCommissionsResult> {
+  async startArcadeAttempt(poolId: number, walletAddress: string): Promise<StartAttemptResult> {
+    const res = await this.request<{ success: true } & StartAttemptResult>(
+      'POST',
+      `/arcade/pools/${poolId}/start-attempt`,
+      { walletAddress },
+    );
+    return { sessionToken: res.sessionToken, attemptNumber: res.attemptNumber, livesRemaining: res.livesRemaining };
+  }
+
+  async submitArcadeScore(poolId: number, params: { walletAddress: string; sessionToken: string; score: number; durationMs?: number }): Promise<SubmitScoreResult> {
+    const res = await this.request<{ success: true } & SubmitScoreResult>(
+      'POST',
+      `/arcade/pools/${poolId}/submit-score`,
+      params,
+    );
+    return { score: res.score, bestScore: res.bestScore, livesUsed: res.livesUsed, isNewBest: res.isNewBest };
+  }
+
+  async getArcadeLeaderboard(poolId: number, params?: { limit?: number; offset?: number }): Promise<ArcadeLeaderboardEntry[]> {
     const qs = new URLSearchParams();
     if (params?.limit != null) qs.set('limit', String(params.limit));
     if (params?.offset != null) qs.set('offset', String(params.offset));
     const query = qs.toString();
-    const res = await this.request<{ success: true } & DeveloperCommissionsResult>(
+    const res = await this.request<{ success: true; leaderboard: ArcadeLeaderboardEntry[] }>(
       'GET',
-      `/commissions${query ? `?${query}` : ''}`,
+      `/arcade/pools/${poolId}/leaderboard${query ? `?${query}` : ''}`,
     );
-    return {
-      commissions: res.commissions,
-      summary: res.summary,
-      pagination: res.pagination,
-    };
+    return res.leaderboard;
   }
 
-  /** Fetch a quick summary of commission earnings for this app */
-  async getCommissionsSummary(): Promise<DeveloperCommissionsSummary> {
-    const res = await this.request<{ success: true; summary: DeveloperCommissionsSummary }>(
+  async getArcadeEntry(poolId: number, walletAddress: string): Promise<ArcadeEntry> {
+    const res = await this.request<{ success: true; entry: ArcadeEntry }>(
       'GET',
-      '/commissions/summary',
+      `/arcade/pools/${poolId}/my-entry?walletAddress=${encodeURIComponent(walletAddress)}`,
     );
-    return res.summary;
+    return res.entry;
   }
+
+  // ── App Config ──
+
+  /** Fetch the app's UI customization config (accent color, icon, tagline, environment) */
+  async getAppConfig(): Promise<UiConfig> {
+    const res = await this.request<{ data: { environment?: string; uiConfig: UiConfig } }>('GET', '/apps/config');
+    const config = res.data?.uiConfig || {};
+    if (res.data?.environment) {
+      config.environment = res.data.environment as UiConfig['environment'];
+    }
+    return config;
+  }
+
 }

package/src/hooks/index.ts

@@ -18,3 +18,9 @@ export { useUFCFightCard } from './useUFCFightCard';
 export { useUFCFighterDetail } from './useUFCFighterDetail';
 export { usePushNotifications } from './usePushNotifications';
 export type { PushNotificationStatus } from './usePushNotifications';
+export { useArcadePools } from './useArcadePools';
+export type { UseArcadePoolsResult } from './useArcadePools';
+export { useArcadePool } from './useArcadePool';
+export type { UseArcadePoolResult } from './useArcadePool';
+export { useArcadeGame } from './useArcadeGame';
+export type { UseArcadeGameResult } from './useArcadeGame';

package/src/hooks/useArcadeGame.ts

@@ -0,0 +1,102 @@
+import { useState, useCallback } from 'react';
+import { useDubs } from '../provider';
+import { useAuth } from './useAuth';
+import type { ArcadeEntry, StartAttemptResult, SubmitScoreResult } from '../types';
+
+export interface UseArcadeGameResult {
+  entry: ArcadeEntry | null;
+  livesRemaining: number;
+  bestScore: number;
+  loading: boolean;
+  error: Error | null;
+  /** Fetch/refresh the user's entry for this pool */
+  refreshEntry: () => Promise<void>;
+  /** Start a new life — returns session token to pass to the game */
+  startAttempt: () => Promise<StartAttemptResult>;
+  /** Submit score after game over */
+  submitScore: (sessionToken: string, score: number, durationMs?: number) => Promise<SubmitScoreResult>;
+}
+
+export function useArcadeGame(poolId: number | null, maxLives: number = 3): UseArcadeGameResult {
+  const { client } = useDubs();
+  const { user } = useAuth();
+  const [entry, setEntry] = useState<ArcadeEntry | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const walletAddress = user?.walletAddress || '';
+
+  const refreshEntry = useCallback(async () => {
+    if (!poolId || !walletAddress) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const e = await client.getArcadeEntry(poolId, walletAddress);
+      setEntry(e);
+    } catch (err) {
+      // 404 means no entry yet — that's fine
+      if (err instanceof Error && err.message.includes('No entry found')) {
+        setEntry(null);
+      } else {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    } finally {
+      setLoading(false);
+    }
+  }, [client, poolId, walletAddress]);
+
+  const startAttempt = useCallback(async (): Promise<StartAttemptResult> => {
+    if (!poolId || !walletAddress) throw new Error('Not ready');
+    setError(null);
+    try {
+      const result = await client.startArcadeAttempt(poolId, walletAddress);
+      return result;
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      setError(e);
+      throw e;
+    }
+  }, [client, poolId, walletAddress]);
+
+  const submitScore = useCallback(async (
+    sessionToken: string,
+    score: number,
+    durationMs?: number,
+  ): Promise<SubmitScoreResult> => {
+    if (!poolId || !walletAddress) throw new Error('Not ready');
+    setError(null);
+    try {
+      const result = await client.submitArcadeScore(poolId, {
+        walletAddress,
+        sessionToken,
+        score,
+        durationMs,
+      });
+      // Update local entry state
+      setEntry(prev => prev ? {
+        ...prev,
+        best_score: result.bestScore,
+        lives_used: result.livesUsed,
+      } : prev);
+      return result;
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      setError(e);
+      throw e;
+    }
+  }, [client, poolId, walletAddress]);
+
+  const livesRemaining = entry ? maxLives - entry.lives_used : maxLives;
+  const bestScore = entry?.best_score || 0;
+
+  return {
+    entry,
+    livesRemaining,
+    bestScore,
+    loading,
+    error,
+    refreshEntry,
+    startAttempt,
+    submitScore,
+  };
+}

package/src/hooks/useArcadePool.ts

@@ -0,0 +1,44 @@
+import { useState, useEffect, useCallback, useMemo } from 'react';
+import { useDubs } from '../provider';
+import type { ArcadePool, ArcadePoolStats, ArcadeLeaderboardEntry } from '../types';
+
+export interface UseArcadePoolResult {
+  pool: ArcadePool | null;
+  stats: ArcadePoolStats | null;
+  leaderboard: ArcadeLeaderboardEntry[];
+  loading: boolean;
+  error: Error | null;
+  refetch: () => void;
+}
+
+export function useArcadePool(poolId: number | null): UseArcadePoolResult {
+  const { client } = useDubs();
+  const [pool, setPool] = useState<ArcadePool | null>(null);
+  const [stats, setStats] = useState<ArcadePoolStats | null>(null);
+  const [leaderboard, setLeaderboard] = useState<ArcadeLeaderboardEntry[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const fetch = useCallback(async () => {
+    if (!poolId) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const [poolRes, lb] = await Promise.all([
+        client.getArcadePool(poolId),
+        client.getArcadeLeaderboard(poolId),
+      ]);
+      setPool(poolRes.pool);
+      setStats(poolRes.stats);
+      setLeaderboard(lb);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, poolId]);
+
+  useEffect(() => { fetch(); }, [fetch]);
+
+  return { pool, stats, leaderboard, loading, error, refetch: fetch };
+}

package/src/hooks/useArcadePools.ts

@@ -0,0 +1,34 @@
+import { useState, useEffect, useCallback } from 'react';
+import { useDubs } from '../provider';
+import type { ArcadePool } from '../types';
+
+export interface UseArcadePoolsResult {
+  pools: ArcadePool[];
+  loading: boolean;
+  error: Error | null;
+  refetch: () => void;
+}
+
+export function useArcadePools(gameSlug?: string): UseArcadePoolsResult {
+  const { client } = useDubs();
+  const [pools, setPools] = useState<ArcadePool[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const fetch = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await client.getArcadePools({ gameSlug });
+      setPools(result);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, gameSlug]);
+
+  useEffect(() => { fetch(); }, [fetch]);
+
+  return { pools, loading, error, refetch: fetch };
+}

package/src/index.ts

@@ -67,9 +67,13 @@ export type {
   UFCData,
   UFCFight,
   UFCEvent,
-  DeveloperCommission,
-  DeveloperCommissionsSummary,
-  DeveloperCommissionsResult,
+  ArcadePool,
+  ArcadeEntry,
+  ArcadeAttempt,
+  ArcadeLeaderboardEntry,
+  ArcadePoolStats,
+  StartAttemptResult,
+  SubmitScoreResult,
 } from './types';
 
 // Provider
@@ -98,6 +102,9 @@ export {
   useUFCFightCard,
   useUFCFighterDetail,
   usePushNotifications,
+  useArcadePools,
+  useArcadePool,
+  useArcadeGame,
 } from './hooks';
 export type {
   CreateGameMutationResult,
@@ -107,11 +114,14 @@ export type {
   ClaimStatus,
   UseAuthResult,
   PushNotificationStatus,
+  UseArcadePoolsResult,
+  UseArcadePoolResult,
+  UseArcadeGameResult,
 } from './hooks';
 
 // UI
-export { AuthGate, ConnectWalletScreen, UserProfileCard, SettingsSheet, UserProfileSheet, DeveloperDashboardSheet, useDubsTheme, mergeTheme } from './ui';
-export type { AuthGateProps, RegistrationScreenProps, ConnectWalletScreenProps, UserProfileCardProps, SettingsSheetProps, UserProfileSheetProps, DeveloperDashboardSheetProps, DubsTheme } from './ui';
+export { AuthGate, ConnectWalletScreen, UserProfileCard, SettingsSheet, UserProfileSheet, useDubsTheme, mergeTheme } from './ui';
+export type { AuthGateProps, RegistrationScreenProps, ConnectWalletScreenProps, UserProfileCardProps, SettingsSheetProps, UserProfileSheetProps, DubsTheme } from './ui';
 
 // Game widgets
 export { GamePoster, LivePoolsCard, PickWinnerCard, PlayersCard, JoinGameButton, CreateCustomGameSheet, JoinGameSheet, ClaimPrizeSheet, ClaimButton } from './ui';

package/src/types.ts

@@ -481,57 +481,74 @@ export interface UFCEvent {
   fights: UFCFight[];
 }
 
-// ── Developer Commissions ──
+// ── Arcade Pools ──
 
-export interface DeveloperCommission {
+export interface ArcadePool {
   id: number;
-  gameId: string;
-  /** Commission amount in lamports */
-  amount: number;
-  /** Commission amount in SOL */
-  amountSol: number;
-  status: 'pending' | 'paid' | 'cancelled';
-  createdAt: string;
-  paidAt: string | null;
-  txSignature: string | null;
-  gameType: string;
-  /** Total pot size in lamports */
-  potSize: number;
-  /** Total pot size in SOL */
-  potSizeSol: number;
-  appId?: number;
-  appName?: string;
+  app_id: number;
+  game_slug: string;
+  name: string;
+  buy_in_lamports: number;
+  max_lives: number;
+  period_start: string;
+  period_end: string;
+  schedule: 'weekly' | 'daily' | 'manual';
+  status: 'open' | 'active' | 'resolving' | 'complete' | 'cancelled';
+  solana_game_id: string | null;
+  solana_game_address: string | null;
+  total_entries: number;
+  created_at: string;
+}
+
+export interface ArcadeEntry {
+  id: number;
+  pool_id: number;
+  wallet_address: string;
+  best_score: number;
+  lives_used: number;
+  rank: number | null;
+  created_at: string;
+  attempts: ArcadeAttempt[] | null;
 }
 
-export interface DeveloperCommissionsSummary {
-  totalEarned: number;
-  totalEarnedSol: number;
-  totalPaid: number;
-  totalPaidSol: number;
-  totalPending: number;
-  totalPendingSol: number;
-  totalGames: number;
-  last7Days?: {
-    games: number;
-    earned: number;
-    earnedSol: number;
-  };
-  last30Days?: {
-    games: number;
-    earned: number;
-    earnedSol: number;
-  };
-  commissionWallet?: string;
+export interface ArcadeAttempt {
+  id: number;
+  attempt_number: number;
+  score: number | null;
+  status: 'active' | 'submitted' | 'expired';
+  started_at: string;
+  submitted_at: string | null;
+  duration_ms: number | null;
 }
 
-export interface DeveloperCommissionsResult {
-  commissions: DeveloperCommission[];
-  summary: DeveloperCommissionsSummary;
-  pagination: {
-    total: number;
-    limit: number;
-    offset: number;
-  };
+export interface ArcadeLeaderboardEntry {
+  id: number;
+  wallet_address: string;
+  best_score: number;
+  lives_used: number;
+  username: string;
+  avatar: string | null;
+  rank: number;
+}
+
+export interface ArcadePoolStats {
+  total_entries: number;
+  top_score: number;
+  avg_score: number;
+  active_players: number;
+}
+
+export interface StartAttemptResult {
+  sessionToken: string;
+  attemptNumber: number;
+  livesRemaining: number;
+}
+
+export interface SubmitScoreResult {
+  score: number;
+  bestScore: number;
+  livesUsed: number;
+  isNewBest: boolean;
 }
 
 // ── UI Config (developer branding) ──

package/src/ui/index.ts

@@ -8,8 +8,6 @@ export { SettingsSheet } from './SettingsSheet';
 export type { SettingsSheetProps } from './SettingsSheet';
 export { UserProfileSheet } from './UserProfileSheet';
 export type { UserProfileSheetProps } from './UserProfileSheet';
-export { DeveloperDashboardSheet } from './DeveloperDashboardSheet';
-export type { DeveloperDashboardSheetProps } from './DeveloperDashboardSheet';
 export { useDubsTheme, mergeTheme } from './theme';
 export type { DubsTheme } from './theme';