@block52/poker-vm-sdk 1.2.16 → 1.3.1

package/dist/index.js

@@ -6,6 +6,7 @@ var events = require('events');
 var crypto = require('@cosmjs/crypto');
 var crypto$1 = require('crypto');
 var encoding = require('@cosmjs/encoding');
+var amino = require('@cosmjs/amino');
 
 /// <reference path="./types.d.ts" />
 const defaultFee$q = {
@@ -57319,6 +57320,109 @@ Deck.SUIT_MAP = {
     [exports.SUIT.SPADES]: "S"
 };
 
+/**
+ * The community board for a Texas Hold'em hand.
+ *
+ * Encapsulates the two community-card arrays the engine currently keeps — the
+ * cards dealt street-by-street (`street`, persisted to the DTO) and the five
+ * pre-dealt up front at `deal()` (`preDealt`) — behind one type. This is a pure
+ * refactor: every accessor returns exactly what the inline engine logic did, so
+ * behaviour is unchanged. Collapsing the two arrays into a single canonical
+ * board is a separate, consensus-affecting change (issue #2299).
+ */
+class Board {
+    constructor() {
+        // Dealt one street at a time via dealCommunityCards() (was `_communityCards`).
+        // This is the board persisted to the game DTO and rehydrated from JSON.
+        this.street = [];
+        // All five dealt up front at deal() (was `_communityCards2`).
+        this.preDealt = [];
+    }
+    /**
+     * Append cards dealt for the current street (was `_communityCards.push`).
+     */
+    addStreet(cards) {
+        this.street.push(...cards);
+    }
+    /**
+     * Record the five cards pre-dealt at deal() (was `_communityCards2.push`).
+     */
+    setPreDealt(cards) {
+        this.preDealt.push(...cards);
+    }
+    /**
+     * Number of street-dealt cards (was `_communityCards.length`).
+     */
+    get streetLength() {
+        return this.street.length;
+    }
+    /**
+     * Number of pre-dealt cards (was `_communityCards2.length`).
+     */
+    get preDealtLength() {
+        return this.preDealt.length;
+    }
+    /**
+     * The street-dealt community cards (was `[...this._communityCards]`).
+     */
+    get cards() {
+        return [...this.street];
+    }
+    /**
+     * The community cards visible at a given round, taken from the pre-dealt
+     * board — matching the previous `getCommunityCards()` exactly:
+     *   FLOP -> preDealt[0..3], TURN -> preDealt[0..4], RIVER -> preDealt[0..5].
+     */
+    forRound(round) {
+        const cards = [];
+        if (round === exports.TexasHoldemRound.FLOP) {
+            cards.push(...this.preDealt.slice(0, 3));
+        }
+        if (round === exports.TexasHoldemRound.TURN) {
+            cards.push(...this.preDealt.slice(0, 4));
+        }
+        if (round === exports.TexasHoldemRound.RIVER) {
+            cards.push(...this.preDealt.slice(0, 5));
+        }
+        return cards;
+    }
+    /**
+     * The board `findWinners` falls back to when `forRound` is short: the
+     * pre-dealt board for live games, else the street board rehydrated from JSON.
+     * Preserves the previous inline selection verbatim.
+     */
+    forEvaluation(count) {
+        return this.preDealt.length >= count
+            ? this.preDealt.slice(0, count)
+            : this.street.slice(0, count);
+    }
+    /**
+     * The board `calculateWinner` falls back to at an early showdown: the fully
+     * dealt street board if available, else the pre-dealt board. Preserves the
+     * previous inline selection verbatim.
+     */
+    forShowdown() {
+        return this.street.length >= Board.MAX_COMMUNITY_CARDS
+            ? this.street.slice(0, Board.MAX_COMMUNITY_CARDS)
+            : this.preDealt.slice(0, Board.MAX_COMMUNITY_CARDS);
+    }
+    /**
+     * Clear both boards for a new hand (was two `.length = 0` assignments).
+     */
+    clear() {
+        this.street.length = 0;
+        this.preDealt.length = 0;
+    }
+    /**
+     * Serialize the street board to mnemonics, matching
+     * `TexasHoldemStateDTO.communityCards` (was `_communityCards.map(...)`).
+     */
+    toJson() {
+        return this.street.map(card => card.mnemonic);
+    }
+}
+Board.MAX_COMMUNITY_CARDS = 5;
+
 /**
  * Example integration of custom poker solver with game engine
  * Demonstrates how to replace pokersolver with our custom implementation
@@ -60837,6 +60941,10 @@ var txExports = requireTx();
  * Default gas limit for all transactions
  */
 const DEFAULT_GAS_LIMIT = 1000000;
+// Registry with the poker message types, used to pack a Msg into an Any when
+// hand-building an unordered TxBody (signUnordered). Module-level so it's built
+// once and shared with the stargate client's registry semantics.
+const pokerRegistry = new protoSigning.Registry(msgTypes$u);
 /**
  * Create a gasless fee object with specified gas limit
  * Chain is configured with min-gas-prices = "0stake" so no fee tokens required
@@ -61327,36 +61435,31 @@ class SigningCosmosClient extends CosmosClient {
      * Requires the player account to EXIST on-chain (funded). Same gasless
      * fee + msg shape as {@link performActionSync}.
      */
-    async signPerformAction(gameId, action, amount = 0n, data, signerData) {
-        await this.initializeSigningClient();
-        if (!this.signingClient || !this.wallet) {
-            throw new Error("Signing client not initialized");
+    async signPerformAction(gameId, action, amount = 0n, data, _signerData) {
+        // Unordered signing needs only the wallet + REST getAccount — no RPC
+        // stargate client, so this works without a reachable RPC endpoint.
+        if (!this.wallet) {
+            throw new Error("No wallet provided for signing");
         }
         const [account] = await this.wallet.getAccounts();
         const player = account.address;
-        const msgPerformAction = {
-            player,
-            gameId,
-            action,
-            amount: Long.fromString(amount.toString(), true),
-            data: data || ""
-        };
         const msg = {
             typeUrl: "/pokerchain.poker.v1.MsgPerformAction",
-            value: msgPerformAction
+            value: {
+                player,
+                gameId,
+                action,
+                amount: Long.fromString(amount.toString(), true),
+                data: data || ""
+            }
         };
-        let explicit = signerData;
-        if (!explicit) {
-            const accountInfo = await this.getAccount(player);
-            explicit = {
-                accountNumber: Number(accountInfo.account.account_number),
-                sequence: Number(accountInfo.account.sequence),
-                chainId: this.config.chainId
-            };
-        }
-        const txRaw = await this.signingClient.sign(player, [msg], gaslessFee(), `Poker action (relay): ${action}`, explicit);
-        const base64 = encoding.toBase64(txExports.TxRaw.encode(txRaw).finish());
-        return { base64, sequence: explicit.sequence, accountNumber: explicit.accountNumber };
+        // Settlement txs are UNORDERED (#247): no account sequence, so optimistic
+        // play can never desync the chain sequence (the #2413 cascade). The
+        // `signerData`/sequence arg is retained for signature compatibility but
+        // ignored — unordered txs carry sequence 0.
+        const { base64, accountNumber } = await this.signUnordered(msg);
+        // sequence is meaningless for unordered txs; return 0 for shape compat.
+        return { base64, sequence: 0, accountNumber };
     }
     /**
      * Resolves the signer data (account number + sequence + chain id) for a
@@ -61392,6 +61495,59 @@ class SigningCosmosClient extends CosmosClient {
         const base64 = encoding.toBase64(txExports.TxRaw.encode(txRaw).finish());
         return { base64, sequence: explicit.sequence, accountNumber: explicit.accountNumber };
     }
+    /**
+     * Sign a single cosmos message as an UNORDERED transaction (SDK 0.53): the
+     * TxBody carries `unordered: true` + a `timeout_timestamp` and NO account
+     * sequence (sequence MUST be 0). The chain admits it regardless of order and
+     * dedups replay on (signer, timeout) — so settlement txs no longer carry a
+     * client-guessed sequence and can never cascade (poker-vm#247, replaces the
+     * sequence-tracking that caused #2413).
+     *
+     * Hand-built because CosmJS 0.32's TxBody proto predates the unordered
+     * fields; we use the SDK's own cosmos.tx proto (which has them) for the body
+     * and CosmJS only for AuthInfo + the direct signature.
+     *
+     * @param ttlSeconds - how far ahead the timeout_timestamp is set. Must be
+     *   within the chain's max unordered TTL (SDK default 10m). Also bounds how
+     *   long a replay of this exact tx is rejected.
+     */
+    async signUnordered(msg, ttlSeconds = 120) {
+        // No RPC signing client needed: unordered signing is a direct signature
+        // over locally-built bytes. Only the wallet (for signDirect) and a REST
+        // getAccount (for account_number) are required.
+        if (!this.wallet) {
+            throw new Error("No wallet provided for signing");
+        }
+        const [account] = await this.wallet.getAccounts();
+        const player = account.address;
+        // account_number + chainId are still needed for the sign doc; the
+        // SEQUENCE is not — unordered txs must sign with sequence 0.
+        const accountInfo = await this.getAccount(player);
+        const accountNumber = Number(accountInfo.account.account_number);
+        const chainId = this.config.chainId;
+        // Body with unordered=true + timeout_timestamp, messages packed as Any
+        // via the poker registry. timeoutHeight stays 0 (we gate on timestamp).
+        const bodyBytes = TxBody.encode(TxBody.fromPartial({
+            messages: [pokerRegistry.encodeAsAny(msg)],
+            memo: "",
+            timeoutHeight: Long.UZERO,
+            unordered: true,
+            timeoutTimestamp: new Date(Date.now() + ttlSeconds * 1000)
+        })).finish();
+        // AuthInfo with sequence 0 (required for unordered). CosmJS builds this
+        // — the pubkey/fee encoding is unchanged from an ordered tx.
+        const pubkey = protoSigning.encodePubkey(amino.encodeSecp256k1Pubkey(account.pubkey));
+        const gas = gaslessFee();
+        const authInfoBytes = protoSigning.makeAuthInfoBytes([{ pubkey, sequence: 0 }], gas.amount, Number(gas.gas), undefined, undefined);
+        const signDoc = protoSigning.makeSignDoc(bodyBytes, authInfoBytes, chainId, accountNumber);
+        const { signature, signed } = await this.wallet.signDirect(player, signDoc);
+        const base64 = encoding.toBase64(TxRaw.encode(TxRaw.fromPartial({
+            bodyBytes: signed.bodyBytes,
+            authInfoBytes: signed.authInfoBytes,
+            signatures: [encoding.fromBase64(signature.signature)]
+        })).finish());
+        return { base64, accountNumber };
+    }
     /**
      * Sign-only MsgJoinGame: builds and signs the player's buy-in tx WITHOUT
      * broadcasting, returning the base64 TxRaw for the gateway to relay
@@ -61865,6 +62021,7 @@ const registry = new protoSigning.Registry([
 
 exports.AllPlayerActions = AllPlayerActions;
 exports.BLOCK52_HD_PATH = BLOCK52_HD_PATH;
+exports.Board = Board;
 exports.COSMOS_CONSTANTS = COSMOS_CONSTANTS;
 exports.Client = Client;
 exports.CosmosClient = CosmosClient;