@block52/poker-vm-sdk 1.5.1 → 1.7.0

package/dist/index.d.ts

@@ -44946,6 +44946,12 @@ interface MsgCreateGame {
      * globally unique, $0.10/char to validators. Empty = unnamed. (block52/pokerchain#337)
      */
     name: string;
+    /**
+     * Betting structure (field 20): "no-limit" | "pot-limit". Empty = the
+     * variant's default, pot-limit for omaha, no-limit for texas-holdem.
+     * (block52/pokerchain#407)
+     */
+    bettingLimit: string;
 }
 declare const MsgCreateGame: MessageFns<MsgCreateGame>;
 /** MsgJoinGame defines the MsgJoinGame message. */
@@ -45286,6 +45292,16 @@ declare enum GameVariant {
     TEXAS_HOLDEM = "texas-holdem",
     OMAHA = "omaha"
 }
+/**
+ * BettingLimit — the table's betting structure. Orthogonal to GameVariant: any
+ * variant can be played at any limit (pot-limit Omaha, pot-limit Hold'em,
+ * fixed-limit Hold'em, …). Absent on GameOptions ⇒ no-limit (current behavior).
+ */
+declare enum BettingLimit {
+    NO_LIMIT = "no-limit",
+    POT_LIMIT = "pot-limit",
+    FIXED_LIMIT = "fixed-limit"
+}
 declare enum GameStatus {
     WAITING_FOR_PLAYERS = "waiting-for-players",
     REGISTRATION = "registration",
@@ -45387,6 +45403,7 @@ type GameOptionsDTO = {
     levelStartTime?: number;
     timeBankMs?: number;
     timeBankCapMs?: number;
+    bettingLimit?: BettingLimit;
     otherOptions?: Record<string, any>;
 };
 type ActionDTO = {
@@ -45941,6 +45958,28 @@ declare const getGameVariant: (variant: GameVariant | string | undefined) => Gam
  * @returns GameVariant enum value, or "unknown" if invalid
  */
 declare const parseGameVariant: (value: string | undefined) => GameVariant | "unknown";
+/**
+ * The betting structure a table plays. The engine treats an absent
+ * `gameOptions.bettingLimit` as no-limit (poker-vm#2652), so this mirrors that
+ * rule rather than inventing a default (block52/pokerchain#407).
+ *
+ * @param options - the table's gameOptions (or anything carrying bettingLimit)
+ * @returns the table's BettingLimit
+ */
+declare const getBettingLimit: (options: {
+    bettingLimit?: BettingLimit;
+} | undefined) => BettingLimit;
+/**
+ * Check whether a table is pot-limit (its max bet or raise is the pot cap).
+ */
+declare const isPotLimit: (options: {
+    bettingLimit?: BettingLimit;
+} | undefined) => boolean;
+/**
+ * How many hole cards a variant deals each player: 4 for Omaha, 2 for Texas
+ * Hold'em. Mirrors the engine's HoleCardsPerPlayer (poker-vm#2650).
+ */
+declare const holeCardsPerPlayer: (variant: GameVariant | string | undefined) => number;
 
 /**
  * Check if a specific action is available in the legal actions list.
@@ -46034,6 +46073,16 @@ declare class PokerSolver {
      * Find the best 5-card hand from 7 cards
      */
     static findBestHand(cards: Card[]): HandEvaluation;
+    /**
+     * Find the best Omaha hand: EXACTLY 2 of the 4 hole cards and EXACTLY 3 of
+     * the 5 board cards — C(4,2) x C(5,3) = 60 candidates, ranked like Hold'em.
+     * Mirrors the engine's FindBestOmahaHand (poker-vm#2650).
+     */
+    static findBestOmahaHand(holeCards: Card[], communityCards: Card[]): HandEvaluation;
+    /**
+     * Best hand for a variant from hole cards and a full 5-card board.
+     */
+    private static bestHandForVariant;
     /**
      * Evaluate a hand with any number of cards (2-7)
      * This is useful for showing hand strength during all betting rounds
@@ -46115,12 +46164,14 @@ declare class PokerSolver {
     static calculateWinPercentages(handA: Card[], handB: Card[], communityCards?: Card[], simulations?: number): [number, number, number];
     /**
      * Calculate win percentages for multiple players (2+) using Monte Carlo simulation
-     * @param hands Array of hole cards for each player (each must have exactly 2 cards)
+     * @param hands Array of hole cards for each player (2 each for Hold'em, 4 for Omaha)
      * @param communityCards Current community cards (0-5 cards)
      * @param simulations Number of simulations to run (default: 10000)
+     * @param variant The table's variant; omitted = Texas Hold'em. Omaha hands are
+     *   scored with the two-plus-three rule (ui#769).
      * @returns Object containing win percentages for each player and overall tie percentage
      */
-    static calculateMultiPlayerEquity(hands: Card[][], communityCards?: Card[], simulations?: number): {
+    static calculateMultiPlayerEquity(hands: Card[][], communityCards?: Card[], simulations?: number, variant?: GameVariant): {
         winPercentages: number[];
         tiePercentage: number;
     };
@@ -46607,9 +46658,14 @@ declare class SigningCosmosClient extends CosmosClient {
      */
     sendB52USDC(fromAddress: string, toAddress: string, amount: bigint, memo?: string): Promise<string>;
     /**
-     * Create a new poker game
+     * Create a new poker game.
+     *
+     * `bettingLimit` is the table's betting structure (block52/pokerchain#407).
+     * Omit it for the variant's default: pot-limit for omaha (PLO), no-limit for
+     * texas-holdem. Omitted, the field is not encoded at all, so a chain without
+     * it accepts the tx unchanged. Fixed-limit is not playable yet (poker-vm#2654).
      */
-    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>;
+    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, bettingLimit?: BettingLimit): Promise<string>;
     /**
      * Join a poker game
      */
@@ -46852,6 +46908,11 @@ declare class SigningCosmosClient extends CosmosClient {
  * Create a signing client from a mnemonic
  */
 declare function createSigningClientFromMnemonic(config: CosmosConfig, mnemonic: string): Promise<SigningCosmosClient>;
+/**
+ * Throws for a betting limit a table cannot be created with (block52/pokerchain#407).
+ * Undefined is allowed: the chain applies the variant's default.
+ */
+declare function assertCreatableBettingLimit(bettingLimit?: BettingLimit): void;
 
 /**
  * The part of a broadcast result this module reads. Structurally a subset of
@@ -47167,5 +47228,5 @@ declare const Client: typeof IgniteClient & Constructor<{
 }>;
 declare const registry: 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, MSG_CREATE_VALIDATOR_TYPE_URL, 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, buildMsgCreateValidator, computeGameNameFee, createSigningClientFromMnemonic, createWalletFromMnemonic, decToAtomics, formatGameFormatDisplay, formatGameVariantDisplay, generateWallet, getActionByType, getAddressFromMnemonic, getDefaultCosmosConfig, getGameFormat, getGameFormatForCosmos, getGameFormatFromObject, getGameVariant, hasAction, isCashFormat, isEmptyAddress, isSitAndGoFormat, isTournamentFormat, isValidMnemonic, isValidPlayerAddress, parseGameFormat, parseGameVariant, registry, toValoperAddress, txFailureHash, txFailurePhase };
+export { AllPlayerActions, BLOCK52_HD_PATH, BettingLimit, Board, COSMOS_CONSTANTS, Client, CosmosClient, Deck, GAME_NAME_MICRO_PER_CHAR, GameFormat, GameStatus, GameVariant, HandType, KEYS, MAX_GAME_NAME_LENGTH, MSG_CREATE_VALIDATOR_TYPE_URL, 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, assertCreatableBettingLimit, assertExecuted, buildMsgCreateValidator, computeGameNameFee, createSigningClientFromMnemonic, createWalletFromMnemonic, decToAtomics, formatGameFormatDisplay, formatGameVariantDisplay, generateWallet, getActionByType, getAddressFromMnemonic, getBettingLimit, getDefaultCosmosConfig, getGameFormat, getGameFormatForCosmos, getGameFormatFromObject, getGameVariant, hasAction, holeCardsPerPlayer, isCashFormat, isEmptyAddress, isPotLimit, isSitAndGoFormat, isTournamentFormat, isValidMnemonic, isValidPlayerAddress, parseGameFormat, parseGameVariant, registry, toValoperAddress, txFailureHash, txFailurePhase };
 export type { AccountDTO, ActionDTO, Block, BlockDTO, BlockHeader, BlockHeaderDTO, BlockID, BlockResponse, BurnResponseDTO, Card, CreateValidatorParams, 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;AAIvG,OAAO,EAAE,uBAAuB,EAAE,YAAY,EAAE,gBAAgB,EAAE,6BAA6B,EAAE,KAAK,qBAAqB,EAAE,MAAM,WAAW,CAAA;AAC9I,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"}
+{"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,2BAA2B,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAIpI,OAAO,EAAE,uBAAuB,EAAE,YAAY,EAAE,gBAAgB,EAAE,6BAA6B,EAAE,KAAK,qBAAqB,EAAE,MAAM,WAAW,CAAA;AAC9I,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

@@ -2845,6 +2845,7 @@ function createBaseMsgCreateGame() {
         gameVariant: "",
         entryFee: Long.UZERO,
         name: "",
+        bettingLimit: "",
     };
 }
 const MsgCreateGame = {
@@ -2903,6 +2904,9 @@ const MsgCreateGame = {
         if (message.name !== "") {
             writer.uint32(154).string(message.name);
         }
+        if (message.bettingLimit !== "") {
+            writer.uint32(162).string(message.bettingLimit);
+        }
         return writer;
     },
     decode(input, length) {
@@ -3038,6 +3042,13 @@ const MsgCreateGame = {
                     message.name = reader.string();
                     continue;
                 }
+                case 20: {
+                    if (tag !== 162) {
+                        break;
+                    }
+                    message.bettingLimit = reader.string();
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -3066,6 +3077,7 @@ const MsgCreateGame = {
             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) : "",
+            bettingLimit: isSet$2b(object.bettingLimit) ? globalThis.String(object.bettingLimit) : "",
         };
     },
     toJSON(message) {
@@ -3124,6 +3136,9 @@ const MsgCreateGame = {
         if (message.name !== "") {
             obj.name = message.name;
         }
+        if (message.bettingLimit !== "") {
+            obj.bettingLimit = message.bettingLimit;
+        }
         return obj;
     },
     create(base) {
@@ -3168,6 +3183,7 @@ const MsgCreateGame = {
         message.blindLevelDuration = object.blindLevelDuration ?? 0;
         message.gameVariant = object.gameVariant ?? "";
         message.name = object.name ?? "";
+        message.bettingLimit = object.bettingLimit ?? "";
         message.entryFee = (object.entryFee !== undefined && object.entryFee !== null)
             ? Long.fromValue(object.entryFee)
             : Long.UZERO;
@@ -56095,6 +56111,17 @@ var GameVariant;
     GameVariant["TEXAS_HOLDEM"] = "texas-holdem";
     GameVariant["OMAHA"] = "omaha";
 })(GameVariant || (GameVariant = {}));
+/**
+ * BettingLimit — the table's betting structure. Orthogonal to GameVariant: any
+ * variant can be played at any limit (pot-limit Omaha, pot-limit Hold'em,
+ * fixed-limit Hold'em, …). Absent on GameOptions ⇒ no-limit (current behavior).
+ */
+var BettingLimit;
+(function (BettingLimit) {
+    BettingLimit["NO_LIMIT"] = "no-limit";
+    BettingLimit["POT_LIMIT"] = "pot-limit";
+    BettingLimit["FIXED_LIMIT"] = "fixed-limit";
+})(BettingLimit || (BettingLimit = {}));
 var GameStatus;
 (function (GameStatus) {
     GameStatus["WAITING_FOR_PLAYERS"] = "waiting-for-players";
@@ -56466,6 +56493,30 @@ const parseGameVariant = (value) => {
             return "unknown";
     }
 };
+/**
+ * The betting structure a table plays. The engine treats an absent
+ * `gameOptions.bettingLimit` as no-limit (poker-vm#2652), so this mirrors that
+ * rule rather than inventing a default (block52/pokerchain#407).
+ *
+ * @param options - the table's gameOptions (or anything carrying bettingLimit)
+ * @returns the table's BettingLimit
+ */
+const getBettingLimit = (options) => {
+    return options?.bettingLimit ?? BettingLimit.NO_LIMIT;
+};
+/**
+ * Check whether a table is pot-limit (its max bet or raise is the pot cap).
+ */
+const isPotLimit = (options) => {
+    return getBettingLimit(options) === BettingLimit.POT_LIMIT;
+};
+/**
+ * How many hole cards a variant deals each player: 4 for Omaha, 2 for Texas
+ * Hold'em. Mirrors the engine's HoleCardsPerPlayer (poker-vm#2650).
+ */
+const holeCardsPerPlayer = (variant) => {
+    return variant === GameVariant.OMAHA ? 4 : 2;
+};
 
 /**
  * Check if a specific action is available in the legal actions list.
@@ -56721,6 +56772,41 @@ class PokerSolver {
         }
         return bestHand;
     }
+    /**
+     * Find the best Omaha hand: EXACTLY 2 of the 4 hole cards and EXACTLY 3 of
+     * the 5 board cards — C(4,2) x C(5,3) = 60 candidates, ranked like Hold'em.
+     * Mirrors the engine's FindBestOmahaHand (poker-vm#2650).
+     */
+    static findBestOmahaHand(holeCards, communityCards) {
+        if (holeCards.length !== 4) {
+            throw new Error("Omaha requires exactly 4 hole cards");
+        }
+        if (communityCards.length !== 5) {
+            throw new Error("Omaha requires exactly 5 community cards");
+        }
+        let bestHand = null;
+        for (const pair of this.getCombinationsFlexible(holeCards, 2)) {
+            for (const triple of this.getCombinationsFlexible(communityCards, 3)) {
+                const evaluation = this.evaluateHand([...pair, ...triple]);
+                if (!bestHand || this.compareHands(evaluation, bestHand) > 0) {
+                    bestHand = evaluation;
+                }
+            }
+        }
+        if (!bestHand) {
+            throw new Error("Failed to evaluate hand");
+        }
+        return bestHand;
+    }
+    /**
+     * Best hand for a variant from hole cards and a full 5-card board.
+     */
+    static bestHandForVariant(variant, holeCards, communityCards) {
+        if (variant === GameVariant.OMAHA) {
+            return this.findBestOmahaHand(holeCards, communityCards);
+        }
+        return this.findBestHand([...holeCards, ...communityCards]);
+    }
     /**
      * Evaluate a hand with any number of cards (2-7)
      * This is useful for showing hand strength during all betting rounds
@@ -57115,12 +57201,14 @@ class PokerSolver {
     }
     /**
      * Calculate win percentages for multiple players (2+) using Monte Carlo simulation
-     * @param hands Array of hole cards for each player (each must have exactly 2 cards)
+     * @param hands Array of hole cards for each player (2 each for Hold'em, 4 for Omaha)
      * @param communityCards Current community cards (0-5 cards)
      * @param simulations Number of simulations to run (default: 10000)
+     * @param variant The table's variant; omitted = Texas Hold'em. Omaha hands are
+     *   scored with the two-plus-three rule (ui#769).
      * @returns Object containing win percentages for each player and overall tie percentage
      */
-    static calculateMultiPlayerEquity(hands, communityCards = [], simulations = 10000) {
+    static calculateMultiPlayerEquity(hands, communityCards = [], simulations = 10000, variant) {
         // Validate inputs
         if (hands.length < 2) {
             throw new Error("Need at least 2 hands to calculate equity");
@@ -57128,9 +57216,10 @@ class PokerSolver {
         if (hands.length > 10) {
             throw new Error("Maximum 10 hands supported");
         }
+        const holeCount = holeCardsPerPlayer(variant);
         for (let i = 0; i < hands.length; i++) {
-            if (hands[i].length !== 2) {
-                throw new Error(`Hand ${i} must have exactly 2 cards`);
+            if (hands[i].length !== holeCount) {
+                throw new Error(`Hand ${i} must have exactly ${holeCount} cards`);
             }
         }
         if (communityCards.length > 5) {
@@ -57157,10 +57246,7 @@ class PokerSolver {
             // Deal remaining community cards
             const fullCommunityCards = [...communityCards, ...shuffledDeck.slice(0, cardsNeeded)];
             // Evaluate all hands
-            const evaluations = hands.map(hand => {
-                const fullHand = [...hand, ...fullCommunityCards];
-                return this.findBestHand(fullHand);
-            });
+            const evaluations = hands.map(hand => this.bestHandForVariant(variant, hand, fullCommunityCards));
             // Find winners using existing findWinners method
             const winnerIndices = this.findWinners(evaluations);
             // Update win counters
@@ -71023,9 +71109,14 @@ class SigningCosmosClient extends CosmosClient {
         return this.sendTokens(fromAddress, toAddress, amount, undefined, memo);
     }
     /**
-     * Create a new poker game
+     * Create a new poker game.
+     *
+     * `bettingLimit` is the table's betting structure (block52/pokerchain#407).
+     * Omit it for the variant's default: pot-limit for omaha (PLO), no-limit for
+     * texas-holdem. Omitted, the field is not encoded at all, so a chain without
+     * it accepts the tx unchanged. Fixed-limit is not playable yet (poker-vm#2654).
      */
-    async createGame(gameFormat, gameVariant, minPlayers, maxPlayers, minBuyInB52USDC, maxBuyInB52USDC, smallBlindB52USDC, bigBlindB52USDC, timeout, rakeConfig, sngConfig, name) {
+    async createGame(gameFormat, gameVariant, minPlayers, maxPlayers, minBuyInB52USDC, maxBuyInB52USDC, smallBlindB52USDC, bigBlindB52USDC, timeout, rakeConfig, sngConfig, name, bettingLimit) {
         // 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
@@ -71045,6 +71136,7 @@ class SigningCosmosClient extends CosmosClient {
                 throw new Error(`${gameFormat} games require a positive blindLevelDuration; got ${sngConfig.blindLevelDuration}.`);
             }
         }
+        assertCreatableBettingLimit(bettingLimit);
         await this.initializeSigningClient();
         if (!this.signingClient || !this.wallet) {
             throw new Error("Signing client not initialized");
@@ -71077,6 +71169,9 @@ class SigningCosmosClient extends CosmosClient {
             // 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 ?? "",
+            // Betting structure (block52/pokerchain#407). "" = the variant's default
+            // on chain, and an empty proto3 string is not encoded at all.
+            bettingLimit: bettingLimit ?? "",
         });
         // Create the transaction message
         const msg = {
@@ -71096,6 +71191,7 @@ class SigningCosmosClient extends CosmosClient {
             smallBlind: smallBlindB52USDC.toString(),
             bigBlind: bigBlindB52USDC.toString(),
             timeout,
+            ...(bettingLimit && { bettingLimit }),
             ...(rakeConfig && {
                 rakeFreeThreshold: rakeConfig.rakeFreeThreshold.toString(),
                 rakePercentage: rakeConfig.rakePercentage,
@@ -71972,6 +72068,21 @@ async function createSigningClientFromMnemonic(config, mnemonic) {
     });
     return createSigningCosmosClient(config, wallet);
 }
+/**
+ * Throws for a betting limit a table cannot be created with (block52/pokerchain#407).
+ * Undefined is allowed: the chain applies the variant's default.
+ */
+function assertCreatableBettingLimit(bettingLimit) {
+    if (bettingLimit === undefined) {
+        return;
+    }
+    if (bettingLimit === BettingLimit.FIXED_LIMIT) {
+        throw new Error("Fixed-limit tables are not available yet (poker-vm#2654).");
+    }
+    if (bettingLimit !== BettingLimit.NO_LIMIT && bettingLimit !== BettingLimit.POT_LIMIT) {
+        throw new Error(`Invalid betting limit: ${bettingLimit}.`);
+    }
+}
 
 // Generated by Ignite ignite.com/cli
 const Client = IgniteClient.plugin([
@@ -72011,5 +72122,5 @@ const registry = new Registry([
     ...msgTypes,
 ]);
 
-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, MSG_CREATE_VALIDATOR_TYPE_URL, 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, buildMsgCreateValidator, computeGameNameFee, createSigningClientFromMnemonic, createWalletFromMnemonic, decToAtomics, formatGameFormatDisplay, formatGameVariantDisplay, generateWallet, getActionByType, getAddressFromMnemonic, getDefaultCosmosConfig, getGameFormat, getGameFormatForCosmos, getGameFormatFromObject, getGameVariant, hasAction, isCashFormat, isEmptyAddress, isSitAndGoFormat, isTournamentFormat, isValidMnemonic, isValidPlayerAddress, parseGameFormat, parseGameVariant, registry, toValoperAddress, txFailureHash, txFailurePhase };
+export { AllPlayerActions, BLOCK52_HD_PATH, BettingLimit, Board, COSMOS_CONSTANTS, Client, CosmosClient, Deck, GAME_NAME_MICRO_PER_CHAR, GameFormat, GameStatus, GameVariant, HandType, KEYS, MAX_GAME_NAME_LENGTH, MSG_CREATE_VALIDATOR_TYPE_URL, 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, assertCreatableBettingLimit, assertExecuted, buildMsgCreateValidator, computeGameNameFee, createSigningClientFromMnemonic, createWalletFromMnemonic, decToAtomics, formatGameFormatDisplay, formatGameVariantDisplay, generateWallet, getActionByType, getAddressFromMnemonic, getBettingLimit, getDefaultCosmosConfig, getGameFormat, getGameFormatForCosmos, getGameFormatFromObject, getGameVariant, hasAction, holeCardsPerPlayer, isCashFormat, isEmptyAddress, isPotLimit, isSitAndGoFormat, isTournamentFormat, isValidMnemonic, isValidPlayerAddress, parseGameFormat, parseGameVariant, registry, toValoperAddress, txFailureHash, txFailurePhase };
 //# sourceMappingURL=index.esm.js.map