@block52/poker-vm-sdk 1.3.5 → 1.4.1

package/dist/index.js

@@ -2846,6 +2846,7 @@ function createBaseMsgCreateGame() {
         blindLevelDuration: 0,
         gameVariant: "",
         entryFee: Long.UZERO,
+        name: "",
     };
 }
 const MsgCreateGame = {
@@ -2901,6 +2902,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) {
@@ -3029,6 +3033,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;
@@ -3056,6 +3067,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) {
@@ -3111,6 +3123,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) {
@@ -3154,6 +3169,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;
@@ -56151,6 +56167,14 @@ exports.NonPlayerActionType = void 0;
     // 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";
 })(exports.NonPlayerActionType || (exports.NonPlayerActionType = {}));
 const AllPlayerActions = { ...exports.PlayerActionType, ...exports.NonPlayerActionType };
@@ -56222,6 +56246,20 @@ exports.SUIT = void 0;
     SUIT[SUIT["HEARTS"] = 3] = "HEARTS";
     SUIT[SUIT["SPADES"] = 4] = "SPADES";
 })(exports.SUIT || (exports.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",
@@ -61126,6 +61164,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 stargate.BroadcastTxError) {
+        return "not-broadcast";
+    }
+    if (error instanceof stargate.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 stargate.TimeoutError) {
+        return error.txId;
+    }
+    return undefined;
+}
+
 /**
  * Default gas limit for all transactions
  */
@@ -61134,6 +61245,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 protoSigning.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
@@ -61159,6 +61282,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') {
@@ -61216,18 +61340,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
@@ -61276,6 +61403,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 = {
@@ -61309,6 +61439,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;
         }
@@ -61346,6 +61477,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;
         }
@@ -61393,6 +61525,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;
         }
@@ -61425,6 +61558,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) {
@@ -61458,6 +61592,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;
         }
@@ -61497,6 +61632,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;
         }
@@ -61545,6 +61681,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;
         }
@@ -61577,6 +61714,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();
@@ -61585,26 +61727,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(encoding.fromBase64(base64));
         }
         catch (error) {
             console.error("❌ Action (sync) failed at CheckTx:", error);
@@ -61714,8 +61860,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).
@@ -61724,7 +61869,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.
@@ -61740,6 +61885,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
@@ -61838,6 +61999,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;
         }
@@ -61875,6 +62037,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;
         }
@@ -61914,6 +62077,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;
         }
@@ -61950,6 +62114,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;
         }
@@ -62030,6 +62195,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;
         }
@@ -62218,7 +62384,9 @@ exports.COSMOS_CONSTANTS = COSMOS_CONSTANTS;
 exports.Client = Client;
 exports.CosmosClient = CosmosClient;
 exports.Deck = Deck;
+exports.GAME_NAME_MICRO_PER_CHAR = GAME_NAME_MICRO_PER_CHAR;
 exports.KEYS = KEYS;
+exports.MAX_GAME_NAME_LENGTH = MAX_GAME_NAME_LENGTH;
 exports.MissingWalletError = MissingWalletError;
 exports.Params = Params$c;
 exports.PokerGameIntegration = PokerGameIntegration;
@@ -62228,8 +62396,11 @@ exports.SIT_IN_METHOD_POST_NOW = SIT_IN_METHOD_POST_NOW;
 exports.SIT_OUT_METHOD_NEXT_BB = SIT_OUT_METHOD_NEXT_BB;
 exports.SIT_OUT_METHOD_NEXT_HAND = SIT_OUT_METHOD_NEXT_HAND;
 exports.SigningCosmosClient = SigningCosmosClient;
+exports.TxExecutionError = TxExecutionError;
 exports.ValidatorBond = ValidatorBond;
 exports.WithdrawalRequest = WithdrawalRequest;
+exports.assertExecuted = assertExecuted;
+exports.computeGameNameFee = computeGameNameFee;
 exports.createSigningClientFromMnemonic = createSigningClientFromMnemonic;
 exports.createWalletFromMnemonic = createWalletFromMnemonic;
 exports.formatGameFormatDisplay = formatGameFormatDisplay;
@@ -62252,4 +62423,6 @@ exports.isValidPlayerAddress = isValidPlayerAddress;
 exports.parseGameFormat = parseGameFormat;
 exports.parseGameVariant = parseGameVariant;
 exports.registry = registry;
+exports.txFailureHash = txFailureHash;
+exports.txFailurePhase = txFailurePhase;
 //# sourceMappingURL=index.js.map