@pokertools/sdk 1.0.4

package/dist/index.cjs

@@ -0,0 +1,1126 @@
+'use strict';
+
+var types = require('@pokertools/types');
+
+// src/types.ts
+var PokerSDKError = class extends Error {
+  constructor(message, code, statusCode, details) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "PokerSDKError";
+  }
+};
+
+// src/client.ts
+var DEFAULT_CONFIG = {
+  timeout: 3e4,
+  retry: {
+    count: 3,
+    delay: 1e3,
+    backoff: 2
+  }
+};
+var PokerClient = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.timeout = config.timeout ?? DEFAULT_CONFIG.timeout;
+    this.retry = {
+      count: config.retry?.count ?? DEFAULT_CONFIG.retry.count,
+      delay: config.retry?.delay ?? DEFAULT_CONFIG.retry.delay,
+      backoff: config.retry?.backoff ?? DEFAULT_CONFIG.retry.backoff
+    };
+    this.fetchFn = config.fetch ?? globalThis.fetch.bind(globalThis);
+    this.debug = config.debug ?? false;
+    this.token = config.token ?? null;
+  }
+  // ============================================================================
+  // Configuration
+  // ============================================================================
+  /**
+   * Set the authentication token
+   */
+  setToken(token) {
+    this.token = token;
+  }
+  /**
+   * Get current token
+   */
+  getToken() {
+    return this.token;
+  }
+  /**
+   * Check if client is authenticated
+   */
+  isAuthenticated() {
+    return this.token !== null;
+  }
+  // ============================================================================
+  // Authentication
+  // ============================================================================
+  /**
+   * Get a nonce for SIWE authentication
+   */
+  async getNonce() {
+    const response = await this.request("POST", "/auth/nonce");
+    return response.nonce;
+  }
+  /**
+   * Login with SIWE signature
+   */
+  async login(request) {
+    const response = await this.request("POST", "/auth/login", request);
+    this.token = response.token;
+    return response;
+  }
+  /**
+   * Logout and revoke session
+   */
+  async logout() {
+    await this.request("POST", "/auth/logout");
+    this.token = null;
+  }
+  // ============================================================================
+  // Tables
+  // ============================================================================
+  /**
+   * Get list of active tables
+   */
+  async getTables() {
+    const response = await this.request("GET", "/tables");
+    return response.tables;
+  }
+  /**
+   * Create a new table
+   */
+  async createTable(config) {
+    const response = await this.request("POST", "/tables", config);
+    return response.tableId;
+  }
+  /**
+   * Get table state
+   * @param tableId - Table ID
+   * @param since - Optional version for conditional fetch (returns null if unchanged)
+   */
+  async getTableState(tableId, since) {
+    const query = since !== void 0 ? `?since=${since}` : "";
+    try {
+      const response = await this.request(
+        "GET",
+        `/tables/${tableId}${query}`
+      );
+      return response.state;
+    } catch (error) {
+      if (error instanceof PokerSDKError && error.statusCode === 304) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Buy in to a table
+   */
+  async buyIn(tableId, request) {
+    await this.request("POST", `/tables/${tableId}/buy-in`, request);
+  }
+  /**
+   * Execute a game action
+   */
+  async action(tableId, request) {
+    const response = await this.request(
+      "POST",
+      `/tables/${tableId}/action`,
+      request
+    );
+    return response.state;
+  }
+  /**
+   * Add chips to stack (rebuy/top-up)
+   */
+  async addChips(tableId, request) {
+    await this.request("POST", `/tables/${tableId}/add-chips`, request);
+  }
+  /**
+   * Stand from table (leave and cash out)
+   */
+  async stand(tableId) {
+    await this.request("POST", `/tables/${tableId}/stand`);
+  }
+  // ============================================================================
+  // Convenience Action Methods
+  // ============================================================================
+  /**
+   * Fold hand
+   */
+  async fold(tableId) {
+    return this.action(tableId, { type: "FOLD" });
+  }
+  /**
+   * Check (pass action)
+   */
+  async check(tableId) {
+    return this.action(tableId, { type: "CHECK" });
+  }
+  /**
+   * Call current bet
+   */
+  async call(tableId) {
+    return this.action(tableId, { type: "CALL" });
+  }
+  /**
+   * Place a bet
+   */
+  async bet(tableId, amount) {
+    return this.action(tableId, { type: "BET", amount });
+  }
+  /**
+   * Raise the current bet
+   */
+  async raise(tableId, amount) {
+    return this.action(tableId, { type: "RAISE", amount });
+  }
+  /**
+   * Deal new hand
+   */
+  async deal(tableId) {
+    return this.action(tableId, { type: "DEAL" });
+  }
+  /**
+   * Show cards at showdown
+   */
+  async show(tableId, cardIndices) {
+    return this.action(tableId, { type: "SHOW", cardIndices });
+  }
+  /**
+   * Muck cards at showdown
+   */
+  async muck(tableId) {
+    return this.action(tableId, { type: "MUCK" });
+  }
+  /**
+   * Use time bank
+   */
+  async timeBank(tableId) {
+    return this.action(tableId, { type: "TIME_BANK" });
+  }
+  // ============================================================================
+  // User
+  // ============================================================================
+  /**
+   * Get current user profile and balances
+   */
+  async getProfile() {
+    return this.request("GET", "/user/me");
+  }
+  /**
+   * Get hand history
+   */
+  async getHandHistory() {
+    const response = await this.request("GET", "/user/history");
+    return response.history;
+  }
+  /**
+   * Request a withdrawal
+   */
+  async withdraw(request) {
+    return this.request("POST", "/user/withdraw", request);
+  }
+  /**
+   * Get withdrawal history
+   */
+  async getWithdrawals() {
+    const response = await this.request(
+      "GET",
+      "/user/withdrawals"
+    );
+    return response.withdrawals;
+  }
+  // ============================================================================
+  // Finance
+  // ============================================================================
+  /**
+   * Get supported blockchains and tokens
+   */
+  async getChains() {
+    return this.request("GET", "/finance/chains");
+  }
+  /**
+   * Start deposit monitoring session
+   */
+  async startDeposit() {
+    return this.request("POST", "/finance/deposit/start");
+  }
+  /**
+   * Get deposit address
+   */
+  async getDepositAddress() {
+    const response = await this.request("GET", "/finance/deposit/address");
+    return response.address;
+  }
+  /**
+   * Get deposit history
+   */
+  async getDeposits() {
+    const response = await this.request("GET", "/finance/deposits");
+    return response.deposits;
+  }
+  // ============================================================================
+  // Notes
+  // ============================================================================
+  /**
+   * Get all notes by current user
+   */
+  async getNotes() {
+    const response = await this.request("GET", "/notes");
+    return response.notes;
+  }
+  /**
+   * Get note for specific player
+   */
+  async getNote(targetId) {
+    const response = await this.request("GET", `/notes/${targetId}`);
+    return response.note;
+  }
+  /**
+   * Save or update note
+   */
+  async saveNote(targetId, content, label) {
+    const response = await this.request("POST", "/notes", {
+      targetId,
+      content,
+      label
+    });
+    return response.note;
+  }
+  /**
+   * Delete note
+   */
+  async deleteNote(targetId) {
+    await this.request("DELETE", `/notes/${targetId}`);
+  }
+  // ============================================================================
+  // Health
+  // ============================================================================
+  /**
+   * Health check
+   */
+  async health() {
+    return this.request("GET", "/health");
+  }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
+  /**
+   * Make HTTP request with retry logic
+   */
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.token) {
+      headers.Authorization = `Bearer ${this.token}`;
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.retry.count; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        if (this.debug) {
+          console.log(`[PokerSDK] ${method} ${path}`, body);
+        }
+        const response = await this.fetchFn(url, {
+          method,
+          headers,
+          body: body ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (response.status === 304) {
+          throw new PokerSDKError("Not Modified", "NOT_MODIFIED", 304);
+        }
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({}));
+          throw new PokerSDKError(
+            errorData.message ?? errorData.error ?? `HTTP ${response.status}`,
+            errorData.code ?? errorData.error ?? "HTTP_ERROR",
+            response.status,
+            errorData
+          );
+        }
+        const data = await response.json();
+        if (this.debug) {
+          console.log(`[PokerSDK] Response:`, data);
+        }
+        return data;
+      } catch (error) {
+        lastError = error;
+        if (error instanceof PokerSDKError) {
+          if (error.statusCode && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429) {
+            throw error;
+          }
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          throw new PokerSDKError("Request timeout", "TIMEOUT", void 0, {
+            timeout: this.timeout
+          });
+        }
+        if (attempt < this.retry.count) {
+          const delay = this.retry.delay * Math.pow(this.retry.backoff, attempt);
+          if (this.debug) {
+            console.log(`[PokerSDK] Retry ${attempt + 1}/${this.retry.count} in ${delay}ms`);
+          }
+          await this.sleep(delay);
+        }
+      }
+    }
+    throw lastError ?? new PokerSDKError("Request failed", "REQUEST_FAILED");
+  }
+  /**
+   * Sleep helper
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+var DEFAULT_SOCKET_CONFIG = {
+  heartbeatInterval: 25e3,
+  reconnectAttempts: 10,
+  reconnectDelay: 1e3,
+  maxReconnectDelay: 3e4
+};
+var PokerSocket = class _PokerSocket {
+  constructor(config) {
+    this.ws = null;
+    this.connectionState = "disconnected";
+    this.reconnectCount = 0;
+    this.heartbeatTimer = null;
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    this.joinedTables = /* @__PURE__ */ new Set();
+    this.listeners = /* @__PURE__ */ new Map();
+    this.shouldReconnect = true;
+    // Latest state cache for each table
+    this.stateCache = /* @__PURE__ */ new Map();
+    const wsUrl = new URL(config.url);
+    wsUrl.searchParams.set("token", config.token);
+    this.url = wsUrl.toString();
+    this.token = config.token;
+    this.heartbeatInterval = config.heartbeatInterval ?? DEFAULT_SOCKET_CONFIG.heartbeatInterval;
+    this.reconnectAttempts = config.reconnectAttempts ?? DEFAULT_SOCKET_CONFIG.reconnectAttempts;
+    this.reconnectDelay = config.reconnectDelay ?? DEFAULT_SOCKET_CONFIG.reconnectDelay;
+    this.maxReconnectDelay = config.maxReconnectDelay ?? DEFAULT_SOCKET_CONFIG.maxReconnectDelay;
+    this.WebSocketImpl = config.WebSocket ?? globalThis.WebSocket;
+    this.debug = config.debug ?? false;
+  }
+  /**
+   * Create a PokerSocket from SDK config
+   */
+  static fromConfig(config) {
+    if (!config.token) {
+      throw new PokerSDKError("Token is required for WebSocket connection", "AUTH_REQUIRED");
+    }
+    const baseUrl = config.baseUrl.replace(/\/$/, "");
+    const wsUrl = config.wsUrl ?? baseUrl.replace(/^http/, "ws") + "/ws/play";
+    return new _PokerSocket({
+      url: wsUrl,
+      token: config.token,
+      WebSocket: config.WebSocket,
+      debug: config.debug
+    });
+  }
+  // ============================================================================
+  // Connection Management
+  // ============================================================================
+  /**
+   * Connect to the WebSocket server
+   */
+  connect() {
+    return new Promise((resolve, reject) => {
+      if (this.connectionState === "connected") {
+        resolve();
+        return;
+      }
+      if (this.connectionState === "connecting") {
+        const checkConnection = () => {
+          if (this.connectionState === "connected") {
+            resolve();
+          } else if (this.connectionState === "disconnected") {
+            reject(new PokerSDKError("Connection failed", "CONNECTION_FAILED"));
+          } else {
+            setTimeout(checkConnection, 100);
+          }
+        };
+        checkConnection();
+        return;
+      }
+      this.shouldReconnect = true;
+      this.connectionState = "connecting";
+      this.log("Connecting to", this.url);
+      try {
+        this.ws = new this.WebSocketImpl(this.url);
+        this.ws.onopen = () => {
+          this.connectionState = "connected";
+          this.reconnectCount = 0;
+          this.startHeartbeat();
+          this.emit("connect");
+          this.log("Connected");
+          void this.rejoinTables();
+          resolve();
+        };
+        this.ws.onclose = (event) => {
+          this.handleDisconnect(event.reason || "Connection closed");
+        };
+        this.ws.onerror = (event) => {
+          this.log("WebSocket error:", event);
+          if (this.connectionState === "connecting") {
+            reject(new PokerSDKError("Connection failed", "CONNECTION_FAILED"));
+          }
+        };
+        this.ws.onmessage = (event) => {
+          this.handleMessage(event.data);
+        };
+      } catch (error) {
+        this.connectionState = "disconnected";
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Disconnect from the WebSocket server
+   */
+  disconnect() {
+    this.shouldReconnect = false;
+    this.stopHeartbeat();
+    this.clearPendingRequests("Connection closed");
+    if (this.ws) {
+      this.ws.close(1e3, "Client disconnect");
+      this.ws = null;
+    }
+    this.connectionState = "disconnected";
+    this.emit("disconnect", "Client disconnect");
+    this.log("Disconnected");
+  }
+  /**
+   * Get current connection state
+   */
+  getState() {
+    return this.connectionState;
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connectionState === "connected";
+  }
+  // ============================================================================
+  // Table Subscription
+  // ============================================================================
+  /**
+   * Join a table to receive real-time updates
+   */
+  async join(tableId) {
+    if (this.connectionState !== "connected") {
+      throw new PokerSDKError("Not connected", "NOT_CONNECTED");
+    }
+    const requestId = this.generateRequestId();
+    const message = {
+      type: "JOIN",
+      tableId,
+      requestId
+    };
+    this.joinedTables.add(tableId);
+    this.send(message);
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(requestId);
+        reject(new PokerSDKError("Join timeout", "TIMEOUT"));
+      }, 1e4);
+      this.pendingRequests.set(`snapshot:${tableId}`, {
+        resolve: (state) => {
+          clearTimeout(timeout);
+          resolve(state);
+        },
+        reject,
+        timeout
+      });
+    });
+  }
+  /**
+   * Leave a table
+   */
+  leave(tableId) {
+    if (this.connectionState !== "connected") {
+      return;
+    }
+    this.joinedTables.delete(tableId);
+    this.stateCache.delete(tableId);
+    const message = {
+      type: "LEAVE",
+      tableId
+    };
+    this.send(message);
+  }
+  /**
+   * Get currently joined tables
+   */
+  getJoinedTables() {
+    return Array.from(this.joinedTables);
+  }
+  /**
+   * Get cached state for a table
+   */
+  getCachedState(tableId) {
+    return this.stateCache.get(tableId);
+  }
+  // ============================================================================
+  // Event Handling
+  // ============================================================================
+  /**
+   * Subscribe to an event
+   */
+  on(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(listener);
+    return () => {
+      this.off(event, listener);
+    };
+  }
+  /**
+   * Unsubscribe from an event
+   */
+  off(event, listener) {
+    const listeners = this.listeners.get(event);
+    if (listeners) {
+      listeners.delete(listener);
+    }
+  }
+  /**
+   * Subscribe to an event (once)
+   */
+  once(event, listener) {
+    const onceWrapper = ((...args) => {
+      this.off(event, onceWrapper);
+      listener(...args);
+    });
+    return this.on(event, onceWrapper);
+  }
+  // ============================================================================
+  // Ping
+  // ============================================================================
+  /**
+   * Send application-level ping (not WebSocket ping)
+   */
+  async ping() {
+    if (this.connectionState !== "connected") {
+      throw new PokerSDKError("Not connected", "NOT_CONNECTED");
+    }
+    const requestId = this.generateRequestId();
+    const startTime = Date.now();
+    const message = {
+      type: "PING",
+      requestId,
+      timestamp: startTime
+    };
+    this.send(message);
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(requestId);
+        reject(new PokerSDKError("Ping timeout", "TIMEOUT"));
+      }, 5e3);
+      this.pendingRequests.set(requestId, {
+        resolve: () => {
+          resolve(Date.now() - startTime);
+        },
+        reject,
+        timeout
+      });
+    });
+  }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
+  /**
+   * Send a message to the server
+   */
+  send(message) {
+    if (this.ws?.readyState !== this.WebSocketImpl.OPEN) {
+      throw new PokerSDKError("WebSocket not open", "NOT_CONNECTED");
+    }
+    this.log("Sending:", message);
+    this.ws.send(JSON.stringify(message));
+  }
+  /**
+   * Handle incoming message
+   */
+  handleMessage(data) {
+    try {
+      const parsed = JSON.parse(data);
+      const result = types.safeParseServerMessage(parsed);
+      if (!result.success) {
+        this.log("Invalid server message:", result.error);
+        return;
+      }
+      const message = result.data;
+      this.log("Received:", message);
+      switch (message.type) {
+        case "SNAPSHOT": {
+          this.stateCache.set(message.tableId, message.state);
+          const pending = this.pendingRequests.get(`snapshot:${message.tableId}`);
+          if (pending) {
+            this.pendingRequests.delete(`snapshot:${message.tableId}`);
+            pending.resolve(message.state);
+          }
+          this.emit("snapshot", message.tableId, message.state);
+          break;
+        }
+        case "STATE_UPDATE": {
+          const cachedState = this.stateCache.get(message.tableId);
+          if (cachedState) {
+            const updatedState = { ...cachedState, version: message.version };
+            this.stateCache.set(message.tableId, updatedState);
+            this.emit("stateUpdate", message.tableId, updatedState);
+          } else {
+            this.emit("stateUpdate", message.tableId, {
+              version: message.version
+            });
+          }
+          break;
+        }
+        case "ACTION": {
+          this.emit(
+            "action",
+            message.tableId,
+            message.playerId,
+            message.actionType,
+            message.amount
+          );
+          break;
+        }
+        case "ACK": {
+          const pending = this.pendingRequests.get(message.requestId);
+          if (pending) {
+            clearTimeout(pending.timeout);
+            this.pendingRequests.delete(message.requestId);
+            pending.resolve(void 0);
+          }
+          break;
+        }
+        case "PONG": {
+          const pending = this.pendingRequests.get(message.requestId);
+          if (pending) {
+            clearTimeout(pending.timeout);
+            this.pendingRequests.delete(message.requestId);
+            pending.resolve(message.timestamp);
+          }
+          break;
+        }
+        case "ERROR": {
+          this.log("Server error:", message);
+          if (message.requestId) {
+            const pending = this.pendingRequests.get(message.requestId);
+            if (pending) {
+              clearTimeout(pending.timeout);
+              this.pendingRequests.delete(message.requestId);
+              pending.reject(new PokerSDKError(message.message, message.code));
+            }
+          }
+          this.emit("error", new PokerSDKError(message.message, message.code));
+          break;
+        }
+      }
+    } catch (error) {
+      this.log("Failed to parse message:", error);
+    }
+  }
+  /**
+   * Handle disconnect
+   */
+  handleDisconnect(reason) {
+    this.stopHeartbeat();
+    this.ws = null;
+    const wasConnected = this.connectionState === "connected";
+    this.connectionState = "disconnected";
+    if (wasConnected) {
+      this.emit("disconnect", reason);
+    }
+    if (this.shouldReconnect && this.reconnectCount < this.reconnectAttempts) {
+      void this.reconnect();
+    }
+  }
+  /**
+   * Attempt to reconnect
+   */
+  async reconnect() {
+    this.reconnectCount++;
+    this.connectionState = "reconnecting";
+    const delay = Math.min(
+      this.reconnectDelay * Math.pow(2, this.reconnectCount - 1),
+      this.maxReconnectDelay
+    );
+    this.log(
+      `Reconnecting in ${delay}ms (attempt ${this.reconnectCount}/${this.reconnectAttempts})`
+    );
+    this.emit("reconnect", this.reconnectCount);
+    await this.sleep(delay);
+    if (!this.shouldReconnect) {
+      return;
+    }
+    try {
+      await this.connect();
+    } catch {
+    }
+  }
+  /**
+   * Rejoin previously joined tables
+   */
+  async rejoinTables() {
+    for (const tableId of this.joinedTables) {
+      try {
+        await this.join(tableId);
+      } catch (error) {
+        this.log("Failed to rejoin table:", tableId, error);
+      }
+    }
+  }
+  /**
+   * Start heartbeat timer
+   */
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (this.connectionState === "connected") {
+        void this.ping().catch(() => {
+          this.log("Heartbeat failed");
+        });
+      }
+    }, this.heartbeatInterval);
+  }
+  /**
+   * Stop heartbeat timer
+   */
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  /**
+   * Clear all pending requests
+   */
+  clearPendingRequests(reason) {
+    for (const pending of this.pendingRequests.values()) {
+      clearTimeout(pending.timeout);
+      pending.reject(new PokerSDKError(reason, "CONNECTION_CLOSED"));
+    }
+    this.pendingRequests.clear();
+  }
+  /**
+   * Emit event to listeners
+   */
+  emit(event, ...args) {
+    const listeners = this.listeners.get(event);
+    if (listeners) {
+      for (const listener of listeners) {
+        try {
+          listener(...args);
+        } catch (error) {
+          this.log("Listener error:", error);
+        }
+      }
+    }
+  }
+  /**
+   * Generate unique request ID
+   */
+  generateRequestId() {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+  /**
+   * Sleep helper
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Debug logger
+   */
+  log(...args) {
+    if (this.debug) {
+      console.log("[PokerSocket]", ...args);
+    }
+  }
+};
+
+// src/auth.ts
+function createSiweMessage(params) {
+  const {
+    domain,
+    address,
+    statement,
+    uri,
+    version = "1",
+    chainId = 1,
+    nonce,
+    issuedAt = (/* @__PURE__ */ new Date()).toISOString(),
+    expirationTime,
+    notBefore,
+    requestId,
+    resources
+  } = params;
+  const lines = [];
+  lines.push(`${domain} wants you to sign in with your Ethereum account:`);
+  lines.push(address);
+  if (statement) {
+    lines.push("");
+    lines.push(statement);
+  }
+  lines.push("");
+  lines.push(`URI: ${uri}`);
+  lines.push(`Version: ${version}`);
+  lines.push(`Chain ID: ${chainId}`);
+  lines.push(`Nonce: ${nonce}`);
+  lines.push(`Issued At: ${issuedAt}`);
+  if (expirationTime) {
+    lines.push(`Expiration Time: ${expirationTime}`);
+  }
+  if (notBefore) {
+    lines.push(`Not Before: ${notBefore}`);
+  }
+  if (requestId) {
+    lines.push(`Request ID: ${requestId}`);
+  }
+  if (resources && resources.length > 0) {
+    lines.push(`Resources:`);
+    for (const resource of resources) {
+      lines.push(`- ${resource}`);
+    }
+  }
+  return lines.join("\n");
+}
+function parseSiweMessage(message) {
+  const lines = message.split("\n");
+  const result = {};
+  const domainMatch = /^(.+) wants you to sign in with your Ethereum account:$/.exec(lines[0]);
+  if (domainMatch) {
+    result.domain = domainMatch[1];
+  }
+  if (lines[1]) {
+    result.address = lines[1];
+  }
+  for (const line of lines) {
+    if (line.startsWith("URI: ")) {
+      result.uri = line.slice(5);
+    } else if (line.startsWith("Version: ")) {
+      result.version = line.slice(9);
+    } else if (line.startsWith("Chain ID: ")) {
+      result.chainId = parseInt(line.slice(10), 10);
+    } else if (line.startsWith("Nonce: ")) {
+      result.nonce = line.slice(7);
+    } else if (line.startsWith("Issued At: ")) {
+      result.issuedAt = line.slice(11);
+    } else if (line.startsWith("Expiration Time: ")) {
+      result.expirationTime = line.slice(17);
+    } else if (line.startsWith("Not Before: ")) {
+      result.notBefore = line.slice(12);
+    } else if (line.startsWith("Request ID: ")) {
+      result.requestId = line.slice(12);
+    }
+  }
+  const uriIndex = lines.findIndex((l) => l.startsWith("URI: "));
+  if (uriIndex > 3) {
+    const statementLines = lines.slice(3, uriIndex - 1).filter((l) => l.trim());
+    if (statementLines.length > 0) {
+      result.statement = statementLines.join("\n");
+    }
+  }
+  return result;
+}
+function isSiweExpired(message) {
+  const parsed = parseSiweMessage(message);
+  if (!parsed.expirationTime) {
+    return false;
+  }
+  return new Date(parsed.expirationTime) < /* @__PURE__ */ new Date();
+}
+function createWithdrawalMessage(amount, destinationAddress) {
+  return `Withdraw ${amount} USD to ${destinationAddress}`;
+}
+function generateIdempotencyKey() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}-${Math.random().toString(36).substr(2, 9)}`;
+}
+
+// src/utils.ts
+function formatChips(chips, currency = "$") {
+  const dollars = chips / 100;
+  return `${currency}${dollars.toFixed(2)}`;
+}
+function parseChips(amount) {
+  const cleaned = amount.replace(/[$€£¥,\s]/g, "");
+  const value = parseFloat(cleaned);
+  if (isNaN(value)) {
+    throw new Error(`Invalid amount: ${amount}`);
+  }
+  if (Number.isInteger(value) && value >= 100) {
+    return value;
+  }
+  return Math.round(value * 100);
+}
+function getActivePlayer(state) {
+  if (state.actionTo === null) {
+    return null;
+  }
+  return state.players[state.actionTo] ?? null;
+}
+function getPlayerById(state, playerId) {
+  return state.players.find((p) => p?.id === playerId) ?? null;
+}
+function getPlayerSeat(state, playerId) {
+  const index = state.players.findIndex((p) => p?.id === playerId);
+  return index === -1 ? null : index;
+}
+function isPlayerTurn(state, playerId) {
+  if (state.actionTo === null) {
+    return false;
+  }
+  const player = state.players[state.actionTo];
+  return player?.id === playerId;
+}
+function getCallAmount(state, playerId) {
+  const player = getPlayerById(state, playerId);
+  if (!player) {
+    return 0;
+  }
+  const currentBet = player.betThisStreet;
+  const activePlayers = state.players.filter((p) => p !== null);
+  const bets = activePlayers.map((p) => p.betThisStreet);
+  const highestBet = Math.max(...bets);
+  return Math.min(highestBet - currentBet, player.stack);
+}
+function getMinRaise(state) {
+  return state.minRaise ?? state.config.bigBlind;
+}
+function canCheck(state, playerId) {
+  const player = getPlayerById(state, playerId);
+  if (!player || !isPlayerTurn(state, playerId)) {
+    return false;
+  }
+  const currentBet = player.betThisStreet;
+  const activePlayers = state.players.filter((p) => p !== null);
+  const bets = activePlayers.map((p) => p.betThisStreet);
+  const highestBet = Math.max(...bets);
+  return currentBet >= highestBet;
+}
+function canBet(state, playerId) {
+  const player = getPlayerById(state, playerId);
+  if (!player || !isPlayerTurn(state, playerId)) {
+    return false;
+  }
+  const activePlayers = state.players.filter((p) => p !== null);
+  const bets = activePlayers.map((p) => p.betThisStreet);
+  const highestBet = Math.max(...bets);
+  return highestBet === 0 && player.stack > 0;
+}
+function getTotalPot(state) {
+  return state.pots.reduce((sum, pot) => sum + pot.amount, 0);
+}
+function getActivePlayers(state) {
+  return state.players.filter(
+    (p) => p !== null && p.status !== "FOLDED" && p.stack > 0
+  );
+}
+function getPlayersInHand(state) {
+  return state.players.filter((p) => p !== null && p.status !== "FOLDED");
+}
+function suitToEmoji(suit) {
+  const suits = {
+    s: "\u2660",
+    h: "\u2665",
+    d: "\u2666",
+    c: "\u2663"
+  };
+  return suits[suit.toLowerCase()] ?? suit;
+}
+function formatCard(card) {
+  if (card.length !== 2) {
+    return card;
+  }
+  const rank = card[0].toUpperCase();
+  const suit = suitToEmoji(card[1]);
+  return `${rank}${suit}`;
+}
+function formatCards(cards) {
+  if (!cards) {
+    return "\u{1F0A0}\u{1F0A0}";
+  }
+  return cards.map((c) => c ? formatCard(c) : "\u{1F0A0}").join(" ");
+}
+function getStreetName(street) {
+  const names = {
+    PREFLOP: "Pre-Flop",
+    FLOP: "Flop",
+    TURN: "Turn",
+    RIVER: "River",
+    SHOWDOWN: "Showdown"
+  };
+  return names[street] ?? street;
+}
+function isShowdown(state) {
+  return state.street === "SHOWDOWN";
+}
+function isHandComplete(state) {
+  return state.winners !== void 0 && state.winners !== null;
+}
+function getPotOdds(state, playerId) {
+  const callAmount = getCallAmount(state, playerId);
+  if (callAmount === 0) {
+    return Infinity;
+  }
+  return getTotalPot(state) / callAmount;
+}
+function abbreviateNumber(num) {
+  if (num >= 1e6) {
+    return `${(num / 1e6).toFixed(1)}M`;
+  }
+  if (num >= 1e3) {
+    return `${(num / 1e3).toFixed(1)}K`;
+  }
+  return num.toString();
+}
+
+exports.PokerClient = PokerClient;
+exports.PokerSDKError = PokerSDKError;
+exports.PokerSocket = PokerSocket;
+exports.abbreviateNumber = abbreviateNumber;
+exports.canBet = canBet;
+exports.canCheck = canCheck;
+exports.createSiweMessage = createSiweMessage;
+exports.createWithdrawalMessage = createWithdrawalMessage;
+exports.formatCard = formatCard;
+exports.formatCards = formatCards;
+exports.formatChips = formatChips;
+exports.generateIdempotencyKey = generateIdempotencyKey;
+exports.getActivePlayer = getActivePlayer;
+exports.getActivePlayers = getActivePlayers;
+exports.getCallAmount = getCallAmount;
+exports.getMinRaise = getMinRaise;
+exports.getPlayerById = getPlayerById;
+exports.getPlayerSeat = getPlayerSeat;
+exports.getPlayersInHand = getPlayersInHand;
+exports.getPotOdds = getPotOdds;
+exports.getStreetName = getStreetName;
+exports.getTotalPot = getTotalPot;
+exports.isHandComplete = isHandComplete;
+exports.isPlayerTurn = isPlayerTurn;
+exports.isShowdown = isShowdown;
+exports.isSiweExpired = isSiweExpired;
+exports.parseChips = parseChips;
+exports.parseSiweMessage = parseSiweMessage;
+exports.suitToEmoji = suitToEmoji;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map