@block52/poker-vm-sdk 1.3.5 → 1.4.1

package/dist/index.d.ts

@@ -44941,6 +44941,11 @@ interface MsgCreateGame {
     gameVariant: string;
     /** SNG flat entry fee in micro-units, skimmed to the creator (poker-vm#2118) */
     entryFee: Long;
+    /**
+     * Optional ENS-style table name (field 19). Lowercase [a-z0-9-], 1-32 chars,
+     * globally unique, $0.10/char to validators. Empty = unnamed. (block52/pokerchain#337)
+     */
+    name: string;
 }
 declare const MsgCreateGame: MessageFns<MsgCreateGame>;
 /** MsgJoinGame defines the MsgJoinGame message. */
@@ -45260,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: {
@@ -45273,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;
@@ -45527,6 +45534,7 @@ type GameStateResponseDTO = {
     creator: string;
     format: GameFormat;
     variant: GameVariant;
+    name?: string;
     gameState: TexasHoldemStateDTO;
 };
 declare enum SUIT {
@@ -45558,11 +45566,26 @@ type GameListItem = {
     creator: string;
     format: GameFormat;
     variant: GameVariant;
+    name?: string;
     gameOptions: GameOptionsDTO;
     currentPlayers: number;
     createdAt?: string;
     updatedAt?: string;
 };
+/**
+ * Cost of ONE character of a paid table name, in micro-USDC ($0.10). The total
+ * naming fee is `length * GAME_NAME_MICRO_PER_CHAR`, charged on top of the
+ * game-creation cost and paid to validators. This is the SINGLE SOURCE OF TRUTH
+ * for the price so the UI preview and the chain agree. (block52/pokerchain#337)
+ */
+declare const GAME_NAME_MICRO_PER_CHAR = 100000n;
+/** Maximum table-name length (code points); bounds the max fee at 32 * $0.10. */
+declare const MAX_GAME_NAME_LENGTH = 32;
+/**
+ * Total naming fee (micro-USDC) for a table name: $0.10 per character. Counts
+ * code points to match the chain's rune-based charge. An empty name is free.
+ */
+declare const computeGameNameFee: (name: string) => bigint;
 type BlockID = {
     hash: string;
     part_set_header?: {
@@ -46537,6 +46560,7 @@ interface SNGConfig {
 declare class SigningCosmosClient extends CosmosClient {
     private wallet?;
     private signingClient?;
+    private readonly accountNumbers;
     private gasPrice;
     constructor(config: SigningCosmosConfig);
     /**
@@ -46558,7 +46582,7 @@ declare class SigningCosmosClient extends CosmosClient {
     /**
      * Create a new poker game
      */
-    createGame(gameFormat: string, gameVariant: string, minPlayers: number, maxPlayers: number, minBuyInB52USDC: bigint, maxBuyInB52USDC: bigint, smallBlindB52USDC: bigint, bigBlindB52USDC: bigint, timeout: number, rakeConfig?: RakeConfig, sngConfig?: SNGConfig): Promise<string>;
+    createGame(gameFormat: string, gameVariant: string, minPlayers: number, maxPlayers: number, minBuyInB52USDC: bigint, maxBuyInB52USDC: bigint, smallBlindB52USDC: bigint, bigBlindB52USDC: bigint, timeout: number, rakeConfig?: RakeConfig, sngConfig?: SNGConfig, name?: string): Promise<string>;
     /**
      * Join a poker game
      */
@@ -46635,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>;
     /**
@@ -46688,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
@@ -46795,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>;
@@ -47046,5 +47145,5 @@ declare const Client: typeof IgniteClient & Constructor<{
 }>;
 declare const registry: 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, ValidatorBond, 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 };
+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" />
@@ -2844,6 +2844,7 @@ function createBaseMsgCreateGame() {
         blindLevelDuration: 0,
         gameVariant: "",
         entryFee: Long.UZERO,
+        name: "",
     };
 }
 const MsgCreateGame = {
@@ -2899,6 +2900,9 @@ const MsgCreateGame = {
         if (!message.entryFee.equals(Long.UZERO)) {
             writer.uint32(136).uint64(message.entryFee.toString());
         }
+        if (message.name !== "") {
+            writer.uint32(154).string(message.name);
+        }
         return writer;
     },
     decode(input, length) {
@@ -3027,6 +3031,13 @@ const MsgCreateGame = {
                     message.entryFee = Long.fromString(reader.uint64().toString(), true);
                     continue;
                 }
+                case 19: {
+                    if (tag !== 154) {
+                        break;
+                    }
+                    message.name = reader.string();
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -3054,6 +3065,7 @@ const MsgCreateGame = {
             blindLevelDuration: isSet$2b(object.blindLevelDuration) ? globalThis.Number(object.blindLevelDuration) : 0,
             gameVariant: isSet$2b(object.gameVariant) ? globalThis.String(object.gameVariant) : "",
             entryFee: isSet$2b(object.entryFee) ? Long.fromValue(object.entryFee) : Long.UZERO,
+            name: isSet$2b(object.name) ? globalThis.String(object.name) : "",
         };
     },
     toJSON(message) {
@@ -3109,6 +3121,9 @@ const MsgCreateGame = {
         if (!message.entryFee.equals(Long.UZERO)) {
             obj.entryFee = (message.entryFee || Long.UZERO).toString();
         }
+        if (message.name !== "") {
+            obj.name = message.name;
+        }
         return obj;
     },
     create(base) {
@@ -3152,6 +3167,7 @@ const MsgCreateGame = {
             : Long.UZERO;
         message.blindLevelDuration = object.blindLevelDuration ?? 0;
         message.gameVariant = object.gameVariant ?? "";
+        message.name = object.name ?? "";
         message.entryFee = (object.entryFee !== undefined && object.entryFee !== null)
             ? Long.fromValue(object.entryFee)
             : Long.UZERO;
@@ -56149,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 };
@@ -56220,6 +56244,20 @@ var SUIT;
     SUIT[SUIT["HEARTS"] = 3] = "HEARTS";
     SUIT[SUIT["SPADES"] = 4] = "SPADES";
 })(SUIT || (SUIT = {}));
+/**
+ * Cost of ONE character of a paid table name, in micro-USDC ($0.10). The total
+ * naming fee is `length * GAME_NAME_MICRO_PER_CHAR`, charged on top of the
+ * game-creation cost and paid to validators. This is the SINGLE SOURCE OF TRUTH
+ * for the price so the UI preview and the chain agree. (block52/pokerchain#337)
+ */
+const GAME_NAME_MICRO_PER_CHAR = 100000n;
+/** Maximum table-name length (code points); bounds the max fee at 32 * $0.10. */
+const MAX_GAME_NAME_LENGTH = 32;
+/**
+ * Total naming fee (micro-USDC) for a table name: $0.10 per character. Counts
+ * code points to match the chain's rune-based charge. An empty name is free.
+ */
+const computeGameNameFee = (name) => BigInt([...name].length) * GAME_NAME_MICRO_PER_CHAR;
 // Constants for URL parameters
 const KEYS = {
     ACTION_TYPE: "action_type",
@@ -61124,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
  */
@@ -61132,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
@@ -61157,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') {
@@ -61214,18 +61338,21 @@ 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
      */
-    async createGame(gameFormat, gameVariant, minPlayers, maxPlayers, minBuyInB52USDC, maxBuyInB52USDC, smallBlindB52USDC, bigBlindB52USDC, timeout, rakeConfig, sngConfig) {
+    async createGame(gameFormat, gameVariant, minPlayers, maxPlayers, minBuyInB52USDC, maxBuyInB52USDC, smallBlindB52USDC, bigBlindB52USDC, timeout, rakeConfig, sngConfig, name) {
         // Validate SNG/Tournament config BEFORE any network work — fail fast.
         // SNG/Tournament games are DEFINED by startingStack + blindLevelDuration.
         // Refuse to create one with missing/zero values rather than silently
@@ -61274,6 +61401,9 @@ class SigningCosmosClient extends CosmosClient {
             blindLevelDuration: sngConfig?.blindLevelDuration ?? 0,
             // SNG flat entry fee (micro-units), skimmed to the creator at join time (poker-vm#2118)
             entryFee: sngConfig?.entryFee ? Long.fromString(sngConfig.entryFee.toString(), true) : Long.UZERO,
+            // Optional ENS-style table name (block52/pokerchain#337). Empty = unnamed
+            // (no fee); a non-empty name costs $0.10/char and must be globally unique.
+            name: name ?? "",
         });
         // Create the transaction message
         const msg = {
@@ -61307,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;
         }
@@ -61344,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;
         }
@@ -61391,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;
         }
@@ -61423,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) {
@@ -61456,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;
         }
@@ -61495,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;
         }
@@ -61543,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;
         }
@@ -61575,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();
@@ -61583,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);
@@ -61712,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).
@@ -61722,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.
@@ -61738,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
@@ -61836,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;
         }
@@ -61873,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;
         }
@@ -61912,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;
         }
@@ -61948,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;
         }
@@ -62028,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;
         }
@@ -62209,5 +62375,5 @@ const registry = new Registry([
     ...msgTypes,
 ]);
 
-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, ValidatorBond, 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, 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