@dubsdotapp/node 0.1.2 → 0.2.0

package/src/resources/base.ts

@@ -0,0 +1,14 @@
+export type RequestFn = <T>(
+  method: string,
+  path: string,
+  body?: string,
+  extraHeaders?: Record<string, string>,
+) => Promise<T>;
+
+export class BaseResource {
+  protected request: RequestFn;
+
+  constructor(request: RequestFn) {
+    this.request = request;
+  }
+}

package/src/resources/events.ts

@@ -0,0 +1,35 @@
+import { BaseResource } from './base';
+import type {
+  EsportsMatchResponse,
+  EsportsParams,
+  EventsResponse,
+  UpcomingEventsParams,
+} from '../types';
+
+export class EventsResource extends BaseResource {
+  async upcoming(params?: UpcomingEventsParams): Promise<EventsResponse> {
+    const query = new URLSearchParams();
+    if (params?.type) query.set('type', params.type);
+    if (params?.page != null) query.set('page', String(params.page));
+    if (params?.limit != null) query.set('limit', String(params.limit));
+    const qs = query.toString();
+    return this.request<EventsResponse>('GET', `/events/upcoming${qs ? `?${qs}` : ''}`);
+  }
+
+  async sports(league: string): Promise<EventsResponse> {
+    return this.request<EventsResponse>('GET', `/events/sports/${encodeURIComponent(league)}`);
+  }
+
+  async esports(params?: EsportsParams): Promise<EventsResponse> {
+    const query = new URLSearchParams();
+    if (params?.videogame) query.set('videogame', params.videogame);
+    if (params?.page != null) query.set('page', String(params.page));
+    if (params?.limit != null) query.set('limit', String(params.limit));
+    const qs = query.toString();
+    return this.request<EventsResponse>('GET', `/events/esports${qs ? `?${qs}` : ''}`);
+  }
+
+  async esportsMatch(matchId: string): Promise<EsportsMatchResponse> {
+    return this.request<EsportsMatchResponse>('GET', `/events/esports/match/${encodeURIComponent(matchId)}`);
+  }
+}

package/src/resources/games.ts

@@ -0,0 +1,71 @@
+import { BaseResource } from './base';
+import type {
+  CustomGameConfirmParams,
+  CustomGameConfirmResponse,
+  CustomGameCreateParams,
+  CustomGameCreateResponse,
+  Game,
+  GameConfirmParams,
+  GameConfirmResponse,
+  GameCreateParams,
+  GameCreateResponse,
+  GameJoinParams,
+  GameJoinResponse,
+  GameListParams,
+  GameListResponse,
+  LiveScoreResponse,
+  NetworkGamesParams,
+  NetworkGamesResponse,
+  ValidateResponse,
+} from '../types';
+
+export class GamesResource extends BaseResource {
+  async validate(eventId: string): Promise<ValidateResponse> {
+    return this.request<ValidateResponse>('GET', `/games/validate?eventId=${encodeURIComponent(eventId)}`);
+  }
+
+  async create(params: GameCreateParams): Promise<GameCreateResponse> {
+    return this.request<GameCreateResponse>('POST', '/games/create', JSON.stringify(params));
+  }
+
+  async join(params: GameJoinParams): Promise<GameJoinResponse> {
+    return this.request<GameJoinResponse>('POST', '/games/join', JSON.stringify(params));
+  }
+
+  async confirm(params: GameConfirmParams): Promise<GameConfirmResponse> {
+    return this.request<GameConfirmResponse>('POST', '/games/confirm', JSON.stringify(params));
+  }
+
+  async get(gameId: string): Promise<{ game: Game }> {
+    return this.request<{ game: Game }>('GET', `/games/${encodeURIComponent(gameId)}`);
+  }
+
+  async list(params?: GameListParams): Promise<GameListResponse> {
+    const query = new URLSearchParams();
+    if (params?.status) query.set('status', params.status);
+    if (params?.limit != null) query.set('limit', String(params.limit));
+    if (params?.offset != null) query.set('offset', String(params.offset));
+    const qs = query.toString();
+    return this.request<GameListResponse>('GET', `/games${qs ? `?${qs}` : ''}`);
+  }
+
+  async network(params?: NetworkGamesParams): Promise<NetworkGamesResponse> {
+    const query = new URLSearchParams();
+    if (params?.limit != null) query.set('limit', String(params.limit));
+    if (params?.offset != null) query.set('offset', String(params.offset));
+    const qs = query.toString();
+    return this.request<NetworkGamesResponse>('GET', `/games/network${qs ? `?${qs}` : ''}`);
+  }
+
+  async liveScore(gameId: string): Promise<LiveScoreResponse> {
+    return this.request<LiveScoreResponse>('GET', `/games/${encodeURIComponent(gameId)}/live-score`);
+  }
+
+  async customCreate(params: CustomGameCreateParams): Promise<CustomGameCreateResponse> {
+    return this.request<CustomGameCreateResponse>('POST', '/games/custom/create', JSON.stringify(params));
+  }
+
+  async customConfirm(params: CustomGameConfirmParams): Promise<CustomGameConfirmResponse> {
+    return this.request<CustomGameConfirmResponse>('POST', '/games/custom/confirm', JSON.stringify(params));
+  }
+}

package/src/resources/index.ts

@@ -0,0 +1,7 @@
+export { BaseResource } from './base';
+export type { RequestFn } from './base';
+export { AuthResource } from './auth';
+export { UsersResource } from './users';
+export { EventsResource } from './events';
+export { GamesResource } from './games';
+export { TransactionsResource } from './transactions';

package/src/resources/transactions.ts

@@ -0,0 +1,8 @@
+import { BaseResource } from './base';
+import type { BuildClaimParams, BuildClaimResponse } from '../types';
+
+export class TransactionsResource extends BaseResource {
+  async buildClaim(params: BuildClaimParams): Promise<BuildClaimResponse> {
+    return this.request<BuildClaimResponse>('POST', '/transactions/build-claim', JSON.stringify(params));
+  }
+}

package/src/resources/users.ts

@@ -0,0 +1,16 @@
+import { BaseResource } from './base';
+import type { UserResponse, UsersListParams, UsersListResponse } from '../types';
+
+export class UsersResource extends BaseResource {
+  async get(walletAddress: string): Promise<UserResponse> {
+    return this.request<UserResponse>('GET', `/users/${encodeURIComponent(walletAddress)}`);
+  }
+
+  async list(params?: UsersListParams): Promise<UsersListResponse> {
+    const query = new URLSearchParams();
+    if (params?.limit != null) query.set('limit', String(params.limit));
+    if (params?.offset != null) query.set('offset', String(params.offset));
+    const qs = query.toString();
+    return this.request<UsersListResponse>('GET', `/users${qs ? `?${qs}` : ''}`);
+  }
+}

package/src/types.ts

@@ -35,3 +35,234 @@ export interface WebhookEvent {
   timestamp: string;
   data: Record<string, unknown>;
 }
+
+// ── Shared shapes ──
+
+export interface User {
+  walletAddress: string;
+  username: string;
+  avatar?: string;
+  createdAt: string;
+  updatedAt: string;
+  [key: string]: unknown;
+}
+
+export interface Game {
+  id: string;
+  status: string;
+  gameMode: number;
+  eventId?: string;
+  wagerAmount: number;
+  players: Record<string, unknown>[];
+  winner?: string | null;
+  createdAt: string;
+  updatedAt: string;
+  [key: string]: unknown;
+}
+
+export interface Event {
+  id: string;
+  name: string;
+  type: string;
+  league?: string;
+  startTime: string;
+  status: string;
+  teams: { home: string; away: string };
+  [key: string]: unknown;
+}
+
+// ── Auth types ──
+
+export interface NonceParams {
+  walletAddress: string;
+}
+
+export interface NonceResponse {
+  nonce: string;
+}
+
+export interface AuthenticateParams {
+  walletAddress: string;
+  signature: string;
+  nonce: string;
+}
+
+export interface AuthenticateResponse {
+  token: string;
+  user: User;
+}
+
+export interface RegisterParams {
+  walletAddress: string;
+  signature: string;
+  nonce: string;
+  username: string;
+}
+
+export interface RegisterResponse {
+  token: string;
+  user: User;
+}
+
+export interface MeResponse {
+  user: User;
+}
+
+export interface CheckUsernameResponse {
+  available: boolean;
+  username: string;
+}
+
+// ── Users types ──
+
+export interface UserResponse {
+  user: User;
+}
+
+export interface UsersListParams {
+  limit?: number;
+  offset?: number;
+}
+
+export interface UsersListResponse {
+  users: User[];
+  total: number;
+}
+
+// ── Events types ──
+
+export interface UpcomingEventsParams {
+  type?: string;
+  page?: number;
+  limit?: number;
+}
+
+export interface EventsResponse {
+  events: Event[];
+  total?: number;
+}
+
+export interface EsportsParams {
+  videogame?: string;
+  page?: number;
+  limit?: number;
+}
+
+export interface EsportsMatchResponse {
+  match: Record<string, unknown>;
+}
+
+// ── Games types ──
+
+export interface ValidateParams {
+  eventId: string;
+}
+
+export interface ValidateResponse {
+  valid: boolean;
+  event: Event;
+}
+
+export interface GameCreateParams {
+  id: string;
+  playerWallet: string;
+  teamChoice: string;
+  wagerAmount: number;
+}
+
+export interface GameCreateResponse {
+  game: Game;
+  transaction: string;
+}
+
+export interface GameJoinParams {
+  playerWallet: string;
+  gameId: string;
+  teamChoice: string;
+  amount: number;
+}
+
+export interface GameJoinResponse {
+  game: Game;
+  transaction: string;
+}
+
+export interface GameConfirmParams {
+  gameId: string;
+  playerWallet: string;
+  signature: string;
+  [key: string]: unknown;
+}
+
+export interface GameConfirmResponse {
+  game: Game;
+}
+
+export interface GameListParams {
+  status?: string;
+  limit?: number;
+  offset?: number;
+}
+
+export interface GameListResponse {
+  games: Game[];
+  total: number;
+}
+
+export interface NetworkGamesParams {
+  limit?: number;
+  offset?: number;
+}
+
+export interface NetworkGamesResponse {
+  games: Game[];
+  total: number;
+}
+
+export interface LiveScoreResponse {
+  gameId: string;
+  score: Record<string, unknown>;
+  status: string;
+  [key: string]: unknown;
+}
+
+export interface CustomGameCreateParams {
+  playerWallet: string;
+  teamChoice: string;
+  wagerAmount: number;
+  [key: string]: unknown;
+}
+
+export interface CustomGameCreateResponse {
+  game: Game;
+  transaction: string;
+}
+
+export interface CustomGameConfirmParams {
+  gameId: string;
+  playerWallet: string;
+  signature: string;
+  [key: string]: unknown;
+}
+
+export interface CustomGameConfirmResponse {
+  game: Game;
+}
+
+// ── Transactions types ──
+
+export interface BuildClaimParams {
+  playerWallet: string;
+  gameId: string;
+}
+
+export interface BuildClaimResponse {
+  transaction: string;
+  [key: string]: unknown;
+}
+
+// ── Config types ──
+
+export interface AppConfigResponse {
+  [key: string]: unknown;
+}