@block52/poker-vm-sdk 1.3.1 → 1.3.3

package/dist/index.js

@@ -56053,6 +56053,11 @@ exports.NonPlayerActionType = void 0;
     NonPlayerActionType["JOIN"] = "join";
     NonPlayerActionType["LEAVE"] = "leave";
     NonPlayerActionType["NEW_HAND"] = "new-hand";
+    // Entry big blind auto-posted when a post-now joiner activates off the blind
+    // seats (poker-vm#2553). Recorded in ANTE; counted toward the pot + the
+    // player's bet (they're matched) but excluded from the first-to-act /
+    // has-acted scans (it's a non-player action, like DEAD_SMALL_BLIND).
+    NonPlayerActionType["POST"] = "post";
     NonPlayerActionType["SIT_IN"] = "sit-in";
     // Sit in and wait for the big blind — distinct action from SIT_IN (post now)
     // so each has a single responsibility. Sets WAITING_FOR_BIG_BLIND. (#2139)
@@ -57193,6 +57198,92 @@ class Deck {
         // Explicitly update hash after shuffling
         this.createHash();
     }
+    /**
+     * Shuffle deterministically from a 32-byte client entropy seed, byte-for-byte
+     * matching the Cosmos chain so the PVM and the chain derive the SAME deck for
+     * the same seed. This is a faithful port of
+     * `pokerchain/x/poker/types/deck.go:ShuffleFromVRF` (poker-vm#2460): without
+     * it the PVM forks from the chain on a client-seed new-hand (#2418).
+     *
+     * DEPRECATED interim: the client-chosen seed is grindable. Superseded by the
+     * validator-entropy VRF re-hardening tracked in poker-vm#2459.
+     *
+     * @param seedHex 32-byte seed as 64 hex chars (the FE's `seed=` value).
+     */
+    shuffleFromSeed(seedHex) {
+        const seed = Buffer.from(seedHex, "hex");
+        if (seed.length !== Deck.PLAYER_SEED_LEN) {
+            throw new Error(`player seed must be ${Deck.PLAYER_SEED_LEN} bytes, got ${seed.length}`);
+        }
+        this.seedHash = crypto$1.createHash("sha256").update(seed).digest("hex");
+        // HKDF-SHA256 expand (salt = HashLen zero bytes, info = VRF_INFO),
+        // consumed as an on-demand byte stream — mirrors Go hkdf.New(...).Read.
+        const read = Deck.hkdfExpandReader(seed, Buffer.alloc(32), Buffer.from(Deck.VRF_INFO));
+        // Fisher-Yates with crypto/rand.Int rejection sampling (Go semantics),
+        // so the HKDF stream is consumed identically to the chain.
+        for (let i = this.cards.length - 1; i > 0; i--) {
+            const j = Deck.randInt(read, i + 1);
+            [this.cards[i], this.cards[j]] = [this.cards[j], this.cards[i]];
+        }
+        this.createHash();
+    }
+    /**
+     * Streaming HKDF-Expand (RFC 5869, SHA-256), matching Go
+     * `hkdf.New(sha256.New, ikm, salt, info).Read`:
+     *   PRK = HMAC(salt, ikm); output = T(1)||T(2)||…, T(n) = HMAC(PRK, T(n-1)||info||n).
+     * salt is HashLen zero bytes (Go's nil-salt default). Returns a reader that
+     * yields the next `n` stream bytes on each call.
+     */
+    static hkdfExpandReader(ikm, salt, info) {
+        const prk = crypto$1.createHmac("sha256", salt).update(ikm).digest();
+        let buffer = Buffer.alloc(0);
+        let t = Buffer.alloc(0);
+        let counter = 1;
+        return (n) => {
+            while (buffer.length < n) {
+                if (counter > 255) {
+                    throw new Error("HKDF stream exhausted (>255 blocks)");
+                }
+                t = crypto$1.createHmac("sha256", prk)
+                    .update(Buffer.concat([t, info, Buffer.from([counter])]))
+                    .digest();
+                buffer = Buffer.concat([buffer, t]);
+                counter++;
+            }
+            const out = Buffer.from(buffer.subarray(0, n)); // copy before advancing
+            buffer = buffer.subarray(n);
+            return out;
+        };
+    }
+    /**
+     * Uniform integer in [0, max) by rejection sampling — a port of Go
+     * `crypto/rand.Int`. The byte count, high-byte mask and reject test match
+     * the stdlib exactly so the HKDF byte stream is consumed the same way the
+     * chain consumes it. `max` here is always ≤ 52, so the result fits a number.
+     */
+    static randInt(read, max) {
+        const nMax = max - 1; // largest valid value; bit length is taken over max-1
+        if (nMax === 0) {
+            return 0; // max === 1: only 0 is valid, no bytes consumed
+        }
+        const bitLen = 32 - Math.clz32(nMax);
+        const k = Math.ceil(bitLen / 8);
+        let b = bitLen % 8;
+        if (b === 0) {
+            b = 8;
+        }
+        for (;;) {
+            const bytes = read(k);
+            bytes[0] &= (1 << b) - 1; // clear high bits of the top byte
+            let n = 0;
+            for (const byte of bytes) {
+                n = n * 256 + byte; // big-endian, matching big.Int.SetBytes
+            }
+            if (n < max) {
+                return n;
+            }
+        }
+    }
     getCardMnemonic(suit, rank) {
         const rankNum = Number(rank);
         const rankStr = Deck.RANK_MAP[rankNum] !== undefined ? Deck.RANK_MAP[rankNum] : rankNum.toString();
@@ -57319,6 +57410,10 @@ Deck.SUIT_MAP = {
     [exports.SUIT.HEARTS]: "H",
     [exports.SUIT.SPADES]: "S"
 };
+// Matches pokerchain types.PlayerSeedLen and VRFInputPrefix — the two sides
+// MUST agree on these or the derived decks diverge.
+Deck.PLAYER_SEED_LEN = 32;
+Deck.VRF_INFO = "poker/deck/v1";
 
 /**
  * The community board for a Texas Hold'em hand.