@dubsdotapp/node 0.1.2 → 0.2.1

package/README.md

@@ -15,12 +15,144 @@ import { Dubs } from '@dubsdotapp/node';
 
 const dubs = new Dubs({
   apiKey: process.env.DUBS_API_KEY!,
-  resolutionSecret: process.env.DUBS_RESOLUTION_SECRET!,
+  resolutionSecret: process.env.DUBS_RESOLUTION_SECRET!, // optional, only needed for resolveGame
   network: 'mainnet-beta', // or 'devnet'
 });
 ```
 
-## Resolve a Game
+## API Reference
+
+### Auth
+
+```ts
+// Get a nonce for wallet authentication
+const { nonce } = await dubs.auth.getNonce('walletAddress');
+
+// Authenticate with a signed nonce
+const { token, user } = await dubs.auth.authenticate({
+  walletAddress: '...',
+  signature: '...',
+  nonce: '...',
+});
+
+// Register a new user
+const { token, user } = await dubs.auth.register({
+  walletAddress: '...',
+  signature: '...',
+  nonce: '...',
+  username: 'player1',
+});
+
+// Get the current user (requires user token)
+const { user } = await dubs.auth.me(userToken);
+
+// Logout
+await dubs.auth.logout(userToken);
+
+// Check username availability
+const { available } = await dubs.auth.checkUsername('player1');
+```
+
+### Users
+
+```ts
+// Get a user by wallet address
+const { user } = await dubs.users.get('walletAddress');
+
+// List users
+const { users, total } = await dubs.users.list({ limit: 20, offset: 0 });
+```
+
+### Events
+
+```ts
+// Get upcoming events
+const { events } = await dubs.events.upcoming({ type: 'sports', page: 1 });
+
+// Get sports events by league
+const { events } = await dubs.events.sports('NBA');
+
+// Get esports events
+const { events } = await dubs.events.esports({ videogame: 'cs-go' });
+
+// Get a specific esports match
+const { match } = await dubs.events.esportsMatch('matchId');
+```
+
+### Games
+
+```ts
+// Validate an event for game creation
+const { valid, event } = await dubs.games.validate('eventId');
+
+// Create a game
+const { game, transaction } = await dubs.games.create({
+  id: 'unique-game-id',
+  playerWallet: '...',
+  teamChoice: 'home',
+  wagerAmount: 1.5,
+});
+
+// Join a game
+const { game, transaction } = await dubs.games.join({
+  playerWallet: '...',
+  gameId: 'game-id',
+  teamChoice: 'away',
+  amount: 1.5,
+});
+
+// Confirm a game (after signing the transaction)
+const { game } = await dubs.games.confirm({
+  gameId: 'game-id',
+  playerWallet: '...',
+  signature: '...',
+});
+
+// Get a game by ID
+const { game } = await dubs.games.get('game-id');
+
+// List games
+const { games, total } = await dubs.games.list({ status: 'open', limit: 20 });
+
+// List network-wide games
+const { games } = await dubs.games.network({ limit: 20 });
+
+// Get live score for a game
+const score = await dubs.games.liveScore('game-id');
+
+// Create a custom game
+const { game, transaction } = await dubs.games.customCreate({
+  playerWallet: '...',
+  teamChoice: 'home',
+  wagerAmount: 2.0,
+});
+
+// Confirm a custom game
+const { game } = await dubs.games.customConfirm({
+  gameId: 'game-id',
+  playerWallet: '...',
+  signature: '...',
+});
+```
+
+### Transactions
+
+```ts
+// Build a claim transaction
+const { transaction } = await dubs.transactions.buildClaim({
+  playerWallet: '...',
+  gameId: 'game-id',
+});
+```
+
+### Config
+
+```ts
+// Get platform configuration
+const config = await dubs.config();
+```
+
+### Resolve a Game
 
 Resolve a custom game (game_mode=6) by declaring a winner. The SDK automatically computes the HMAC-SHA256 signature using your resolution secret.
 
@@ -40,7 +172,7 @@ console.log(result);
 // }
 ```
 
-## Verify Webhooks
+### Verify Webhooks
 
 Verify incoming webhook requests from Dubs using your webhook secret.
 
@@ -64,12 +196,12 @@ app.post('/webhooks/dubs', (req, res) => {
 
 ## Configuration
 
-| Option             | Type          | Description                                              |
-| ------------------ | ------------- | -------------------------------------------------------- |
-| `apiKey`           | `string`      | Your Dubs API key (from the developer portal)            |
-| `resolutionSecret` | `string?`     | Secret for signing `resolveGame` requests                |
-| `network`          | `string?`     | `'mainnet-beta'` or `'devnet'` — sets the base URL       |
-| `baseUrl`          | `string?`     | Explicit base URL (overrides `network` if both provided) |
+| Option             | Type       | Description                                              |
+| ------------------ | ---------- | -------------------------------------------------------- |
+| `apiKey`           | `string`   | Your Dubs API key (from the developer portal)            |
+| `resolutionSecret` | `string?`  | Secret for signing `resolveGame` requests                |
+| `network`          | `string?`  | `'mainnet-beta'` or `'devnet'` — sets the base URL       |
+| `baseUrl`          | `string?`  | Explicit base URL (overrides `network` if both provided) |
 
 ## Error Handling
 

package/dist/index.d.mts

@@ -1,3 +1,9 @@
+type RequestFn = <T>(method: string, path: string, body?: string, extraHeaders?: Record<string, string>) => Promise<T>;
+declare class BaseResource {
+    protected request: RequestFn;
+    constructor(request: RequestFn);
+}
+
 declare const DEFAULT_BASE_URL = "https://dubs-server-prod-9c91d3f01199.herokuapp.com/api/developer/v1";
 type DubsNetwork = 'devnet' | 'mainnet-beta';
 declare const NETWORK_CONFIG: Record<DubsNetwork, {
@@ -36,12 +42,280 @@ interface WebhookEvent {
     timestamp: string;
     data: Record<string, unknown>;
 }
+interface User {
+    walletAddress: string;
+    username: string;
+    avatar?: string;
+    createdAt: string;
+    updatedAt: string;
+    [key: string]: unknown;
+}
+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;
+}
+interface Event {
+    id: string;
+    name: string;
+    type: string;
+    league?: string;
+    startTime: string;
+    status: string;
+    teams: {
+        home: string;
+        away: string;
+    };
+    [key: string]: unknown;
+}
+interface NonceParams {
+    walletAddress: string;
+}
+interface NonceResponse {
+    nonce: string;
+}
+interface AuthenticateParams {
+    walletAddress: string;
+    signature: string;
+    nonce: string;
+}
+interface AuthenticateResponse {
+    token: string;
+    user: User;
+}
+interface RegisterParams {
+    walletAddress: string;
+    signature: string;
+    nonce: string;
+    username: string;
+}
+interface RegisterResponse {
+    token: string;
+    user: User;
+}
+interface MeResponse {
+    user: User;
+}
+interface CheckUsernameResponse {
+    available: boolean;
+    username: string;
+}
+interface UserResponse {
+    user: User;
+}
+interface UsersListParams {
+    limit?: number;
+    offset?: number;
+}
+interface UsersListResponse {
+    users: User[];
+    total: number;
+}
+interface UpcomingEventsParams {
+    type?: string;
+    page?: number;
+    limit?: number;
+}
+interface EventsResponse {
+    events: Event[];
+    total?: number;
+}
+interface EsportsParams {
+    videogame?: string;
+    page?: number;
+    limit?: number;
+}
+interface EsportsMatchResponse {
+    match: Record<string, unknown>;
+}
+interface ValidateParams {
+    eventId: string;
+}
+interface ValidateResponse {
+    valid: boolean;
+    event: Event;
+}
+interface GameCreateParams {
+    id: string;
+    playerWallet: string;
+    teamChoice: string;
+    wagerAmount: number;
+}
+interface GameCreateResponse {
+    game: Game;
+    transaction: string;
+}
+interface GameJoinParams {
+    playerWallet: string;
+    gameId: string;
+    teamChoice: string;
+    amount: number;
+}
+interface GameJoinResponse {
+    game: Game;
+    transaction: string;
+}
+interface GameConfirmParams {
+    gameId: string;
+    playerWallet: string;
+    signature: string;
+    [key: string]: unknown;
+}
+interface GameConfirmResponse {
+    game: Game;
+}
+interface GameListParams {
+    status?: string;
+    limit?: number;
+    offset?: number;
+}
+interface GameListResponse {
+    games: Game[];
+    total: number;
+}
+interface NetworkGamesParams {
+    limit?: number;
+    offset?: number;
+}
+interface NetworkGamesResponse {
+    games: Game[];
+    total: number;
+}
+interface LiveScoreResponse {
+    gameId: string;
+    score: Record<string, unknown>;
+    status: string;
+    [key: string]: unknown;
+}
+interface CustomGameCreateParams {
+    playerWallet: string;
+    teamChoice: string;
+    wagerAmount: number;
+    [key: string]: unknown;
+}
+interface CustomGameCreateResponse {
+    game: Game;
+    transaction: string;
+}
+interface CustomGameConfirmParams {
+    gameId: string;
+    playerWallet: string;
+    signature: string;
+    [key: string]: unknown;
+}
+interface CustomGameConfirmResponse {
+    game: Game;
+}
+interface BuildClaimParams {
+    playerWallet: string;
+    gameId: string;
+}
+interface BuildClaimResponse {
+    transaction: string;
+    [key: string]: unknown;
+}
+interface AppConfigResponse {
+    [key: string]: unknown;
+}
+interface UFCFighter {
+    name: string;
+    imageUrl: string | null;
+    abbreviation: string;
+    record: string | null;
+    winner: boolean;
+}
+interface UFCData {
+    currentRound: number;
+    totalRounds: number;
+    clock: string;
+    fightState: 'pre' | 'in' | 'post';
+    statusDetail: string;
+    statusShortDetail?: string;
+}
+interface UFCFight {
+    id: string | null;
+    home: UFCFighter;
+    away: UFCFighter;
+    weightClass: string | null;
+    status: string;
+    ufcData: UFCData | null;
+}
+interface UFCEvent {
+    eventName: string;
+    date: string | null;
+    fights: UFCFight[];
+}
+interface UFCFightCardResponse {
+    success: boolean;
+    events: UFCEvent[];
+}
+
+declare class AuthResource extends BaseResource {
+    getNonce(walletAddress: string): Promise<NonceResponse>;
+    authenticate(params: AuthenticateParams): Promise<AuthenticateResponse>;
+    register(params: RegisterParams): Promise<RegisterResponse>;
+    me(userToken: string): Promise<MeResponse>;
+    logout(userToken: string): Promise<void>;
+    checkUsername(username: string): Promise<CheckUsernameResponse>;
+}
+
+declare class UsersResource extends BaseResource {
+    get(walletAddress: string): Promise<UserResponse>;
+    list(params?: UsersListParams): Promise<UsersListResponse>;
+}
+
+declare class EventsResource extends BaseResource {
+    upcoming(params?: UpcomingEventsParams): Promise<EventsResponse>;
+    sports(league: string): Promise<EventsResponse>;
+    esports(params?: EsportsParams): Promise<EventsResponse>;
+    esportsMatch(matchId: string): Promise<EsportsMatchResponse>;
+}
+
+declare class GamesResource extends BaseResource {
+    validate(eventId: string): Promise<ValidateResponse>;
+    create(params: GameCreateParams): Promise<GameCreateResponse>;
+    join(params: GameJoinParams): Promise<GameJoinResponse>;
+    confirm(params: GameConfirmParams): Promise<GameConfirmResponse>;
+    get(gameId: string): Promise<{
+        game: Game;
+    }>;
+    list(params?: GameListParams): Promise<GameListResponse>;
+    network(params?: NetworkGamesParams): Promise<NetworkGamesResponse>;
+    liveScore(gameId: string): Promise<LiveScoreResponse>;
+    customCreate(params: CustomGameCreateParams): Promise<CustomGameCreateResponse>;
+    customConfirm(params: CustomGameConfirmParams): Promise<CustomGameConfirmResponse>;
+}
+
+declare class TransactionsResource extends BaseResource {
+    buildClaim(params: BuildClaimParams): Promise<BuildClaimResponse>;
+}
+
+declare class UFCResource extends BaseResource {
+    fightCard(): Promise<UFCFightCardResponse>;
+}
 
 declare class Dubs {
     private readonly apiKey;
     private readonly resolutionSecret?;
     private readonly baseUrl;
+    readonly auth: AuthResource;
+    readonly users: UsersResource;
+    readonly events: EventsResource;
+    readonly games: GamesResource;
+    readonly transactions: TransactionsResource;
+    readonly ufc: UFCResource;
     constructor(config: DubsConfig);
+    /**
+     * Fetch the platform configuration.
+     */
+    config(): Promise<AppConfigResponse>;
     /**
      * Resolve a custom game (game_mode=6).
      *
@@ -67,4 +341,4 @@ declare class DubsApiError extends Error {
     constructor(code: string, message: string, httpStatus: number);
 }
 
-export { DEFAULT_BASE_URL, Dubs, DubsApiError, type DubsConfig, type DubsNetwork, NETWORK_CONFIG, type ResolveGameParams, type ResolveGameResult, type WebhookEvent };
+export { type AppConfigResponse, AuthResource, type AuthenticateParams, type AuthenticateResponse, type BuildClaimParams, type BuildClaimResponse, type CheckUsernameResponse, type CustomGameConfirmParams, type CustomGameConfirmResponse, type CustomGameCreateParams, type CustomGameCreateResponse, DEFAULT_BASE_URL, Dubs, DubsApiError, type DubsConfig, type DubsNetwork, type EsportsMatchResponse, type EsportsParams, type Event, EventsResource, type EventsResponse, type Game, type GameConfirmParams, type GameConfirmResponse, type GameCreateParams, type GameCreateResponse, type GameJoinParams, type GameJoinResponse, type GameListParams, type GameListResponse, GamesResource, type LiveScoreResponse, type MeResponse, NETWORK_CONFIG, type NetworkGamesParams, type NetworkGamesResponse, type NonceParams, type NonceResponse, type RegisterParams, type RegisterResponse, type RequestFn, type ResolveGameParams, type ResolveGameResult, TransactionsResource, type UFCData, type UFCEvent, type UFCFight, type UFCFightCardResponse, type UFCFighter, UFCResource, type UpcomingEventsParams, type User, type UserResponse, type UsersListParams, type UsersListResponse, UsersResource, type ValidateParams, type ValidateResponse, type WebhookEvent };