@block52/poker-vm-sdk 1.4.0 → 1.4.1

package/dist/index.js

@@ -56167,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 };
@@ -61156,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
  */
@@ -61164,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
@@ -61189,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') {
@@ -61246,13 +61340,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
@@ -61342,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;
         }
@@ -61379,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;
         }
@@ -61426,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;
         }
@@ -61458,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) {
@@ -61491,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;
         }
@@ -61530,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;
         }
@@ -61578,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;
         }
@@ -61610,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();
@@ -61618,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);
@@ -61747,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).
@@ -61757,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.
@@ -61773,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
@@ -61871,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;
         }
@@ -61908,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;
         }
@@ -61947,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;
         }
@@ -61983,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;
         }
@@ -62063,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;
         }
@@ -62263,8 +62396,10 @@ 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;
@@ -62288,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