@dubsdotapp/expo 0.5.17 → 0.5.19

package/src/chat/socket.ts

@@ -0,0 +1,175 @@
+import { io, Socket } from 'socket.io-client';
+import type {
+  ChatMessage,
+  OnlineUser,
+  ChatNotification,
+  ChatConnectionStatus,
+  DirectMessage,
+  SendMessageParams,
+  SendDMParams,
+} from './types';
+
+export interface ChatSocketConfig {
+  /** Server origin, e.g. "https://dubs-server-prod-xxx.herokuapp.com" */
+  host: string;
+  /** JWT token for authentication */
+  token: string;
+}
+
+export interface ChatSocketListeners {
+  onConnectionChange?: (status: ChatConnectionStatus) => void;
+  // Global chat
+  onNewMessage?: (message: ChatMessage) => void;
+  onOnlineUsers?: (users: OnlineUser[]) => void;
+  onOnlineCount?: (count: number) => void;
+  onTyping?: (data: { userId: number; username: string; walletAddress: string; isTyping: boolean }) => void;
+  onReactionAdded?: (data: { messageId: number; userId: number; reaction: string; walletAddress: string }) => void;
+  onReactionRemoved?: (data: { messageId: number; userId: number; reaction: string }) => void;
+  // Notifications
+  onNotification?: (notification: ChatNotification) => void;
+  onUnreadCount?: (count: number) => void;
+  // DMs
+  onDMNewMessage?: (message: DirectMessage) => void;
+  onDMMessageSent?: (message: DirectMessage) => void;
+  onDMNotification?: (data: { senderId: number; senderUsername: string; senderAvatar: string | null; senderWallet: string; preview: string; createdAt: string }) => void;
+  onDMMessagesRead?: (data: { readBy: number; readByWallet: string }) => void;
+  // Social
+  onFriendRequestAccepted?: (data: { requestId: number; acceptedBy: number; acceptedByUsername: string }) => void;
+  onFriendRequestDeclined?: (data: { requestId: number; declinedBy: number }) => void;
+  onFriendRemoved?: (data: { removedBy: number }) => void;
+  // Errors
+  onError?: (error: { message: string }) => void;
+}
+
+/**
+ * Manages the Socket.IO connection to the Dubs chat namespace.
+ */
+export class ChatSocket {
+  private socket: Socket | null = null;
+  private listeners: ChatSocketListeners = {};
+
+  /** Set event listeners. Call before or after connect. */
+  setListeners(listeners: ChatSocketListeners): void {
+    this.listeners = listeners;
+  }
+
+  /** Connect to the /chat namespace */
+  connect(config: ChatSocketConfig): void {
+    if (this.socket?.connected) {
+      console.log('[Dubs:ChatSocket] Already connected');
+      return;
+    }
+
+    this.listeners.onConnectionChange?.('connecting');
+
+    console.log(`[Dubs:ChatSocket] Connecting to ${config.host}/chat`);
+
+    this.socket = io(`${config.host}/chat`, {
+      auth: { token: config.token },
+      transports: ['websocket'],
+      reconnection: true,
+      reconnectionDelay: 1000,
+      reconnectionAttempts: 10,
+    });
+
+    this.socket.on('connect', () => {
+      console.log('[Dubs:ChatSocket] Connected');
+      this.listeners.onConnectionChange?.('connected');
+    });
+
+    this.socket.on('disconnect', (reason) => {
+      console.log('[Dubs:ChatSocket] Disconnected:', reason);
+      this.listeners.onConnectionChange?.('disconnected');
+    });
+
+    this.socket.on('connect_error', (error) => {
+      console.error('[Dubs:ChatSocket] Connection error:', error.message);
+      this.listeners.onConnectionChange?.('error');
+    });
+
+    // Global chat events
+    this.socket.on('new_message', (msg: ChatMessage) => this.listeners.onNewMessage?.(msg));
+    this.socket.on('online_users', (users: OnlineUser[]) => this.listeners.onOnlineUsers?.(users));
+    this.socket.on('online_count', (count: number) => this.listeners.onOnlineCount?.(count));
+    this.socket.on('user_typing', (data: any) => this.listeners.onTyping?.(data));
+    this.socket.on('reaction_added', (data: any) => this.listeners.onReactionAdded?.(data));
+    this.socket.on('reaction_removed', (data: any) => this.listeners.onReactionRemoved?.(data));
+
+    // Notifications
+    this.socket.on('notification', (n: ChatNotification) => this.listeners.onNotification?.(n));
+    this.socket.on('unread_count', (count: number) => this.listeners.onUnreadCount?.(count));
+
+    // DM events
+    this.socket.on('dm:new_message', (msg: DirectMessage) => this.listeners.onDMNewMessage?.(msg));
+    this.socket.on('dm:message_sent', (msg: DirectMessage) => this.listeners.onDMMessageSent?.(msg));
+    this.socket.on('dm:notification', (data: any) => this.listeners.onDMNotification?.(data));
+    this.socket.on('dm:messages_read', (data: any) => this.listeners.onDMMessagesRead?.(data));
+
+    // Social events
+    this.socket.on('friend_request_accepted', (data: any) => this.listeners.onFriendRequestAccepted?.(data));
+    this.socket.on('friend_request_declined', (data: any) => this.listeners.onFriendRequestDeclined?.(data));
+    this.socket.on('friend_removed', (data: any) => this.listeners.onFriendRemoved?.(data));
+
+    // Error
+    this.socket.on('error', (err: { message: string }) => this.listeners.onError?.(err));
+  }
+
+  /** Disconnect from the chat namespace */
+  disconnect(): void {
+    if (this.socket) {
+      console.log('[Dubs:ChatSocket] Disconnecting');
+      this.socket.removeAllListeners();
+      this.socket.disconnect();
+      this.socket = null;
+    }
+  }
+
+  /** Whether the socket is currently connected */
+  isConnected(): boolean {
+    return this.socket?.connected ?? false;
+  }
+
+  // ── Global Chat Actions ──
+
+  /** Send a message to global chat */
+  sendMessage(params: SendMessageParams): void {
+    this.socket?.emit('send_message', params);
+  }
+
+  /** Emit typing indicator */
+  sendTyping(isTyping: boolean): void {
+    this.socket?.emit('typing', isTyping);
+  }
+
+  /** Add an emoji reaction to a message */
+  addReaction(messageId: number, reaction: string): void {
+    this.socket?.emit('add_reaction', { messageId, reaction });
+  }
+
+  /** Remove an emoji reaction from a message */
+  removeReaction(messageId: number, reaction: string): void {
+    this.socket?.emit('remove_reaction', { messageId, reaction });
+  }
+
+  // ── DM Actions ──
+
+  /** Join a DM room to receive messages in real-time */
+  joinDM(recipientWallet: string): void {
+    this.socket?.emit('dm:join', { recipientWallet });
+  }
+
+  /** Leave a DM room */
+  leaveDM(recipientWallet: string): void {
+    this.socket?.emit('dm:leave', { recipientWallet });
+  }
+
+  /** Send a direct message via socket */
+  sendDM(params: SendDMParams): void {
+    this.socket?.emit('dm:send', params);
+  }
+
+  /** Mark DMs from a sender as read */
+  markDMRead(senderWallet: string): void {
+    this.socket?.emit('dm:mark_read', { senderWallet });
+  }
+}

package/src/chat/types.ts

@@ -0,0 +1,146 @@
+// ── Chat Message Types ──
+
+export interface ChatMessage {
+  id: number;
+  userId: number;
+  walletAddress: string;
+  username: string;
+  avatar: string | null;
+  message: string;
+  replyTo: {
+    id: number;
+    message: string;
+    username: string;
+    walletAddress: string;
+  } | null;
+  timestamp: string;
+  edited: boolean;
+  editedAt: string | null;
+  isWinnerAnnouncement: boolean;
+  winAmount?: number;
+  roundId?: number;
+  gameInvite: Record<string, unknown> | null;
+  pnlShare: Record<string, unknown> | null;
+  gifUrl: string | null;
+  reactions: Record<string, { count: number; reactors: string[] }>;
+  mentions: ChatMention[];
+  payment: ChatPayment | null;
+}
+
+export interface ChatMention {
+  userId: number;
+  username: string;
+  walletAddress: string;
+}
+
+export interface ChatPayment {
+  id: number;
+  senderUsername: string;
+  recipientUsername: string;
+  amount: number;
+  signature: string;
+  status: string;
+  errorMessage: string | null;
+  createdAt: string;
+  confirmedAt: string | null;
+}
+
+// ── DM Types ──
+
+export interface DirectMessage {
+  id: number;
+  senderId: number;
+  recipientId?: number;
+  senderUsername: string;
+  senderAvatar: string | null;
+  senderWallet: string;
+  message: string;
+  read: boolean;
+  createdAt: string;
+  isOwn: boolean;
+  gameInvite: Record<string, unknown> | null;
+}
+
+export interface Conversation {
+  otherUserId: number;
+  otherUsername: string;
+  otherAvatar: string | null;
+  otherWallet: string;
+  lastMessage: string;
+  lastMessageAt: string;
+  unreadCount: number;
+}
+
+// ── Social Types ──
+
+export interface FriendUser {
+  userId: number;
+  username: string;
+  avatar: string | null;
+  walletAddress: string;
+  friendsSince?: string;
+  isFriend?: boolean;
+  isBlocked?: boolean;
+  friendRequestSent?: boolean;
+  friendRequestReceived?: boolean;
+  friendRequestId?: number;
+}
+
+export interface FriendRequest {
+  id: number;
+  fromUserId: number;
+  fromUsername: string;
+  fromAvatar: string | null;
+  fromWallet: string;
+  createdAt: string;
+}
+
+// ── Online / Real-time Types ──
+
+export interface OnlineUser {
+  walletAddress: string;
+  username: string;
+  avatar: string | null;
+}
+
+export interface TypingEvent {
+  userId: number;
+  username: string;
+  walletAddress: string;
+  isTyping: boolean;
+}
+
+export interface ChatNotification {
+  id: number;
+  type: string;
+  read: boolean;
+  message: string;
+  messageId?: number;
+  senderUsername: string;
+  senderWallet: string;
+  senderAvatar: string | null;
+  createdAt: string;
+  [key: string]: unknown;
+}
+
+// ── Connection State ──
+
+export type ChatConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error';
+
+// ── Params ──
+
+export interface SendMessageParams {
+  message: string;
+  replyToId?: number;
+  mentions?: number[];
+  gifUrl?: string;
+  gameInvite?: Record<string, unknown>;
+  pnlShare?: Record<string, unknown>;
+}
+
+export interface SendDMParams {
+  recipientWallet: string;
+  message: string;
+  gameInvite?: Record<string, unknown>;
+  animation?: string;
+}

package/src/client.ts

@@ -45,6 +45,13 @@ import type {
   StartAttemptResult,
   SubmitScoreResult,
   BuildArcadeEntryResult,
+  JackpotRound,
+  JackpotLastWinner,
+  JackpotEntry,
+  JackpotRoundResult,
+  JackpotConfig,
+  BuildJackpotEnterResult,
+  ConfirmJackpotEnterResult,
 } from './types';
 
 export interface DubsClientConfig {
@@ -573,6 +580,181 @@ export class DubsClient {
     return res.entry;
   }
 
+  // ── Jackpot ──
+
+  /** Get current jackpot round + last winner */
+  async getJackpotCurrent(): Promise<{ round: JackpotRound | null; lastWinner: JackpotLastWinner | null }> {
+    const res = await this.request<{ success: true; round: JackpotRound | null; lastWinner: JackpotLastWinner | null }>(
+      'GET',
+      '/jackpot/current',
+    );
+    return { round: res.round, lastWinner: res.lastWinner };
+  }
+
+  /** Get current round entries with odds */
+  async getJackpotEntries(): Promise<{ roundId: string; entries: JackpotEntry[]; totalEntries: number }> {
+    const res = await this.request<{ success: true; roundId: string; entries: JackpotEntry[]; totalEntries: number }>(
+      'GET',
+      '/jackpot/entries',
+    );
+    return { roundId: res.roundId, entries: res.entries, totalEntries: res.totalEntries };
+  }
+
+  /** Get recent jackpot round results */
+  async getJackpotHistory(limit?: number): Promise<JackpotRoundResult[]> {
+    const qs = limit ? `?limit=${limit}` : '';
+    const res = await this.request<{ success: true; rounds: JackpotRoundResult[] }>(
+      'GET',
+      `/jackpot/history${qs}`,
+    );
+    return res.rounds;
+  }
+
+  /** Get jackpot protocol config */
+  async getJackpotConfig(): Promise<JackpotConfig> {
+    const res = await this.request<{ success: true; config: JackpotConfig }>(
+      'GET',
+      '/jackpot/config',
+    );
+    return res.config;
+  }
+
+  /** Build unsigned jackpot enter transaction */
+  async buildJackpotEnter(playerAddress: string, amount: number): Promise<BuildJackpotEnterResult> {
+    const res = await this.request<{ success: true } & BuildJackpotEnterResult>(
+      'POST',
+      '/jackpot/build-enter',
+      { playerAddress, amount },
+    );
+    return { transaction: res.transaction, roundId: res.roundId, amount: res.amount, amountSol: res.amountSol };
+  }
+
+  /** Confirm jackpot entry after wallet signs (creates developer attribution) */
+  async confirmJackpotEnter(params: { playerAddress: string; roundId?: string; amount?: number; signature: string }): Promise<ConfirmJackpotEnterResult> {
+    const res = await this.request<{ success: true } & ConfirmJackpotEnterResult>(
+      'POST',
+      '/jackpot/confirm-enter',
+      params,
+    );
+    return { attributed: res.attributed, appId: res.appId, signature: res.signature };
+  }
+
+  // ── Chat ──
+
+  /** Get recent global chat messages */
+  async getChatMessages(params?: { limit?: number; before?: number }): Promise<{ messages: any[]; hasMore: boolean }> {
+    const qs = new URLSearchParams();
+    if (params?.limit) qs.set('limit', String(params.limit));
+    if (params?.before) qs.set('before', String(params.before));
+    const query = qs.toString();
+    return this.request('GET', `/chat/messages${query ? `?${query}` : ''}`);
+  }
+
+  /** Send a message to global chat */
+  async sendChatMessage(params: { message: string; replyToId?: number }): Promise<{ message: any }> {
+    return this.request('POST', '/chat/message', params);
+  }
+
+  /** Edit your own message */
+  async editChatMessage(id: number, message: string): Promise<{ message: any }> {
+    return this.request('PUT', `/chat/message/${id}`, { message });
+  }
+
+  /** Delete your own message */
+  async deleteChatMessage(id: number): Promise<{ messageId: number }> {
+    return this.request('DELETE', `/chat/message/${id}`);
+  }
+
+  /** Block a user */
+  async blockUser(targetUserId: number): Promise<void> {
+    await this.request('POST', `/chat/block/${targetUserId}`);
+  }
+
+  /** Unblock a user */
+  async unblockUser(targetUserId: number): Promise<void> {
+    await this.request('DELETE', `/chat/block/${targetUserId}`);
+  }
+
+  // ── DMs ──
+
+  /** Get DM conversations inbox */
+  async getConversations(limit?: number): Promise<{ conversations: any[] }> {
+    const qs = limit ? `?limit=${limit}` : '';
+    return this.request('GET', `/dm/conversations${qs}`);
+  }
+
+  /** Get conversation history with a specific user */
+  async getConversation(walletAddress: string, params?: { limit?: number; beforeId?: number }): Promise<{ messages: any[]; otherUser: any }> {
+    const qs = new URLSearchParams();
+    if (params?.limit) qs.set('limit', String(params.limit));
+    if (params?.beforeId) qs.set('beforeId', String(params.beforeId));
+    const query = qs.toString();
+    return this.request('GET', `/dm/conversation/${encodeURIComponent(walletAddress)}${query ? `?${query}` : ''}`);
+  }
+
+  /** Send a direct message */
+  async sendDirectMessage(params: { recipientWallet: string; message: string }): Promise<{ message: any }> {
+    return this.request('POST', '/dm/send', params);
+  }
+
+  /** Mark all DMs from a user as read */
+  async markDMRead(walletAddress: string): Promise<{ markedRead: number }> {
+    return this.request('POST', `/dm/read/${encodeURIComponent(walletAddress)}`);
+  }
+
+  /** Get unread DM count */
+  async getDMUnreadCount(): Promise<{ unreadCount: number }> {
+    return this.request('GET', '/dm/unread');
+  }
+
+  /** Delete a DM conversation (soft delete) */
+  async deleteConversation(walletAddress: string): Promise<void> {
+    await this.request('DELETE', `/dm/conversation/${encodeURIComponent(walletAddress)}`);
+  }
+
+  // ── Social ──
+
+  /** Search users by username */
+  async searchUsers(query: string): Promise<{ results: any[] }> {
+    const qs = query ? `?q=${encodeURIComponent(query)}` : '';
+    return this.request('GET', `/social/search${qs}`);
+  }
+
+  /** Send a friend request */
+  async sendFriendRequest(targetUserId: number): Promise<{ requestId: number }> {
+    return this.request('POST', `/social/friend-request/${targetUserId}`);
+  }
+
+  /** Get pending friend requests (received) */
+  async getPendingFriendRequests(): Promise<{ requests: any[] }> {
+    return this.request('GET', '/social/friend-requests');
+  }
+
+  /** Accept a friend request */
+  async acceptFriendRequest(requestId: number): Promise<void> {
+    await this.request('POST', `/social/request/${requestId}/accept`);
+  }
+
+  /** Reject a friend request */
+  async rejectFriendRequest(requestId: number): Promise<void> {
+    await this.request('POST', `/social/request/${requestId}/reject`);
+  }
+
+  /** Get friends list */
+  async getFriends(): Promise<{ friends: any[] }> {
+    return this.request('GET', '/social/friends');
+  }
+
+  /** Remove a friend */
+  async removeFriend(targetUserId: number): Promise<void> {
+    await this.request('DELETE', `/social/friend/${targetUserId}`);
+  }
+
+  /** Get blocked users list */
+  async getBlockedUsers(): Promise<{ blocked: any[] }> {
+    return this.request('GET', '/social/blocked');
+  }
+
   // ── App Config ──
 
   /** Fetch the app's UI customization config (accent color, icon, tagline, environment) */

package/src/hooks/index.ts

@@ -34,3 +34,9 @@ export { useArcadeCountdown } from './useArcadeCountdown';
 export type { ArcadeCountdown } from './useArcadeCountdown';
 export { useArcadeBridge } from './useArcadeBridge';
 export type { UseArcadeBridgeOptions, UseArcadeBridgeResult } from './useArcadeBridge';
+export { useJackpot } from './useJackpot';
+export type { UseJackpotResult } from './useJackpot';
+export { useJackpotHistory } from './useJackpotHistory';
+export type { UseJackpotHistoryResult } from './useJackpotHistory';
+export { useEnterJackpot } from './useEnterJackpot';
+export type { EnterJackpotMutationResult } from './useEnterJackpot';

package/src/hooks/useEnterJackpot.ts

@@ -0,0 +1,80 @@
+import { useState, useCallback } from 'react';
+import { useDubs } from '../provider';
+import { signAndSendBase64Transaction } from '../utils/transaction';
+import type { MutationStatus } from '../types';
+
+export interface EnterJackpotMutationResult {
+  roundId: string;
+  amount: string;
+  amountSol: number;
+  signature: string;
+}
+
+export function useEnterJackpot() {
+  const { client, wallet, connection } = useDubs();
+  const [status, setStatus] = useState<MutationStatus>('idle');
+  const [error, setError] = useState<Error | null>(null);
+  const [data, setData] = useState<EnterJackpotMutationResult | null>(null);
+
+  const reset = useCallback(() => {
+    setStatus('idle');
+    setError(null);
+    setData(null);
+  }, []);
+
+  const execute = useCallback(async (amountLamports: number): Promise<EnterJackpotMutationResult> => {
+    if (!wallet.publicKey) throw new Error('Wallet not connected');
+    const walletAddress = wallet.publicKey.toBase58();
+
+    setStatus('building');
+    setError(null);
+    setData(null);
+
+    try {
+      // 1. Build unsigned transaction
+      console.log('[useEnterJackpot] Step 1: Building transaction...', { walletAddress, amountLamports });
+      const buildResult = await client.buildJackpotEnter(walletAddress, amountLamports);
+      console.log('[useEnterJackpot] Step 1 done:', { roundId: buildResult.roundId, amount: buildResult.amount });
+
+      // 2. Sign and send transaction
+      setStatus('signing');
+      console.log('[useEnterJackpot] Step 2: Signing and sending...');
+      const signature = await signAndSendBase64Transaction(
+        buildResult.transaction,
+        wallet,
+        connection,
+      );
+      console.log('[useEnterJackpot] Step 2 done. Signature:', signature);
+
+      // 3. Confirm entry with backend (creates developer attribution)
+      setStatus('confirming');
+      console.log('[useEnterJackpot] Step 3: Confirming with backend...');
+      await client.confirmJackpotEnter({
+        playerAddress: walletAddress,
+        roundId: buildResult.roundId,
+        amount: amountLamports,
+        signature,
+      });
+      console.log('[useEnterJackpot] Step 3 done. Entry confirmed + attributed.');
+
+      const result: EnterJackpotMutationResult = {
+        roundId: buildResult.roundId,
+        amount: buildResult.amount,
+        amountSol: buildResult.amountSol,
+        signature,
+      };
+
+      setData(result);
+      setStatus('success');
+      return result;
+    } catch (err) {
+      console.error('[useEnterJackpot] FAILED:', err);
+      const e = err instanceof Error ? err : new Error(String(err));
+      setError(e);
+      setStatus('error');
+      throw e;
+    }
+  }, [client, wallet, connection]);
+
+  return { execute, status, error, data, reset };
+}

package/src/hooks/useJackpot.ts

@@ -0,0 +1,37 @@
+import { useState, useEffect, useCallback } from 'react';
+import { useDubs } from '../provider';
+import type { JackpotRound, JackpotLastWinner } from '../types';
+
+export interface UseJackpotResult {
+  round: JackpotRound | null;
+  lastWinner: JackpotLastWinner | null;
+  loading: boolean;
+  error: Error | null;
+  refetch: () => void;
+}
+
+export function useJackpot(): UseJackpotResult {
+  const { client } = useDubs();
+  const [round, setRound] = useState<JackpotRound | null>(null);
+  const [lastWinner, setLastWinner] = useState<JackpotLastWinner | null>(null);
+  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.getJackpotCurrent();
+      setRound(result.round);
+      setLastWinner(result.lastWinner);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+
+  useEffect(() => { fetch(); }, [fetch]);
+
+  return { round, lastWinner, loading, error, refetch: fetch };
+}

package/src/hooks/useJackpotHistory.ts

@@ -0,0 +1,34 @@
+import { useState, useEffect, useCallback } from 'react';
+import { useDubs } from '../provider';
+import type { JackpotRoundResult } from '../types';
+
+export interface UseJackpotHistoryResult {
+  rounds: JackpotRoundResult[];
+  loading: boolean;
+  error: Error | null;
+  refetch: () => void;
+}
+
+export function useJackpotHistory(limit?: number): UseJackpotHistoryResult {
+  const { client } = useDubs();
+  const [rounds, setRounds] = useState<JackpotRoundResult[]>([]);
+  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.getJackpotHistory(limit);
+      setRounds(result);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, limit]);
+
+  useEffect(() => { fetch(); }, [fetch]);
+
+  return { rounds, loading, error, refetch: fetch };
+}