@dubsdotapp/expo 0.3.1 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dubsdotapp/expo",
-  "version": "0.3.1",
+  "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,6 +37,12 @@ import type {
   UiConfig,
   UFCEvent,
   UFCFighterDetail,
+  ArcadePool,
+  ArcadeEntry,
+  ArcadeLeaderboardEntry,
+  ArcadePoolStats,
+  StartAttemptResult,
+  SubmitScoreResult,
 } from './types';
 
 export interface DubsClientConfig {
@@ -471,6 +477,75 @@ export class DubsClient {
     return { ...SOLANA_PROGRAM_ERRORS };
   }
 
+  // ── Arcade Pools ──
+
+  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 };
+  }
+
+  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;
+  }
+
+  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; leaderboard: ArcadeLeaderboardEntry[] }>(
+      'GET',
+      `/arcade/pools/${poolId}/leaderboard${query ? `?${query}` : ''}`,
+    );
+    return res.leaderboard;
+  }
+
+  async getArcadeEntry(poolId: number, walletAddress: string): Promise<ArcadeEntry> {
+    const res = await this.request<{ success: true; entry: ArcadeEntry }>(
+      'GET',
+      `/arcade/pools/${poolId}/my-entry?walletAddress=${encodeURIComponent(walletAddress)}`,
+    );
+    return res.entry;
+  }
+
   // ── App Config ──
 
   /** Fetch the app's UI customization config (accent color, icon, tagline, environment) */

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,6 +67,13 @@ export type {
   UFCData,
   UFCFight,
   UFCEvent,
+  ArcadePool,
+  ArcadeEntry,
+  ArcadeAttempt,
+  ArcadeLeaderboardEntry,
+  ArcadePoolStats,
+  StartAttemptResult,
+  SubmitScoreResult,
 } from './types';
 
 // Provider
@@ -95,6 +102,9 @@ export {
   useUFCFightCard,
   useUFCFighterDetail,
   usePushNotifications,
+  useArcadePools,
+  useArcadePool,
+  useArcadeGame,
 } from './hooks';
 export type {
   CreateGameMutationResult,
@@ -104,6 +114,9 @@ export type {
   ClaimStatus,
   UseAuthResult,
   PushNotificationStatus,
+  UseArcadePoolsResult,
+  UseArcadePoolResult,
+  UseArcadeGameResult,
 } from './hooks';
 
 // UI

package/src/types.ts

@@ -481,6 +481,76 @@ export interface UFCEvent {
   fights: UFCFight[];
 }
 
+// ── Arcade Pools ──
+
+export interface ArcadePool {
+  id: number;
+  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 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 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) ──
 
 export interface UiConfig {