@provable-games/budokan-sdk 0.1.0 → 0.1.1

package/dist/react.js

@@ -0,0 +1,2760 @@
+import { createContext, useMemo, useRef, useEffect, useContext, useState, useCallback } from 'react';
+import { num } from 'starknet';
+import { jsx } from 'react/jsx-runtime';
+
+// src/react/context.tsx
+
+// src/errors/index.ts
+var BudokanError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BudokanError";
+  }
+};
+var BudokanApiError = class extends BudokanError {
+  status;
+  statusText;
+  constructor(message, status, statusText = "") {
+    super(message);
+    this.name = "BudokanApiError";
+    this.status = status;
+    this.statusText = statusText;
+  }
+};
+var BudokanTimeoutError = class extends BudokanError {
+  constructor(message = "Request timed out") {
+    super(message);
+    this.name = "BudokanTimeoutError";
+  }
+};
+var BudokanConnectionError = class extends BudokanError {
+  constructor(message = "Connection failed") {
+    super(message);
+    this.name = "BudokanConnectionError";
+  }
+};
+var TournamentNotFoundError = class extends BudokanError {
+  tournamentId;
+  constructor(tournamentId) {
+    super(`Tournament not found: ${tournamentId}`);
+    this.name = "TournamentNotFoundError";
+    this.tournamentId = tournamentId;
+  }
+};
+var RpcError = class extends BudokanError {
+  contractAddress;
+  constructor(message, contractAddress) {
+    super(message);
+    this.name = "RpcError";
+    this.contractAddress = contractAddress;
+  }
+};
+var DataSourceError = class extends BudokanError {
+  primaryError;
+  fallbackError;
+  constructor(primaryError, fallbackError) {
+    super(`Both data sources failed. Primary: ${primaryError.message}. Fallback: ${fallbackError.message}`);
+    this.name = "DataSourceError";
+    this.primaryError = primaryError;
+    this.fallbackError = fallbackError;
+  }
+};
+function isNonRetryableError(error) {
+  if (error instanceof TournamentNotFoundError) return true;
+  if (error instanceof BudokanApiError && error.status >= 400 && error.status < 500 && error.status !== 429) {
+    return true;
+  }
+  return false;
+}
+
+// src/utils/retry.ts
+function calculateBackoff(attempt, baseDelay, maxDelay) {
+  let delay = baseDelay * Math.pow(2, attempt);
+  if (delay > maxDelay) delay = maxDelay;
+  const minDelay = delay / 2;
+  const jitter = Math.random() * (delay - minDelay);
+  return minDelay + jitter;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withRetry(fn, attempts = 3, delay = 1e3) {
+  let lastError = null;
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (isNonRetryableError(error)) {
+        throw error;
+      }
+      if (attempt === attempts - 1) break;
+      const backoff = calculateBackoff(attempt, delay, delay * 8);
+      await sleep(backoff);
+    }
+  }
+  throw lastError ?? new BudokanTimeoutError("Unknown error after retries");
+}
+
+// src/api/base.ts
+var DEFAULT_TIMEOUT = 1e4;
+var DEFAULT_RETRY_ATTEMPTS = 3;
+var DEFAULT_RETRY_DELAY = 1e3;
+async function apiFetch(url, options = {}) {
+  const {
+    method = "GET",
+    headers = {},
+    body,
+    signal,
+    timeout = DEFAULT_TIMEOUT,
+    retryAttempts = DEFAULT_RETRY_ATTEMPTS,
+    retryDelay = DEFAULT_RETRY_DELAY
+  } = options;
+  return withRetry(
+    async () => {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      if (signal) {
+        if (signal.aborted) {
+          clearTimeout(timeoutId);
+          throw new BudokanTimeoutError("Request was aborted");
+        }
+        signal.addEventListener("abort", () => controller.abort(), { once: true });
+      }
+      try {
+        const response = await fetch(url, {
+          method,
+          headers: {
+            "Content-Type": "application/json",
+            ...headers
+          },
+          body: body ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          const errorBody = await response.json().catch(() => ({}));
+          throw new BudokanApiError(
+            errorBody.error ?? `API error: ${response.status}`,
+            response.status,
+            response.statusText
+          );
+        }
+        return await response.json();
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof BudokanApiError) {
+          throw error;
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          if (signal?.aborted) throw new BudokanTimeoutError("Request was aborted");
+          throw new BudokanTimeoutError();
+        }
+        throw new BudokanConnectionError(
+          error instanceof Error ? error.message : "Connection failed"
+        );
+      }
+    },
+    retryAttempts,
+    retryDelay
+  );
+}
+function extractPagination(result, defaults) {
+  const pagination = result.pagination;
+  return {
+    total: pagination?.total ?? result.total,
+    limit: pagination?.limit ?? result.limit ?? defaults?.limit ?? 50,
+    offset: pagination?.offset ?? result.offset ?? defaults?.offset ?? 0
+  };
+}
+function buildQueryString(params) {
+  const qs = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== null) {
+      qs.set(key, String(value));
+    }
+  }
+  const str = qs.toString();
+  return str ? `?${str}` : "";
+}
+
+// src/utils/mappers.ts
+function toCamelCase(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function snakeToCamel(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map((item) => snakeToCamel(item));
+  }
+  if (obj !== null && typeof obj === "object" && !(obj instanceof Date)) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[toCamelCase(key)] = snakeToCamel(value);
+    }
+    return result;
+  }
+  return obj;
+}
+
+// src/api/tournaments.ts
+function normalizeTournament(raw) {
+  const t = snakeToCamel(raw);
+  if (t.id && !t.tournamentId) {
+    t.tournamentId = t.id;
+  } else if (t.tournamentId && !t.id) {
+    t.id = t.tournamentId;
+  }
+  return t;
+}
+function fetchOpts(ctx) {
+  return {
+    retryAttempts: ctx?.retryAttempts,
+    retryDelay: ctx?.retryDelay,
+    timeout: ctx?.timeout
+  };
+}
+async function getTournaments(baseUrl, params, ctx) {
+  const qs = buildQueryString({
+    game_address: params?.gameAddress,
+    creator: params?.creator,
+    phase: params?.phase,
+    limit: params?.limit,
+    offset: params?.offset,
+    sort: params?.sort,
+    from_id: params?.fromId,
+    exclude_ids: params?.excludeIds?.join(","),
+    whitelisted_extensions: params?.whitelistedExtensions?.join(","),
+    include_prizes: params?.includePrizeSummary
+  });
+  const result = await apiFetch(`${baseUrl}/tournaments${qs}`, fetchOpts(ctx));
+  const { total, limit: resLimit, offset: resOffset } = extractPagination(result, { limit: params?.limit, offset: params?.offset });
+  return {
+    data: result.data.map((item) => normalizeTournament(item)),
+    total,
+    limit: resLimit,
+    offset: resOffset
+  };
+}
+async function getTournament(baseUrl, tournamentId, ctx) {
+  const result = await apiFetch(
+    `${baseUrl}/tournaments/${tournamentId}`,
+    fetchOpts(ctx)
+  );
+  return normalizeTournament(result.data);
+}
+async function getTournamentLeaderboard(baseUrl, tournamentId, ctx) {
+  const result = await apiFetch(
+    `${baseUrl}/tournaments/${tournamentId}/leaderboard`,
+    fetchOpts(ctx)
+  );
+  return result.data.map((item) => snakeToCamel(item));
+}
+async function getTournamentRegistrations(baseUrl, tournamentId, params, ctx) {
+  const qs = buildQueryString({
+    limit: params?.limit,
+    offset: params?.offset
+  });
+  const result = await apiFetch(`${baseUrl}/tournaments/${tournamentId}/registrations${qs}`, fetchOpts(ctx));
+  const { total, limit: resLimit, offset: resOffset } = extractPagination(result, { limit: params?.limit, offset: params?.offset });
+  return {
+    data: result.data.map((item) => snakeToCamel(item)),
+    total,
+    limit: resLimit,
+    offset: resOffset
+  };
+}
+async function getTournamentPrizes(baseUrl, tournamentId, ctx) {
+  const result = await apiFetch(
+    `${baseUrl}/tournaments/${tournamentId}/prizes`,
+    fetchOpts(ctx)
+  );
+  return result.data.map((item) => snakeToCamel(item));
+}
+async function getTournamentRewardClaims(baseUrl, tournamentId, params, ctx) {
+  const qs = buildQueryString({
+    limit: params?.limit,
+    offset: params?.offset
+  });
+  const result = await apiFetch(`${baseUrl}/tournaments/${tournamentId}/reward-claims${qs}`, fetchOpts(ctx));
+  const { total, limit: resLimit, offset: resOffset } = extractPagination(result, { limit: params?.limit, offset: params?.offset });
+  return {
+    data: result.data.map((item) => snakeToCamel(item)),
+    total,
+    limit: resLimit,
+    offset: resOffset
+  };
+}
+async function getTournamentRewardClaimsSummary(baseUrl, tournamentId, ctx) {
+  const result = await apiFetch(
+    `${baseUrl}/tournaments/${tournamentId}/reward-claims/summary`,
+    fetchOpts(ctx)
+  );
+  return snakeToCamel(result.data);
+}
+async function getTournamentQualifications(baseUrl, tournamentId, params, ctx) {
+  const qs = buildQueryString({
+    limit: params?.limit,
+    offset: params?.offset
+  });
+  const result = await apiFetch(`${baseUrl}/tournaments/${tournamentId}/qualifications${qs}`, fetchOpts(ctx));
+  const { total, limit: resLimit, offset: resOffset } = extractPagination(result, { limit: params?.limit, offset: params?.offset });
+  return {
+    data: result.data.map((item) => snakeToCamel(item)),
+    total,
+    limit: resLimit,
+    offset: resOffset
+  };
+}
+async function getTournamentPrizeAggregation(baseUrl, tournamentId, ctx) {
+  const qs = buildQueryString({ include_aggregation: true });
+  const result = await apiFetch(
+    `${baseUrl}/tournaments/${tournamentId}/prizes${qs}`,
+    fetchOpts(ctx)
+  );
+  return result.data.map((item) => snakeToCamel(item));
+}
+
+// src/utils/address.ts
+function normalizeAddress(address) {
+  const stripped = address.replace(/^0x0*/i, "");
+  return ("0x" + stripped.padStart(64, "0")).toLowerCase();
+}
+
+// src/api/players.ts
+function fetchOpts2(ctx) {
+  return {
+    retryAttempts: ctx?.retryAttempts,
+    retryDelay: ctx?.retryDelay,
+    timeout: ctx?.timeout
+  };
+}
+async function getPlayerTournaments(baseUrl, address, params, ctx) {
+  const normalized = normalizeAddress(address);
+  const qs = buildQueryString({
+    limit: params?.limit,
+    offset: params?.offset,
+    phase: params?.phase,
+    game_token_ids: params?.gameTokenIds?.join(",")
+  });
+  const result = await apiFetch(`${baseUrl}/players/${normalized}/tournaments${qs}`, fetchOpts2(ctx));
+  return {
+    data: result.data.map((item) => snakeToCamel(item)),
+    total: result.pagination?.total ?? result.total,
+    limit: result.pagination?.limit ?? result.limit,
+    offset: result.pagination?.offset ?? result.offset
+  };
+}
+async function getPlayerStats(baseUrl, address, ctx) {
+  const normalized = normalizeAddress(address);
+  const result = await apiFetch(
+    `${baseUrl}/players/${normalized}/stats`,
+    fetchOpts2(ctx)
+  );
+  return snakeToCamel(result.data);
+}
+
+// src/api/games.ts
+function fetchOpts3(ctx) {
+  return {
+    retryAttempts: ctx?.retryAttempts,
+    retryDelay: ctx?.retryDelay,
+    timeout: ctx?.timeout
+  };
+}
+async function getGameTournaments(baseUrl, gameAddress, params, ctx) {
+  const normalized = normalizeAddress(gameAddress);
+  const qs = buildQueryString({
+    creator: params?.creator,
+    phase: params?.phase,
+    limit: params?.limit,
+    offset: params?.offset
+  });
+  const result = await apiFetch(`${baseUrl}/games/${normalized}/tournaments${qs}`, fetchOpts3(ctx));
+  return {
+    data: result.data.map((item) => snakeToCamel(item)),
+    total: result.pagination?.total ?? result.total,
+    limit: result.pagination?.limit ?? result.limit,
+    offset: result.pagination?.offset ?? result.offset
+  };
+}
+async function getGameStats(baseUrl, gameAddress, ctx) {
+  const normalized = normalizeAddress(gameAddress);
+  const result = await apiFetch(
+    `${baseUrl}/games/${normalized}/stats`,
+    fetchOpts3(ctx)
+  );
+  return snakeToCamel(result.data);
+}
+
+// src/api/activity.ts
+function fetchOpts4(ctx) {
+  return {
+    retryAttempts: ctx?.retryAttempts,
+    retryDelay: ctx?.retryDelay,
+    timeout: ctx?.timeout
+  };
+}
+async function getActivity(baseUrl, params, ctx) {
+  const qs = buildQueryString({
+    event_type: params?.eventType,
+    tournament_id: params?.tournamentId,
+    player_address: params?.playerAddress,
+    limit: params?.limit,
+    offset: params?.offset
+  });
+  const result = await apiFetch(`${baseUrl}/activity${qs}`, fetchOpts4(ctx));
+  return {
+    data: result.data.map((item) => snakeToCamel(item)),
+    total: result.pagination?.total ?? result.total,
+    limit: result.pagination?.limit ?? result.limit,
+    offset: result.pagination?.offset ?? result.offset
+  };
+}
+async function getActivityStats(baseUrl, ctx) {
+  const result = await apiFetch(
+    `${baseUrl}/activity/stats`,
+    fetchOpts4(ctx)
+  );
+  return snakeToCamel(result.data);
+}
+async function getPrizeStats(baseUrl, ctx) {
+  const result = await apiFetch(
+    `${baseUrl}/activity/prize-stats`,
+    fetchOpts4(ctx)
+  );
+  return snakeToCamel(result.data);
+}
+
+// src/ws/manager.ts
+var DEFAULT_WS_CONFIG = {
+  maxReconnectAttempts: 10,
+  reconnectBaseDelay: 1e3
+};
+var WSManager = class {
+  ws = null;
+  wsUrl;
+  config;
+  reconnectAttempts = 0;
+  reconnectTimeout = null;
+  subscriptions = /* @__PURE__ */ new Map();
+  nextSubId = 1;
+  connected = false;
+  connectionListeners = /* @__PURE__ */ new Set();
+  constructor(wsUrl, config) {
+    this.wsUrl = wsUrl;
+    this.config = { ...DEFAULT_WS_CONFIG, ...config };
+  }
+  /**
+   * Open a WebSocket connection. No-op if already connected.
+   */
+  connect() {
+    if (this.ws) return;
+    try {
+      this.ws = new WebSocket(this.wsUrl);
+      this.ws.onopen = () => {
+        this.connected = true;
+        this.reconnectAttempts = 0;
+        this.notifyConnectionChange(true);
+        for (const [, sub] of this.subscriptions) {
+          this.sendSubscribe(sub.options);
+        }
+      };
+      this.ws.onmessage = (event) => {
+        try {
+          const message = JSON.parse(event.data);
+          if (message.type === "event") {
+            for (const [, sub] of this.subscriptions) {
+              sub.handler(message);
+            }
+          }
+        } catch {
+        }
+      };
+      this.ws.onclose = () => {
+        this.connected = false;
+        this.notifyConnectionChange(false);
+        this.ws = null;
+        this.attemptReconnect();
+      };
+      this.ws.onerror = () => {
+      };
+    } catch {
+      this.attemptReconnect();
+    }
+  }
+  /**
+   * Close the WebSocket connection and stop reconnecting.
+   */
+  disconnect() {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    if (this.ws) {
+      this.ws.onclose = null;
+      this.ws.close();
+      this.ws = null;
+    }
+    this.connected = false;
+    this.notifyConnectionChange(false);
+    this.reconnectAttempts = 0;
+  }
+  /**
+   * Subscribe to channels with an optional tournament filter.
+   * Returns an unsubscribe function.
+   */
+  subscribe(options, handler) {
+    const id = String(this.nextSubId++);
+    this.subscriptions.set(id, { options, handler });
+    if (this.connected) {
+      this.sendSubscribe(options);
+    }
+    return () => {
+      this.subscriptions.delete(id);
+      if (this.connected && this.ws) {
+        this.ws.send(JSON.stringify({
+          type: "unsubscribe",
+          channels: options.channels
+        }));
+      }
+    };
+  }
+  /**
+   * Register a callback for a single message. Convenience wrapper around subscribe.
+   * Returns an unsubscribe function.
+   */
+  onMessage(callback) {
+    const id = String(this.nextSubId++);
+    this.subscriptions.set(id, {
+      options: { channels: [] },
+      handler: callback
+    });
+    return () => {
+      this.subscriptions.delete(id);
+    };
+  }
+  /**
+   * Whether the WebSocket is currently connected.
+   */
+  get isConnected() {
+    return this.connected;
+  }
+  /**
+   * Register a listener for connection state changes.
+   * Returns an unsubscribe function.
+   */
+  onConnectionChange(listener) {
+    this.connectionListeners.add(listener);
+    return () => {
+      this.connectionListeners.delete(listener);
+    };
+  }
+  notifyConnectionChange(isConnected) {
+    for (const listener of this.connectionListeners) {
+      try {
+        listener(isConnected);
+      } catch {
+      }
+    }
+  }
+  sendSubscribe(options) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+    if (options.channels.length === 0) return;
+    this.ws.send(JSON.stringify({
+      type: "subscribe",
+      channels: options.channels,
+      tournamentIds: options.tournamentIds
+    }));
+  }
+  attemptReconnect() {
+    if (this.reconnectAttempts >= this.config.maxReconnectAttempts) return;
+    if (this.subscriptions.size === 0) return;
+    const delay = this.config.reconnectBaseDelay * Math.pow(2, this.reconnectAttempts);
+    this.reconnectAttempts++;
+    this.reconnectTimeout = setTimeout(() => {
+      this.connect();
+    }, Math.min(delay, 3e4));
+  }
+};
+
+// src/chains/constants.ts
+var CHAINS = {
+  mainnet: {
+    rpcUrl: "https://api.cartridge.gg/x/starknet/mainnet/rpc/v0_10",
+    apiBaseUrl: "https://budokan-api-production.up.railway.app",
+    wsUrl: "wss://budokan-api-production.up.railway.app/ws",
+    budokanAddress: "",
+    // TODO: set after mainnet deployment
+    viewerAddress: ""
+    // TODO: set after mainnet deployment
+  },
+  sepolia: {
+    rpcUrl: "https://starknet-sepolia.public.blastapi.io",
+    apiBaseUrl: "https://budokan-api-sepolia.up.railway.app",
+    wsUrl: "wss://budokan-api-sepolia.up.railway.app/ws",
+    budokanAddress: "",
+    // TODO: set after sepolia deployment
+    viewerAddress: ""
+    // TODO: set after sepolia deployment
+  }
+};
+function getChainConfig(chain) {
+  return CHAINS[chain];
+}
+
+// src/datasource/health.ts
+var ConnectionStatus = class {
+  status = {
+    api: { available: true, lastChecked: 0, latency: null, error: null },
+    rpc: { available: true, lastChecked: 0, latency: null, error: null },
+    mode: "api",
+    initialCheckComplete: false
+  };
+  listeners = /* @__PURE__ */ new Set();
+  checkInterval = null;
+  initialCheckTimeout = null;
+  apiUrl;
+  rpcUrl;
+  initialCheckDelay;
+  checkIntervalMs;
+  checkTimeoutMs;
+  constructor(apiUrl, rpcUrl, config) {
+    this.apiUrl = apiUrl;
+    this.rpcUrl = rpcUrl;
+    this.initialCheckDelay = Math.max(config?.initialCheckDelay ?? 1e3, 100);
+    this.checkIntervalMs = Math.max(config?.checkInterval ?? 3e4, 1e3);
+    this.checkTimeoutMs = Math.max(config?.checkTimeout ?? 5e3, 1e3);
+  }
+  getStatus() {
+    return { ...this.status };
+  }
+  get mode() {
+    return this.status.mode;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    listener(this.status);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  startMonitoring() {
+    if (this.checkInterval) return;
+    this.initialCheckTimeout = setTimeout(() => {
+      this.performHealthCheck();
+      this.checkInterval = setInterval(() => this.performHealthCheck(), this.checkIntervalMs);
+    }, this.initialCheckDelay);
+  }
+  stopMonitoring() {
+    if (this.checkInterval) {
+      clearInterval(this.checkInterval);
+      this.checkInterval = null;
+    }
+    if (this.initialCheckTimeout) {
+      clearTimeout(this.initialCheckTimeout);
+      this.initialCheckTimeout = null;
+    }
+  }
+  markApiUnavailable(error) {
+    this.updateStatus({
+      api: { ...this.status.api, available: false, lastChecked: Date.now(), error: error || "Request failed" }
+    });
+  }
+  markRpcUnavailable(error) {
+    this.updateStatus({
+      rpc: { ...this.status.rpc, available: false, lastChecked: Date.now(), error: error || "Request failed" }
+    });
+  }
+  async checkNow() {
+    await this.performHealthCheck();
+  }
+  destroy() {
+    this.stopMonitoring();
+    this.listeners.clear();
+  }
+  async performHealthCheck() {
+    const [apiResult, rpcResult] = await Promise.all([
+      this.checkApi(),
+      this.checkRpc()
+    ]);
+    this.updateStatus({ api: apiResult, rpc: rpcResult, initialCheckComplete: true });
+  }
+  async checkApi() {
+    const startTime = Date.now();
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.checkTimeoutMs);
+      const response = await fetch(`${this.apiUrl}/health`, { signal: controller.signal });
+      clearTimeout(timeoutId);
+      const latency = Date.now() - startTime;
+      if (!response.ok) {
+        return { available: false, lastChecked: Date.now(), latency, error: `HTTP ${response.status}` };
+      }
+      const data = await response.json();
+      const isAvailable = data.status === "healthy" || data.status === "degraded";
+      return { available: isAvailable, lastChecked: Date.now(), latency, error: isAvailable ? null : `API status: ${data.status}` };
+    } catch (error) {
+      return { available: false, lastChecked: Date.now(), latency: null, error: error instanceof Error ? error.message : "Network error" };
+    }
+  }
+  async checkRpc() {
+    const startTime = Date.now();
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.checkTimeoutMs);
+      const response = await fetch(this.rpcUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ jsonrpc: "2.0", method: "starknet_chainId", params: [], id: 1 }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const latency = Date.now() - startTime;
+      if (!response.ok) {
+        return { available: false, lastChecked: Date.now(), latency, error: `HTTP ${response.status}` };
+      }
+      const data = await response.json();
+      const isHealthy = data.result !== void 0 && !data.error;
+      return { available: isHealthy, lastChecked: Date.now(), latency, error: isHealthy ? null : "RPC error" };
+    } catch (error) {
+      return { available: false, lastChecked: Date.now(), latency: null, error: error instanceof Error ? error.message : "Network error" };
+    }
+  }
+  updateStatus(partial) {
+    const newStatus = { ...this.status, ...partial };
+    if (newStatus.api.available) {
+      newStatus.mode = "api";
+    } else if (newStatus.rpc.available) {
+      newStatus.mode = "rpc-fallback";
+    } else {
+      newStatus.mode = "offline";
+    }
+    const changed = this.status.api.available !== newStatus.api.available || this.status.rpc.available !== newStatus.rpc.available || this.status.mode !== newStatus.mode || this.status.initialCheckComplete !== newStatus.initialCheckComplete;
+    this.status = newStatus;
+    if (changed) {
+      this.listeners.forEach((listener) => {
+        try {
+          listener(this.status);
+        } catch {
+        }
+      });
+    }
+  }
+};
+
+// src/datasource/resolver.ts
+async function withFallback(primary, fallback, health) {
+  if (health) {
+    const mode = health.mode;
+    if (mode === "rpc-fallback") {
+      try {
+        return await fallback();
+      } catch (fallbackError) {
+        throw fallbackError;
+      }
+    }
+  }
+  let primaryError;
+  try {
+    return await primary();
+  } catch (error) {
+    primaryError = error;
+    if (health) {
+      health.markApiUnavailable(primaryError.message);
+    }
+  }
+  try {
+    return await fallback();
+  } catch (fallbackError) {
+    if (health) {
+      health.markRpcUnavailable(fallbackError.message);
+    }
+    throw new DataSourceError(primaryError, fallbackError);
+  }
+}
+
+// src/rpc/provider.ts
+var starknetModule = null;
+var useObjectConstructor = null;
+async function getStarknet() {
+  if (!starknetModule) {
+    starknetModule = await import('starknet');
+  }
+  return starknetModule;
+}
+async function createProvider(rpcUrl) {
+  const { RpcProvider: StarknetRpcProvider } = await getStarknet();
+  const provider = new StarknetRpcProvider({ nodeUrl: rpcUrl });
+  return provider;
+}
+async function createContract(abi, address, provider) {
+  let resolvedAbi = abi;
+  if (abi && !Array.isArray(abi) && typeof abi === "object" && "default" in abi) {
+    resolvedAbi = abi.default;
+  }
+  const starknet = await getStarknet();
+  const StarknetContract = starknet.Contract;
+  if (useObjectConstructor === null) {
+    try {
+      const contract = new StarknetContract({
+        abi: resolvedAbi,
+        address,
+        providerOrAccount: provider
+      });
+      useObjectConstructor = true;
+      return contract;
+    } catch {
+      useObjectConstructor = false;
+      return new StarknetContract(resolvedAbi, address, provider);
+    }
+  }
+  if (useObjectConstructor) {
+    return new StarknetContract({
+      abi: resolvedAbi,
+      address,
+      providerOrAccount: provider
+    });
+  } else {
+    return new StarknetContract(resolvedAbi, address, provider);
+  }
+}
+function wrapRpcCall(fn, contractAddress) {
+  return fn().catch((error) => {
+    throw new RpcError(
+      error instanceof Error ? error.message : "RPC call failed",
+      contractAddress
+    );
+  });
+}
+function decodeShortString(value) {
+  if (!value) return "";
+  const hex = num.toHex(value);
+  if (hex === "0x0") return "";
+  const hexStr = hex.slice(2);
+  let result = "";
+  for (let i = 0; i < hexStr.length; i += 2) {
+    const charCode = parseInt(hexStr.slice(i, i + 2), 16);
+    if (charCode === 0) break;
+    result += String.fromCharCode(charCode);
+  }
+  return result;
+}
+function decodeByteArray(value) {
+  if (!value) return "";
+  const obj = value;
+  const data = obj.data;
+  const pendingWord = obj.pending_word;
+  const pendingWordLen = Number(obj.pending_word_len ?? 0);
+  let result = "";
+  if (data) {
+    for (const chunk of data) {
+      const hex = num.toHex(chunk).slice(2).padStart(62, "0");
+      for (let i = 0; i < 62; i += 2) {
+        const charCode = parseInt(hex.slice(i, i + 2), 16);
+        if (charCode !== 0) result += String.fromCharCode(charCode);
+      }
+    }
+  }
+  if (pendingWord && pendingWordLen > 0) {
+    const hex = num.toHex(pendingWord).slice(2).padStart(pendingWordLen * 2, "0");
+    for (let i = 0; i < pendingWordLen * 2; i += 2) {
+      const charCode = parseInt(hex.slice(i, i + 2), 16);
+      if (charCode !== 0) result += String.fromCharCode(charCode);
+    }
+  }
+  return result;
+}
+function phaseToRpcArg(phase) {
+  const map = {
+    scheduled: "Scheduled",
+    registration: "Registration",
+    staging: "Staging",
+    live: "Live",
+    submission: "Submission",
+    finalized: "Finalized"
+  };
+  return { [map[phase]]: {} };
+}
+function parseTournament(raw, entryCount) {
+  const obj = raw;
+  const id = String(obj.id ?? "0");
+  const createdAt = Number(obj.created_at ?? 0);
+  const createdBy = num.toHex(obj.created_by);
+  const creatorTokenId = obj.creator_token_id ? num.toHex(obj.creator_token_id) : null;
+  const metadata = obj.metadata;
+  const name = metadata ? decodeShortString(metadata.name) : "";
+  const description = metadata ? decodeByteArray(metadata.description) : "";
+  const sched = obj.schedule;
+  const registrationStartDelay = Number(sched?.registration_start_delay ?? 0);
+  const registrationEndDelay = Number(sched?.registration_end_delay ?? 0);
+  const gameStartDelay = Number(sched?.game_start_delay ?? 0);
+  const gameEndDelay = Number(sched?.game_end_delay ?? 0);
+  const submissionDuration = Number(sched?.submission_duration ?? 0);
+  const createdAtStr = String(createdAt);
+  const registrationStartTime = String(createdAt + registrationStartDelay);
+  const registrationEndTime = String(createdAt + registrationEndDelay);
+  const gameStartTime = String(createdAt + gameStartDelay);
+  const gameEndTime = String(createdAt + gameEndDelay);
+  const submissionEndTime = String(createdAt + gameEndDelay + submissionDuration);
+  const gc = obj.game_config;
+  const gameAddress = gc ? num.toHex(gc.game_address) : "";
+  const settingsId = Number(gc?.settings_id ?? 0);
+  const soulbound = Boolean(gc?.soulbound);
+  const paymaster = Boolean(gc?.paymaster);
+  const clientUrl = gc?.client_url ? decodeOptionalByteArray(gc.client_url) : null;
+  const renderer = gc?.renderer ? parseOptionalAddress(gc.renderer) : null;
+  const lc = obj.leaderboard_config;
+  const ascending = Boolean(lc?.ascending);
+  const gameMustBeOver = Boolean(lc?.game_must_be_over);
+  const entryFeeRaw = parseOption(obj.entry_fee);
+  let entryFeeToken = null;
+  let entryFeeAmount = null;
+  let entryFee = null;
+  if (entryFeeRaw) {
+    const ef = entryFeeRaw;
+    entryFeeToken = num.toHex(ef.token_address);
+    entryFeeAmount = String(ef.amount ?? "0");
+    entryFee = {
+      tokenAddress: entryFeeToken,
+      amount: entryFeeAmount,
+      tournamentCreatorShare: Number(ef.tournament_creator_share ?? 0),
+      gameCreatorShare: Number(ef.game_creator_share ?? 0),
+      refundShare: Number(ef.refund_share ?? 0),
+      distribution: ef.distribution ?? null,
+      distributionCount: Number(ef.distribution_count ?? 0)
+    };
+  }
+  const entryRequirement = parseOption(obj.entry_requirement) ?? null;
+  const hasEntryRequirement = entryRequirement !== null;
+  return {
+    id,
+    tournamentId: id,
+    gameAddress,
+    createdAt: new Date(createdAt * 1e3).toISOString(),
+    createdBy,
+    creatorTokenId,
+    name,
+    description,
+    registrationStartDelay,
+    registrationEndDelay,
+    gameStartDelay,
+    gameEndDelay,
+    submissionDuration,
+    createdAtOnchain: createdAtStr,
+    registrationStartTime,
+    registrationEndTime,
+    gameStartTime,
+    gameEndTime,
+    submissionEndTime,
+    settingsId,
+    soulbound,
+    paymaster,
+    clientUrl,
+    renderer,
+    leaderboardAscending: ascending,
+    leaderboardGameMustBeOver: gameMustBeOver,
+    entryFeeToken,
+    entryFeeAmount,
+    hasEntryRequirement,
+    schedule: {
+      registrationStartDelay,
+      registrationEndDelay,
+      gameStartDelay,
+      gameEndDelay,
+      submissionDuration
+    },
+    gameConfig: {
+      gameAddress,
+      settingsId,
+      soulbound,
+      paymaster,
+      clientUrl,
+      renderer
+    },
+    entryFee,
+    entryRequirement,
+    leaderboardConfig: { ascending, gameMustBeOver },
+    entryCount,
+    prizeCount: 0,
+    // Not available from viewer
+    submissionCount: 0,
+    // Not available from viewer
+    metadata: null
+  };
+}
+function parseLeaderboardEntry(raw) {
+  const obj = raw;
+  return {
+    position: Number(obj.position ?? 0),
+    tokenId: num.toHex(obj.token_id)
+  };
+}
+function parseRegistration(raw, tournamentId) {
+  const obj = raw;
+  return {
+    tournamentId,
+    gameTokenId: num.toHex(obj.game_token_id),
+    gameAddress: "",
+    // Not in on-chain struct
+    playerAddress: "",
+    // Not in on-chain struct
+    entryNumber: Number(obj.entry_id ?? 0),
+    hasSubmitted: Boolean(obj.has_submitted),
+    isBanned: Boolean(obj.is_banned)
+  };
+}
+function parsePrize(raw) {
+  const obj = raw;
+  const tokenTypeData = obj.token_type;
+  let tokenType = "erc20";
+  let amount = null;
+  let tokenId = null;
+  let distributionType = null;
+  let distributionWeight = null;
+  let distributionCount = null;
+  let payoutPosition = 0;
+  if (tokenTypeData) {
+    if ("erc20" in tokenTypeData) {
+      const erc20 = tokenTypeData.erc20;
+      tokenType = "erc20";
+      amount = String(erc20.amount ?? "0");
+      const dist = erc20.distribution;
+      if (dist) {
+        distributionType = String(dist.type ?? null);
+        distributionWeight = dist.weight != null ? Number(dist.weight) : null;
+      }
+      distributionCount = erc20.distribution_count != null ? Number(erc20.distribution_count) : null;
+    } else if ("erc721" in tokenTypeData) {
+      const erc721 = tokenTypeData.erc721;
+      tokenType = "erc721";
+      tokenId = String(erc721.id ?? "0");
+    } else if ("variant" in tokenTypeData) {
+      const variant = tokenTypeData.variant?.toLowerCase();
+      if (variant === "erc20") {
+        tokenType = "erc20";
+        amount = String(tokenTypeData.amount ?? "0");
+        const dist = tokenTypeData.distribution;
+        if (dist) {
+          distributionType = String(dist.type ?? null);
+          distributionWeight = dist.weight != null ? Number(dist.weight) : null;
+        }
+        distributionCount = tokenTypeData.distribution_count != null ? Number(tokenTypeData.distribution_count) : null;
+      } else if (variant === "erc721") {
+        tokenType = "erc721";
+        tokenId = String(tokenTypeData.id ?? "0");
+      }
+    }
+  }
+  return {
+    prizeId: String(obj.id ?? "0"),
+    tournamentId: String(obj.context_id ?? "0"),
+    payoutPosition,
+    tokenAddress: num.toHex(obj.token_address),
+    tokenType,
+    amount,
+    tokenId,
+    distributionType,
+    distributionWeight,
+    distributionCount,
+    sponsorAddress: num.toHex(obj.sponsor_address)
+  };
+}
+function parseOption(raw) {
+  if (raw === void 0 || raw === null) return null;
+  const obj = raw;
+  if ("Some" in obj) return obj.Some;
+  if ("None" in obj) return null;
+  return raw;
+}
+function decodeOptionalByteArray(raw) {
+  const inner = parseOption(raw);
+  if (!inner) return null;
+  return decodeByteArray(inner);
+}
+function parseOptionalAddress(raw) {
+  const inner = parseOption(raw);
+  if (!inner) return null;
+  const hex = num.toHex(inner);
+  return hex === "0x0" ? null : hex;
+}
+function parseFilterResult(raw) {
+  const obj = raw;
+  const ids = obj.tournament_ids?.map((v) => String(v)) ?? [];
+  const total = Number(obj.total ?? 0);
+  return { tournamentIds: ids, total };
+}
+function parseTournamentFullState(raw) {
+  const obj = raw;
+  const entryCount = Number(obj.entry_count ?? 0);
+  return parseTournament(obj.tournament, entryCount);
+}
+async function viewerTournaments(contract, offset, limit) {
+  return wrapRpcCall(async () => {
+    const result = await contract.call("tournaments", [offset, limit]);
+    return parseFilterResult(result);
+  }, contract.address);
+}
+async function viewerTournamentsByGame(contract, gameAddress, offset, limit) {
+  return wrapRpcCall(async () => {
+    const result = await contract.call("tournaments_by_game", [gameAddress, offset, limit]);
+    return parseFilterResult(result);
+  }, contract.address);
+}
+async function viewerTournamentsByCreator(contract, creator, offset, limit) {
+  return wrapRpcCall(async () => {
+    const result = await contract.call("tournaments_by_creator", [creator, offset, limit]);
+    return parseFilterResult(result);
+  }, contract.address);
+}
+async function viewerTournamentsByPhase(contract, phase, offset, limit) {
+  return wrapRpcCall(async () => {
+    const result = await contract.call("tournaments_by_phase", [phaseToRpcArg(phase), offset, limit]);
+    return parseFilterResult(result);
+  }, contract.address);
+}
+async function viewerTournamentDetail(contract, tournamentId) {
+  return wrapRpcCall(async () => {
+    const result = await contract.call("tournament_detail", [tournamentId]);
+    return parseTournamentFullState(result);
+  }, contract.address);
+}
+async function viewerTournamentsBatch(contract, tournamentIds) {
+  return wrapRpcCall(async () => {
+    const result = await contract.call("tournaments_batch", [tournamentIds]);
+    return result.map(parseTournamentFullState);
+  }, contract.address);
+}
+async function viewerRegistrations(contract, tournamentId, offset, limit) {
+  return wrapRpcCall(async () => {
+    const result = await contract.call("tournament_registrations", [tournamentId, offset, limit]);
+    const obj = result;
+    const entries = obj.entries ?? [];
+    const total = Number(obj.total ?? 0);
+    return {
+      data: entries.map((e) => parseRegistration(e, tournamentId)),
+      total,
+      limit,
+      offset
+    };
+  }, contract.address);
+}
+async function viewerLeaderboard(contract, tournamentId, offset, limit) {
+  return wrapRpcCall(async () => {
+    const result = await contract.call("leaderboard", [tournamentId, offset, limit]);
+    return result.map(parseLeaderboardEntry);
+  }, contract.address);
+}
+async function viewerPrizes(contract, tournamentId) {
+  return wrapRpcCall(async () => {
+    const result = await contract.call("tournament_prizes", [tournamentId]);
+    return result.map(parsePrize);
+  }, contract.address);
+}
+
+// src/rpc/abis/budokanViewer.json
+var budokanViewer_default = [
+  {
+    type: "impl",
+    name: "UpgradeableImpl",
+    interface_name: "openzeppelin_interfaces::upgrades::IUpgradeable"
+  },
+  {
+    type: "interface",
+    name: "openzeppelin_interfaces::upgrades::IUpgradeable",
+    items: [
+      {
+        type: "function",
+        name: "upgrade",
+        inputs: [
+          {
+            name: "new_class_hash",
+            type: "core::starknet::class_hash::ClassHash"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      }
+    ]
+  },
+  {
+    type: "impl",
+    name: "BudokanViewerImpl",
+    interface_name: "budokan_interfaces::viewer::IBudokanViewer"
+  },
+  {
+    type: "struct",
+    name: "budokan_interfaces::viewer::TournamentFilterResult",
+    members: [
+      {
+        name: "tournament_ids",
+        type: "core::array::Array::<core::integer::u64>"
+      },
+      {
+        name: "total",
+        type: "core::integer::u64"
+      }
+    ]
+  },
+  {
+    type: "enum",
+    name: "budokan_interfaces::budokan::Phase",
+    variants: [
+      {
+        name: "Scheduled",
+        type: "()"
+      },
+      {
+        name: "Registration",
+        type: "()"
+      },
+      {
+        name: "Staging",
+        type: "()"
+      },
+      {
+        name: "Live",
+        type: "()"
+      },
+      {
+        name: "Submission",
+        type: "()"
+      },
+      {
+        name: "Finalized",
+        type: "()"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "core::byte_array::ByteArray",
+    members: [
+      {
+        name: "data",
+        type: "core::array::Array::<core::bytes_31::bytes31>"
+      },
+      {
+        name: "pending_word",
+        type: "core::felt252"
+      },
+      {
+        name: "pending_word_len",
+        type: "core::internal::bounded_int::BoundedInt::<0, 30>"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "budokan_interfaces::budokan::Metadata",
+    members: [
+      {
+        name: "name",
+        type: "core::felt252"
+      },
+      {
+        name: "description",
+        type: "core::byte_array::ByteArray"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "budokan_interfaces::budokan::Schedule",
+    members: [
+      {
+        name: "registration_start_delay",
+        type: "core::integer::u32"
+      },
+      {
+        name: "registration_end_delay",
+        type: "core::integer::u32"
+      },
+      {
+        name: "game_start_delay",
+        type: "core::integer::u32"
+      },
+      {
+        name: "game_end_delay",
+        type: "core::integer::u32"
+      },
+      {
+        name: "submission_duration",
+        type: "core::integer::u32"
+      }
+    ]
+  },
+  {
+    type: "enum",
+    name: "core::bool",
+    variants: [
+      {
+        name: "False",
+        type: "()"
+      },
+      {
+        name: "True",
+        type: "()"
+      }
+    ]
+  },
+  {
+    type: "enum",
+    name: "core::option::Option::<core::byte_array::ByteArray>",
+    variants: [
+      {
+        name: "Some",
+        type: "core::byte_array::ByteArray"
+      },
+      {
+        name: "None",
+        type: "()"
+      }
+    ]
+  },
+  {
+    type: "enum",
+    name: "core::option::Option::<core::starknet::contract_address::ContractAddress>",
+    variants: [
+      {
+        name: "Some",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "None",
+        type: "()"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "budokan_interfaces::budokan::GameConfig",
+    members: [
+      {
+        name: "game_address",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "settings_id",
+        type: "core::integer::u32"
+      },
+      {
+        name: "soulbound",
+        type: "core::bool"
+      },
+      {
+        name: "paymaster",
+        type: "core::bool"
+      },
+      {
+        name: "client_url",
+        type: "core::option::Option::<core::byte_array::ByteArray>"
+      },
+      {
+        name: "renderer",
+        type: "core::option::Option::<core::starknet::contract_address::ContractAddress>"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "core::array::Span::<core::integer::u16>",
+    members: [
+      {
+        name: "snapshot",
+        type: "@core::array::Array::<core::integer::u16>"
+      }
+    ]
+  },
+  {
+    type: "enum",
+    name: "game_components_interfaces::distribution::Distribution",
+    variants: [
+      {
+        name: "Linear",
+        type: "core::integer::u16"
+      },
+      {
+        name: "Exponential",
+        type: "core::integer::u16"
+      },
+      {
+        name: "Uniform",
+        type: "()"
+      },
+      {
+        name: "Custom",
+        type: "core::array::Span::<core::integer::u16>"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "budokan_interfaces::budokan::EntryFee",
+    members: [
+      {
+        name: "token_address",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "amount",
+        type: "core::integer::u128"
+      },
+      {
+        name: "tournament_creator_share",
+        type: "core::integer::u16"
+      },
+      {
+        name: "game_creator_share",
+        type: "core::integer::u16"
+      },
+      {
+        name: "refund_share",
+        type: "core::integer::u16"
+      },
+      {
+        name: "distribution",
+        type: "game_components_interfaces::distribution::Distribution"
+      },
+      {
+        name: "distribution_count",
+        type: "core::integer::u32"
+      }
+    ]
+  },
+  {
+    type: "enum",
+    name: "core::option::Option::<budokan_interfaces::budokan::EntryFee>",
+    variants: [
+      {
+        name: "Some",
+        type: "budokan_interfaces::budokan::EntryFee"
+      },
+      {
+        name: "None",
+        type: "()"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "core::array::Span::<core::starknet::contract_address::ContractAddress>",
+    members: [
+      {
+        name: "snapshot",
+        type: "@core::array::Array::<core::starknet::contract_address::ContractAddress>"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "core::array::Span::<core::felt252>",
+    members: [
+      {
+        name: "snapshot",
+        type: "@core::array::Array::<core::felt252>"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "interfaces::extension::ExtensionConfig",
+    members: [
+      {
+        name: "address",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "config",
+        type: "core::array::Span::<core::felt252>"
+      }
+    ]
+  },
+  {
+    type: "enum",
+    name: "game_components_interfaces::entry_requirement::EntryRequirementType",
+    variants: [
+      {
+        name: "token",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "allowlist",
+        type: "core::array::Span::<core::starknet::contract_address::ContractAddress>"
+      },
+      {
+        name: "extension",
+        type: "interfaces::extension::ExtensionConfig"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "game_components_interfaces::entry_requirement::EntryRequirement",
+    members: [
+      {
+        name: "entry_limit",
+        type: "core::integer::u32"
+      },
+      {
+        name: "entry_requirement_type",
+        type: "game_components_interfaces::entry_requirement::EntryRequirementType"
+      }
+    ]
+  },
+  {
+    type: "enum",
+    name: "core::option::Option::<game_components_interfaces::entry_requirement::EntryRequirement>",
+    variants: [
+      {
+        name: "Some",
+        type: "game_components_interfaces::entry_requirement::EntryRequirement"
+      },
+      {
+        name: "None",
+        type: "()"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "budokan_interfaces::budokan::LeaderboardConfig",
+    members: [
+      {
+        name: "ascending",
+        type: "core::bool"
+      },
+      {
+        name: "game_must_be_over",
+        type: "core::bool"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "budokan_interfaces::budokan::Tournament",
+    members: [
+      {
+        name: "id",
+        type: "core::integer::u64"
+      },
+      {
+        name: "created_at",
+        type: "core::integer::u64"
+      },
+      {
+        name: "created_by",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "creator_token_id",
+        type: "core::felt252"
+      },
+      {
+        name: "metadata",
+        type: "budokan_interfaces::budokan::Metadata"
+      },
+      {
+        name: "schedule",
+        type: "budokan_interfaces::budokan::Schedule"
+      },
+      {
+        name: "game_config",
+        type: "budokan_interfaces::budokan::GameConfig"
+      },
+      {
+        name: "entry_fee",
+        type: "core::option::Option::<budokan_interfaces::budokan::EntryFee>"
+      },
+      {
+        name: "entry_requirement",
+        type: "core::option::Option::<game_components_interfaces::entry_requirement::EntryRequirement>"
+      },
+      {
+        name: "leaderboard_config",
+        type: "budokan_interfaces::budokan::LeaderboardConfig"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "budokan_interfaces::viewer::TournamentFullState",
+    members: [
+      {
+        name: "tournament",
+        type: "budokan_interfaces::budokan::Tournament"
+      },
+      {
+        name: "entry_count",
+        type: "core::integer::u32"
+      },
+      {
+        name: "phase",
+        type: "budokan_interfaces::budokan::Phase"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "game_components_interfaces::registration::Registration",
+    members: [
+      {
+        name: "context_id",
+        type: "core::integer::u64"
+      },
+      {
+        name: "entry_id",
+        type: "core::integer::u32"
+      },
+      {
+        name: "game_token_id",
+        type: "core::felt252"
+      },
+      {
+        name: "has_submitted",
+        type: "core::bool"
+      },
+      {
+        name: "is_banned",
+        type: "core::bool"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "budokan_interfaces::viewer::RegistrationResult",
+    members: [
+      {
+        name: "entries",
+        type: "core::array::Array::<game_components_interfaces::registration::Registration>"
+      },
+      {
+        name: "total",
+        type: "core::integer::u32"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "budokan_interfaces::viewer::LeaderboardEntryView",
+    members: [
+      {
+        name: "position",
+        type: "core::integer::u32"
+      },
+      {
+        name: "token_id",
+        type: "core::felt252"
+      }
+    ]
+  },
+  {
+    type: "enum",
+    name: "core::option::Option::<game_components_interfaces::distribution::Distribution>",
+    variants: [
+      {
+        name: "Some",
+        type: "game_components_interfaces::distribution::Distribution"
+      },
+      {
+        name: "None",
+        type: "()"
+      }
+    ]
+  },
+  {
+    type: "enum",
+    name: "core::option::Option::<core::integer::u32>",
+    variants: [
+      {
+        name: "Some",
+        type: "core::integer::u32"
+      },
+      {
+        name: "None",
+        type: "()"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "game_components_interfaces::prize::ERC20Data",
+    members: [
+      {
+        name: "amount",
+        type: "core::integer::u128"
+      },
+      {
+        name: "distribution",
+        type: "core::option::Option::<game_components_interfaces::distribution::Distribution>"
+      },
+      {
+        name: "distribution_count",
+        type: "core::option::Option::<core::integer::u32>"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "game_components_interfaces::prize::ERC721Data",
+    members: [
+      {
+        name: "id",
+        type: "core::integer::u128"
+      }
+    ]
+  },
+  {
+    type: "enum",
+    name: "game_components_interfaces::prize::TokenTypeData",
+    variants: [
+      {
+        name: "erc20",
+        type: "game_components_interfaces::prize::ERC20Data"
+      },
+      {
+        name: "erc721",
+        type: "game_components_interfaces::prize::ERC721Data"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "game_components_interfaces::prize::PrizeData",
+    members: [
+      {
+        name: "id",
+        type: "core::integer::u64"
+      },
+      {
+        name: "context_id",
+        type: "core::integer::u64"
+      },
+      {
+        name: "token_address",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "token_type",
+        type: "game_components_interfaces::prize::TokenTypeData"
+      },
+      {
+        name: "sponsor_address",
+        type: "core::starknet::contract_address::ContractAddress"
+      }
+    ]
+  },
+  {
+    type: "interface",
+    name: "budokan_interfaces::viewer::IBudokanViewer",
+    items: [
+      {
+        type: "function",
+        name: "tournaments",
+        inputs: [
+          {
+            name: "offset",
+            type: "core::integer::u64"
+          },
+          {
+            name: "limit",
+            type: "core::integer::u64"
+          }
+        ],
+        outputs: [
+          {
+            type: "budokan_interfaces::viewer::TournamentFilterResult"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "tournaments_by_game",
+        inputs: [
+          {
+            name: "game_address",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "offset",
+            type: "core::integer::u64"
+          },
+          {
+            name: "limit",
+            type: "core::integer::u64"
+          }
+        ],
+        outputs: [
+          {
+            type: "budokan_interfaces::viewer::TournamentFilterResult"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "tournaments_by_creator",
+        inputs: [
+          {
+            name: "creator",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "offset",
+            type: "core::integer::u64"
+          },
+          {
+            name: "limit",
+            type: "core::integer::u64"
+          }
+        ],
+        outputs: [
+          {
+            type: "budokan_interfaces::viewer::TournamentFilterResult"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "tournaments_by_phase",
+        inputs: [
+          {
+            name: "phase",
+            type: "budokan_interfaces::budokan::Phase"
+          },
+          {
+            name: "offset",
+            type: "core::integer::u64"
+          },
+          {
+            name: "limit",
+            type: "core::integer::u64"
+          }
+        ],
+        outputs: [
+          {
+            type: "budokan_interfaces::viewer::TournamentFilterResult"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "count_tournaments",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::integer::u64"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "count_tournaments_by_game",
+        inputs: [
+          {
+            name: "game_address",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u64"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "count_tournaments_by_creator",
+        inputs: [
+          {
+            name: "creator",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u64"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "count_tournaments_by_phase",
+        inputs: [
+          {
+            name: "phase",
+            type: "budokan_interfaces::budokan::Phase"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u64"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "tournament_detail",
+        inputs: [
+          {
+            name: "tournament_id",
+            type: "core::integer::u64"
+          }
+        ],
+        outputs: [
+          {
+            type: "budokan_interfaces::viewer::TournamentFullState"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "tournaments_batch",
+        inputs: [
+          {
+            name: "tournament_ids",
+            type: "core::array::Array::<core::integer::u64>"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::array::Array::<budokan_interfaces::viewer::TournamentFullState>"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "tournament_registrations",
+        inputs: [
+          {
+            name: "tournament_id",
+            type: "core::integer::u64"
+          },
+          {
+            name: "offset",
+            type: "core::integer::u32"
+          },
+          {
+            name: "limit",
+            type: "core::integer::u32"
+          }
+        ],
+        outputs: [
+          {
+            type: "budokan_interfaces::viewer::RegistrationResult"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "leaderboard",
+        inputs: [
+          {
+            name: "tournament_id",
+            type: "core::integer::u64"
+          },
+          {
+            name: "offset",
+            type: "core::integer::u32"
+          },
+          {
+            name: "limit",
+            type: "core::integer::u32"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::array::Array::<budokan_interfaces::viewer::LeaderboardEntryView>"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "tournament_prizes",
+        inputs: [
+          {
+            name: "tournament_id",
+            type: "core::integer::u64"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::array::Array::<game_components_interfaces::prize::PrizeData>"
+          }
+        ],
+        state_mutability: "view"
+      }
+    ]
+  },
+  {
+    type: "impl",
+    name: "OwnableImpl",
+    interface_name: "openzeppelin_interfaces::access::ownable::IOwnable"
+  },
+  {
+    type: "interface",
+    name: "openzeppelin_interfaces::access::ownable::IOwnable",
+    items: [
+      {
+        type: "function",
+        name: "owner",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "transfer_ownership",
+        inputs: [
+          {
+            name: "new_owner",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "renounce_ownership",
+        inputs: [],
+        outputs: [],
+        state_mutability: "external"
+      }
+    ]
+  },
+  {
+    type: "impl",
+    name: "OwnableCamelOnlyImpl",
+    interface_name: "openzeppelin_interfaces::access::ownable::IOwnableCamelOnly"
+  },
+  {
+    type: "interface",
+    name: "openzeppelin_interfaces::access::ownable::IOwnableCamelOnly",
+    items: [
+      {
+        type: "function",
+        name: "transferOwnership",
+        inputs: [
+          {
+            name: "newOwner",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "renounceOwnership",
+        inputs: [],
+        outputs: [],
+        state_mutability: "external"
+      }
+    ]
+  },
+  {
+    type: "constructor",
+    name: "constructor",
+    inputs: [
+      {
+        name: "owner",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "budokan_address",
+        type: "core::starknet::contract_address::ContractAddress"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_access::ownable::ownable::OwnableComponent::OwnershipTransferred",
+    kind: "struct",
+    members: [
+      {
+        name: "previous_owner",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "new_owner",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_access::ownable::ownable::OwnableComponent::OwnershipTransferStarted",
+    kind: "struct",
+    members: [
+      {
+        name: "previous_owner",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "new_owner",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_access::ownable::ownable::OwnableComponent::Event",
+    kind: "enum",
+    variants: [
+      {
+        name: "OwnershipTransferred",
+        type: "openzeppelin_access::ownable::ownable::OwnableComponent::OwnershipTransferred",
+        kind: "nested"
+      },
+      {
+        name: "OwnershipTransferStarted",
+        type: "openzeppelin_access::ownable::ownable::OwnableComponent::OwnershipTransferStarted",
+        kind: "nested"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_upgrades::upgradeable::UpgradeableComponent::Upgraded",
+    kind: "struct",
+    members: [
+      {
+        name: "class_hash",
+        type: "core::starknet::class_hash::ClassHash",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_upgrades::upgradeable::UpgradeableComponent::Event",
+    kind: "enum",
+    variants: [
+      {
+        name: "Upgraded",
+        type: "openzeppelin_upgrades::upgradeable::UpgradeableComponent::Upgraded",
+        kind: "nested"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "budokan_viewer::budokan_viewer::BudokanViewer::Event",
+    kind: "enum",
+    variants: [
+      {
+        name: "OwnableEvent",
+        type: "openzeppelin_access::ownable::ownable::OwnableComponent::Event",
+        kind: "flat"
+      },
+      {
+        name: "UpgradeableEvent",
+        type: "openzeppelin_upgrades::upgradeable::UpgradeableComponent::Event",
+        kind: "flat"
+      }
+    ]
+  }
+];
+
+// src/client.ts
+var BudokanClient = class {
+  resolvedConfig;
+  wsManager;
+  connectionStatus;
+  cachedProvider = null;
+  cachedViewerContract = null;
+  constructor(config) {
+    const chainConfig = config.chain ? getChainConfig(config.chain) : void 0;
+    this.resolvedConfig = {
+      ...config,
+      apiBaseUrl: config.apiBaseUrl ?? chainConfig?.apiBaseUrl ?? "",
+      rpcUrl: config.rpcUrl ?? chainConfig?.rpcUrl ?? "",
+      viewerAddress: config.viewerAddress ?? chainConfig?.viewerAddress ?? "",
+      budokanAddress: config.budokanAddress ?? chainConfig?.budokanAddress ?? ""
+    };
+    const wsUrl = config.wsUrl ?? chainConfig?.wsUrl ?? this.resolvedConfig.apiBaseUrl.replace(/^http/, "ws").replace(/\/$/, "") + "/ws";
+    this.wsManager = new WSManager(wsUrl);
+    this.connectionStatus = new ConnectionStatus(
+      this.resolvedConfig.apiBaseUrl,
+      this.resolvedConfig.rpcUrl,
+      config.health
+    );
+    if (this.resolvedConfig.apiBaseUrl && this.resolvedConfig.rpcUrl) {
+      this.connectionStatus.startMonitoring();
+    }
+  }
+  // ---- Configuration ----
+  /** Returns the resolved configuration. */
+  get clientConfig() {
+    return { ...this.resolvedConfig };
+  }
+  /** Whether the WebSocket is currently connected. */
+  get wsConnected() {
+    return this.wsManager.isConnected;
+  }
+  // ---- Connection status ----
+  /** Returns the current connection status (API, RPC, mode). */
+  getConnectionStatus() {
+    return this.connectionStatus.getStatus();
+  }
+  /** Subscribe to connection status changes. Returns an unsubscribe function. */
+  onConnectionStatusChange(listener) {
+    return this.connectionStatus.subscribe(listener);
+  }
+  // ---- Lazy RPC getters ----
+  async getProvider() {
+    if (this.cachedProvider) return this.cachedProvider;
+    if (!this.resolvedConfig.rpcUrl) {
+      throw new RpcError("No rpcUrl configured");
+    }
+    if (this.resolvedConfig.provider) {
+      this.cachedProvider = this.resolvedConfig.provider;
+      return this.cachedProvider;
+    }
+    this.cachedProvider = await createProvider(this.resolvedConfig.rpcUrl);
+    return this.cachedProvider;
+  }
+  async getViewerContract() {
+    if (this.cachedViewerContract) return this.cachedViewerContract;
+    if (!this.resolvedConfig.viewerAddress) {
+      throw new RpcError("No viewerAddress configured. Set viewerAddress in config or use a chain preset with a deployed viewer contract.");
+    }
+    const provider = await this.getProvider();
+    this.cachedViewerContract = await createContract(
+      budokanViewer_default,
+      this.resolvedConfig.viewerAddress,
+      provider
+    );
+    return this.cachedViewerContract;
+  }
+  // ---- API context ----
+  get apiCtx() {
+    return {
+      retryAttempts: this.resolvedConfig.retryAttempts,
+      retryDelay: this.resolvedConfig.retryDelay,
+      timeout: this.resolvedConfig.timeout
+    };
+  }
+  // ---- Tournament Queries ----
+  /**
+   * Fetch a paginated list of tournaments with optional filtering.
+   * Supports RPC fallback when API is unavailable.
+   */
+  async getTournaments(params) {
+    const rpcFallback = async () => {
+      const contract = await this.getViewerContract();
+      const offset = params?.offset ?? 0;
+      const limit = params?.limit ?? 20;
+      let filterResult;
+      if (params?.phase) {
+        filterResult = await viewerTournamentsByPhase(contract, params.phase, offset, limit);
+      } else if (params?.gameAddress) {
+        filterResult = await viewerTournamentsByGame(contract, params.gameAddress, offset, limit);
+      } else if (params?.creator) {
+        filterResult = await viewerTournamentsByCreator(contract, params.creator, offset, limit);
+      } else {
+        filterResult = await viewerTournaments(contract, offset, limit);
+      }
+      let data = [];
+      if (filterResult.tournamentIds.length > 0) {
+        data = await viewerTournamentsBatch(contract, filterResult.tournamentIds);
+      }
+      return { data, total: filterResult.total, limit, offset };
+    };
+    if (this.resolvedConfig.primarySource === "rpc") {
+      return rpcFallback();
+    }
+    return withFallback(
+      () => getTournaments(this.resolvedConfig.apiBaseUrl, params, this.apiCtx),
+      rpcFallback,
+      this.connectionStatus
+    );
+  }
+  /**
+   * Fetch a single tournament by its ID.
+   * Supports RPC fallback when API is unavailable.
+   */
+  async getTournament(tournamentId) {
+    const rpcFallback = async () => {
+      const contract = await this.getViewerContract();
+      return viewerTournamentDetail(contract, tournamentId);
+    };
+    if (this.resolvedConfig.primarySource === "rpc") {
+      return rpcFallback();
+    }
+    return withFallback(
+      () => getTournament(this.resolvedConfig.apiBaseUrl, tournamentId, this.apiCtx),
+      rpcFallback,
+      this.connectionStatus
+    );
+  }
+  /**
+   * Fetch the leaderboard for a tournament.
+   * Supports RPC fallback when API is unavailable.
+   */
+  async getTournamentLeaderboard(tournamentId) {
+    const rpcFallback = async () => {
+      const contract = await this.getViewerContract();
+      return viewerLeaderboard(contract, tournamentId, 0, 1e3);
+    };
+    if (this.resolvedConfig.primarySource === "rpc") {
+      return rpcFallback();
+    }
+    return withFallback(
+      () => getTournamentLeaderboard(this.resolvedConfig.apiBaseUrl, tournamentId, this.apiCtx),
+      rpcFallback,
+      this.connectionStatus
+    );
+  }
+  /**
+   * Fetch registrations for a tournament.
+   * Supports RPC fallback when API is unavailable.
+   * Note: In RPC mode, `playerAddress` and `gameAddress` fields will be empty strings.
+   */
+  async getTournamentRegistrations(tournamentId, params) {
+    const rpcFallback = async () => {
+      const contract = await this.getViewerContract();
+      const offset = params?.offset ?? 0;
+      const limit = params?.limit ?? 20;
+      return viewerRegistrations(contract, tournamentId, offset, limit);
+    };
+    if (this.resolvedConfig.primarySource === "rpc") {
+      return rpcFallback();
+    }
+    return withFallback(
+      () => getTournamentRegistrations(this.resolvedConfig.apiBaseUrl, tournamentId, params, this.apiCtx),
+      rpcFallback,
+      this.connectionStatus
+    );
+  }
+  /**
+   * Fetch prizes for a tournament.
+   * Supports RPC fallback when API is unavailable.
+   */
+  async getTournamentPrizes(tournamentId) {
+    const rpcFallback = async () => {
+      const contract = await this.getViewerContract();
+      return viewerPrizes(contract, tournamentId);
+    };
+    if (this.resolvedConfig.primarySource === "rpc") {
+      return rpcFallback();
+    }
+    return withFallback(
+      () => getTournamentPrizes(this.resolvedConfig.apiBaseUrl, tournamentId, this.apiCtx),
+      rpcFallback,
+      this.connectionStatus
+    );
+  }
+  // ---- Player Queries (API-only, no on-chain equivalent) ----
+  /**
+   * Fetch tournaments that a player has registered for.
+   * API-only — no RPC fallback available.
+   */
+  async getPlayerTournaments(address, params) {
+    return getPlayerTournaments(this.resolvedConfig.apiBaseUrl, address, params, this.apiCtx);
+  }
+  /**
+   * Fetch stats for a player.
+   * API-only — no RPC fallback available.
+   */
+  async getPlayerStats(address) {
+    return getPlayerStats(this.resolvedConfig.apiBaseUrl, address, this.apiCtx);
+  }
+  // ---- Game Queries ----
+  /**
+   * Fetch tournaments for a specific game.
+   * Supports RPC fallback when API is unavailable.
+   */
+  async getGameTournaments(gameAddress, params) {
+    const rpcFallback = async () => {
+      const contract = await this.getViewerContract();
+      const offset = params?.offset ?? 0;
+      const limit = params?.limit ?? 20;
+      const filterResult = await viewerTournamentsByGame(contract, gameAddress, offset, limit);
+      let data = [];
+      if (filterResult.tournamentIds.length > 0) {
+        data = await viewerTournamentsBatch(contract, filterResult.tournamentIds);
+      }
+      return { data, total: filterResult.total, limit, offset };
+    };
+    if (this.resolvedConfig.primarySource === "rpc") {
+      return rpcFallback();
+    }
+    return withFallback(
+      () => getGameTournaments(this.resolvedConfig.apiBaseUrl, gameAddress, params, this.apiCtx),
+      rpcFallback,
+      this.connectionStatus
+    );
+  }
+  /**
+   * Fetch tournament stats for a specific game.
+   * API-only — no RPC fallback available.
+   */
+  async getGameStats(gameAddress) {
+    return getGameStats(this.resolvedConfig.apiBaseUrl, gameAddress, this.apiCtx);
+  }
+  // ---- Reward Claims & Qualifications (API-only) ----
+  /**
+   * Fetch reward claims for a tournament.
+   * API-only -- no RPC fallback available.
+   */
+  async getTournamentRewardClaims(tournamentId, params) {
+    return getTournamentRewardClaims(this.resolvedConfig.apiBaseUrl, tournamentId, params, this.apiCtx);
+  }
+  /**
+   * Fetch reward claims summary for a tournament.
+   * API-only -- no RPC fallback available.
+   */
+  async getTournamentRewardClaimsSummary(tournamentId) {
+    return getTournamentRewardClaimsSummary(this.resolvedConfig.apiBaseUrl, tournamentId, this.apiCtx);
+  }
+  /**
+   * Fetch qualifications for a tournament.
+   * API-only -- no RPC fallback available.
+   */
+  async getTournamentQualifications(tournamentId, params) {
+    return getTournamentQualifications(this.resolvedConfig.apiBaseUrl, tournamentId, params, this.apiCtx);
+  }
+  /**
+   * Fetch prize aggregation for a tournament.
+   * API-only -- no RPC fallback available.
+   */
+  async getTournamentPrizeAggregation(tournamentId) {
+    return getTournamentPrizeAggregation(this.resolvedConfig.apiBaseUrl, tournamentId, this.apiCtx);
+  }
+  // ---- Activity Queries (API-only, activity is indexed) ----
+  /**
+   * Fetch activity events with optional filtering.
+   * API-only — no RPC fallback available.
+   */
+  async getActivity(params) {
+    return getActivity(this.resolvedConfig.apiBaseUrl, params, this.apiCtx);
+  }
+  /**
+   * Fetch platform-wide activity stats.
+   * API-only — no RPC fallback available.
+   */
+  async getActivityStats() {
+    return getActivityStats(this.resolvedConfig.apiBaseUrl, this.apiCtx);
+  }
+  /**
+   * Fetch platform-wide prize stats.
+   * API-only — no RPC fallback available.
+   */
+  async getPrizeStats() {
+    return getPrizeStats(this.resolvedConfig.apiBaseUrl, this.apiCtx);
+  }
+  // ---- WebSocket ----
+  /**
+   * Open a WebSocket connection for real-time updates.
+   */
+  connect() {
+    this.wsManager.connect();
+  }
+  /**
+   * Close the WebSocket connection.
+   */
+  disconnect() {
+    this.wsManager.disconnect();
+  }
+  /**
+   * Stop health monitoring and close all connections.
+   */
+  destroy() {
+    this.connectionStatus.destroy();
+    this.wsManager.disconnect();
+  }
+  /**
+   * Subscribe to WebSocket channels with optional tournament filtering.
+   * Returns an unsubscribe function.
+   */
+  subscribe(channels, handler, tournamentIds) {
+    return this.wsManager.subscribe({ channels, tournamentIds }, handler);
+  }
+  /**
+   * Register a listener for WebSocket connection state changes.
+   * Returns an unsubscribe function.
+   */
+  onWsConnectionChange(listener) {
+    return this.wsManager.onConnectionChange(listener);
+  }
+};
+function createBudokanClient(config) {
+  return new BudokanClient(config);
+}
+var BudokanContext = createContext(null);
+function BudokanProvider({ children, config, client: existingClient }) {
+  const client = useMemo(() => {
+    if (existingClient) return existingClient;
+    if (config) return createBudokanClient(config);
+    throw new Error("BudokanProvider requires either 'config' or 'client' prop");
+  }, [existingClient, config]);
+  const clientRef = useRef(client);
+  useEffect(() => {
+    return () => {
+      if (!existingClient && clientRef.current !== client) {
+        clientRef.current.destroy();
+      }
+    };
+  }, [client, existingClient]);
+  useEffect(() => {
+    clientRef.current = client;
+  }, [client]);
+  return /* @__PURE__ */ jsx(BudokanContext.Provider, { value: client, children });
+}
+function useBudokanClient() {
+  const client = useContext(BudokanContext);
+  if (!client) {
+    throw new Error("useBudokanClient must be used within a BudokanProvider");
+  }
+  return client;
+}
+function useTournaments(params) {
+  const client = useBudokanClient();
+  const [tournaments, setTournaments] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const paramsKey = JSON.stringify(params);
+  const fetch2 = useCallback(() => {
+    setLoading(true);
+    setError(null);
+    client.getTournaments(params).then(setTournaments).catch(setError).finally(() => setLoading(false));
+  }, [client, paramsKey]);
+  useEffect(() => {
+    fetch2();
+  }, [fetch2]);
+  return { tournaments, loading, error, refetch: fetch2 };
+}
+function useTournament(tournamentId) {
+  const client = useBudokanClient();
+  const [tournament, setTournament] = useState(null);
+  const [loading, setLoading] = useState(!!tournamentId);
+  const [error, setError] = useState(null);
+  const fetch2 = useCallback(() => {
+    if (!tournamentId) return;
+    setLoading(true);
+    setError(null);
+    client.getTournament(tournamentId).then(setTournament).catch(setError).finally(() => setLoading(false));
+  }, [client, tournamentId]);
+  useEffect(() => {
+    fetch2();
+  }, [fetch2]);
+  return { tournament, loading, error, refetch: fetch2 };
+}
+function useLeaderboard(tournamentId) {
+  const client = useBudokanClient();
+  const [leaderboard, setLeaderboard] = useState(null);
+  const [loading, setLoading] = useState(!!tournamentId);
+  const [error, setError] = useState(null);
+  const fetch2 = useCallback(() => {
+    if (!tournamentId) return;
+    setLoading(true);
+    setError(null);
+    client.getTournamentLeaderboard(tournamentId).then(setLeaderboard).catch(setError).finally(() => setLoading(false));
+  }, [client, tournamentId]);
+  useEffect(() => {
+    fetch2();
+  }, [fetch2]);
+  return { leaderboard, loading, error, refetch: fetch2 };
+}
+function usePlayer(address) {
+  const client = useBudokanClient();
+  const [tournaments, setTournaments] = useState(null);
+  const [stats, setStats] = useState(null);
+  const [loading, setLoading] = useState(!!address);
+  const [error, setError] = useState(null);
+  const fetch2 = useCallback(() => {
+    if (!address) return;
+    setLoading(true);
+    setError(null);
+    Promise.all([
+      client.getPlayerTournaments(address),
+      client.getPlayerStats(address)
+    ]).then(([tournamentsResult, statsResult]) => {
+      setTournaments(tournamentsResult);
+      setStats(statsResult);
+    }).catch(setError).finally(() => setLoading(false));
+  }, [client, address]);
+  useEffect(() => {
+    fetch2();
+  }, [fetch2]);
+  return { tournaments, stats, loading, error };
+}
+function usePlayerStats(address) {
+  const client = useBudokanClient();
+  const [stats, setStats] = useState(null);
+  const [loading, setLoading] = useState(!!address);
+  const [error, setError] = useState(null);
+  const fetch2 = useCallback(() => {
+    if (!address) return;
+    setLoading(true);
+    setError(null);
+    client.getPlayerStats(address).then(setStats).catch(setError).finally(() => setLoading(false));
+  }, [client, address]);
+  useEffect(() => {
+    fetch2();
+  }, [fetch2]);
+  return { stats, loading, error, refetch: fetch2 };
+}
+function usePlayerTournaments(address, params) {
+  const client = useBudokanClient();
+  const [tournaments, setTournaments] = useState(null);
+  const [loading, setLoading] = useState(!!address);
+  const [error, setError] = useState(null);
+  const fetch2 = useCallback(() => {
+    if (!address) return;
+    setLoading(true);
+    setError(null);
+    client.getPlayerTournaments(address, params).then(setTournaments).catch(setError).finally(() => setLoading(false));
+  }, [client, address, params]);
+  useEffect(() => {
+    fetch2();
+  }, [fetch2]);
+  return { tournaments, loading, error, refetch: fetch2 };
+}
+function useRewardClaims(tournamentId) {
+  const client = useBudokanClient();
+  const [rewardClaims, setRewardClaims] = useState(null);
+  const [loading, setLoading] = useState(!!tournamentId);
+  const [error, setError] = useState(null);
+  const fetch2 = useCallback(() => {
+    if (!tournamentId) return;
+    setLoading(true);
+    setError(null);
+    client.getTournamentRewardClaims(tournamentId).then(setRewardClaims).catch(setError).finally(() => setLoading(false));
+  }, [client, tournamentId]);
+  useEffect(() => {
+    fetch2();
+  }, [fetch2]);
+  return { rewardClaims, loading, error, refetch: fetch2 };
+}
+function useRewardClaimsSummary(tournamentId) {
+  const client = useBudokanClient();
+  const [summary, setSummary] = useState(null);
+  const [loading, setLoading] = useState(!!tournamentId);
+  const [error, setError] = useState(null);
+  const fetch2 = useCallback(() => {
+    if (!tournamentId) return;
+    setLoading(true);
+    setError(null);
+    client.getTournamentRewardClaimsSummary(tournamentId).then(setSummary).catch(setError).finally(() => setLoading(false));
+  }, [client, tournamentId]);
+  useEffect(() => {
+    fetch2();
+  }, [fetch2]);
+  return { summary, loading, error, refetch: fetch2 };
+}
+function usePrizes(tournamentId) {
+  const client = useBudokanClient();
+  const [prizes, setPrizes] = useState(null);
+  const [loading, setLoading] = useState(!!tournamentId);
+  const [error, setError] = useState(null);
+  const fetch2 = useCallback(() => {
+    if (!tournamentId) return;
+    setLoading(true);
+    setError(null);
+    client.getTournamentPrizes(tournamentId).then(setPrizes).catch(setError).finally(() => setLoading(false));
+  }, [client, tournamentId]);
+  useEffect(() => {
+    fetch2();
+  }, [fetch2]);
+  return { prizes, loading, error, refetch: fetch2 };
+}
+function usePrizeStats() {
+  const client = useBudokanClient();
+  const [prizeStats, setPrizeStats] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const fetch2 = useCallback(() => {
+    setLoading(true);
+    setError(null);
+    client.getPrizeStats().then(setPrizeStats).catch(setError).finally(() => setLoading(false));
+  }, [client]);
+  useEffect(() => {
+    fetch2();
+  }, [fetch2]);
+  return { prizeStats, loading, error, refetch: fetch2 };
+}
+function useQualifications(tournamentId) {
+  const client = useBudokanClient();
+  const [qualifications, setQualifications] = useState(null);
+  const [loading, setLoading] = useState(!!tournamentId);
+  const [error, setError] = useState(null);
+  const fetch2 = useCallback(() => {
+    if (!tournamentId) return;
+    setLoading(true);
+    setError(null);
+    client.getTournamentQualifications(tournamentId).then(setQualifications).catch(setError).finally(() => setLoading(false));
+  }, [client, tournamentId]);
+  useEffect(() => {
+    fetch2();
+  }, [fetch2]);
+  return { qualifications, loading, error, refetch: fetch2 };
+}
+function useSubscription(channels, tournamentIds) {
+  const client = useBudokanClient();
+  const [lastMessage, setLastMessage] = useState(null);
+  const [isConnected, setIsConnected] = useState(client.wsConnected);
+  const channelsRef = useRef(channels);
+  const tournamentIdsRef = useRef(tournamentIds);
+  channelsRef.current = channels;
+  tournamentIdsRef.current = tournamentIds;
+  useEffect(() => {
+    if (channels.length === 0) return;
+    client.connect();
+    const unsubscribe = client.subscribe(
+      channels,
+      (message) => setLastMessage(message),
+      tournamentIds
+    );
+    const unsubscribeConnection = client.onWsConnectionChange((connected) => {
+      setIsConnected(connected);
+    });
+    return () => {
+      unsubscribe();
+      unsubscribeConnection();
+    };
+  }, [client, JSON.stringify(channels), JSON.stringify(tournamentIds)]);
+  return { lastMessage, isConnected };
+}
+function useConnectionStatus() {
+  const client = useBudokanClient();
+  const [isConnected, setIsConnected] = useState(client.wsConnected);
+  const [datasourceMode, setDatasourceMode] = useState("api");
+  useEffect(() => {
+    const unsubWs = client.onWsConnectionChange((connected) => {
+      setIsConnected(connected);
+    });
+    const unsubDs = client.onConnectionStatusChange((status) => {
+      setDatasourceMode(status.mode);
+    });
+    return () => {
+      unsubWs();
+      unsubDs();
+    };
+  }, [client]);
+  return { isConnected, datasourceMode };
+}
+
+export { BudokanProvider, useBudokanClient, useConnectionStatus, useLeaderboard, usePlayer, usePlayerStats, usePlayerTournaments, usePrizeStats, usePrizes, useQualifications, useRewardClaims, useRewardClaimsSummary, useSubscription, useTournament, useTournaments };
+//# sourceMappingURL=react.js.map
+//# sourceMappingURL=react.js.map