@block52/poker-vm-sdk 1.2.16 → 1.3.1

package/dist/board.d.ts

@@ -0,0 +1,65 @@
+import { IJSONModel } from "./deck";
+import { Card, TexasHoldemRound } from "./types/game";
+/**
+ * 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).
+ */
+export declare class Board implements IJSONModel {
+    static readonly MAX_COMMUNITY_CARDS = 5;
+    private readonly street;
+    private readonly preDealt;
+    /**
+     * Append cards dealt for the current street (was `_communityCards.push`).
+     */
+    addStreet(cards: Card[]): void;
+    /**
+     * Record the five cards pre-dealt at deal() (was `_communityCards2.push`).
+     */
+    setPreDealt(cards: Card[]): void;
+    /**
+     * Number of street-dealt cards (was `_communityCards.length`).
+     */
+    get streetLength(): number;
+    /**
+     * Number of pre-dealt cards (was `_communityCards2.length`).
+     */
+    get preDealtLength(): number;
+    /**
+     * The street-dealt community cards (was `[...this._communityCards]`).
+     */
+    get cards(): Card[];
+    /**
+     * 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: TexasHoldemRound): Card[];
+    /**
+     * 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: number): Card[];
+    /**
+     * 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(): Card[];
+    /**
+     * Clear both boards for a new hand (was two `.length = 0` assignments).
+     */
+    clear(): void;
+    /**
+     * Serialize the street board to mnemonics, matching
+     * `TexasHoldemStateDTO.communityCards` (was `_communityCards.map(...)`).
+     */
+    toJson(): string[];
+}
+//# sourceMappingURL=board.d.ts.map

package/dist/board.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"board.d.ts","sourceRoot":"","sources":["../src/board.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAEtD;;;;;;;;;GASG;AACH,qBAAa,KAAM,YAAW,UAAU;IACpC,gBAAuB,mBAAmB,KAAK;IAI/C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IAErC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAc;IAEvC;;OAEG;IACI,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI;IAIrC;;OAEG;IACI,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI;IAIvC;;OAEG;IACH,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED;;OAEG;IACH,IAAW,cAAc,IAAI,MAAM,CAElC;IAED;;OAEG;IACH,IAAW,KAAK,IAAI,IAAI,EAAE,CAEzB;IAED;;;;OAIG;IACI,QAAQ,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI,EAAE;IAchD;;;;OAIG;IACI,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE;IAM3C;;;;OAIG;IACI,WAAW,IAAI,IAAI,EAAE;IAM5B;;OAEG;IACI,KAAK,IAAI,IAAI;IAKpB;;;OAGG;IACI,MAAM,IAAI,MAAM,EAAE;CAG5B"}

package/dist/index.d.ts

@@ -46125,6 +46125,69 @@ declare class Deck implements IDeck, IJSONModel {
     private initStandard52;
 }
 
+/**
+ * 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).
+ */
+declare class Board implements IJSONModel {
+    static readonly MAX_COMMUNITY_CARDS = 5;
+    private readonly street;
+    private readonly preDealt;
+    /**
+     * Append cards dealt for the current street (was `_communityCards.push`).
+     */
+    addStreet(cards: Card[]): void;
+    /**
+     * Record the five cards pre-dealt at deal() (was `_communityCards2.push`).
+     */
+    setPreDealt(cards: Card[]): void;
+    /**
+     * Number of street-dealt cards (was `_communityCards.length`).
+     */
+    get streetLength(): number;
+    /**
+     * Number of pre-dealt cards (was `_communityCards2.length`).
+     */
+    get preDealtLength(): number;
+    /**
+     * The street-dealt community cards (was `[...this._communityCards]`).
+     */
+    get cards(): Card[];
+    /**
+     * 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: TexasHoldemRound): Card[];
+    /**
+     * 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: number): Card[];
+    /**
+     * 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(): Card[];
+    /**
+     * Clear both boards for a new hand (was two `.length = 0` assignments).
+     */
+    clear(): void;
+    /**
+     * Serialize the street board to mnemonics, matching
+     * `TexasHoldemStateDTO.communityCards` (was `_communityCards.map(...)`).
+     */
+    toJson(): string[];
+}
+
 /**
  * Example integration of custom poker solver with game engine
  * Demonstrates how to replace pokersolver with our custom implementation
@@ -46535,7 +46598,7 @@ declare class SigningCosmosClient extends CosmosClient {
      * Requires the player account to EXIST on-chain (funded). Same gasless
      * fee + msg shape as {@link performActionSync}.
      */
-    signPerformAction(gameId: string, action: string, amount?: bigint, data?: string, signerData?: SignerData): Promise<{
+    signPerformAction(gameId: string, action: string, amount?: bigint, data?: string, _signerData?: SignerData): Promise<{
         base64: string;
         sequence: number;
         accountNumber: number;
@@ -46553,6 +46616,23 @@ declare class SigningCosmosClient extends CosmosClient {
      * helpers below share with signPerformAction's gateway-settlement pattern.
      */
     private signMsgOnly;
+    /**
+     * 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.
+     */
+    private signUnordered;
     /**
      * Sign-only MsgJoinGame: builds and signs the player's buy-in tx WITHOUT
      * broadcasting, returning the base64 TxRaw for the gateway to relay
@@ -46911,5 +46991,5 @@ declare const Client: typeof IgniteClient & Constructor<{
 }>;
 declare const registry: Registry;
 
-export { AllPlayerActions, BLOCK52_HD_PATH, COSMOS_CONSTANTS, Client, CosmosClient, Deck, GameFormat, GameStatus, GameVariant, HandType, KEYS, MissingWalletError, NonPlayerActionType, Params, PlayerActionType, PlayerStatus, PokerGameIntegration, PokerSolver, RPCMethods, SIT_IN_METHOD_NEXT_BB, SIT_IN_METHOD_POST_NOW, SIT_OUT_METHOD_NEXT_BB, SIT_OUT_METHOD_NEXT_HAND, SUIT, SigningCosmosClient, TexasHoldemRound, WithdrawalRequest, createSigningClientFromMnemonic, createWalletFromMnemonic, formatGameFormatDisplay, formatGameVariantDisplay, generateWallet, getActionByType, getAddressFromMnemonic, getDefaultCosmosConfig, getGameFormat, getGameFormatForCosmos, getGameFormatFromObject, getGameVariant, hasAction, isCashFormat, isEmptyAddress, isSitAndGoFormat, isTournamentFormat, isValidMnemonic, isValidPlayerAddress, parseGameFormat, parseGameVariant, registry };
+export { AllPlayerActions, BLOCK52_HD_PATH, Board, COSMOS_CONSTANTS, Client, CosmosClient, Deck, GameFormat, GameStatus, GameVariant, HandType, KEYS, MissingWalletError, NonPlayerActionType, Params, PlayerActionType, PlayerStatus, PokerGameIntegration, PokerSolver, RPCMethods, SIT_IN_METHOD_NEXT_BB, SIT_IN_METHOD_POST_NOW, SIT_OUT_METHOD_NEXT_BB, SIT_OUT_METHOD_NEXT_HAND, SUIT, SigningCosmosClient, TexasHoldemRound, WithdrawalRequest, createSigningClientFromMnemonic, createWalletFromMnemonic, formatGameFormatDisplay, formatGameVariantDisplay, generateWallet, getActionByType, getAddressFromMnemonic, getDefaultCosmosConfig, getGameFormat, getGameFormatForCosmos, getGameFormatFromObject, getGameVariant, hasAction, isCashFormat, isEmptyAddress, isSitAndGoFormat, isTournamentFormat, isValidMnemonic, isValidPlayerAddress, parseGameFormat, parseGameVariant, registry };
 export type { AccountDTO, ActionDTO, Block, BlockDTO, BlockHeader, BlockHeaderDTO, BlockID, BlockResponse, BurnResponseDTO, Card, EquityHand, EquityRequest, EquityResponse, EquityResult, GameListItem, GameOptions, GameOptionsDTO, GameOptionsResponse, GameStateResponse, GameStateResponseDTO, HandEvaluation, ISignedResponse, LegalActionDTO, PayoutPlaceDTO, PerformActionResponse, PlayerDTO, RPCRequest, RPCRequestParams, RPCResponse, RakeConfig, RakeConfigDTO, ResultDTO, SitInMethod, SitOutMethod, TexasHoldemGameState, TexasHoldemStateDTO, TransactionDTO, TransactionResponse, WalletInfo, WinnerDTO, WithdrawResponseDTO };

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAkC/C,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEV,CAAC;AAEH,QAAA,MAAM,QAAQ,UAiCZ,CAAA;AAGF,cAAc,6BAA6B,CAAA;AAG3C,cAAc,cAAc,CAAA;AAG5B,cAAc,SAAS,CAAA;AAGvB,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAGpG,cAAc,eAAe,CAAA;AAG7B,cAAc,eAAe,CAAA;AAG7B,cAAc,yBAAyB,CAAA;AAGvC,cAAc,qBAAqB,CAAA;AAGnC,cAAc,sBAAsB,CAAA;AAGpC,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAGrE,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAG7B,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AAG7D,OAAO,EAAE,YAAY,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AACvF,OAAO,EAAE,mBAAmB,EAAE,+BAA+B,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAGvG,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAGzF,OAAO,EACL,MAAM,EACN,QAAQ,EACR,kBAAkB,EACnB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAkC/C,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEV,CAAC;AAEH,QAAA,MAAM,QAAQ,UAiCZ,CAAA;AAGF,cAAc,6BAA6B,CAAA;AAG3C,cAAc,cAAc,CAAA;AAG5B,cAAc,SAAS,CAAA;AAGvB,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAGpG,cAAc,eAAe,CAAA;AAG7B,cAAc,eAAe,CAAA;AAG7B,cAAc,yBAAyB,CAAA;AAGvC,cAAc,qBAAqB,CAAA;AAGnC,cAAc,sBAAsB,CAAA;AAGpC,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAGrE,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAG7B,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAG/B,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AAG7D,OAAO,EAAE,YAAY,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AACvF,OAAO,EAAE,mBAAmB,EAAE,+BAA+B,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAGvG,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAGzF,OAAO,EACL,MAAM,EACN,QAAQ,EACR,kBAAkB,EACnB,CAAA"}

package/dist/index.esm.js

@@ -1,9 +1,10 @@
-import { Registry, DirectSecp256k1HdWallet } from '@cosmjs/proto-signing';
+import { Registry, DirectSecp256k1HdWallet, encodePubkey, makeAuthInfoBytes, makeSignDoc } from '@cosmjs/proto-signing';
 import { SigningStargateClient, GasPrice } from '@cosmjs/stargate';
 import { EventEmitter } from 'events';
 import { stringToPath } from '@cosmjs/crypto';
 import { createHash } from 'crypto';
-import { toBase64 } from '@cosmjs/encoding';
+import { toBase64, fromBase64 } from '@cosmjs/encoding';
+import { encodeSecp256k1Pubkey } from '@cosmjs/amino';
 
 /// <reference path="./types.d.ts" />
 const defaultFee$q = {
@@ -57317,6 +57318,109 @@ Deck.SUIT_MAP = {
     [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 === TexasHoldemRound.FLOP) {
+            cards.push(...this.preDealt.slice(0, 3));
+        }
+        if (round === TexasHoldemRound.TURN) {
+            cards.push(...this.preDealt.slice(0, 4));
+        }
+        if (round === 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
@@ -60835,6 +60939,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 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
@@ -61325,36 +61433,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 = 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
@@ -61390,6 +61493,59 @@ class SigningCosmosClient extends CosmosClient {
         const base64 = 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 = encodePubkey(encodeSecp256k1Pubkey(account.pubkey));
+        const gas = gaslessFee();
+        const authInfoBytes = makeAuthInfoBytes([{ pubkey, sequence: 0 }], gas.amount, Number(gas.gas), undefined, undefined);
+        const signDoc = makeSignDoc(bodyBytes, authInfoBytes, chainId, accountNumber);
+        const { signature, signed } = await this.wallet.signDirect(player, signDoc);
+        const base64 = toBase64(TxRaw.encode(TxRaw.fromPartial({
+            bodyBytes: signed.bodyBytes,
+            authInfoBytes: signed.authInfoBytes,
+            signatures: [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
@@ -61861,5 +62017,5 @@ const registry = new Registry([
     ...msgTypes,
 ]);
 
-export { AllPlayerActions, BLOCK52_HD_PATH, COSMOS_CONSTANTS, Client, CosmosClient, Deck, GameFormat, GameStatus, GameVariant, HandType, KEYS, MissingWalletError, NonPlayerActionType, Params$c as Params, PlayerActionType, PlayerStatus, PokerGameIntegration, PokerSolver, RPCMethods, SIT_IN_METHOD_NEXT_BB, SIT_IN_METHOD_POST_NOW, SIT_OUT_METHOD_NEXT_BB, SIT_OUT_METHOD_NEXT_HAND, SUIT, SigningCosmosClient, TexasHoldemRound, WithdrawalRequest, createSigningClientFromMnemonic, createWalletFromMnemonic, formatGameFormatDisplay, formatGameVariantDisplay, generateWallet, getActionByType, getAddressFromMnemonic, getDefaultCosmosConfig, getGameFormat, getGameFormatForCosmos, getGameFormatFromObject, getGameVariant, hasAction, isCashFormat, isEmptyAddress, isSitAndGoFormat, isTournamentFormat, isValidMnemonic, isValidPlayerAddress, parseGameFormat, parseGameVariant, registry };
+export { AllPlayerActions, BLOCK52_HD_PATH, Board, COSMOS_CONSTANTS, Client, CosmosClient, Deck, GameFormat, GameStatus, GameVariant, HandType, KEYS, MissingWalletError, NonPlayerActionType, Params$c as Params, PlayerActionType, PlayerStatus, PokerGameIntegration, PokerSolver, RPCMethods, SIT_IN_METHOD_NEXT_BB, SIT_IN_METHOD_POST_NOW, SIT_OUT_METHOD_NEXT_BB, SIT_OUT_METHOD_NEXT_HAND, SUIT, SigningCosmosClient, TexasHoldemRound, WithdrawalRequest, createSigningClientFromMnemonic, createWalletFromMnemonic, formatGameFormatDisplay, formatGameVariantDisplay, generateWallet, getActionByType, getAddressFromMnemonic, getDefaultCosmosConfig, getGameFormat, getGameFormatForCosmos, getGameFormatFromObject, getGameVariant, hasAction, isCashFormat, isEmptyAddress, isSitAndGoFormat, isTournamentFormat, isValidMnemonic, isValidPlayerAddress, parseGameFormat, parseGameVariant, registry };
 //# sourceMappingURL=index.esm.js.map