@dubsdotapp/expo 0.1.0

package/dist/index.js

@@ -0,0 +1,1364 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ConnectWalletScreen: () => ConnectWalletScreen,
+  DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
+  DEFAULT_RPC_URL: () => DEFAULT_RPC_URL,
+  DubsApiError: () => DubsApiError,
+  DubsClient: () => DubsClient,
+  DubsProvider: () => DubsProvider,
+  MwaWalletAdapter: () => MwaWalletAdapter,
+  SOLANA_PROGRAM_ERRORS: () => SOLANA_PROGRAM_ERRORS,
+  SettingsSheet: () => SettingsSheet,
+  UserProfileCard: () => UserProfileCard,
+  parseSolanaError: () => parseSolanaError,
+  pollTransactionConfirmation: () => pollTransactionConfirmation,
+  signAndSendBase64Transaction: () => signAndSendBase64Transaction,
+  useAuth: () => useAuth,
+  useClaim: () => useClaim,
+  useCreateGame: () => useCreateGame,
+  useDubs: () => useDubs,
+  useDubsTheme: () => useDubsTheme,
+  useEvents: () => useEvents,
+  useGame: () => useGame,
+  useGames: () => useGames,
+  useJoinGame: () => useJoinGame,
+  useNetworkGames: () => useNetworkGames
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/constants.ts
+var DEFAULT_BASE_URL = "https://dubs-server-prod-9c91d3f01199.herokuapp.com/api/developer/v1";
+var DEFAULT_RPC_URL = "https://api.mainnet-beta.solana.com";
+
+// src/errors.ts
+var DubsApiError = class extends Error {
+  constructor(code, message, httpStatus) {
+    super(message);
+    this.name = "DubsApiError";
+    this.code = code;
+    this.httpStatus = httpStatus;
+  }
+};
+var SOLANA_PROGRAM_ERRORS = {
+  6e3: { code: "invalid_amount", message: "Amount must be greater than 0" },
+  6001: { code: "invalid_max_players", message: "Max players must be between 1 and 20" },
+  6002: { code: "game_not_active", message: "Game is not active" },
+  6003: { code: "game_full", message: "Game is full" },
+  6004: { code: "player_already_joined", message: "Player has already joined this game" },
+  6005: { code: "insufficient_funds", message: "Insufficient funds in pot" },
+  6006: { code: "unauthorized", message: "Only the game creator can perform this action" },
+  6007: { code: "invalid_winner_index", message: "Invalid winner index" },
+  6008: { code: "game_still_active", message: "Game is still active \u2014 must close before resetting" },
+  6009: { code: "pot_not_empty", message: "Pot must be empty before resetting \u2014 distribute winnings first" },
+  6010: { code: "no_winners_specified", message: "At least one winner must be specified" },
+  6011: { code: "mismatched_winners_percentages", message: "Number of winners must match number of percentages" },
+  6012: { code: "percentages_invalid", message: "Percentages must sum to exactly 100" },
+  6013: { code: "winner_account_mismatch", message: "Winner account does not match expected player" },
+  6014: { code: "invalid_operator_fee", message: "Operator fee must be between 0 and 100" },
+  6015: { code: "operator_wallet_mismatch", message: "Operator wallet does not match game settings" },
+  6016: { code: "winner_not_in_game", message: "Winner address is not a player in this game" },
+  6017: { code: "voting_not_enabled", message: "Voting is not enabled for this game" },
+  6018: { code: "voter_not_in_game", message: "Voter is not a player in this game" },
+  6019: { code: "voted_for_not_in_game", message: "Cannot vote for someone who is not in the game" },
+  6020: { code: "voting_incomplete", message: "Voting incomplete \u2014 need majority of players to vote" },
+  6021: { code: "invalid_referee_commission", message: "Referee commission must be between 0 and 100" },
+  6022: { code: "total_fees_exceed_100", message: "Total fees (operator + referee) cannot exceed 100%" },
+  6023: { code: "referee_mode_requires_referee", message: "Referee mode requires a referee address" },
+  6024: { code: "referee_must_earn_commission", message: "Referee must earn commission" },
+  6025: { code: "referee_cannot_be_player", message: "Referee cannot join as a player (conflict of interest)" },
+  6026: { code: "only_referee_can_vote", message: "Only the referee can vote in Referee mode" },
+  6027: { code: "referee_account_mismatch", message: "Referee account does not match game settings" },
+  6028: { code: "invalid_lock_time", message: "Lock time must be in the future" },
+  6029: { code: "game_locked", message: "Game is locked \u2014 no more players can join" },
+  6030: { code: "lock_time_passed", message: "Lock time has passed \u2014 game is now locked" },
+  6031: { code: "unauthorized_oracle", message: "Only authorized oracle can resolve this game" },
+  6032: { code: "game_not_locked", message: "Game must be locked before it can be resolved" },
+  6033: { code: "already_resolved", message: "Game has already been resolved" },
+  6034: { code: "game_not_resolved", message: "Game has not been resolved yet" },
+  6035: { code: "player_not_in_game", message: "Player is not in this game" },
+  6036: { code: "not_a_winner", message: "Player did not win this game" },
+  6037: { code: "invalid_game_mode", message: "Invalid game mode for this operation" },
+  6038: { code: "already_claimed", message: "Player has already claimed their winnings" },
+  6039: { code: "lock_time_too_soon", message: "Lock time must be at least 2 minutes in the future" },
+  6040: { code: "operator_account_missing", message: "Operator account must be provided" },
+  6041: { code: "no_winners_to_distribute", message: "No winners to distribute funds to" },
+  6042: { code: "insufficient_funds_for_rent", message: "Insufficient funds to maintain rent exemption" },
+  6043: { code: "cannot_resolve_before_lock", message: "Cannot resolve game before lock time has passed" },
+  6044: { code: "emergency_refund_not_available", message: "Emergency refund not available yet \u2014 must wait 7 days after lock time" },
+  6045: { code: "sponsor_account_missing", message: "Sponsor account must be provided for tie refund" },
+  6046: { code: "sponsor_wallet_mismatch", message: "Sponsor wallet does not match stored sponsor" },
+  6047: { code: "invalid_bet_amount", message: "Bet amount must be greater than zero" },
+  6048: { code: "no_survivors_to_distribute", message: "No survivors to distribute winnings to" },
+  6049: { code: "too_many_survivors", message: "Too many survivors (max 50 per batch)" }
+};
+var SOLANA_BUILTIN_ERRORS = {
+  0: { code: "generic_error", message: "Generic instruction error" },
+  1: { code: "invalid_argument", message: "Invalid argument passed to program" },
+  2: { code: "invalid_instruction_data", message: "Invalid instruction data" },
+  3: { code: "invalid_account_data", message: "Invalid account data" },
+  4: { code: "account_data_too_small", message: "Account data too small" },
+  5: { code: "insufficient_funds", message: "Insufficient funds for transaction" },
+  6: { code: "incorrect_program_id", message: "Incorrect program ID" },
+  7: { code: "missing_required_signature", message: "Missing required signature" },
+  8: { code: "account_already_initialized", message: "Account already initialized" },
+  9: { code: "uninitialized_account", message: "Attempt to operate on uninitialized account" }
+};
+function parseSolanaError(err) {
+  if (!err) return { code: "unknown_error", message: "Unknown transaction error" };
+  let parsed = err;
+  if (typeof parsed === "string") {
+    try {
+      const jsonMatch = parsed.match(/\{.*\}/s);
+      if (jsonMatch) parsed = JSON.parse(jsonMatch[0]);
+      else return { code: "transaction_failed", message: parsed };
+    } catch {
+      return { code: "transaction_failed", message: parsed };
+    }
+  }
+  if (typeof parsed === "object" && parsed !== null && "InstructionError" in parsed) {
+    const [ixIndex, details] = parsed.InstructionError;
+    if (details && typeof details === "object" && "Custom" in details) {
+      const customCode = details.Custom;
+      const known = SOLANA_PROGRAM_ERRORS[customCode];
+      if (known) return known;
+      return { code: `program_error_${customCode}`, message: `Program error code ${customCode} (instruction ${ixIndex})` };
+    }
+    if (typeof details === "string") {
+      const snake = details.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+      return { code: snake, message: details.replace(/([a-z])([A-Z])/g, "$1 $2") };
+    }
+    if (typeof details === "number") {
+      const known = SOLANA_BUILTIN_ERRORS[details];
+      if (known) return known;
+      return { code: `instruction_error_${details}`, message: `Instruction error ${details}` };
+    }
+    return { code: "instruction_error", message: `Instruction ${ixIndex} failed: ${JSON.stringify(details)}` };
+  }
+  return { code: "transaction_failed", message: typeof parsed === "object" ? JSON.stringify(parsed) : String(parsed) };
+}
+
+// src/client.ts
+var DubsClient = class {
+  constructor(config) {
+    this._token = null;
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+  }
+  /** Set the user JWT token for authenticated requests */
+  setToken(token) {
+    this._token = token;
+  }
+  /** Get the current user JWT token */
+  getToken() {
+    return this._token;
+  }
+  // ── Private HTTP helper ──
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      "X-API-Key": this.apiKey,
+      "Content-Type": "application/json"
+    };
+    if (this._token) {
+      headers["Authorization"] = `Bearer ${this._token}`;
+    }
+    const res = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    const json = await res.json();
+    if (!json.success) {
+      const err = json.error;
+      if (typeof err === "object" && err !== null) {
+        throw new DubsApiError(err.code || "unknown", err.message || "Unknown error", res.status);
+      }
+      throw new DubsApiError("unknown", typeof err === "string" ? err : "Request failed", res.status);
+    }
+    return json;
+  }
+  // ── Events ──
+  async getUpcomingEvents(params) {
+    const qs = new URLSearchParams();
+    if (params?.type) qs.set("type", params.type);
+    if (params?.game) qs.set("game", params.game);
+    if (params?.page) qs.set("page", String(params.page));
+    if (params?.per_page) qs.set("per_page", String(params.per_page));
+    const query = qs.toString();
+    const res = await this.request(
+      "GET",
+      `/events/upcoming${query ? `?${query}` : ""}`
+    );
+    return { events: res.events, pagination: res.pagination };
+  }
+  async getSportsEvents(league) {
+    const res = await this.request(
+      "GET",
+      `/sports/events/${encodeURIComponent(league)}`
+    );
+    return res.events;
+  }
+  async getEsportsMatches(videogame) {
+    const qs = videogame ? `?videogame=${encodeURIComponent(videogame)}` : "";
+    const res = await this.request(
+      "GET",
+      `/esports/matches/upcoming${qs}`
+    );
+    return res.matches;
+  }
+  async getEsportsMatchDetail(matchId) {
+    const res = await this.request(
+      "GET",
+      `/esports/matches/${encodeURIComponent(String(matchId))}`
+    );
+    return res.match;
+  }
+  // ── Game Lifecycle ──
+  async validateEvent(id) {
+    const res = await this.request(
+      "POST",
+      "/games/validate",
+      { id }
+    );
+    return {
+      bettable: res.bettable,
+      gameMode: res.gameMode,
+      lockTimestamp: res.lockTimestamp,
+      startTime: res.startTime,
+      status: res.status
+    };
+  }
+  async createGame(params) {
+    const res = await this.request(
+      "POST",
+      "/games/create",
+      params
+    );
+    return {
+      gameId: res.gameId,
+      gameAddress: res.gameAddress,
+      transaction: res.transaction,
+      lockTimestamp: res.lockTimestamp,
+      event: res.event
+    };
+  }
+  async joinGame(params) {
+    const res = await this.request(
+      "POST",
+      "/games/join",
+      params
+    );
+    return {
+      gameId: res.gameId,
+      transaction: res.transaction,
+      gameAddress: res.gameAddress
+    };
+  }
+  async confirmGame(params) {
+    const res = await this.request(
+      "POST",
+      "/games/confirm",
+      params
+    );
+    return {
+      gameId: res.gameId,
+      signature: res.signature,
+      explorerUrl: res.explorerUrl,
+      message: res.message
+    };
+  }
+  async buildClaimTransaction(params) {
+    const res = await this.request(
+      "POST",
+      "/transactions/build/claim",
+      params
+    );
+    return {
+      transaction: res.transaction,
+      gameAddress: res.gameAddress,
+      message: res.message
+    };
+  }
+  // ── Game Queries ──
+  async getGame(gameId) {
+    const res = await this.request(
+      "GET",
+      `/games/${encodeURIComponent(gameId)}`
+    );
+    return res.game;
+  }
+  async getGames(params) {
+    const qs = new URLSearchParams();
+    if (params?.wallet) qs.set("wallet", params.wallet);
+    if (params?.status) qs.set("status", params.status);
+    if (params?.limit != null) qs.set("limit", String(params.limit));
+    if (params?.offset != null) qs.set("offset", String(params.offset));
+    const query = qs.toString();
+    const res = await this.request(
+      "GET",
+      `/games${query ? `?${query}` : ""}`
+    );
+    return res.games;
+  }
+  // ── Network ──
+  async getNetworkGames(params) {
+    const qs = new URLSearchParams();
+    if (params?.league) qs.set("league", params.league);
+    if (params?.limit != null) qs.set("limit", String(params.limit));
+    if (params?.offset != null) qs.set("offset", String(params.offset));
+    const query = qs.toString();
+    const res = await this.request(
+      "GET",
+      `/network/games${query ? `?${query}` : ""}`
+    );
+    return { games: res.games, pagination: res.pagination };
+  }
+  // ── User Auth ──
+  async getNonce(walletAddress) {
+    const res = await this.request(
+      "POST",
+      "/auth/nonce",
+      { walletAddress }
+    );
+    return res.data;
+  }
+  async authenticate(params) {
+    const res = await this.request(
+      "POST",
+      "/auth/authenticate",
+      params
+    );
+    if (res.data.token) {
+      this._token = res.data.token;
+    }
+    return res.data;
+  }
+  async register(params) {
+    const res = await this.request(
+      "POST",
+      "/auth/register",
+      params
+    );
+    if (res.data.token) {
+      this._token = res.data.token;
+    }
+    return res.data;
+  }
+  async getMe() {
+    const res = await this.request(
+      "GET",
+      "/auth/me"
+    );
+    return res.data.user;
+  }
+  async getUser(walletAddress) {
+    const res = await this.request(
+      "GET",
+      `/users/${encodeURIComponent(walletAddress)}`
+    );
+    return res.data.user;
+  }
+  async getAppUsers(params) {
+    const qs = new URLSearchParams();
+    if (params?.limit != null) qs.set("limit", String(params.limit));
+    if (params?.offset != null) qs.set("offset", String(params.offset));
+    const query = qs.toString();
+    const res = await this.request(
+      "GET",
+      `/users${query ? `?${query}` : ""}`
+    );
+    return res.data;
+  }
+  async checkUsername(username) {
+    const res = await this.request(
+      "GET",
+      `/auth/check-username/${encodeURIComponent(username)}`
+    );
+    return res.data;
+  }
+  async logout() {
+    await this.request(
+      "POST",
+      "/auth/logout"
+    );
+    this._token = null;
+  }
+  // ── Error Utilities ──
+  async parseError(error) {
+    const res = await this.request(
+      "POST",
+      "/errors/parse",
+      { error }
+    );
+    return res.error;
+  }
+  async getErrorCodes() {
+    const res = await this.request(
+      "GET",
+      "/errors/codes"
+    );
+    return res.errors;
+  }
+  /**
+   * Parse a Solana error locally without an API call.
+   * Useful for instant feedback in the UI.
+   */
+  parseErrorLocal(error) {
+    return parseSolanaError(error);
+  }
+  /** Get the full local error code map */
+  getErrorCodesLocal() {
+    return { ...SOLANA_PROGRAM_ERRORS };
+  }
+};
+
+// src/provider.tsx
+var import_react = require("react");
+var import_web3 = require("@solana/web3.js");
+var import_jsx_runtime = require("react/jsx-runtime");
+var DubsContext = (0, import_react.createContext)(null);
+function DubsProvider({ apiKey, baseUrl, rpcUrl, wallet, children }) {
+  const value = (0, import_react.useMemo)(() => {
+    const client = new DubsClient({ apiKey, baseUrl });
+    const connection = new import_web3.Connection(rpcUrl || DEFAULT_RPC_URL, { commitment: "confirmed" });
+    return { client, wallet, connection };
+  }, [apiKey, baseUrl, rpcUrl, wallet]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DubsContext.Provider, { value, children });
+}
+function useDubs() {
+  const ctx = (0, import_react.useContext)(DubsContext);
+  if (!ctx) {
+    throw new Error("useDubs must be used within a <DubsProvider>");
+  }
+  return ctx;
+}
+
+// src/wallet/mwa-adapter.ts
+var import_web32 = require("@solana/web3.js");
+function toPublicKey(address) {
+  if (address instanceof Uint8Array) {
+    return new import_web32.PublicKey(address);
+  }
+  const bytes = Uint8Array.from(atob(address), (c) => c.charCodeAt(0));
+  return new import_web32.PublicKey(bytes);
+}
+var MwaWalletAdapter = class {
+  constructor(config) {
+    this._publicKey = null;
+    this._connected = false;
+    this._authToken = null;
+    this.config = config;
+    this.transact = config.transact;
+  }
+  get publicKey() {
+    return this._publicKey;
+  }
+  get connected() {
+    return this._connected;
+  }
+  /**
+   * Connect to a mobile wallet. Call this before any signing.
+   */
+  async connect() {
+    await this.transact(async (wallet) => {
+      const authResult = this._authToken ? await wallet.reauthorize({ auth_token: this._authToken }) : await wallet.authorize({
+        identity: this.config.appIdentity,
+        cluster: this.config.cluster || "mainnet-beta"
+      });
+      this._publicKey = toPublicKey(authResult.accounts[0].address);
+      this._authToken = authResult.auth_token;
+      this._connected = true;
+      this.config.onAuthTokenChange?.(this._authToken);
+    });
+  }
+  /**
+   * Disconnect and clear auth token.
+   */
+  disconnect() {
+    this._publicKey = null;
+    this._connected = false;
+    this._authToken = null;
+    this.config.onAuthTokenChange?.(null);
+  }
+  async signTransaction(transaction) {
+    if (!this._connected) throw new Error("Wallet not connected");
+    const signed = await this.transact(async (wallet) => {
+      const reauth = await wallet.reauthorize({ auth_token: this._authToken });
+      this._authToken = reauth.auth_token;
+      this.config.onAuthTokenChange?.(this._authToken);
+      const result = await wallet.signTransactions({
+        transactions: [transaction]
+      });
+      return result[0];
+    });
+    return signed;
+  }
+  async signMessage(message) {
+    if (!this._connected || !this._publicKey) throw new Error("Wallet not connected");
+    const sig = await this.transact(async (wallet) => {
+      const reauth = await wallet.reauthorize({ auth_token: this._authToken });
+      this._authToken = reauth.auth_token;
+      this.config.onAuthTokenChange?.(this._authToken);
+      const result = await wallet.signMessages({
+        addresses: [this._publicKey.toBytes()],
+        payloads: [message]
+      });
+      return result[0];
+    });
+    return sig instanceof Uint8Array ? sig : new Uint8Array(sig);
+  }
+  async signAndSendTransaction(transaction) {
+    if (!this._connected) throw new Error("Wallet not connected");
+    const signature = await this.transact(async (wallet) => {
+      const reauth = await wallet.reauthorize({ auth_token: this._authToken });
+      this._authToken = reauth.auth_token;
+      this.config.onAuthTokenChange?.(this._authToken);
+      const result = await wallet.signAndSendTransactions({
+        transactions: [transaction]
+      });
+      return result[0];
+    });
+    if (signature instanceof Uint8Array) {
+      const bs582 = await import("@solana/web3.js").then(() => {
+        return new import_web32.PublicKey(signature).toBase58();
+      }).catch(() => {
+        return Buffer.from(signature).toString("base64");
+      });
+      return bs582;
+    }
+    return String(signature);
+  }
+};
+
+// src/hooks/useEvents.ts
+var import_react2 = require("react");
+function useEvents(params) {
+  const { client } = useDubs();
+  const [data, setData] = (0, import_react2.useState)(null);
+  const [loading, setLoading] = (0, import_react2.useState)(true);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const paramKey = JSON.stringify(params ?? {});
+  const fetchData = (0, import_react2.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await client.getUpcomingEvents(params);
+      setData(result);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, paramKey]);
+  (0, import_react2.useEffect)(() => {
+    fetchData();
+  }, [fetchData]);
+  return { data, loading, error, refetch: fetchData };
+}
+
+// src/hooks/useGame.ts
+var import_react3 = require("react");
+function useGame(gameId) {
+  const { client } = useDubs();
+  const [data, setData] = (0, import_react3.useState)(null);
+  const [loading, setLoading] = (0, import_react3.useState)(!!gameId);
+  const [error, setError] = (0, import_react3.useState)(null);
+  const fetchData = (0, import_react3.useCallback)(async () => {
+    if (!gameId) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const game = await client.getGame(gameId);
+      setData(game);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, gameId]);
+  (0, import_react3.useEffect)(() => {
+    fetchData();
+  }, [fetchData]);
+  return { data, loading, error, refetch: fetchData };
+}
+
+// src/hooks/useGames.ts
+var import_react4 = require("react");
+function useGames(params) {
+  const { client } = useDubs();
+  const [data, setData] = (0, import_react4.useState)(null);
+  const [loading, setLoading] = (0, import_react4.useState)(true);
+  const [error, setError] = (0, import_react4.useState)(null);
+  const paramKey = JSON.stringify(params ?? {});
+  const fetchData = (0, import_react4.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const games = await client.getGames(params);
+      setData(games);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, paramKey]);
+  (0, import_react4.useEffect)(() => {
+    fetchData();
+  }, [fetchData]);
+  return { data, loading, error, refetch: fetchData };
+}
+
+// src/hooks/useNetworkGames.ts
+var import_react5 = require("react");
+function useNetworkGames(params) {
+  const { client } = useDubs();
+  const [data, setData] = (0, import_react5.useState)(null);
+  const [loading, setLoading] = (0, import_react5.useState)(true);
+  const [error, setError] = (0, import_react5.useState)(null);
+  const paramKey = JSON.stringify(params ?? {});
+  const fetchData = (0, import_react5.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await client.getNetworkGames(params);
+      setData(result);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, paramKey]);
+  (0, import_react5.useEffect)(() => {
+    fetchData();
+  }, [fetchData]);
+  return { data, loading, error, refetch: fetchData };
+}
+
+// src/hooks/useCreateGame.ts
+var import_react6 = require("react");
+
+// src/utils/transaction.ts
+var import_web33 = require("@solana/web3.js");
+async function signAndSendBase64Transaction(base64Tx, wallet, connection) {
+  if (!wallet.publicKey) throw new Error("Wallet not connected");
+  const txBuffer = Buffer.from(base64Tx, "base64");
+  const transaction = import_web33.Transaction.from(txBuffer);
+  if (wallet.signAndSendTransaction) {
+    return wallet.signAndSendTransaction(transaction);
+  }
+  const signed = await wallet.signTransaction(transaction);
+  const signature = await connection.sendRawTransaction(signed.serialize(), {
+    skipPreflight: true
+  });
+  return signature;
+}
+async function pollTransactionConfirmation(signature, connection, commitment = "confirmed", timeout = 6e4, interval = 1500) {
+  const start = Date.now();
+  const confirmationOrder = ["processed", "confirmed", "finalized"];
+  const targetIndex = confirmationOrder.indexOf(commitment);
+  while (Date.now() - start < timeout) {
+    const statuses = await connection.getSignatureStatuses([signature]);
+    const status = statuses?.value?.[0];
+    if (status?.err) {
+      throw new Error(`Transaction failed: ${JSON.stringify(status.err)}`);
+    }
+    if (status?.confirmationStatus) {
+      const currentIndex = confirmationOrder.indexOf(status.confirmationStatus);
+      if (currentIndex >= targetIndex) {
+        return;
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, interval));
+  }
+  throw new Error(`Transaction confirmation timeout after ${timeout}ms`);
+}
+
+// src/hooks/useCreateGame.ts
+function useCreateGame() {
+  const { client, wallet, connection } = useDubs();
+  const [status, setStatus] = (0, import_react6.useState)("idle");
+  const [error, setError] = (0, import_react6.useState)(null);
+  const [data, setData] = (0, import_react6.useState)(null);
+  const reset = (0, import_react6.useCallback)(() => {
+    setStatus("idle");
+    setError(null);
+    setData(null);
+  }, []);
+  const execute = (0, import_react6.useCallback)(async (params) => {
+    setStatus("building");
+    setError(null);
+    setData(null);
+    try {
+      const createResult = await client.createGame(params);
+      setStatus("signing");
+      const signature = await signAndSendBase64Transaction(
+        createResult.transaction,
+        wallet,
+        connection
+      );
+      setStatus("confirming");
+      await pollTransactionConfirmation(signature, connection);
+      setStatus("saving");
+      const explorerUrl = `https://solscan.io/tx/${signature}`;
+      await client.confirmGame({
+        gameId: createResult.gameId,
+        playerWallet: params.playerWallet,
+        signature,
+        teamChoice: params.teamChoice,
+        wagerAmount: params.wagerAmount,
+        role: "creator",
+        gameAddress: createResult.gameAddress
+      });
+      const result = {
+        gameId: createResult.gameId,
+        gameAddress: createResult.gameAddress,
+        signature,
+        explorerUrl
+      };
+      setData(result);
+      setStatus("success");
+      return result;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+      setStatus("error");
+      throw error2;
+    }
+  }, [client, wallet, connection]);
+  return { execute, status, error, data, reset };
+}
+
+// src/hooks/useJoinGame.ts
+var import_react7 = require("react");
+function useJoinGame() {
+  const { client, wallet, connection } = useDubs();
+  const [status, setStatus] = (0, import_react7.useState)("idle");
+  const [error, setError] = (0, import_react7.useState)(null);
+  const [data, setData] = (0, import_react7.useState)(null);
+  const reset = (0, import_react7.useCallback)(() => {
+    setStatus("idle");
+    setError(null);
+    setData(null);
+  }, []);
+  const execute = (0, import_react7.useCallback)(async (params) => {
+    setStatus("building");
+    setError(null);
+    setData(null);
+    try {
+      const joinResult = await client.joinGame(params);
+      setStatus("signing");
+      const signature = await signAndSendBase64Transaction(
+        joinResult.transaction,
+        wallet,
+        connection
+      );
+      setStatus("confirming");
+      await pollTransactionConfirmation(signature, connection);
+      setStatus("saving");
+      const explorerUrl = `https://solscan.io/tx/${signature}`;
+      await client.confirmGame({
+        gameId: params.gameId,
+        playerWallet: params.playerWallet,
+        signature,
+        teamChoice: params.teamChoice,
+        wagerAmount: params.amount,
+        role: "joiner",
+        gameAddress: joinResult.gameAddress
+      });
+      const result = {
+        gameId: params.gameId,
+        gameAddress: joinResult.gameAddress,
+        signature,
+        explorerUrl
+      };
+      setData(result);
+      setStatus("success");
+      return result;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+      setStatus("error");
+      throw error2;
+    }
+  }, [client, wallet, connection]);
+  return { execute, status, error, data, reset };
+}
+
+// src/hooks/useClaim.ts
+var import_react8 = require("react");
+function useClaim() {
+  const { client, wallet, connection } = useDubs();
+  const [status, setStatus] = (0, import_react8.useState)("idle");
+  const [error, setError] = (0, import_react8.useState)(null);
+  const [data, setData] = (0, import_react8.useState)(null);
+  const reset = (0, import_react8.useCallback)(() => {
+    setStatus("idle");
+    setError(null);
+    setData(null);
+  }, []);
+  const execute = (0, import_react8.useCallback)(async (params) => {
+    setStatus("building");
+    setError(null);
+    setData(null);
+    try {
+      const claimResult = await client.buildClaimTransaction(params);
+      setStatus("signing");
+      const signature = await signAndSendBase64Transaction(
+        claimResult.transaction,
+        wallet,
+        connection
+      );
+      setStatus("confirming");
+      await pollTransactionConfirmation(signature, connection);
+      const explorerUrl = `https://solscan.io/tx/${signature}`;
+      const result = {
+        gameId: params.gameId,
+        signature,
+        explorerUrl
+      };
+      setData(result);
+      setStatus("success");
+      return result;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+      setStatus("error");
+      throw error2;
+    }
+  }, [client, wallet, connection]);
+  return { execute, status, error, data, reset };
+}
+
+// src/hooks/useAuth.ts
+var import_react9 = require("react");
+var import_bs58 = __toESM(require("bs58"));
+function useAuth() {
+  const { client, wallet } = useDubs();
+  const [status, setStatus] = (0, import_react9.useState)("idle");
+  const [user, setUser] = (0, import_react9.useState)(null);
+  const [token, setToken] = (0, import_react9.useState)(null);
+  const [error, setError] = (0, import_react9.useState)(null);
+  const pendingAuth = (0, import_react9.useRef)(null);
+  const reset = (0, import_react9.useCallback)(() => {
+    setStatus("idle");
+    setUser(null);
+    setToken(null);
+    setError(null);
+    pendingAuth.current = null;
+    client.setToken(null);
+  }, [client]);
+  const authenticate = (0, import_react9.useCallback)(async () => {
+    try {
+      if (!wallet.publicKey) {
+        throw new Error("Wallet not connected");
+      }
+      if (!wallet.signMessage) {
+        throw new Error("Wallet does not support signMessage");
+      }
+      const walletAddress = wallet.publicKey.toBase58();
+      setStatus("authenticating");
+      setError(null);
+      const { nonce, message } = await client.getNonce(walletAddress);
+      setStatus("signing");
+      const messageBytes = new TextEncoder().encode(message);
+      const signatureBytes = await wallet.signMessage(messageBytes);
+      const signature = import_bs58.default.encode(signatureBytes);
+      setStatus("verifying");
+      const result = await client.authenticate({ walletAddress, signature, nonce });
+      if (result.needsRegistration) {
+        pendingAuth.current = { walletAddress, nonce, signature };
+        setStatus("needsRegistration");
+        return;
+      }
+      setUser(result.user);
+      setToken(result.token);
+      setStatus("authenticated");
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+      setStatus("error");
+    }
+  }, [client, wallet]);
+  const register = (0, import_react9.useCallback)(async (username, referralCode) => {
+    try {
+      const pending = pendingAuth.current;
+      if (!pending) {
+        throw new Error("No pending authentication \u2014 call authenticate() first");
+      }
+      setStatus("registering");
+      setError(null);
+      const result = await client.register({
+        walletAddress: pending.walletAddress,
+        signature: pending.signature,
+        nonce: pending.nonce,
+        username,
+        referralCode
+      });
+      pendingAuth.current = null;
+      setUser(result.user);
+      setToken(result.token);
+      setStatus("authenticated");
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+      setStatus("error");
+    }
+  }, [client]);
+  const logout = (0, import_react9.useCallback)(async () => {
+    try {
+      await client.logout();
+    } catch {
+    }
+    setUser(null);
+    setToken(null);
+    setStatus("idle");
+    setError(null);
+    pendingAuth.current = null;
+  }, [client]);
+  const restoreSession = (0, import_react9.useCallback)(async (savedToken) => {
+    try {
+      client.setToken(savedToken);
+      const me = await client.getMe();
+      setUser(me);
+      setToken(savedToken);
+      setStatus("authenticated");
+      return true;
+    } catch {
+      client.setToken(null);
+      setUser(null);
+      setToken(null);
+      setStatus("idle");
+      return false;
+    }
+  }, [client]);
+  return {
+    status,
+    user,
+    token,
+    isAuthenticated: status === "authenticated",
+    error,
+    authenticate,
+    register,
+    logout,
+    restoreSession,
+    reset
+  };
+}
+
+// src/ui/ConnectWalletScreen.tsx
+var import_react_native2 = require("react-native");
+
+// src/ui/theme.ts
+var import_react_native = require("react-native");
+var dark = {
+  background: "#08080D",
+  surface: "#111118",
+  surfaceActive: "#7C3AED",
+  border: "#1A1A24",
+  text: "#FFFFFF",
+  textSecondary: "#E0E0EE",
+  textMuted: "#666666",
+  textDim: "#555555",
+  accent: "#7C3AED",
+  success: "#22C55E",
+  live: "#EF4444",
+  errorText: "#F87171",
+  errorBg: "#1A0A0A",
+  errorBorder: "#3A1515"
+};
+var light = {
+  background: "#FFFFFF",
+  surface: "#F0F0F5",
+  surfaceActive: "#7C3AED",
+  border: "#E0E0E8",
+  text: "#111118",
+  textSecondary: "#333333",
+  textMuted: "#888888",
+  textDim: "#999999",
+  accent: "#7C3AED",
+  success: "#16A34A",
+  live: "#DC2626",
+  errorText: "#DC2626",
+  errorBg: "#FEF2F2",
+  errorBorder: "#FECACA"
+};
+function useDubsTheme() {
+  const scheme = (0, import_react_native.useColorScheme)();
+  return scheme === "light" ? light : dark;
+}
+
+// src/ui/ConnectWalletScreen.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function ConnectWalletScreen({
+  onConnect,
+  connecting = false,
+  error = null,
+  appName = "Dubs"
+}) {
+  const t = useDubsTheme();
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native2.View, { style: [styles.container, { backgroundColor: t.background }], children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_native2.View, { style: styles.content, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_native2.View, { style: styles.brandingSection, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native2.View, { style: [styles.logoCircle, { backgroundColor: t.accent }], children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native2.Text, { style: styles.logoText, children: "D" }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native2.Text, { style: [styles.appName, { color: t.text }], children: appName }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native2.Text, { style: [styles.subtitle, { color: t.textMuted }], children: "Connect your Solana wallet to get started" })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_native2.View, { style: styles.actionSection, children: [
+      error ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+        import_react_native2.View,
+        {
+          style: [
+            styles.errorBox,
+            { backgroundColor: t.errorBg, borderColor: t.errorBorder }
+          ],
+          children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native2.Text, { style: [styles.errorText, { color: t.errorText }], children: error })
+        }
+      ) : null,
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+        import_react_native2.TouchableOpacity,
+        {
+          style: [styles.connectButton, { backgroundColor: t.accent }],
+          onPress: onConnect,
+          disabled: connecting,
+          activeOpacity: 0.8,
+          children: connecting ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native2.ActivityIndicator, { color: "#FFFFFF", size: "small" }) : /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native2.Text, { style: styles.connectButtonText, children: "Connect Wallet" })
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native2.Text, { style: [styles.hint, { color: t.textDim }], children: "Phantom, Solflare, or any Solana wallet" })
+    ] })
+  ] }) });
+}
+var styles = import_react_native2.StyleSheet.create({
+  container: {
+    flex: 1,
+    justifyContent: "center"
+  },
+  content: {
+    flex: 1,
+    justifyContent: "space-between",
+    paddingHorizontal: 32,
+    paddingTop: 120,
+    paddingBottom: 80
+  },
+  brandingSection: {
+    alignItems: "center",
+    gap: 12
+  },
+  logoCircle: {
+    width: 80,
+    height: 80,
+    borderRadius: 40,
+    justifyContent: "center",
+    alignItems: "center",
+    marginBottom: 8
+  },
+  logoText: {
+    fontSize: 36,
+    fontWeight: "800",
+    color: "#FFFFFF"
+  },
+  appName: {
+    fontSize: 32,
+    fontWeight: "800"
+  },
+  subtitle: {
+    fontSize: 16,
+    textAlign: "center",
+    lineHeight: 22
+  },
+  actionSection: {
+    gap: 16
+  },
+  errorBox: {
+    borderWidth: 1,
+    borderRadius: 12,
+    paddingHorizontal: 16,
+    paddingVertical: 12
+  },
+  errorText: {
+    fontSize: 14,
+    textAlign: "center"
+  },
+  connectButton: {
+    height: 56,
+    borderRadius: 16,
+    justifyContent: "center",
+    alignItems: "center"
+  },
+  connectButtonText: {
+    color: "#FFFFFF",
+    fontSize: 18,
+    fontWeight: "700"
+  },
+  hint: {
+    fontSize: 13,
+    textAlign: "center"
+  }
+});
+
+// src/ui/UserProfileCard.tsx
+var import_react10 = require("react");
+var import_react_native3 = require("react-native");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+function truncateAddress(address, chars = 4) {
+  if (address.length <= chars * 2 + 3) return address;
+  return `${address.slice(0, chars)}...${address.slice(-chars)}`;
+}
+function formatMemberSince(iso) {
+  const date = new Date(iso);
+  const month = date.toLocaleString("en-US", { month: "short" });
+  const year = date.getFullYear();
+  return `Member since ${month} ${year}`;
+}
+function UserProfileCard({
+  walletAddress,
+  username,
+  avatarUrl,
+  memberSince
+}) {
+  const t = useDubsTheme();
+  const imageUri = (0, import_react10.useMemo)(
+    () => avatarUrl || `https://api.dicebear.com/9.x/avataaars/png?seed=${walletAddress}&size=128`,
+    [avatarUrl, walletAddress]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_react_native3.View, { style: [styles2.card, { backgroundColor: t.surface, borderColor: t.border }], children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native3.Image, { source: { uri: imageUri }, style: styles2.avatar }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_react_native3.View, { style: styles2.info, children: [
+      username ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native3.Text, { style: [styles2.username, { color: t.text }], children: username }) : null,
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native3.Text, { style: [styles2.address, { color: t.textMuted }], children: truncateAddress(walletAddress) }),
+      memberSince ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native3.Text, { style: [styles2.memberSince, { color: t.textDim }], children: formatMemberSince(memberSince) }) : null
+    ] })
+  ] });
+}
+var styles2 = import_react_native3.StyleSheet.create({
+  card: {
+    flexDirection: "row",
+    alignItems: "center",
+    padding: 16,
+    borderRadius: 16,
+    borderWidth: 1,
+    gap: 14
+  },
+  avatar: {
+    width: 64,
+    height: 64,
+    borderRadius: 32,
+    backgroundColor: "#1A1A24"
+  },
+  info: {
+    flex: 1,
+    gap: 2
+  },
+  username: {
+    fontSize: 18,
+    fontWeight: "700"
+  },
+  address: {
+    fontSize: 14,
+    fontFamily: "monospace"
+  },
+  memberSince: {
+    fontSize: 12,
+    marginTop: 2
+  }
+});
+
+// src/ui/SettingsSheet.tsx
+var import_react_native4 = require("react-native");
+var import_jsx_runtime4 = require("react/jsx-runtime");
+function truncateAddress2(address, chars = 4) {
+  if (address.length <= chars * 2 + 3) return address;
+  return `${address.slice(0, chars)}...${address.slice(-chars)}`;
+}
+function SettingsSheet({
+  walletAddress,
+  username,
+  avatarUrl,
+  memberSince,
+  appVersion,
+  onCopyAddress,
+  onSupport,
+  onLogout,
+  loggingOut = false
+}) {
+  const t = useDubsTheme();
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
+    import_react_native4.ScrollView,
+    {
+      style: [styles3.container, { backgroundColor: t.background }],
+      contentContainerStyle: styles3.content,
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          UserProfileCard,
+          {
+            walletAddress,
+            username,
+            avatarUrl,
+            memberSince
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_react_native4.View, { style: [styles3.actionsCard, { backgroundColor: t.surface, borderColor: t.border }], children: [
+          onCopyAddress ? /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
+            import_react_native4.TouchableOpacity,
+            {
+              style: styles3.actionRow,
+              onPress: onCopyAddress,
+              activeOpacity: 0.7,
+              children: [
+                /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_react_native4.View, { style: styles3.actionRowLeft, children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native4.Text, { style: [styles3.actionLabel, { color: t.text }], children: "Wallet Address" }),
+                  /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native4.Text, { style: [styles3.actionValue, { color: t.textMuted }], children: truncateAddress2(walletAddress) })
+                ] }),
+                /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native4.Text, { style: [styles3.copyLabel, { color: t.accent }], children: "Copy" })
+              ]
+            }
+          ) : null,
+          onSupport ? /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_jsx_runtime4.Fragment, { children: [
+            onCopyAddress ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native4.View, { style: [styles3.separator, { backgroundColor: t.border }] }) : null,
+            /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
+              import_react_native4.TouchableOpacity,
+              {
+                style: styles3.actionRow,
+                onPress: onSupport,
+                activeOpacity: 0.7,
+                children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native4.Text, { style: [styles3.actionLabel, { color: t.text }], children: "Help & Support" }),
+                  /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native4.Text, { style: [styles3.chevron, { color: t.textMuted }], children: "\u203A" })
+                ]
+              }
+            )
+          ] }) : null
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          import_react_native4.TouchableOpacity,
+          {
+            style: [styles3.logoutButton, { borderColor: t.live }],
+            onPress: onLogout,
+            disabled: loggingOut,
+            activeOpacity: 0.7,
+            children: loggingOut ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native4.ActivityIndicator, { color: t.live, size: "small" }) : /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native4.Text, { style: [styles3.logoutText, { color: t.live }], children: "Log Out" })
+          }
+        ),
+        appVersion ? /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_react_native4.Text, { style: [styles3.version, { color: t.textDim }], children: [
+          "v",
+          appVersion
+        ] }) : null
+      ]
+    }
+  );
+}
+var styles3 = import_react_native4.StyleSheet.create({
+  container: {
+    flex: 1
+  },
+  content: {
+    padding: 20,
+    paddingTop: 24,
+    gap: 20
+  },
+  actionsCard: {
+    borderRadius: 16,
+    borderWidth: 1,
+    overflow: "hidden"
+  },
+  actionRow: {
+    flexDirection: "row",
+    alignItems: "center",
+    justifyContent: "space-between",
+    paddingHorizontal: 16,
+    paddingVertical: 14
+  },
+  actionRowLeft: {
+    flex: 1,
+    gap: 2
+  },
+  actionLabel: {
+    fontSize: 15,
+    fontWeight: "600"
+  },
+  actionValue: {
+    fontSize: 13,
+    fontFamily: "monospace"
+  },
+  copyLabel: {
+    fontSize: 14,
+    fontWeight: "600"
+  },
+  chevron: {
+    fontSize: 22,
+    fontWeight: "300"
+  },
+  separator: {
+    height: 1,
+    marginHorizontal: 16
+  },
+  logoutButton: {
+    height: 52,
+    borderRadius: 16,
+    borderWidth: 1.5,
+    justifyContent: "center",
+    alignItems: "center"
+  },
+  logoutText: {
+    fontSize: 16,
+    fontWeight: "700"
+  },
+  version: {
+    fontSize: 12,
+    textAlign: "center"
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConnectWalletScreen,
+  DEFAULT_BASE_URL,
+  DEFAULT_RPC_URL,
+  DubsApiError,
+  DubsClient,
+  DubsProvider,
+  MwaWalletAdapter,
+  SOLANA_PROGRAM_ERRORS,
+  SettingsSheet,
+  UserProfileCard,
+  parseSolanaError,
+  pollTransactionConfirmation,
+  signAndSendBase64Transaction,
+  useAuth,
+  useClaim,
+  useCreateGame,
+  useDubs,
+  useDubsTheme,
+  useEvents,
+  useGame,
+  useGames,
+  useJoinGame,
+  useNetworkGames
+});
+//# sourceMappingURL=index.js.map