@dubsdotapp/expo 0.2.33 → 0.2.35

package/package.json

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

package/src/errors.ts

@@ -66,6 +66,14 @@ export const SOLANA_PROGRAM_ERRORS: Record<number, SolanaErrorCode> = {
   6049: { code: 'too_many_survivors', message: 'Too many survivors (max 50 per batch)' },
 };
 
+/** Known wallet/MWA error patterns that don't contain Solana error codes */
+const WALLET_ERROR_PATTERNS: Array<{ pattern: RegExp; error: ParsedError }> = [
+  { pattern: /CancellationException/i, error: { code: 'transaction_rejected', message: 'Transaction was rejected by the wallet' } },
+  { pattern: /declined/i, error: { code: 'user_declined', message: 'Transaction was declined' } },
+  { pattern: /timeout/i, error: { code: 'transaction_timeout', message: 'Transaction timed out' } },
+  { pattern: /not connected/i, error: { code: 'wallet_not_connected', message: 'Wallet is not connected' } },
+];
+
 /** Known Solana built-in instruction errors */
 const SOLANA_BUILTIN_ERRORS: Record<number, SolanaErrorCode> = {
   0: { code: 'generic_error', message: 'Generic instruction error' },
@@ -90,6 +98,11 @@ export function parseSolanaError(err: unknown): ParsedError {
   let parsed = err;
 
   if (typeof parsed === 'string') {
+    // Check for known wallet/MWA error patterns before attempting JSON parse
+    for (const { pattern, error } of WALLET_ERROR_PATTERNS) {
+      if (pattern.test(parsed)) return error;
+    }
+
     try {
       const jsonMatch = parsed.match(/\{.*\}/s);
       if (jsonMatch) parsed = JSON.parse(jsonMatch[0]);

package/src/hooks/index.ts

@@ -10,5 +10,7 @@ export { useClaim } from './useClaim';
 export type { ClaimMutationResult } from './useClaim';
 export { useCreateCustomGame } from './useCreateCustomGame';
 export type { CreateCustomGameMutationResult } from './useCreateCustomGame';
+export { useHasClaimed } from './useHasClaimed';
+export type { ClaimStatus } from './useHasClaimed';
 export { useAuth } from './useAuth';
 export type { UseAuthResult } from './useAuth';

package/src/hooks/useClaim.ts

@@ -1,6 +1,7 @@
 import { useState, useCallback } from 'react';
 import { useDubs } from '../provider';
 import { signAndSendBase64Transaction } from '../utils/transaction';
+import { parseSolanaError } from '../errors';
 import type { BuildClaimParams, MutationStatus } from '../types';
 
 export interface ClaimMutationResult {
@@ -64,7 +65,34 @@ export function useClaim() {
       return result;
     } catch (err) {
       console.error('[useClaim] FAILED:', err);
-      const error = err instanceof Error ? err : new Error(String(err));
+      // Parse Solana program errors into human-readable messages
+      const raw = err instanceof Error ? err.message : String(err);
+      const parsed = parseSolanaError(raw);
+
+      // If the error is generic (wallet rejected / unrecognizable), check if it's
+      // actually an "already claimed" situation by querying the game state.
+      if (parsed.code === 'transaction_rejected' || parsed.code === 'transaction_failed') {
+        try {
+          const game = await client.getGame(params.gameId);
+          const myBet = game.bettors?.find(
+            (b: { wallet: string }) => b.wallet === params.playerWallet,
+          );
+          if (myBet?.amountClaimed != null && myBet.amountClaimed > 0) {
+            const claimedErr = new Error('Player has already claimed their winnings');
+            (claimedErr as any).code = 'already_claimed';
+            setError(claimedErr);
+            setStatus('error');
+            throw claimedErr;
+          }
+        } catch (checkErr) {
+          // If the post-hoc check itself identified "already claimed", rethrow it
+          if ((checkErr as any)?.code === 'already_claimed') throw checkErr;
+          // Otherwise fall through to the generic parsed error
+        }
+      }
+
+      const error = new Error(parsed.message);
+      (error as any).code = parsed.code;
       setError(error);
       setStatus('error');
       throw error;

package/src/hooks/useHasClaimed.ts

@@ -0,0 +1,85 @@
+import { useState, useEffect } from 'react';
+import { useDubs } from '../provider';
+
+export interface ClaimStatus {
+  /** Whether the current wallet has claimed this game's prize */
+  hasClaimed: boolean;
+  /** Amount claimed (null if not claimed) */
+  amountClaimed: number | null;
+  /** Claim transaction signature (null if not claimed) */
+  claimSignature: string | null;
+  /** Whether the game has been resolved */
+  isResolved: boolean;
+  /** Loading state */
+  loading: boolean;
+  /** Error if fetch failed */
+  error: Error | null;
+  /** Re-fetch claim status */
+  refetch: () => void;
+}
+
+/**
+ * Check whether the current wallet has already claimed a prize for a game.
+ *
+ * Uses the game detail endpoint which includes per-bettor claim data.
+ */
+export function useHasClaimed(gameId: string | null): ClaimStatus {
+  const { client, wallet } = useDubs();
+  const [hasClaimed, setHasClaimed] = useState(false);
+  const [amountClaimed, setAmountClaimed] = useState<number | null>(null);
+  const [claimSignature, setClaimSignature] = useState<string | null>(null);
+  const [isResolved, setIsResolved] = useState(false);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+  const [trigger, setTrigger] = useState(0);
+
+  const refetch = () => setTrigger(t => t + 1);
+
+  useEffect(() => {
+    if (!gameId || !wallet.publicKey) {
+      setHasClaimed(false);
+      setAmountClaimed(null);
+      setClaimSignature(null);
+      setIsResolved(false);
+      return;
+    }
+
+    let cancelled = false;
+    setLoading(true);
+    setError(null);
+
+    client
+      .getGame(gameId)
+      .then(game => {
+        if (cancelled) return;
+        setIsResolved(game.isResolved);
+
+        const myWallet = wallet.publicKey!.toBase58();
+        const myBet = game.bettors?.find(b => b.wallet === myWallet);
+
+        if (myBet?.amountClaimed != null && myBet.amountClaimed > 0) {
+          setHasClaimed(true);
+          setAmountClaimed(myBet.amountClaimed);
+          setClaimSignature(myBet.claimSignature ?? null);
+        } else {
+          setHasClaimed(false);
+          setAmountClaimed(null);
+          setClaimSignature(null);
+        }
+      })
+      .catch(err => {
+        if (!cancelled) {
+          setError(err instanceof Error ? err : new Error(String(err)));
+        }
+      })
+      .finally(() => {
+        if (!cancelled) setLoading(false);
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [gameId, wallet.publicKey, client, trigger]);
+
+  return { hasClaimed, amountClaimed, claimSignature, isResolved, loading, error, refetch };
+}

package/src/index.ts

@@ -82,6 +82,7 @@ export {
   useCreateCustomGame,
   useJoinGame,
   useClaim,
+  useHasClaimed,
   useAuth,
 } from './hooks';
 export type {
@@ -89,6 +90,7 @@ export type {
   CreateCustomGameMutationResult,
   JoinGameMutationResult,
   ClaimMutationResult,
+  ClaimStatus,
   UseAuthResult,
 } from './hooks';
 

package/src/types.ts

@@ -198,6 +198,8 @@ export interface Bettor {
   avatar: string | null;
   team: 'home' | 'away' | 'draw';
   amount: number;
+  amountClaimed: number | null;
+  claimSignature: string | null;
 }
 
 export interface GameDetail {