@chitincasino/openclaw-plugin 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Chitin Casino Plugin for OpenClaw
+ *
+ * Provides:
+ * 1. Wallet tools — check balance, claim faucet, deposit to table
+ * 2. Game tools — discover, lobby, create table, register, send action
+ * 3. WebSocket connection — persistent connection to poker table, your_turn events
+ *    injected into agent session via hooks
+ */
+declare const plugin: {
+    id: string;
+    name: string;
+    description: string;
+    configSchema: {
+        type: "object";
+        additionalProperties: boolean;
+        properties: {};
+    };
+    register(api: any): void;
+};
+
+export { plugin as default };

package/dist/index.js

@@ -0,0 +1,385 @@
+// src/index.ts
+import {
+  createPublicClient,
+  createWalletClient,
+  http,
+  parseAbi,
+  parseEther,
+  formatEther,
+  encodeAbiParameters
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { baseSepolia } from "viem/chains";
+import WebSocket from "ws";
+import { execFile } from "child_process";
+var ERC20_ABI = parseAbi([
+  "function balanceOf(address) view returns (uint256)",
+  "function transferAndCall(address to, uint256 amount, bytes data) returns (bool)",
+  "function faucet() external"
+]);
+function getWalletClients() {
+  const privateKey = process.env.PRIVATE_KEY;
+  if (!privateKey) throw new Error("PRIVATE_KEY env var is required");
+  const rpcUrl = process.env.RPC_URL || "https://sepolia.base.org";
+  const account = privateKeyToAccount(privateKey);
+  const publicClient = createPublicClient({ chain: baseSepolia, transport: http(rpcUrl) });
+  const walletClient = createWalletClient({ account, chain: baseSepolia, transport: http(rpcUrl) });
+  return { account, publicClient, walletClient };
+}
+function connectToTable(gameServerUrl, roomCode, playerId, name, walletAddress, logger, wsStore) {
+  let ws = null;
+  let aborted = false;
+  function connect() {
+    if (aborted) return;
+    const wsUrl = gameServerUrl.replace(/^http/, "ws") + `/parties/poker/${roomCode}`;
+    logger.info(`[chitin] Connecting WebSocket to ${wsUrl}`);
+    ws = new WebSocket(wsUrl);
+    ws.on("open", () => {
+      logger.info(`[chitin] WebSocket connected to table ${roomCode}`);
+      wsStore.set(roomCode, ws);
+      ws.send(JSON.stringify({
+        type: "enter",
+        playerId,
+        name,
+        walletAddress
+      }));
+    });
+    ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        handleMessage(msg, roomCode, logger);
+      } catch (err) {
+        logger.warn(`[chitin] Failed to parse message: ${err.message}`);
+      }
+    });
+    ws.on("close", () => {
+      if (aborted) return;
+      logger.info(`[chitin] WebSocket closed for table ${roomCode}, reconnecting in 3s...`);
+      setTimeout(connect, 3e3);
+    });
+    ws.on("error", (err) => {
+      logger.warn(`[chitin] WebSocket error: ${err.message}`);
+    });
+  }
+  const latestState = /* @__PURE__ */ new Map();
+  function handleMessage(msg, roomCode2, logger2) {
+    if (msg.type === "game_state") {
+      latestState.set(roomCode2, msg);
+    } else if (msg.type === "your_turn") {
+      const state = latestState.get(roomCode2);
+      const legalActions = msg.legalActions?.join(", ") || "";
+      const chipRange = msg.chipRange ? `${msg.chipRange.min}-${msg.chipRange.max}` : "";
+      const parts = [`POKER: It's your turn at table ${roomCode2}.`];
+      if (state?.holeCards) {
+        const cards = state.holeCards.map((c) => `${c.rank}${c.suit[0]}`).join(" ");
+        parts.push(`Your cards: ${cards}.`);
+      }
+      if (state?.communityCards?.length > 0) {
+        const cards = state.communityCards.map((c) => `${c.rank}${c.suit[0]}`).join(" ");
+        parts.push(`Community: ${cards}.`);
+      }
+      if (state?.pots?.length > 0) {
+        const potSize = state.pots.reduce((s, p) => s + (p.size || 0), 0);
+        parts.push(`Pot: ${potSize}.`);
+      }
+      if (state?.yourStack !== void 0) {
+        parts.push(`Your stack: ${state.yourStack}.`);
+      }
+      parts.push(`Legal actions: ${legalActions}.`);
+      if (chipRange) parts.push(`Bet/raise range: ${chipRange}.`);
+      parts.push(`Use chitin_poker_action to respond with roomCode "${roomCode2}".`);
+      promptAgent(parts.join(" "), logger2);
+    } else if (msg.type === "hand_result") {
+      const winners = msg.result?.winners?.flat() || [];
+      const winnerNames = winners.map((w) => `${w.playerId}(${w.amount})`).join(", ");
+      const text = `POKER HAND RESULT at table ${roomCode2}: Winners: ${winnerNames}. Rake: ${msg.result?.rake || 0}.`;
+      promptAgent(text, logger2);
+    }
+  }
+  function promptAgent(text, logger2) {
+    execFile("openclaw", ["agent", "--local", "--message", text], (err, _stdout, stderr) => {
+      if (err) {
+        logger2.error(`[chitin] Failed to prompt agent: ${err.message}`);
+        return;
+      }
+      if (stderr) logger2.warn(`[chitin] Agent stderr: ${stderr}`);
+      logger2.info(`[chitin] Agent prompted successfully`);
+    });
+  }
+  const sendAction = (action) => {
+    if (ws?.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({ type: "action", action }));
+    }
+  };
+  connect();
+  return () => {
+    aborted = true;
+    ws?.close();
+  };
+}
+var plugin = {
+  id: "chitin-casino",
+  name: "Chitin Casino",
+  description: "Play poker at Chitin Casino \u2014 wallet management and real-time game connection",
+  configSchema: {
+    type: "object",
+    additionalProperties: false,
+    properties: {}
+  },
+  register(api) {
+    api.logger.info("[chitin] Chitin Casino plugin loaded");
+    const gameServerUrl = process.env.GAME_SERVER_URL || "http://localhost:3665";
+    const activeConnections = /* @__PURE__ */ new Map();
+    const wsInstances = /* @__PURE__ */ new Map();
+    api.registerTool({
+      name: "chitin_test",
+      label: "Chitin Test",
+      description: "A test tool that returns hello world",
+      parameters: { type: "object", properties: {} },
+      execute: async (_toolCallId) => {
+        return { message: "Hello from Chitin Casino plugin!" };
+      }
+    });
+    api.registerTool({
+      name: "chitin_wallet_address",
+      description: "Get your Chitin Casino wallet address",
+      parameters: {},
+      execute: async (_toolCallId) => {
+        const { account } = getWalletClients();
+        return { address: account.address };
+      }
+    });
+    api.registerTool({
+      name: "chitin_wallet_balance",
+      description: "Check ETH and NUMERO token balance",
+      parameters: {
+        type: "object",
+        properties: {
+          tokenAddress: { type: "string", description: "Token address (auto-fetched if omitted)" }
+        }
+      },
+      execute: async (_toolCallId, params) => {
+        const { account, publicClient } = getWalletClients();
+        const ethBalance = await publicClient.getBalance({ address: account.address });
+        let tokenBalance = BigInt(0);
+        let tokenAddr = params.tokenAddress;
+        if (!tokenAddr) {
+          try {
+            const res = await fetch(`${gameServerUrl}/contracts`);
+            const data = await res.json();
+            tokenAddr = data.token;
+          } catch {
+          }
+        }
+        if (tokenAddr) {
+          tokenBalance = await publicClient.readContract({
+            address: tokenAddr,
+            abi: ERC20_ABI,
+            functionName: "balanceOf",
+            args: [account.address]
+          });
+        }
+        return {
+          address: account.address,
+          ethBalance: formatEther(ethBalance),
+          tokenBalance: formatEther(tokenBalance)
+        };
+      }
+    });
+    api.registerTool({
+      name: "chitin_faucet_claim",
+      description: "Claim NUMERO tokens from the faucet. This is a free server-side operation \u2014 no gas needed.",
+      parameters: {},
+      execute: async (_toolCallId) => {
+        const { account } = getWalletClients();
+        const adminServerUrl = process.env.ADMIN_SERVER_URL || "http://localhost:3667";
+        const serviceKey = process.env.SERVICE_KEY || "";
+        const res = await fetch(`${adminServerUrl}/faucet/claim`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-service-key": serviceKey
+          },
+          body: JSON.stringify({ walletAddress: account.address })
+        });
+        const data = await res.json();
+        if (!res.ok) throw new Error(data.error || "Faucet claim failed");
+        return data;
+      }
+    });
+    api.registerTool({
+      name: "chitin_deposit",
+      description: "Deposit NUMERO tokens to a poker table on-chain",
+      parameters: {
+        type: "object",
+        properties: {
+          amount: { type: "string", description: 'Amount to deposit (e.g. "200")' },
+          tableId: { type: "string", description: "Table ID (bytes32)" },
+          gameId: { type: "string", description: "Game ID (bytes32)" }
+        },
+        required: ["amount", "tableId", "gameId"]
+      },
+      execute: async (_toolCallId, params) => {
+        const { publicClient, walletClient } = getWalletClients();
+        const res = await fetch(`${gameServerUrl}/contracts`);
+        const contracts = await res.json();
+        const amountWei = parseEther(params.amount);
+        const data = encodeAbiParameters(
+          [{ type: "bytes32" }, { type: "bytes32" }],
+          [params.tableId, params.gameId]
+        );
+        const hash = await walletClient.writeContract({
+          address: contracts.token,
+          abi: ERC20_ABI,
+          functionName: "transferAndCall",
+          args: [contracts.diamond, amountWei, data]
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash });
+        return { txHash: hash, blockNumber: Number(receipt.blockNumber) };
+      }
+    });
+    api.registerTool({
+      name: "chitin_discover",
+      description: "Discover Chitin Casino \u2014 games, contracts, faucet info",
+      parameters: {},
+      execute: async (_toolCallId) => {
+        const res = await fetch(`${gameServerUrl}/discover`);
+        return await res.json();
+      }
+    });
+    api.registerTool({
+      name: "chitin_lobby",
+      description: "List poker tables with open seats",
+      parameters: {},
+      execute: async (_toolCallId) => {
+        const res = await fetch(`${gameServerUrl}/parties/pokerlobby/main/tables`);
+        return await res.json();
+      }
+    });
+    api.registerTool({
+      name: "chitin_create_table",
+      description: "Create a new poker table (fails if open seats exist elsewhere)",
+      parameters: {
+        type: "object",
+        properties: {
+          smallBlind: { type: "number" },
+          bigBlind: { type: "number" },
+          minBuyIn: { type: "number" },
+          maxBuyIn: { type: "number" }
+        }
+      },
+      execute: async (_toolCallId, params) => {
+        const res = await fetch(`${gameServerUrl}/parties/poker/create`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            settings: {
+              smallBlind: params.smallBlind || 1,
+              bigBlind: params.bigBlind || 2,
+              minBuyIn: params.minBuyIn || 50,
+              maxBuyIn: params.maxBuyIn || 200
+            }
+          })
+        });
+        return await res.json();
+      }
+    });
+    api.registerTool({
+      name: "chitin_register",
+      description: "Register at a poker table and connect via WebSocket. Events will be delivered to your session automatically.",
+      parameters: {
+        type: "object",
+        properties: {
+          roomCode: { type: "string", description: "Table room code" },
+          name: { type: "string", description: "Display name" },
+          buyIn: { type: "number", description: "Buy-in amount (default: 200)" }
+        },
+        required: ["roomCode"]
+      },
+      execute: async (_toolCallId, params) => {
+        const { account } = getWalletClients();
+        const botName = params.name || "ClawBot";
+        const res = await fetch(`${gameServerUrl}/parties/poker/${params.roomCode}/register`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            name: botName,
+            buyIn: params.buyIn || 200,
+            walletAddress: account.address
+          })
+        });
+        const result = await res.json();
+        if (!res.ok) return result;
+        const cleanup = connectToTable(
+          gameServerUrl,
+          params.roomCode,
+          result.playerId,
+          botName,
+          account.address,
+          api.logger,
+          wsInstances
+        );
+        activeConnections.set(params.roomCode, { cleanup, ws: null });
+        api.logger.info(`[chitin] Registered at ${params.roomCode}, WebSocket connected`);
+        return { ...result, wsConnected: true };
+      }
+    });
+    api.registerTool({
+      name: "chitin_poker_action",
+      description: "Send a poker action: fold, check, call, bet (with amount), or raise (with amount)",
+      parameters: {
+        type: "object",
+        properties: {
+          roomCode: { type: "string" },
+          action: { type: "string", description: "fold, check, call, bet, or raise" },
+          amount: { type: "number", description: "Required for bet and raise" }
+        },
+        required: ["roomCode", "action"]
+      },
+      execute: async (_toolCallId, params) => {
+        const ws = wsInstances.get(params.roomCode);
+        if (!ws || ws.readyState !== WebSocket.OPEN) {
+          return { error: "Not connected to table. Call chitin_register first." };
+        }
+        const action = { type: params.action };
+        if (params.amount !== void 0) action.amount = params.amount;
+        ws.send(JSON.stringify({ type: "action", action }));
+        return { ok: true, sent: action };
+      }
+    });
+    api.registerTool({
+      name: "chitin_leave_table",
+      description: "Leave a poker table and disconnect",
+      parameters: {
+        type: "object",
+        properties: {
+          roomCode: { type: "string" },
+          token: { type: "string" }
+        },
+        required: ["roomCode", "token"]
+      },
+      execute: async (_toolCallId, params) => {
+        const conn = activeConnections.get(params.roomCode);
+        if (conn) {
+          conn.cleanup();
+          activeConnections.delete(params.roomCode);
+        }
+        wsInstances.delete(params.roomCode);
+        const ws = wsInstances.get(params.roomCode);
+        if (ws?.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: "leave" }));
+          return { ok: true };
+        }
+        const res = await fetch(`${gameServerUrl}/parties/poker/${params.roomCode}/leave`, {
+          method: "POST",
+          headers: { "Authorization": `Bearer ${params.token}` }
+        });
+        return await res.json();
+      }
+    });
+  }
+};
+var index_default = plugin;
+export {
+  index_default as default
+};

package/openclaw.plugin.json

@@ -0,0 +1,17 @@
+{
+  "id": "chitin-casino",
+  "name": "Chitin Casino",
+  "version": "0.1.0",
+  "description": "Play poker at Chitin Casino — wallet management and real-time game connection",
+  "author": "Chitin Casino",
+  "license": "MIT",
+  "configSchema": {
+    "type": "object",
+    "properties": {
+      "enabled": {
+        "type": "boolean",
+        "default": true
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@chitincasino/openclaw-plugin",
+  "version": "0.1.0",
+  "description": "OpenClaw plugin for Chitin Casino — wallet management and poker game connection",
+  "type": "module",
+  "main": "./dist/index.js",
+  "files": [
+    "dist/",
+    "openclaw.plugin.json"
+  ],
+  "keywords": [
+    "openclaw",
+    "openclaw-plugin",
+    "poker",
+    "chitin-casino",
+    "blockchain",
+    "base"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chitincasino/numero"
+  },
+  "license": "MIT",
+  "openclaw": {
+    "extensions": ["./src/index.ts"]
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "viem": "^2.0.0",
+    "ws": "^8.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  }
+}