@block52/poker-vm-sdk 1.4.0 → 1.4.1

package/dist/index.d.ts

@@ -45265,6 +45265,7 @@ declare enum NonPlayerActionType {
     SIT_IN = "sit-in",
     SIT_IN_AND_WAIT = "sit-in-and-wait",
     SIT_OUT = "sit-out",
+    TIMEOUT = "timeout",
     TOP_UP = "top-up"
 }
 declare const AllPlayerActions: {
@@ -45278,6 +45279,7 @@ declare const AllPlayerActions: {
     SIT_IN: NonPlayerActionType.SIT_IN;
     SIT_IN_AND_WAIT: NonPlayerActionType.SIT_IN_AND_WAIT;
     SIT_OUT: NonPlayerActionType.SIT_OUT;
+    TIMEOUT: NonPlayerActionType.TIMEOUT;
     TOP_UP: NonPlayerActionType.TOP_UP;
     SMALL_BLIND: PlayerActionType.SMALL_BLIND;
     BIG_BLIND: PlayerActionType.BIG_BLIND;
@@ -46558,6 +46560,7 @@ interface SNGConfig {
 declare class SigningCosmosClient extends CosmosClient {
     private wallet?;
     private signingClient?;
+    private readonly accountNumbers;
     private gasPrice;
     constructor(config: SigningCosmosConfig);
     /**
@@ -46656,6 +46659,11 @@ declare class SigningCosmosClient extends CosmosClient {
      *
      * Returns the tx hash on CheckTx success; throws if CheckTx
      * rejects (invalid signature, malformed msg, insufficient gas).
+     *
+     * Deliberately NOT routed through `assertExecuted` (#2609): there is no
+     * DeliverTx result to check at this point — the hash is a CheckTx receipt,
+     * and the execution outcome arrives over the WebSocket. Every other
+     * broadcasting method in this class waits for inclusion and must check.
      */
     performActionSync(gameId: string, action: string, amount?: bigint, data?: string): Promise<string>;
     /**
@@ -46709,6 +46717,13 @@ declare class SigningCosmosClient extends CosmosClient {
      *   long a replay of this exact tx is rejected.
      */
     private signUnordered;
+    /**
+     * account_number for the unordered sign doc. It is assigned once when the
+     * account is created and never changes, so look it up once per signer —
+     * performActionSync signs on every player action and shouldn't pay a REST
+     * round trip (or inherit its failure modes) each time.
+     */
+    private unorderedAccountNumber;
     /**
      * Sign-only MsgJoinGame: builds and signs the player's buy-in tx WITHOUT
      * broadcasting, returning the base64 TxRaw for the gateway to relay
@@ -46816,6 +46831,69 @@ declare class SigningCosmosClient extends CosmosClient {
  */
 declare function createSigningClientFromMnemonic(config: CosmosConfig, mnemonic: string): Promise<SigningCosmosClient>;
 
+/**
+ * The part of a broadcast result this module reads. Structurally a subset of
+ * CosmJS's `DeliverTxResponse`, so both the real response and a test double fit.
+ */
+interface ExecutionResult {
+    transactionHash: string;
+    code: number;
+    rawLog?: string;
+}
+/**
+ * Thrown when a transaction was broadcast and included in a block but its
+ * EXECUTION failed (nonzero `DeliverTxResponse.code`). The hash, code and raw
+ * log are retained so the failure can be looked up and shown. (#2609)
+ */
+declare class TxExecutionError extends Error {
+    readonly transactionHash: string;
+    readonly code: number;
+    readonly rawLog?: string;
+    constructor(operation: string, result: ExecutionResult);
+}
+/**
+ * Assert that a broadcast transaction actually EXECUTED successfully.
+ *
+ * CosmJS resolves `signAndBroadcast` normally when execution fails — a nonzero
+ * `DeliverTxResponse.code` is the only failure signal, and it is easy to miss
+ * because nothing throws. Returning `result.transactionHash` without checking
+ * reports "insufficient funds" and "invalid request" to the caller as success.
+ *
+ * Every SDK method that broadcasts and waits for inclusion goes through this.
+ * The exception is `performActionSync`, which returns a CheckTx-only hash by
+ * design and whose caller waits on a WebSocket push for the committed result —
+ * see the comment there before adding a check to it.
+ */
+declare function assertExecuted(operation: string, result: ExecutionResult): void;
+/**
+ * Where a failed SDK transaction call stopped. Lets a caller decide whether
+ * chain state may have changed and whether resubmitting is safe:
+ *
+ * - `"not-broadcast"`: the node rejected the tx at CheckTx (CosmJS
+ *   `BroadcastTxError`). It never entered a block; nothing changed; fix the
+ *   cause and resubmit.
+ * - `"execution-failed"`: the tx was included in a block but failed there
+ *   ({@link TxExecutionError}). The state change did not happen, the hash
+ *   exists, and resubmitting the same tx fails the same way unless the cause
+ *   changed.
+ * - `"unknown"`: the mempool accepted the tx but inclusion was not observed
+ *   before CosmJS's timeout (`TimeoutError`). It MAY still execute — look the
+ *   hash up before retrying, or the retry can double-submit.
+ */
+type TxFailurePhase = "not-broadcast" | "execution-failed" | "unknown";
+/**
+ * Classify an error thrown by an SDK broadcast method. Returns `undefined` for
+ * errors raised before any broadcast (argument validation, no wallet, signing)
+ * or by another layer (REST queries, network) — those carry no transaction.
+ */
+declare function txFailurePhase(error: unknown): TxFailurePhase | undefined;
+/**
+ * The hash of the transaction behind a failed broadcast call, when one exists:
+ * the included-but-failed tx for `"execution-failed"`, the pending tx for
+ * `"unknown"`. `"not-broadcast"` and pre-broadcast errors have none.
+ */
+declare function txFailureHash(error: unknown): string | undefined;
+
 declare const Client: typeof IgniteClient & Constructor<{
     PokerchainPokerV_1: {
         query: ReturnType<typeof queryClient>;
@@ -47067,5 +47145,5 @@ declare const Client: typeof IgniteClient & Constructor<{
 }>;
 declare const registry: Registry;
 
-export { AllPlayerActions, BLOCK52_HD_PATH, Board, COSMOS_CONSTANTS, Client, CosmosClient, Deck, GAME_NAME_MICRO_PER_CHAR, GameFormat, GameStatus, GameVariant, HandType, KEYS, MAX_GAME_NAME_LENGTH, 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, ValidatorBond, WithdrawalRequest, computeGameNameFee, 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 };
+export { AllPlayerActions, BLOCK52_HD_PATH, Board, COSMOS_CONSTANTS, Client, CosmosClient, Deck, GAME_NAME_MICRO_PER_CHAR, GameFormat, GameStatus, GameVariant, HandType, KEYS, MAX_GAME_NAME_LENGTH, 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, TxExecutionError, ValidatorBond, WithdrawalRequest, assertExecuted, computeGameNameFee, createSigningClientFromMnemonic, createWalletFromMnemonic, formatGameFormatDisplay, formatGameVariantDisplay, generateWallet, getActionByType, getAddressFromMnemonic, getDefaultCosmosConfig, getGameFormat, getGameFormatForCosmos, getGameFormatFromObject, getGameVariant, hasAction, isCashFormat, isEmptyAddress, isSitAndGoFormat, isTournamentFormat, isValidMnemonic, isValidPlayerAddress, parseGameFormat, parseGameVariant, registry, txFailureHash, txFailurePhase };
+export type { AccountDTO, ActionDTO, Block, BlockDTO, BlockHeader, BlockHeaderDTO, BlockID, BlockResponse, BurnResponseDTO, Card, EquityHand, EquityRequest, EquityResponse, EquityResult, ExecutionResult, GameListItem, GameOptions, GameOptionsDTO, GameOptionsResponse, GameStateResponse, GameStateResponseDTO, HandEvaluation, ISignedResponse, LegalActionDTO, PayoutPlaceDTO, PerformActionResponse, PlayerDTO, RPCRequest, RPCRequestParams, RPCResponse, RakeConfig, RakeConfigDTO, ResultDTO, SitInMethod, SitOutMethod, TexasHoldemGameState, TexasHoldemStateDTO, TransactionDTO, TransactionResponse, TxFailurePhase, 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,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"}
+{"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;AAIvG,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,cAAc,EAAE,aAAa,EAAE,KAAK,cAAc,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAA;AAGvI,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,9 @@
 import { Registry, DirectSecp256k1HdWallet, encodePubkey, makeAuthInfoBytes, makeSignDoc } from '@cosmjs/proto-signing';
-import { SigningStargateClient, GasPrice } from '@cosmjs/stargate';
+import { SigningStargateClient, BroadcastTxError, TimeoutError, GasPrice } from '@cosmjs/stargate';
 import { EventEmitter } from 'events';
 import { stringToPath } from '@cosmjs/crypto';
 import { createHash, createHmac } from 'crypto';
-import { toBase64, fromBase64 } from '@cosmjs/encoding';
+import { fromBase64, toBase64 } from '@cosmjs/encoding';
 import { encodeSecp256k1Pubkey } from '@cosmjs/amino';
 
 /// <reference path="./types.d.ts" />
@@ -56165,6 +56165,14 @@ var NonPlayerActionType;
     // so each has a single responsibility. Sets WAITING_FOR_BIG_BLIND. (#2139)
     NonPlayerActionType["SIT_IN_AND_WAIT"] = "sit-in-and-wait";
     NonPlayerActionType["SIT_OUT"] = "sit-out";
+    // Action clock enforcement (poker-vm#2523): submitted by ANY address once the
+    // next-to-act player's turn deadline (last recorded action timestamp +
+    // gameOptions.timeout seconds) has passed. The engine plays that player's
+    // forced default action on their behalf — CHECK if legal else FOLD in a
+    // betting round, the owed blind post or DEAL in ANTE, MUCK if legal else
+    // SHOW at showdown — and records THAT action; no "timeout" turn is ever
+    // written to previousActions. Rejected while the turn has time remaining.
+    NonPlayerActionType["TIMEOUT"] = "timeout";
     NonPlayerActionType["TOP_UP"] = "top-up";
 })(NonPlayerActionType || (NonPlayerActionType = {}));
 const AllPlayerActions = { ...PlayerActionType, ...NonPlayerActionType };
@@ -61154,6 +61162,79 @@ function requireTx () {
 
 var txExports = requireTx();
 
+/**
+ * Thrown when a transaction was broadcast and included in a block but its
+ * EXECUTION failed (nonzero `DeliverTxResponse.code`). The hash, code and raw
+ * log are retained so the failure can be looked up and shown. (#2609)
+ */
+class TxExecutionError extends Error {
+    constructor(operation, result) {
+        super(`Failed to ${operation}: transaction ${result.transactionHash} failed with code ${result.code}` +
+            (result.rawLog ? ` — ${result.rawLog}` : ""));
+        this.name = "TxExecutionError";
+        this.transactionHash = result.transactionHash;
+        this.code = result.code;
+        this.rawLog = result.rawLog;
+    }
+}
+/**
+ * Assert that a broadcast transaction actually EXECUTED successfully.
+ *
+ * CosmJS resolves `signAndBroadcast` normally when execution fails — a nonzero
+ * `DeliverTxResponse.code` is the only failure signal, and it is easy to miss
+ * because nothing throws. Returning `result.transactionHash` without checking
+ * reports "insufficient funds" and "invalid request" to the caller as success.
+ *
+ * Every SDK method that broadcasts and waits for inclusion goes through this.
+ * The exception is `performActionSync`, which returns a CheckTx-only hash by
+ * design and whose caller waits on a WebSocket push for the committed result —
+ * see the comment there before adding a check to it.
+ */
+function assertExecuted(operation, result) {
+    // A real DeliverTxResponse always carries `code`. If it is missing we cannot
+    // tell success from failure, so fail closed and say why — reporting it as
+    // "code undefined" would send someone hunting a chain error that does not
+    // exist, when the actual problem is a malformed response or a partial mock.
+    if (typeof result?.code !== "number") {
+        throw new Error(`Failed to ${operation}: broadcast response has no execution code, so success cannot be confirmed ` +
+            `(transaction ${result?.transactionHash ?? "unknown"})`);
+    }
+    if (result.code !== 0) {
+        throw new TxExecutionError(operation, result);
+    }
+}
+/**
+ * Classify an error thrown by an SDK broadcast method. Returns `undefined` for
+ * errors raised before any broadcast (argument validation, no wallet, signing)
+ * or by another layer (REST queries, network) — those carry no transaction.
+ */
+function txFailurePhase(error) {
+    if (error instanceof TxExecutionError) {
+        return "execution-failed";
+    }
+    if (error instanceof BroadcastTxError) {
+        return "not-broadcast";
+    }
+    if (error instanceof TimeoutError) {
+        return "unknown";
+    }
+    return undefined;
+}
+/**
+ * The hash of the transaction behind a failed broadcast call, when one exists:
+ * the included-but-failed tx for `"execution-failed"`, the pending tx for
+ * `"unknown"`. `"not-broadcast"` and pre-broadcast errors have none.
+ */
+function txFailureHash(error) {
+    if (error instanceof TxExecutionError) {
+        return error.transactionHash;
+    }
+    if (error instanceof TimeoutError) {
+        return error.txId;
+    }
+    return undefined;
+}
+
 /**
  * Default gas limit for all transactions
  */
@@ -61162,6 +61243,18 @@ const DEFAULT_GAS_LIMIT = 1000000;
 // 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);
+// The chain dedups unordered txs on (signer, timeout_timestamp), so two txs
+// from one account must never share a timeout. Date has millisecond resolution
+// and a client fires blind + deal + action back to back, so track the last
+// timeout handed out per signer and keep it strictly increasing. Module-level:
+// callers rebuild the client (e.g. after a transport error) mid-session.
+const lastUnorderedTimeoutMs = new Map();
+function nextUnorderedTimeoutMs(signer, ttlSeconds) {
+    const wanted = Date.now() + ttlSeconds * 1000;
+    const timeoutMs = Math.max(wanted, (lastUnorderedTimeoutMs.get(signer) ?? 0) + 1);
+    lastUnorderedTimeoutMs.set(signer, timeoutMs);
+    return timeoutMs;
+}
 /**
  * Create a gasless fee object with specified gas limit
  * Chain is configured with min-gas-prices = "0stake" so no fee tokens required
@@ -61187,6 +61280,7 @@ class SigningCosmosClient extends CosmosClient {
             gasPrice: typeof config.gasPrice === 'string' ? config.gasPrice : (config.gasPrice?.toString() || COSMOS_CONSTANTS.DEFAULT_GAS_PRICE)
         };
         super(baseConfig);
+        this.accountNumbers = new Map();
         this.wallet = config.wallet;
         // Handle gasPrice - convert string to GasPrice if needed
         if (typeof config.gasPrice === 'string') {
@@ -61244,13 +61338,16 @@ class SigningCosmosClient extends CosmosClient {
         const coins = [{ denom: denom, amount: amount.toString() }];
         const fee = gaslessFee();
         const result = await this.signingClient.sendTokens(fromAddress, toAddress, coins, fee, memo || "");
+        assertExecuted("send tokens", result);
         return result.transactionHash;
     }
     /**
      * Send B52USDC tokens
      */
     async sendB52USDC(fromAddress, toAddress, amount, memo) {
-        return this.sendTokens(fromAddress, toAddress, amount, memo);
+        // `denom` is the 4th parameter — passing `memo` here put the memo text
+        // into the coin denom and always sent an empty memo.
+        return this.sendTokens(fromAddress, toAddress, amount, undefined, memo);
     }
     /**
      * Create a new poker game
@@ -61340,6 +61437,7 @@ class SigningCosmosClient extends CosmosClient {
         });
         try {
             const result = await this.signingClient.signAndBroadcast(creator, [msg], fee, memo);
+            assertExecuted("create game", result);
             console.log("✅ Game creation transaction successful:", result.transactionHash);
             return result.transactionHash;
         }
@@ -61377,6 +61475,7 @@ class SigningCosmosClient extends CosmosClient {
         console.log("🪑 Joining game:", { gameId, seat, buyInAmount: buyInAmount.toString() });
         try {
             const result = await this.signingClient.signAndBroadcast(player, [msg], fee, memo);
+            assertExecuted("join game", result);
             console.log("✅ Join game transaction successful:", result.transactionHash);
             return result.transactionHash;
         }
@@ -61424,6 +61523,7 @@ class SigningCosmosClient extends CosmosClient {
         console.log("🚪 Leaving game:", { gameId });
         try {
             const result = await this.signingClient.signAndBroadcast(creator, [msg], fee, memo);
+            assertExecuted("leave game", result);
             console.log("✅ Leave game transaction successful:", result.transactionHash);
             return result.transactionHash;
         }
@@ -61456,6 +61556,7 @@ class SigningCosmosClient extends CosmosClient {
         const memo = "Record hand end via SDK";
         try {
             const result = await this.signingClient.signAndBroadcast(creator, [msg], fee, memo);
+            assertExecuted("record hand end", result);
             return result.transactionHash;
         }
         catch (error) {
@@ -61489,6 +61590,7 @@ class SigningCosmosClient extends CosmosClient {
         console.log("🗑️ Deleting game:", { gameId });
         try {
             const result = await this.signingClient.signAndBroadcast(creator, [msg], fee, memo);
+            assertExecuted("delete game", result);
             console.log("✅ Delete game transaction successful:", result.transactionHash);
             return result.transactionHash;
         }
@@ -61528,6 +61630,7 @@ class SigningCosmosClient extends CosmosClient {
         console.log("🛑 Force-closing game:", { gameId });
         try {
             const result = await this.signingClient.signAndBroadcast(creator, [msg], fee, memo);
+            assertExecuted("force close game", result);
             console.log("✅ Force-close transaction successful:", result.transactionHash);
             return result.transactionHash;
         }
@@ -61576,6 +61679,7 @@ class SigningCosmosClient extends CosmosClient {
         });
         try {
             const result = await this.signingClient.signAndBroadcast(player, [msg], fee, memo);
+            assertExecuted("perform action", result);
             console.log("✅ Action transaction successful:", result.transactionHash);
             return result.transactionHash;
         }
@@ -61608,6 +61712,11 @@ class SigningCosmosClient extends CosmosClient {
      *
      * Returns the tx hash on CheckTx success; throws if CheckTx
      * rejects (invalid signature, malformed msg, insufficient gas).
+     *
+     * Deliberately NOT routed through `assertExecuted` (#2609): there is no
+     * DeliverTx result to check at this point — the hash is a CheckTx receipt,
+     * and the execution outcome arrives over the WebSocket. Every other
+     * broadcasting method in this class waits for inclusion and must check.
      */
     async performActionSync(gameId, action, amount = 0n, data) {
         await this.initializeSigningClient();
@@ -61616,26 +61725,30 @@ class SigningCosmosClient extends CosmosClient {
         }
         const [account] = await this.wallet.getAccounts();
         const player = account.address;
-        // Same msg shape as performAction — only the broadcast mode differs.
-        const msgPerformAction = {
-            player,
-            gameId,
-            action,
-            amount: Long.fromString(amount.toString(), true),
-            data: data || ""
-        };
+        // Same msg shape as performAction — only signing + broadcast mode differ.
         const msg = {
             typeUrl: "/pokerchain.poker.v1.MsgPerformAction",
-            value: msgPerformAction
+            value: {
+                player,
+                gameId,
+                action,
+                amount: Long.fromString(amount.toString(), true),
+                data: data || ""
+            }
         };
-        const fee = gaslessFee();
-        const memo = `Poker action (sync): ${action}`;
         try {
-            // signAndBroadcastSync returns just the txhash, no DeliverTx
-            // result. The caller waits on the WS push for the
+            // UNORDERED (#2619): gameplay txs carry no account sequence. Sync
+            // broadcast returns at CheckTx, not at commit, so an ordered tx
+            // signed before the previous one commits re-reads the same
+            // committed sequence and is rejected with code 32 — blind + deal +
+            // action from one account inside a block did exactly that. This is
+            // the chain-direct twin of signPerformAction's fix (#247, ui#520).
+            const { base64 } = await this.signUnordered(msg);
+            // broadcastTxSync returns just the txhash, no DeliverTx result, and
+            // throws BroadcastTxError when CheckTx rejects — the same contract
+            // signAndBroadcastSync had. The caller waits on the WS push for the
             // authoritative outcome.
-            const txHash = await this.signingClient.signAndBroadcastSync(player, [msg], fee, memo);
-            return txHash;
+            return await this.signingClient.broadcastTxSync(fromBase64(base64));
         }
         catch (error) {
             console.error("❌ Action (sync) failed at CheckTx:", error);
@@ -61745,8 +61858,7 @@ class SigningCosmosClient extends CosmosClient {
         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 accountNumber = await this.unorderedAccountNumber(player);
         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).
@@ -61755,7 +61867,7 @@ class SigningCosmosClient extends CosmosClient {
             memo: "",
             timeoutHeight: Long.UZERO,
             unordered: true,
-            timeoutTimestamp: new Date(Date.now() + ttlSeconds * 1000)
+            timeoutTimestamp: new Date(nextUnorderedTimeoutMs(player, ttlSeconds))
         })).finish();
         // AuthInfo with sequence 0 (required for unordered). CosmJS builds this
         // — the pubkey/fee encoding is unchanged from an ordered tx.
@@ -61771,6 +61883,22 @@ class SigningCosmosClient extends CosmosClient {
         })).finish());
         return { base64, accountNumber };
     }
+    /**
+     * account_number for the unordered sign doc. It is assigned once when the
+     * account is created and never changes, so look it up once per signer —
+     * performActionSync signs on every player action and shouldn't pay a REST
+     * round trip (or inherit its failure modes) each time.
+     */
+    async unorderedAccountNumber(player) {
+        const cached = this.accountNumbers.get(player);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const accountInfo = await this.getAccount(player);
+        const accountNumber = Number(accountInfo.account.account_number);
+        this.accountNumbers.set(player, accountNumber);
+        return accountNumber;
+    }
     /**
      * Sign-only MsgJoinGame: builds and signs the player's buy-in tx WITHOUT
      * broadcasting, returning the base64 TxRaw for the gateway to relay
@@ -61869,6 +61997,7 @@ class SigningCosmosClient extends CosmosClient {
         });
         try {
             const result = await this.signingClient.signAndBroadcast(player, [msg], fee, memo);
+            assertExecuted("top up", result);
             console.log("✅ Top-up transaction successful:", result.transactionHash);
             return result.transactionHash;
         }
@@ -61906,6 +62035,7 @@ class SigningCosmosClient extends CosmosClient {
         });
         try {
             const result = await this.signingClient.signAndBroadcast(creator, [msg], fee, memo);
+            assertExecuted("process deposit", result);
             console.log("✅ Process deposit transaction successful:", result.transactionHash);
             return result.transactionHash;
         }
@@ -61945,6 +62075,7 @@ class SigningCosmosClient extends CosmosClient {
         });
         try {
             const result = await this.signingClient.signAndBroadcast(creator, [msg], fee, memo);
+            assertExecuted("initiate withdrawal", result);
             console.log("✅ Withdrawal initiation successful:", result.transactionHash);
             return result.transactionHash;
         }
@@ -61981,6 +62112,7 @@ class SigningCosmosClient extends CosmosClient {
         });
         try {
             const result = await this.signingClient.signAndBroadcast(signer, [msg], fee, memo);
+            assertExecuted("sign withdrawal", result);
             console.log("✅ Withdrawal signing successful:", result.transactionHash);
             return result.transactionHash;
         }
@@ -62061,6 +62193,7 @@ class SigningCosmosClient extends CosmosClient {
         });
         try {
             const result = await this.signingClient.signAndBroadcast(creator, [msg], fee, memo);
+            assertExecuted("register NFT avatar", result);
             console.log("✅ NFT avatar registration successful:", result.transactionHash);
             return result.transactionHash;
         }
@@ -62242,5 +62375,5 @@ const registry = new Registry([
     ...msgTypes,
 ]);
 
-export { AllPlayerActions, BLOCK52_HD_PATH, Board, COSMOS_CONSTANTS, Client, CosmosClient, Deck, GAME_NAME_MICRO_PER_CHAR, GameFormat, GameStatus, GameVariant, HandType, KEYS, MAX_GAME_NAME_LENGTH, 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, ValidatorBond, WithdrawalRequest, computeGameNameFee, 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, GAME_NAME_MICRO_PER_CHAR, GameFormat, GameStatus, GameVariant, HandType, KEYS, MAX_GAME_NAME_LENGTH, 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, TxExecutionError, ValidatorBond, WithdrawalRequest, assertExecuted, computeGameNameFee, createSigningClientFromMnemonic, createWalletFromMnemonic, formatGameFormatDisplay, formatGameVariantDisplay, generateWallet, getActionByType, getAddressFromMnemonic, getDefaultCosmosConfig, getGameFormat, getGameFormatForCosmos, getGameFormatFromObject, getGameVariant, hasAction, isCashFormat, isEmptyAddress, isSitAndGoFormat, isTournamentFormat, isValidMnemonic, isValidPlayerAddress, parseGameFormat, parseGameVariant, registry, txFailureHash, txFailurePhase };
 //# sourceMappingURL=index.esm.js.map