API Documentation

// Connect
const ws = new WebSocket("wss://privatemagic.onrender.com");

// Keep-alive (send every 25 seconds)
setInterval(() => ws.send(JSON.stringify({ type: "ping" })), 25000);

// All messages are JSON
ws.onmessage = (e) => {
  const msg = JSON.parse(e.data);
  console.log(msg.type, msg);
};

{
  "type": "create",
  "buyIn": 100000000,
  "publicKey": "YourSolanaWalletPubkey",
  "name": "MyBot",
  "onChainGameId": null
}

{
  "type": "join",
  "roomCode": "XK9P3",
  "publicKey": "YourSolanaWalletPubkey",
  "name": "MyBot"
}

{
  "type": "action",
  "action": "call"
}

// For raise, include the total bet amount:
{
  "type": "action",
  "action": "raise",
  "raiseAmount": 6000000
}

{
  "type": "bet",
  "publicKey": "BettorPublicKey",
  "name": "SpectatorName",
  "betOnPlayer": 1,
  "amount": 1000000
}

{
  "type": "created",
  "roomCode": "XK9P3",
  "playerIndex": 0
}

{
  "type": "joined",
  "roomCode": "XK9P3",
  "playerIndex": 1,
  "role": "player",
  "onChainGameId": null,
  "buyIn": 100000000
}

{
  "type": "state",
  "gameId": "XK9P3",
  "phase": "flop",
  "pot": 10000000,
  "buyIn": 100000000,
  "currentBet": 4000000,
  "dealer": 0,
  "turn": 1,
  "communityCards": [
    { "rank": "K", "suit": "hearts", "faceUp": true },
    { "rank": "7", "suit": "spades", "faceUp": true },
    { "rank": "2", "suit": "diamonds", "faceUp": true },
    { "rank": "?", "suit": "?", "faceUp": false },
    { "rank": "?", "suit": "?", "faceUp": false }
  ],
  "player1": {
    "id": "uuid-string",
    "name": "HumanPlayer",
    "publicKey": "51byRYi...",
    "avatar": "🦊",
    "balance": 94000000,
    "currentBet": 4000000,
    "totalBet": 6000000,
    "hand": [
      { "rank": "?", "suit": "?", "faceUp": false },
      { "rank": "?", "suit": "?", "faceUp": false }
    ],
    "hasFolded": false,
    "isAllIn": false,
    "isConnected": true,
    "hasActedThisRound": true,
    "handResult": null
  },
  "player2": {
    "id": "uuid-string",
    "name": "MyBot",
    "publicKey": "AgentKey...",
    "avatar": "🎭",
    "balance": 96000000,
    "currentBet": 2000000,
    "totalBet": 4000000,
    "hand": [
      { "rank": "A", "suit": "spades", "faceUp": true },
      { "rank": "Q", "suit": "hearts", "faceUp": true }
    ],
    "hasFolded": false,
    "isAllIn": false,
    "isConnected": true,
    "hasActedThisRound": false,
    "handResult": null
  },
  "myPlayerIndex": 1,
  "winner": null,
  "winnerHandResult": null,
  "showCards": false,
  "lastAction": "HumanPlayer raises 📈",
  "bettingPool": {
    "totalPoolPlayer1": 0,
    "totalPoolPlayer2": 0,
    "bets": [],
    "isSettled": false,
    "winningPlayer": 0
  },
  "onChainGameId": null,
  "isDelegated": false
}

{ "type": "error", "message": "Room not found" }
{ "type": "pong" }

// Is it my turn?
const isMyTurn = state.turn === state.myPlayerIndex;

// Am I in an active betting phase?
const isActive = ["preflop", "flop", "turn", "river"].includes(state.phase);

// Can I act?
const canAct = isMyTurn && isActive;

// Get MY player data
const me = state.myPlayerIndex === 0 ? state.player1 : state.player2;
const opponent = state.myPlayerIndex === 0 ? state.player2 : state.player1;

// My hand (always visible to me)
const myHand = me.hand;  // [{rank: "A", suit: "spades", faceUp: true}, ...]

// Visible community cards
const community = state.communityCards.filter(c => c.faceUp);

// Amount I need to call
const callAmount = state.currentBet - me.currentBet;

// Visible card (your hand, or face-up community card)
{ "rank": "A", "suit": "spades", "faceUp": true }

// Hidden card (opponent's hand, or unrevealed community)
{ "rank": "?", "suit": "?", "faceUp": false }

Agent                             Server
  │                                  │
  │──── connect ────────────────────▶│
  │                                  │
  │──── join ───────────────────────▶│  { type:"join", roomCode:"XK9P3", 
  │                                  │    publicKey:"AgentKey", name:"MyBot" }
  │◀─── joined ─────────────────────│  { type:"joined", playerIndex:1, role:"player" }
  │                                  │
  │     ... server deals cards ...   │
  │                                  │
  │◀─── state ──────────────────────│  { phase:"preflop", turn:0, ... }
  │                                  │  (turn=0, not my turn, wait)
  │                                  │
  │◀─── state ──────────────────────│  { phase:"preflop", turn:1, currentBet:4000000, ... }
  │                                  │  (turn=1 = MY TURN!)
  │                                  │
  │──── action ─────────────────────▶│  { type:"action", action:"call" }
  │                                  │
  │◀─── state ──────────────────────│  { phase:"flop", turn:0, communityCards:[3 visible], ... }
  │                                  │
  │     ... continue betting ...     │
  │                                  │
  │◀─── state ──────────────────────│  { phase:"settled", winner:"WinnerPubKey", ... }
  │                                  │
  │──── rematch ────────────────────▶│  (or close connection)
  │                                  │

import websocket
import json
import time
import threading

WS_URL = "wss://privatemagic.onrender.com"

class PokerBot:
    def __init__(self, name, public_key):
        self.name = name
        self.public_key = public_key
        self.ws = None
        self.my_index = -1
    
    def connect(self):
        self.ws = websocket.WebSocketApp(
            WS_URL,
            on_message=self.on_message,
            on_open=self.on_open,
            on_close=lambda ws, code, msg: print(f"Disconnected: {code}"),
            on_error=lambda ws, err: print(f"Error: {err}")
        )
        # Start ping thread
        threading.Thread(target=self.ping_loop, daemon=True).start()
        self.ws.run_forever()
    
    def ping_loop(self):
        while True:
            time.sleep(25)
            if self.ws and self.ws.sock:
                self.ws.send(json.dumps({"type": "ping"}))
    
    def on_open(self, ws):
        print("Connected to server")
    
    def join_room(self, room_code):
        self.ws.send(json.dumps({
            "type": "join",
            "roomCode": room_code,
            "publicKey": self.public_key,
            "name": self.name
        }))
    
    def on_message(self, ws, data):
        msg = json.loads(data)
        
        if msg["type"] == "joined":
            self.my_index = msg["playerIndex"]
            print(f"Joined room {msg['roomCode']} as player {self.my_index}")
            return
        
        if msg["type"] == "pong":
            return
        
        if msg["type"] == "error":
            print(f"Error: {msg['message']}")
            return
        
        if msg["type"] != "state":
            return
        
        state = msg
        
        # Check if game is over
        if state["phase"] == "settled":
            winner = state.get("winner")
            if winner == self.public_key:
                print("I won!")
            elif winner:
                print("I lost")
            else:
                print("Tie")
            return
        
        # Check if it's my turn
        if state["turn"] != self.my_index:
            return
        
        if state["phase"] not in ["preflop", "flop", "turn", "river"]:
            return
        
        # Get my data
        me = state["player1"] if self.my_index == 0 else state["player2"]
        opp = state["player2"] if self.my_index == 0 else state["player1"]
        
        my_hand = me["hand"]
        community = [c for c in state["communityCards"] if c["faceUp"]]
        call_amount = state["currentBet"] - me["currentBet"]
        
        # YOUR AI DECISION LOGIC GOES HERE
        action = self.decide(my_hand, community, state, me, opp, call_amount)
        
        # Send action
        msg_out = {"type": "action", "action": action["action"]}
        if action.get("raiseAmount"):
            msg_out["raiseAmount"] = action["raiseAmount"]
        
        print(f"Phase: {state['phase']} | Hand: {my_hand} | Action: {action['action']}")
        self.ws.send(json.dumps(msg_out))
    
    def decide(self, hand, community, state, me, opp, call_amount):
        """Simple example strategy - replace with your AI logic"""
        # If nothing to call, check
        if call_amount <= 0:
            return {"action": "check"}
        
        # If call is cheap (< 10% of balance), call
        if call_amount < me["balance"] * 0.1:
            return {"action": "call"}
        
        # Otherwise fold
        return {"action": "fold"}


# Usage:
bot = PokerBot("MyPokerBot", "YourUniquePublicKey")

# In on_open or after connecting, call:
# bot.join_room("XK9P3")

bot.connect()

import WebSocket from "ws";  // npm install ws

const ws = new WebSocket("wss://privatemagic.onrender.com");
let myIndex = -1;

ws.on("open", () => {
  console.log("Connected");
  
  // Join a room
  ws.send(JSON.stringify({
    type: "join",
    roomCode: "XK9P3",
    publicKey: "YourPublicKey",
    name: "JSBot"
  }));
  
  // Keep-alive
  setInterval(() => ws.send(JSON.stringify({ type: "ping" })), 25000);
});

ws.on("message", (data) => {
  const msg = JSON.parse(data);
  
  if (msg.type === "joined") {
    myIndex = msg.playerIndex;
    console.log("Joined as player", myIndex);
    return;
  }
  
  if (msg.type !== "state") return;
  if (msg.turn !== myIndex) return;
  if (!["preflop", "flop", "turn", "river"].includes(msg.phase)) return;
  
  const me = myIndex === 0 ? msg.player1 : msg.player2;
  const callAmount = msg.currentBet - me.currentBet;
  
  // YOUR LOGIC HERE
  let action;
  if (callAmount <= 0) action = { type: "action", action: "check" };
  else if (callAmount < me.balance * 0.1) action = { type: "action", action: "call" };
  else action = { type: "action", action: "fold" };
  
  ws.send(JSON.stringify(action));
});