@block52/poker-vm-sdk 1.2.17 → 1.3.1

package/dist/index.js

@@ -6,6 +6,7 @@ var events = require('events');
 var crypto = require('@cosmjs/crypto');
 var crypto$1 = require('crypto');
 var encoding = require('@cosmjs/encoding');
+var amino = require('@cosmjs/amino');
 
 /// <reference path="./types.d.ts" />
 const defaultFee$q = {
@@ -60940,6 +60941,10 @@ var txExports = requireTx();
  * Default gas limit for all transactions
  */
 const DEFAULT_GAS_LIMIT = 1000000;
+// Registry with the poker message types, used to pack a Msg into an Any when
+// hand-building an unordered TxBody (signUnordered). Module-level so it's built
+// once and shared with the stargate client's registry semantics.
+const pokerRegistry = new protoSigning.Registry(msgTypes$u);
 /**
  * Create a gasless fee object with specified gas limit
  * Chain is configured with min-gas-prices = "0stake" so no fee tokens required
@@ -61430,36 +61435,31 @@ class SigningCosmosClient extends CosmosClient {
      * Requires the player account to EXIST on-chain (funded). Same gasless
      * fee + msg shape as {@link performActionSync}.
      */
-    async signPerformAction(gameId, action, amount = 0n, data, signerData) {
-        await this.initializeSigningClient();
-        if (!this.signingClient || !this.wallet) {
-            throw new Error("Signing client not initialized");
+    async signPerformAction(gameId, action, amount = 0n, data, _signerData) {
+        // Unordered signing needs only the wallet + REST getAccount — no RPC
+        // stargate client, so this works without a reachable RPC endpoint.
+        if (!this.wallet) {
+            throw new Error("No wallet provided for signing");
         }
         const [account] = await this.wallet.getAccounts();
         const player = account.address;
-        const msgPerformAction = {
-            player,
-            gameId,
-            action,
-            amount: Long.fromString(amount.toString(), true),
-            data: data || ""
-        };
         const msg = {
             typeUrl: "/pokerchain.poker.v1.MsgPerformAction",
-            value: msgPerformAction
+            value: {
+                player,
+                gameId,
+                action,
+                amount: Long.fromString(amount.toString(), true),
+                data: data || ""
+            }
         };
-        let explicit = signerData;
-        if (!explicit) {
-            const accountInfo = await this.getAccount(player);
-            explicit = {
-                accountNumber: Number(accountInfo.account.account_number),
-                sequence: Number(accountInfo.account.sequence),
-                chainId: this.config.chainId
-            };
-        }
-        const txRaw = await this.signingClient.sign(player, [msg], gaslessFee(), `Poker action (relay): ${action}`, explicit);
-        const base64 = encoding.toBase64(txExports.TxRaw.encode(txRaw).finish());
-        return { base64, sequence: explicit.sequence, accountNumber: explicit.accountNumber };
+        // Settlement txs are UNORDERED (#247): no account sequence, so optimistic
+        // play can never desync the chain sequence (the #2413 cascade). The
+        // `signerData`/sequence arg is retained for signature compatibility but
+        // ignored — unordered txs carry sequence 0.
+        const { base64, accountNumber } = await this.signUnordered(msg);
+        // sequence is meaningless for unordered txs; return 0 for shape compat.
+        return { base64, sequence: 0, accountNumber };
     }
     /**
      * Resolves the signer data (account number + sequence + chain id) for a
@@ -61495,6 +61495,59 @@ class SigningCosmosClient extends CosmosClient {
         const base64 = encoding.toBase64(txExports.TxRaw.encode(txRaw).finish());
         return { base64, sequence: explicit.sequence, accountNumber: explicit.accountNumber };
     }
+    /**
+     * Sign a single cosmos message as an UNORDERED transaction (SDK 0.53): the
+     * TxBody carries `unordered: true` + a `timeout_timestamp` and NO account
+     * sequence (sequence MUST be 0). The chain admits it regardless of order and
+     * dedups replay on (signer, timeout) — so settlement txs no longer carry a
+     * client-guessed sequence and can never cascade (poker-vm#247, replaces the
+     * sequence-tracking that caused #2413).
+     *
+     * Hand-built because CosmJS 0.32's TxBody proto predates the unordered
+     * fields; we use the SDK's own cosmos.tx proto (which has them) for the body
+     * and CosmJS only for AuthInfo + the direct signature.
+     *
+     * @param ttlSeconds - how far ahead the timeout_timestamp is set. Must be
+     *   within the chain's max unordered TTL (SDK default 10m). Also bounds how
+     *   long a replay of this exact tx is rejected.
+     */
+    async signUnordered(msg, ttlSeconds = 120) {
+        // No RPC signing client needed: unordered signing is a direct signature
+        // over locally-built bytes. Only the wallet (for signDirect) and a REST
+        // getAccount (for account_number) are required.
+        if (!this.wallet) {
+            throw new Error("No wallet provided for signing");
+        }
+        const [account] = await this.wallet.getAccounts();
+        const player = account.address;
+        // account_number + chainId are still needed for the sign doc; the
+        // SEQUENCE is not — unordered txs must sign with sequence 0.
+        const accountInfo = await this.getAccount(player);
+        const accountNumber = Number(accountInfo.account.account_number);
+        const chainId = this.config.chainId;
+        // Body with unordered=true + timeout_timestamp, messages packed as Any
+        // via the poker registry. timeoutHeight stays 0 (we gate on timestamp).
+        const bodyBytes = TxBody.encode(TxBody.fromPartial({
+            messages: [pokerRegistry.encodeAsAny(msg)],
+            memo: "",
+            timeoutHeight: Long.UZERO,
+            unordered: true,
+            timeoutTimestamp: new Date(Date.now() + ttlSeconds * 1000)
+        })).finish();
+        // AuthInfo with sequence 0 (required for unordered). CosmJS builds this
+        // — the pubkey/fee encoding is unchanged from an ordered tx.
+        const pubkey = protoSigning.encodePubkey(amino.encodeSecp256k1Pubkey(account.pubkey));
+        const gas = gaslessFee();
+        const authInfoBytes = protoSigning.makeAuthInfoBytes([{ pubkey, sequence: 0 }], gas.amount, Number(gas.gas), undefined, undefined);
+        const signDoc = protoSigning.makeSignDoc(bodyBytes, authInfoBytes, chainId, accountNumber);
+        const { signature, signed } = await this.wallet.signDirect(player, signDoc);
+        const base64 = encoding.toBase64(TxRaw.encode(TxRaw.fromPartial({
+            bodyBytes: signed.bodyBytes,
+            authInfoBytes: signed.authInfoBytes,
+            signatures: [encoding.fromBase64(signature.signature)]
+        })).finish());
+        return { base64, accountNumber };
+    }
     /**
      * Sign-only MsgJoinGame: builds and signs the player's buy-in tx WITHOUT
      * broadcasting, returning the base64 TxRaw for the gateway to relay