@dubsdotapp/expo 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,577 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React from 'react';
+import { PublicKey, Transaction, Connection, TransactionConfirmationStatus } from '@solana/web3.js';
+
+interface Opponent {
+    name: string | null;
+    imageUrl: string | null;
+    score: number | null;
+}
+interface EventMedia {
+    poster: string | null;
+    thumbnail: string | null;
+    streams: EventStream[];
+}
+interface EventStream {
+    url: string | null;
+    language: string | null;
+}
+interface EventMeta {
+    matchType: string | null;
+    numberOfGames: number | null;
+    tournament: string | null;
+    country: string | null;
+}
+interface UnifiedEvent {
+    id: string;
+    type: 'sports' | 'esports';
+    title: string;
+    league: string | null;
+    game: string | null;
+    startTime: string | null;
+    status: 'upcoming' | 'live' | 'finished' | 'canceled';
+    tier: string | null;
+    venue: string | null;
+    opponents: Opponent[];
+    media: EventMedia;
+    meta: EventMeta;
+}
+interface Pagination {
+    page: number;
+    perPage: number;
+    total: number;
+    totalPages: number;
+}
+interface EsportsMatchOpponent {
+    id: number;
+    name: string;
+    acronym: string | null;
+    imageUrl: string | null;
+}
+interface EsportsMatchResult {
+    teamId: number;
+    score: number;
+}
+interface EsportsMatchDetail {
+    matchId: number;
+    title: string;
+    status: string;
+    videogame: string | null;
+    league: string | null;
+    serie: string | null;
+    tournament: string | null;
+    tier: string | null;
+    startTime: string | null;
+    endTime: string | null;
+    matchType: string | null;
+    numberOfGames: number | null;
+    opponents: EsportsMatchOpponent[];
+    results: EsportsMatchResult[];
+    winnerId: number | null;
+}
+interface ValidateEventResult {
+    bettable: boolean;
+    gameMode: number;
+    lockTimestamp: number;
+    startTime: string | null;
+    status: string;
+}
+interface CreateGameParams {
+    id: string;
+    playerWallet: string;
+    teamChoice: 'home' | 'away' | 'draw';
+    wagerAmount: number;
+}
+interface CreateGameResult {
+    gameId: string;
+    gameAddress: string;
+    transaction: string;
+    lockTimestamp: number;
+    event: UnifiedEvent;
+}
+interface JoinGameParams {
+    playerWallet: string;
+    gameId: string;
+    teamChoice: 'home' | 'away' | 'draw';
+    amount: number;
+}
+interface JoinGameResult {
+    gameId: string;
+    transaction: string;
+    gameAddress: string;
+}
+interface ConfirmGameParams {
+    gameId: string;
+    playerWallet: string;
+    signature: string;
+    teamChoice?: 'home' | 'away' | 'draw';
+    wagerAmount?: number;
+    role?: 'creator' | 'joiner';
+    gameAddress?: string;
+}
+interface ConfirmGameResult {
+    gameId: string;
+    signature: string;
+    explorerUrl: string;
+    message: string;
+}
+interface BuildClaimParams {
+    playerWallet: string;
+    gameId: string;
+}
+interface BuildClaimResult {
+    transaction: string;
+    gameAddress: string;
+    message: string;
+}
+interface GameMedia {
+    poster: string | null;
+    thumbnail: string | null;
+}
+interface GameDetail {
+    gameId: string;
+    gameAddress: string;
+    title: string;
+    buyIn: number;
+    gameMode: number;
+    isLocked: boolean;
+    isResolved: boolean;
+    status: string;
+    lockTimestamp: number | null;
+    homePlayers: string[];
+    awayPlayers: string[];
+    drawPlayers: string[];
+    homePool: number;
+    awayPool: number;
+    drawPool: number;
+    totalPool: number;
+    sportsEvent: Record<string, unknown> | null;
+    media: GameMedia;
+    createdAt: string;
+    updatedAt: string;
+}
+interface GameListOpponent {
+    name: string | null;
+    imageUrl: string | null;
+}
+interface GameListItem {
+    gameId: string;
+    title: string;
+    buyIn: number;
+    gameMode: number;
+    isLocked: boolean;
+    isResolved: boolean;
+    status: string;
+    totalPool: number;
+    league: string | null;
+    lockTimestamp: number | null;
+    createdAt: string;
+    opponents: GameListOpponent[];
+    media: GameMedia;
+}
+interface GetGamesParams {
+    wallet?: string;
+    status?: 'open' | 'locked' | 'resolved';
+    limit?: number;
+    offset?: number;
+}
+interface GetNetworkGamesParams {
+    league?: string;
+    limit?: number;
+    offset?: number;
+}
+interface GetUpcomingEventsParams {
+    type?: 'sports' | 'esports';
+    game?: string;
+    page?: number;
+    per_page?: number;
+}
+interface ParsedError {
+    code: string;
+    message: string;
+}
+interface SolanaErrorCode {
+    code: string;
+    message: string;
+}
+interface DubsUser {
+    walletAddress: string;
+    username: string;
+    avatar: string | null;
+    myReferralCode: string | null;
+    onboardingComplete: boolean;
+    createdAt: string;
+}
+interface DubsPublicUser {
+    walletAddress: string;
+    username: string;
+    avatar: string | null;
+    createdAt: string;
+}
+interface DubsAppUser extends DubsPublicUser {
+    firstSeenAt: string;
+    lastSeenAt: string;
+}
+interface NonceResult {
+    nonce: string;
+    message: string;
+}
+interface AuthenticateParams {
+    walletAddress: string;
+    signature: string;
+    nonce: string;
+}
+interface AuthenticateResult {
+    needsRegistration: boolean;
+    user?: DubsUser;
+    token?: string;
+}
+interface RegisterParams {
+    walletAddress: string;
+    signature: string;
+    nonce: string;
+    username: string;
+    referralCode?: string;
+}
+interface RegisterResult {
+    user: DubsUser;
+    token: string;
+}
+interface CheckUsernameResult {
+    available: boolean;
+    reason?: string;
+}
+type AuthStatus = 'idle' | 'authenticating' | 'signing' | 'verifying' | 'needsRegistration' | 'registering' | 'authenticated' | 'error';
+type MutationStatus = 'idle' | 'building' | 'signing' | 'confirming' | 'saving' | 'success' | 'error';
+interface QueryResult<T> {
+    data: T | null;
+    loading: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+interface MutationResult<TParams, TResult> {
+    execute: (params: TParams) => Promise<TResult>;
+    status: MutationStatus;
+    error: Error | null;
+    data: TResult | null;
+    reset: () => void;
+}
+
+interface DubsClientConfig {
+    apiKey: string;
+    baseUrl?: string;
+}
+declare class DubsClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private _token;
+    constructor(config: DubsClientConfig);
+    /** Set the user JWT token for authenticated requests */
+    setToken(token: string | null): void;
+    /** Get the current user JWT token */
+    getToken(): string | null;
+    private request;
+    getUpcomingEvents(params?: GetUpcomingEventsParams): Promise<{
+        events: UnifiedEvent[];
+        pagination: Pagination;
+    }>;
+    getSportsEvents(league: string): Promise<UnifiedEvent[]>;
+    getEsportsMatches(videogame?: string): Promise<UnifiedEvent[]>;
+    getEsportsMatchDetail(matchId: string | number): Promise<EsportsMatchDetail>;
+    validateEvent(id: string): Promise<ValidateEventResult>;
+    createGame(params: CreateGameParams): Promise<CreateGameResult>;
+    joinGame(params: JoinGameParams): Promise<JoinGameResult>;
+    confirmGame(params: ConfirmGameParams): Promise<ConfirmGameResult>;
+    buildClaimTransaction(params: BuildClaimParams): Promise<BuildClaimResult>;
+    getGame(gameId: string): Promise<GameDetail>;
+    getGames(params?: GetGamesParams): Promise<GameListItem[]>;
+    getNetworkGames(params?: GetNetworkGamesParams): Promise<{
+        games: GameListItem[];
+        pagination: Pagination;
+    }>;
+    getNonce(walletAddress: string): Promise<NonceResult>;
+    authenticate(params: AuthenticateParams): Promise<AuthenticateResult>;
+    register(params: RegisterParams): Promise<RegisterResult>;
+    getMe(): Promise<DubsUser>;
+    getUser(walletAddress: string): Promise<DubsPublicUser | null>;
+    getAppUsers(params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        users: DubsAppUser[];
+        pagination: {
+            total: number;
+            limit: number;
+            offset: number;
+        };
+    }>;
+    checkUsername(username: string): Promise<CheckUsernameResult>;
+    logout(): Promise<void>;
+    parseError(error: unknown): Promise<ParsedError>;
+    getErrorCodes(): Promise<Record<number, SolanaErrorCode>>;
+    /**
+     * Parse a Solana error locally without an API call.
+     * Useful for instant feedback in the UI.
+     */
+    parseErrorLocal(error: unknown): ParsedError;
+    /** Get the full local error code map */
+    getErrorCodesLocal(): Record<number, SolanaErrorCode>;
+}
+
+declare class DubsApiError extends Error {
+    readonly code: string;
+    readonly httpStatus: number;
+    constructor(code: string, message: string, httpStatus: number);
+}
+/** Custom error codes from dubs_solana_program (6000-6049) */
+declare const SOLANA_PROGRAM_ERRORS: Record<number, SolanaErrorCode>;
+/**
+ * Parse a raw Solana transaction error into a human-readable { code, message }.
+ * Handles: { InstructionError: [idx, { Custom: N }] }, string errors, etc.
+ */
+declare function parseSolanaError(err: unknown): ParsedError;
+
+declare const DEFAULT_BASE_URL = "https://dubs-server-prod-9c91d3f01199.herokuapp.com/api/developer/v1";
+declare const DEFAULT_RPC_URL = "https://api.mainnet-beta.solana.com";
+
+/**
+ * Minimal wallet adapter interface.
+ * Two required methods: publicKey + signTransaction.
+ * signAndSendTransaction is optional — if not provided, the SDK signs then sends via RPC.
+ */
+interface WalletAdapter {
+    /** The connected wallet's public key, or null if not connected */
+    publicKey: PublicKey | null;
+    /** Whether the wallet is currently connected */
+    connected: boolean;
+    /** Sign a transaction without sending it */
+    signTransaction(transaction: Transaction): Promise<Transaction>;
+    /**
+     * Optional: Sign and send in one step.
+     * If provided, the SDK will prefer this over signTransaction + sendRawTransaction.
+     * Returns the transaction signature.
+     */
+    signAndSendTransaction?(transaction: Transaction): Promise<string>;
+    /**
+     * Optional: Sign an arbitrary message (for authentication).
+     * Returns the signature as a Uint8Array.
+     */
+    signMessage?(message: Uint8Array): Promise<Uint8Array>;
+}
+
+interface DubsContextValue {
+    client: DubsClient;
+    wallet: WalletAdapter;
+    connection: Connection;
+}
+interface DubsProviderProps {
+    apiKey: string;
+    baseUrl?: string;
+    rpcUrl?: string;
+    wallet: WalletAdapter;
+    children: React.ReactNode;
+}
+declare function DubsProvider({ apiKey, baseUrl, rpcUrl, wallet, children }: DubsProviderProps): react_jsx_runtime.JSX.Element;
+declare function useDubs(): DubsContextValue;
+
+/** The `transact` function signature from @solana-mobile/mobile-wallet-adapter-protocol-web3js */
+type MwaTransactFn = (callback: (wallet: any) => Promise<any>) => Promise<any>;
+interface MwaAdapterConfig {
+    /** The MWA `transact` function — import it from @solana-mobile/mobile-wallet-adapter-protocol-web3js */
+    transact: MwaTransactFn;
+    appIdentity: {
+        name: string;
+        uri?: string;
+        icon?: string;
+    };
+    cluster?: string;
+    onAuthTokenChange?: (token: string | null) => void;
+}
+/**
+ * Mobile Wallet Adapter implementation.
+ * Wraps @solana-mobile/mobile-wallet-adapter-protocol-web3js.
+ *
+ * Usage:
+ * ```ts
+ * import { transact } from '@solana-mobile/mobile-wallet-adapter-protocol-web3js';
+ *
+ * const adapter = new MwaWalletAdapter({
+ *   transact,
+ *   appIdentity: { name: 'My App' },
+ * });
+ * ```
+ */
+declare class MwaWalletAdapter implements WalletAdapter {
+    private _publicKey;
+    private _connected;
+    private _authToken;
+    private readonly config;
+    private readonly transact;
+    constructor(config: MwaAdapterConfig);
+    get publicKey(): PublicKey | null;
+    get connected(): boolean;
+    /**
+     * Connect to a mobile wallet. Call this before any signing.
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect and clear auth token.
+     */
+    disconnect(): void;
+    signTransaction(transaction: Transaction): Promise<Transaction>;
+    signMessage(message: Uint8Array): Promise<Uint8Array>;
+    signAndSendTransaction(transaction: Transaction): Promise<string>;
+}
+
+declare function useEvents(params?: GetUpcomingEventsParams): QueryResult<{
+    events: UnifiedEvent[];
+    pagination: Pagination;
+}>;
+
+declare function useGame(gameId: string | null): QueryResult<GameDetail>;
+
+declare function useGames(params?: GetGamesParams): QueryResult<GameListItem[]>;
+
+declare function useNetworkGames(params?: GetNetworkGamesParams): QueryResult<{
+    games: GameListItem[];
+    pagination: Pagination;
+}>;
+
+interface CreateGameMutationResult {
+    gameId: string;
+    gameAddress: string;
+    signature: string;
+    explorerUrl: string;
+}
+declare function useCreateGame(): {
+    execute: (params: CreateGameParams) => Promise<CreateGameMutationResult>;
+    status: MutationStatus;
+    error: Error | null;
+    data: CreateGameMutationResult | null;
+    reset: () => void;
+};
+
+interface JoinGameMutationResult {
+    gameId: string;
+    gameAddress: string;
+    signature: string;
+    explorerUrl: string;
+}
+declare function useJoinGame(): {
+    execute: (params: JoinGameParams) => Promise<JoinGameMutationResult>;
+    status: MutationStatus;
+    error: Error | null;
+    data: JoinGameMutationResult | null;
+    reset: () => void;
+};
+
+interface ClaimMutationResult {
+    gameId: string;
+    signature: string;
+    explorerUrl: string;
+}
+declare function useClaim(): {
+    execute: (params: BuildClaimParams) => Promise<ClaimMutationResult>;
+    status: MutationStatus;
+    error: Error | null;
+    data: ClaimMutationResult | null;
+    reset: () => void;
+};
+
+interface UseAuthResult {
+    /** Current auth status */
+    status: AuthStatus;
+    /** Authenticated user profile, or null */
+    user: DubsUser | null;
+    /** JWT token, or null */
+    token: string | null;
+    /** Convenience boolean */
+    isAuthenticated: boolean;
+    /** Error from the last operation, or null */
+    error: Error | null;
+    /**
+     * Full nonce → sign → verify flow.
+     * If the wallet is already registered, resolves to authenticated state.
+     * If new wallet, resolves to needsRegistration state — call register() next.
+     */
+    authenticate: () => Promise<void>;
+    /**
+     * Register a new user after authenticate() returned needsRegistration.
+     * Reuses the nonce+signature from authenticate() — no second signing prompt.
+     */
+    register: (username: string, referralCode?: string) => Promise<void>;
+    /** Log out and clear state */
+    logout: () => Promise<void>;
+    /**
+     * Restore a session from a saved token (e.g. AsyncStorage on app restart).
+     * Calls GET /auth/me to validate. Returns true if valid, false otherwise.
+     */
+    restoreSession: (token: string) => Promise<boolean>;
+    /** Reset to idle state, clearing errors and user */
+    reset: () => void;
+}
+declare function useAuth(): UseAuthResult;
+
+interface ConnectWalletScreenProps {
+    /** Called when the user taps Connect Wallet */
+    onConnect: () => void | Promise<void>;
+    /** Show a loading spinner on the button while connecting */
+    connecting?: boolean;
+    /** Error message to display (e.g. "User rejected the request") */
+    error?: string | null;
+    /** App name shown in the header. Defaults to "Dubs" */
+    appName?: string;
+}
+declare function ConnectWalletScreen({ onConnect, connecting, error, appName, }: ConnectWalletScreenProps): react_jsx_runtime.JSX.Element;
+
+interface UserProfileCardProps {
+    walletAddress: string;
+    username?: string;
+    avatarUrl?: string | null;
+    memberSince?: string | null;
+}
+declare function UserProfileCard({ walletAddress, username, avatarUrl, memberSince, }: UserProfileCardProps): react_jsx_runtime.JSX.Element;
+
+interface SettingsSheetProps {
+    walletAddress: string;
+    username?: string;
+    avatarUrl?: string | null;
+    memberSince?: string | null;
+    appVersion?: string;
+    onCopyAddress?: () => void;
+    onSupport?: () => void;
+    onLogout: () => void | Promise<void>;
+    loggingOut?: boolean;
+}
+declare function SettingsSheet({ walletAddress, username, avatarUrl, memberSince, appVersion, onCopyAddress, onSupport, onLogout, loggingOut, }: SettingsSheetProps): react_jsx_runtime.JSX.Element;
+
+interface DubsTheme {
+    background: string;
+    surface: string;
+    surfaceActive: string;
+    border: string;
+    text: string;
+    textSecondary: string;
+    textMuted: string;
+    textDim: string;
+    accent: string;
+    success: string;
+    live: string;
+    errorText: string;
+    errorBg: string;
+    errorBorder: string;
+}
+declare function useDubsTheme(): DubsTheme;
+
+/**
+ * Deserialize a base64-encoded transaction, sign via wallet adapter, send to Solana.
+ * Returns the transaction signature.
+ */
+declare function signAndSendBase64Transaction(base64Tx: string, wallet: WalletAdapter, connection: Connection): Promise<string>;
+/**
+ * Poll for transaction confirmation using getSignatureStatuses.
+ * Uses polling instead of deprecated WebSocket-based confirmTransaction.
+ */
+declare function pollTransactionConfirmation(signature: string, connection: Connection, commitment?: TransactionConfirmationStatus, timeout?: number, interval?: number): Promise<void>;
+
+export { type AuthStatus, type AuthenticateParams, type AuthenticateResult, type BuildClaimParams, type BuildClaimResult, type CheckUsernameResult, type ClaimMutationResult, type ConfirmGameParams, type ConfirmGameResult, ConnectWalletScreen, type ConnectWalletScreenProps, type CreateGameMutationResult, type CreateGameParams, type CreateGameResult, DEFAULT_BASE_URL, DEFAULT_RPC_URL, DubsApiError, type DubsAppUser, DubsClient, type DubsClientConfig, type DubsContextValue, DubsProvider, type DubsProviderProps, type DubsPublicUser, type DubsTheme, type DubsUser, type EsportsMatchDetail, type EsportsMatchOpponent, type EsportsMatchResult, type EventMedia, type EventMeta, type EventStream, type GameDetail, type GameListItem, type GameListOpponent, type GameMedia, type GetGamesParams, type GetNetworkGamesParams, type GetUpcomingEventsParams, type JoinGameMutationResult, type JoinGameParams, type JoinGameResult, type MutationResult, type MutationStatus, type MwaAdapterConfig, type MwaTransactFn, MwaWalletAdapter, type NonceResult, type Opponent, type Pagination, type ParsedError, type QueryResult, type RegisterParams, type RegisterResult, SOLANA_PROGRAM_ERRORS, SettingsSheet, type SettingsSheetProps, type SolanaErrorCode, type UnifiedEvent, type UseAuthResult, UserProfileCard, type UserProfileCardProps, type ValidateEventResult, type WalletAdapter, parseSolanaError, pollTransactionConfirmation, signAndSendBase64Transaction, useAuth, useClaim, useCreateGame, useDubs, useDubsTheme, useEvents, useGame, useGames, useJoinGame, useNetworkGames };