@block52/poker-vm-sdk 1.10.0 → 1.12.0

package/dist/index.d.ts

@@ -44960,6 +44960,14 @@ interface MsgCreateGame {
      * 0 = unscheduled: starts only when full. (poker-vm#2680)
      */
     startTime: Long;
+    /**
+     * Blind structure for a sit-and-go / tournament (field 22): JSON of the SDK's
+     * BlindStructureDTO — a preset ({"preset":"turbo"}) or an explicit double /
+     * linear / percentage / table structure. Empty = the blinds double every
+     * blind_level_duration minutes. Cash games must leave it empty.
+     * (poker-vm#1734, block52/pokerchain#434)
+     */
+    blindStructure: string;
 }
 declare const MsgCreateGame: MessageFns<MsgCreateGame>;
 /** MsgJoinGame defines the MsgJoinGame message. */
@@ -46144,6 +46152,34 @@ declare const isEmptyAddress: (address: string | null | undefined) => boolean;
  */
 declare const isValidPlayerAddress: (address: string | null | undefined) => boolean;
 
+/**
+ * Parses the text form into the typed structure. Throws on anything the
+ * engine would refuse that can be seen without expanding levels; the engine
+ * validates the result again on load.
+ */
+declare function parseBlindStructure(text: string): BlindStructureDTO;
+/**
+ * The inverse of parseBlindStructure. A preset formats as `BLINDS <preset>`;
+ * anything else as a block under `name` (default "custom").
+ */
+declare function formatBlindStructure(structure: BlindStructureDTO, name?: string): string;
+/**
+ * #1734's preset library, as the engine resolves it (pvm/go/engine
+ * tournament_blinds.go blindPresets). The engine resolves a preset on the
+ * table's first action; `resolveBlindPreset` does the same client-side so the
+ * levels can be previewed before the table exists.
+ */
+declare const BLIND_PRESET_STRUCTURES: Readonly<Record<BlindPreset, Exclude<BlindStructureDTO, BlindStructurePresetDTO>>>;
+/** Replaces a preset with its concrete structure (a deep copy); anything else is returned as is. */
+declare function resolveBlindPreset(structure: BlindStructureDTO): Exclude<BlindStructureDTO, BlindStructurePresetDTO>;
+/**
+ * Level n (0-based) of a structure, exactly as the engine expands it: the cap
+ * (`maxLevel`) freezes the blinds while the level number keeps counting; a
+ * table schedule repeats its last row once it runs out; the ante rule applies
+ * from its start level. A preset must be resolved first (`resolveBlindPreset`).
+ */
+declare function expandBlindLevel(structure: BlindStructureDTO, n: number): BlindLevelDTO;
+
 /**
  * Poker hand types in order of strength (weakest to strongest)
  */
@@ -46746,6 +46782,7 @@ interface SNGConfig {
     blindLevelDuration: number;
     entryFee?: bigint;
     startTime?: number;
+    blindStructure?: BlindStructureDTO;
 }
 /**
  * Signing Cosmos Client that extends the read-only CosmosClient with transaction capabilities
@@ -47353,5 +47390,5 @@ declare const Client: typeof IgniteClient & Constructor<{
 }>;
 declare const registry: Registry;
 
-export { AllPlayerActions, BLIND_PRESETS, BLIND_PROGRESSIONS, 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 { AllPlayerActions, BLIND_PRESETS, BLIND_PRESET_STRUCTURES, BLIND_PROGRESSIONS, 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, expandBlindLevel, formatBlindStructure, formatGameFormatDisplay, formatGameVariantDisplay, generateWallet, getActionByType, getAddressFromMnemonic, getBettingLimit, getDefaultCosmosConfig, getGameFormat, getGameFormatForCosmos, getGameFormatFromObject, getGameVariant, hasAction, holeCardsPerPlayer, isCashFormat, isEmptyAddress, isPotLimit, isSitAndGoFormat, isTournamentFormat, isValidMnemonic, isValidPlayerAddress, parseBlindStructure, parseGameFormat, parseGameVariant, registry, resolveBlindPreset, toValoperAddress, txFailureHash, txFailurePhase };
 export type { AccountDTO, ActionDTO, AnteRuleDTO, BlindLevelDTO, BlindPreset, BlindProgression, BlindStructureDTO, BlindStructurePresetDTO, Block, BlockDTO, BlockHeader, BlockHeaderDTO, BlockID, BlockResponse, BurnResponseDTO, Card, CreateValidatorParams, DoubleBlindStructureDTO, EquityHand, EquityRequest, EquityResponse, EquityResult, ExecutionResult, GameListItem, GameOptions, GameOptionsDTO, GameOptionsResponse, GameStateResponse, GameStateResponseDTO, HandEvaluation, ISignedResponse, LegalActionDTO, LinearBlindStructureDTO, PayoutPlaceDTO, PercentageBlindStructureDTO, PerformActionResponse, PlayerDTO, RPCRequest, RPCRequestParams, RPCResponse, RakeConfig, RakeConfigDTO, ResultDTO, SealedAwaiting, SealedDTO, SitInMethod, SitOutMethod, TableBlindStructureDTO, 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,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"}
+{"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,cAAc,wBAAwB,CAAA;AAGtC,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

@@ -2847,6 +2847,7 @@ function createBaseMsgCreateGame() {
         name: "",
         bettingLimit: "",
         startTime: Long.ZERO,
+        blindStructure: "",
     };
 }
 const MsgCreateGame = {
@@ -2911,6 +2912,9 @@ const MsgCreateGame = {
         if (!message.startTime.equals(Long.ZERO)) {
             writer.uint32(168).int64(message.startTime.toString());
         }
+        if (message.blindStructure !== "") {
+            writer.uint32(178).string(message.blindStructure);
+        }
         return writer;
     },
     decode(input, length) {
@@ -3060,6 +3064,13 @@ const MsgCreateGame = {
                     message.startTime = Long.fromString(reader.int64().toString());
                     continue;
                 }
+                case 22: {
+                    if (tag !== 178) {
+                        break;
+                    }
+                    message.blindStructure = reader.string();
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -3090,6 +3101,7 @@ const MsgCreateGame = {
             name: isSet$2b(object.name) ? globalThis.String(object.name) : "",
             bettingLimit: isSet$2b(object.bettingLimit) ? globalThis.String(object.bettingLimit) : "",
             startTime: isSet$2b(object.startTime) ? Long.fromValue(object.startTime) : Long.ZERO,
+            blindStructure: isSet$2b(object.blindStructure) ? globalThis.String(object.blindStructure) : "",
         };
     },
     toJSON(message) {
@@ -3154,6 +3166,9 @@ const MsgCreateGame = {
         if (!message.startTime.equals(Long.ZERO)) {
             obj.startTime = (message.startTime || Long.ZERO).toString();
         }
+        if (message.blindStructure !== "") {
+            obj.blindStructure = message.blindStructure;
+        }
         return obj;
     },
     create(base) {
@@ -3202,6 +3217,7 @@ const MsgCreateGame = {
         message.startTime = (object.startTime !== undefined && object.startTime !== null)
             ? Long.fromValue(object.startTime)
             : Long.ZERO;
+        message.blindStructure = object.blindStructure ?? "";
         message.entryFee = (object.entryFee !== undefined && object.entryFee !== null)
             ? Long.fromValue(object.entryFee)
             : Long.UZERO;
@@ -56601,6 +56617,451 @@ const isValidPlayerAddress = (address) => {
     return !isEmptyAddress(address);
 };
 
+/**
+ * The text form of blind structures (poker-vm#1734's "SPL", decided on #2613 /
+ * #2713): a human-readable notation over the typed `BlindStructureDTO`, which
+ * stays canonical in the engine and on chain. These two functions are the only
+ * conversion (Commandment 12); no parser runs inside consensus code.
+ *
+ *   BLINDS turbo                                  a preset, no block
+ *
+ *   BLINDS custom {                               algorithmic
+ *     start: 25/50
+ *     duration: 5m
+ *     progression: double | linear 25 | percentage 1.5
+ *     round: 25                                   percentage only (the engine's roundTo)
+ *     ante: bb | bb * 0.1 | level >= 4 ? bb * 0.1 : 0
+ *     cap: 15
+ *   }
+ *
+ *   BLINDS wsop_main {                            table
+ *     duration: 120m                              default for rows without their own
+ *     ante: bb                                    rule applied per row unless the row gives an amount
+ *     levels {
+ *       0: 100/200
+ *       1: 200/300 ante 300 duration 90m
+ *       2: break 20m
+ *     }
+ *   }
+ *
+ * Fields may share a line, separated by spaces. `#` starts a comment. Level
+ * numbers are the engine's 0-based levels everywhere (`levels` rows, `cap`,
+ * `level >=`): a table row's position is its level in the engine, so rows run
+ * 0, 1, 2… without gaps. Amounts are chip-unit integers; `ante` multipliers
+ * and `percentage` factors have at most four decimals (basis points).
+ * `parseBlindStructure(formatBlindStructure(x))` deep-equals `x`.
+ */
+const BPS = 10000n;
+const IDENT = /^[A-Za-z_][\w-]*$/;
+const FIELD_KEY = /^([A-Za-z_]\w*):$/;
+const ROW_KEY = /^(\d+):$/;
+function fail(message) {
+    throw new Error(`blind structure: ${message}`);
+}
+function tokenize(text) {
+    const noComments = text
+        .split("\n")
+        .map(line => line.replace(/#.*$/, ""))
+        .join("\n");
+    return noComments
+        .replace(/\{/g, " { ")
+        .replace(/\}/g, " } ")
+        .split(/\s+/)
+        .filter(t => t.length > 0);
+}
+function parseAmount(what, s) {
+    if (!/^\d+$/.test(s))
+        fail(`${what} must be a whole number of chips, got "${s}"`);
+    return BigInt(s).toString();
+}
+function parseMinutes(what, s) {
+    const m = /^(\d+)(m|h)$/.exec(s);
+    if (!m)
+        fail(`${what} must be a duration like 5m or 2h, got "${s}"`);
+    const n = Number(m[1]) * (m[2] === "h" ? 60 : 1);
+    if (n <= 0)
+        fail(`${what} must be positive`);
+    return n;
+}
+function parseInteger(what, s) {
+    if (!/^\d+$/.test(s) || !Number.isSafeInteger(Number(s)))
+        fail(`${what} must be a whole number, got "${s}"`);
+    return Number(s);
+}
+/** "1.5" → 15000, "0.125" → 1250 (exact; at most four decimals). */
+function parseBps(what, s) {
+    const m = /^(\d+)(?:\.(\d{1,4}))?$/.exec(s);
+    if (!m)
+        fail(`${what} must be a decimal with at most four places, got "${s}"`);
+    return Number(m[1]) * 10000 + Number((m[2] ?? "").padEnd(4, "0"));
+}
+function formatBps(bps) {
+    const whole = Math.floor(bps / 10000);
+    const frac = String(bps % 10000).padStart(4, "0").replace(/0+$/, "");
+    return frac === "" ? String(whole) : `${whole}.${frac}`;
+}
+function parseAnteRule(expr) {
+    const text = expr.replace(/\s+/g, " ").trim();
+    if (text === "0")
+        return undefined;
+    const conditional = /^level >= (\d+) \? (.+) : 0$/.exec(text);
+    const startLevel = conditional ? parseInteger("ante start level", conditional[1]) : 0;
+    const multiplier = (conditional ? conditional[2] : text).replace(/\s+/g, "");
+    if (multiplier === "bb")
+        return { startLevel, bps: 10000 };
+    const m = /^bb\*(\d+(?:\.\d+)?)$/.exec(multiplier);
+    if (!m)
+        fail(`ante must be "bb", "bb * <fraction>" or "level >= N ? bb * <fraction> : 0", got "${expr}"`);
+    const bps = parseBps("ante fraction", m[1]);
+    if (bps <= 0 || bps > 10000)
+        fail(`ante fraction must be within 0..1, got "${m[1]}"`);
+    return { startLevel, bps };
+}
+function formatAnteRule(rule) {
+    const multiplier = rule.bps === 10000 ? "bb" : `bb * ${formatBps(rule.bps)}`;
+    return rule.startLevel > 0 ? `level >= ${rule.startLevel} ? ${multiplier} : 0` : multiplier;
+}
+function anteFor(bigBlind, rule, level) {
+    if (!rule || level < rule.startLevel)
+        return "0";
+    return ((BigInt(bigBlind) * BigInt(rule.bps)) / BPS).toString();
+}
+/** Splits the block body into `key:` fields (value = the tokens up to the next key) and the `levels { … }` rows. */
+function readBody(toks) {
+    const fields = new Map();
+    let rows;
+    let i = 0;
+    while (i < toks.length) {
+        const tok = toks[i];
+        if (tok === "levels") {
+            if (toks[i + 1] !== "{")
+                fail("levels must be followed by { … }");
+            if (rows)
+                fail("levels given twice");
+            rows = new Map();
+            i += 2;
+            let current;
+            for (; i < toks.length && toks[i] !== "}"; i++) {
+                const row = ROW_KEY.exec(toks[i]);
+                if (row) {
+                    current = Number(row[1]);
+                    if (rows.has(current))
+                        fail(`level ${current} given twice`);
+                    rows.set(current, []);
+                }
+                else if (current === undefined) {
+                    fail(`expected a level number like "0:" before "${toks[i]}"`);
+                }
+                else {
+                    rows.get(current).push(toks[i]);
+                }
+            }
+            if (i >= toks.length)
+                fail("levels block is not closed");
+            i++;
+            continue;
+        }
+        const key = FIELD_KEY.exec(tok);
+        if (!key)
+            fail(`expected a field like "start:" but found "${tok}"`);
+        if (fields.has(key[1]))
+            fail(`${key[1]} given twice`);
+        const value = [];
+        for (i++; i < toks.length && !FIELD_KEY.test(toks[i]) && toks[i] !== "levels"; i++)
+            value.push(toks[i]);
+        if (value.length === 0)
+            fail(`${key[1]} has no value`);
+        fields.set(key[1], value);
+    }
+    return { fields, rows };
+}
+const ALGORITHMIC_FIELDS = new Set(["start", "duration", "progression", "round", "ante", "cap"]);
+const TABLE_FIELDS = new Set(["duration", "ante", "cap"]);
+function parseRow(level, toks, defaults) {
+    if (toks[0] === "break") {
+        if (toks.length !== 2)
+            fail(`level ${level}: a break is "break <duration>"`);
+        return { level, smallBlind: "", bigBlind: "", ante: "", durationMinutes: parseMinutes(`level ${level} break`, toks[1]), isBreak: true };
+    }
+    const blinds = /^(\d+)\/(\d+)$/.exec(toks[0] ?? "");
+    if (!blinds)
+        fail(`level ${level}: expected "<sb>/<bb>" or "break <duration>", got "${toks.join(" ")}"`);
+    const smallBlind = parseAmount(`level ${level} small blind`, blinds[1]);
+    const bigBlind = parseAmount(`level ${level} big blind`, blinds[2]);
+    if (BigInt(smallBlind) <= 0n || BigInt(bigBlind) < BigInt(smallBlind)) {
+        fail(`level ${level}: blinds must be positive with the big blind at least the small blind`);
+    }
+    let ante;
+    let durationMinutes;
+    for (let i = 1; i < toks.length; i += 2) {
+        const value = toks[i + 1];
+        if (value === undefined)
+            fail(`level ${level}: "${toks[i]}" needs a value`);
+        if (toks[i] === "ante") {
+            if (ante !== undefined)
+                fail(`level ${level}: ante given twice`);
+            ante = parseAmount(`level ${level} ante`, value);
+        }
+        else if (toks[i] === "duration") {
+            if (durationMinutes !== undefined)
+                fail(`level ${level}: duration given twice`);
+            durationMinutes = parseMinutes(`level ${level} duration`, value);
+        }
+        else {
+            fail(`level ${level}: unknown row option "${toks[i]}" (ante or duration)`);
+        }
+    }
+    if (durationMinutes === undefined)
+        durationMinutes = defaults.duration;
+    if (durationMinutes === undefined)
+        fail(`level ${level} has no duration and the structure sets no default "duration:"`);
+    return { level, smallBlind, bigBlind, ante: ante ?? anteFor(bigBlind, defaults.ante, level), durationMinutes, isBreak: false };
+}
+function parseTable(body) {
+    for (const key of body.fields.keys()) {
+        if (!TABLE_FIELDS.has(key))
+            fail(`"${key}" is not a table-mode field (a table takes its blinds from levels)`);
+    }
+    const defaults = {
+        duration: body.fields.has("duration") ? parseMinutes("duration", body.fields.get("duration").join(" ")) : undefined,
+        ante: body.fields.has("ante") ? parseAnteRule(body.fields.get("ante").join(" ")) : undefined
+    };
+    const rows = body.rows;
+    if (rows.size === 0)
+        fail("levels has no rows");
+    const levels = [];
+    const numbers = [...rows.keys()];
+    numbers.forEach((n, i) => {
+        if (n !== i)
+            fail(`levels must run 0, 1, 2… in order (0-based, as the engine numbers them); found level ${n} at position ${i}`);
+        levels.push(parseRow(n, rows.get(n), defaults));
+    });
+    if (levels[0].isBreak)
+        fail("the first level must not be a break");
+    if (levels[levels.length - 1].isBreak)
+        fail("the last level must not be a break (it repeats once the schedule runs out)");
+    const out = { progression: "table", levels };
+    if (body.fields.has("cap"))
+        out.maxLevel = parseInteger("cap", body.fields.get("cap").join(" "));
+    return out;
+}
+function parseAlgorithmic(body) {
+    const f = body.fields;
+    for (const key of f.keys()) {
+        if (!ALGORITHMIC_FIELDS.has(key))
+            fail(`unknown field "${key}" (start, duration, progression, round, ante, cap, levels)`);
+    }
+    for (const required of ["start", "duration", "progression"]) {
+        if (!f.has(required))
+            fail(`${required} is required (or give levels { … } for a table)`);
+    }
+    const start = /^(\d+)\/(\d+)$/.exec(f.get("start").join(""));
+    if (!start)
+        fail(`start must be "<sb>/<bb>", got "${f.get("start").join(" ")}"`);
+    const startSmallBlind = parseAmount("start small blind", start[1]);
+    const startBigBlind = parseAmount("start big blind", start[2]);
+    if (BigInt(startSmallBlind) <= 0n || BigInt(startBigBlind) !== 2n * BigInt(startSmallBlind)) {
+        fail(`opening blinds ${startSmallBlind}/${startBigBlind}: the algorithmic progressions need a positive small blind and big blind = 2 × small blind`);
+    }
+    const base = {
+        startSmallBlind,
+        startBigBlind,
+        durationMinutes: parseMinutes("duration", f.get("duration").join(" ")),
+        ...(f.has("cap") ? { maxLevel: parseInteger("cap", f.get("cap").join(" ")) } : {}),
+        ...(f.has("ante") ? (() => { const ante = parseAnteRule(f.get("ante").join(" ")); return ante ? { ante } : {}; })() : {})
+    };
+    const [kind, ...rest] = f.get("progression");
+    switch (kind) {
+        case "double":
+            if (rest.length !== 0 || f.has("round"))
+                fail("double takes no argument and no round");
+            return { progression: "double", ...base };
+        case "linear": {
+            if (rest.length !== 1 || f.has("round"))
+                fail('linear needs one step, e.g. "linear 25", and no round');
+            const step = parseAmount("linear step", rest[0]);
+            if (BigInt(step) <= 0n)
+                fail("linear step must be positive");
+            return { progression: "linear", ...base, step };
+        }
+        case "percentage": {
+            if (rest.length !== 1)
+                fail('percentage needs one factor, e.g. "percentage 1.5"');
+            const factorBps = parseBps("percentage factor", rest[0]);
+            if (factorBps <= 10000)
+                fail(`percentage factor must exceed 1, got "${rest[0]}"`);
+            if (!f.has("round"))
+                fail('percentage needs "round: <chips>" (the engine rounds each level to a multiple of it)');
+            const roundTo = parseAmount("round", f.get("round").join(" "));
+            if (BigInt(roundTo) <= 0n)
+                fail("round must be positive");
+            return { progression: "percentage", ...base, factorBps, roundTo };
+        }
+        default:
+            fail(`progression must be double, "linear <step>" or "percentage <factor>", got "${[kind, ...rest].join(" ")}"`);
+    }
+}
+/**
+ * Parses the text form into the typed structure. Throws on anything the
+ * engine would refuse that can be seen without expanding levels; the engine
+ * validates the result again on load.
+ */
+function parseBlindStructure(text) {
+    const toks = tokenize(text);
+    if (toks[0] !== "BLINDS")
+        fail('must start with "BLINDS <name>"');
+    const name = toks[1];
+    if (name === undefined || !IDENT.test(name))
+        fail(`"BLINDS" needs a name, got "${name ?? ""}"`);
+    if (toks.length === 2) {
+        if (!BLIND_PRESETS.includes(name)) {
+            fail(`"${name}" is not a preset (${BLIND_PRESETS.join(", ")}); a custom structure needs a { … } block`);
+        }
+        return { preset: name };
+    }
+    if (toks[2] !== "{" || toks[toks.length - 1] !== "}")
+        fail("the structure must be a { … } block after the name");
+    if (BLIND_PRESETS.includes(name))
+        fail(`"${name}" is a preset and takes no block`);
+    const body = readBody(toks.slice(3, -1));
+    return body.rows ? parseTable(body) : parseAlgorithmic(body);
+}
+/**
+ * The inverse of parseBlindStructure. A preset formats as `BLINDS <preset>`;
+ * anything else as a block under `name` (default "custom").
+ */
+function formatBlindStructure(structure, name = "custom") {
+    if ("preset" in structure)
+        return `BLINDS ${structure.preset}`;
+    if (!IDENT.test(name) || BLIND_PRESETS.includes(name))
+        fail(`"${name}" is not a usable structure name`);
+    const lines = [];
+    if (structure.progression === "table") {
+        lines.push("  levels {");
+        for (const l of structure.levels) {
+            if (l.isBreak) {
+                lines.push(`    ${l.level}: break ${l.durationMinutes}m`);
+            }
+            else {
+                const ante = l.ante !== "0" ? ` ante ${l.ante}` : "";
+                lines.push(`    ${l.level}: ${l.smallBlind}/${l.bigBlind}${ante} duration ${l.durationMinutes}m`);
+            }
+        }
+        lines.push("  }");
+    }
+    else {
+        lines.push(`  start: ${structure.startSmallBlind}/${structure.startBigBlind}`);
+        lines.push(`  duration: ${structure.durationMinutes}m`);
+        switch (structure.progression) {
+            case "double":
+                lines.push("  progression: double");
+                break;
+            case "linear":
+                lines.push(`  progression: linear ${structure.step}`);
+                break;
+            case "percentage":
+                lines.push(`  progression: percentage ${formatBps(structure.factorBps)}`);
+                lines.push(`  round: ${structure.roundTo}`);
+                break;
+        }
+        if (structure.ante)
+            lines.push(`  ante: ${formatAnteRule(structure.ante)}`);
+    }
+    if (structure.maxLevel !== undefined)
+        lines.push(`  cap: ${structure.maxLevel}`);
+    return [`BLINDS ${name} {`, ...lines, "}"].join("\n");
+}
+// --- Level expansion (poker-vm#2718) --------------------------------------
+//
+// A TypeScript port of the engine's ExpandLevel (pvm/go/engine/tournament_blinds.go),
+// integer-exact with BigInt, so a create-form preview or a table's "Blinds"
+// panel shows exactly the levels the engine will play. Pinned against the
+// engine's own expansions in blindStructure.test.ts.
+/**
+ * #1734's preset library, as the engine resolves it (pvm/go/engine
+ * tournament_blinds.go blindPresets). The engine resolves a preset on the
+ * table's first action; `resolveBlindPreset` does the same client-side so the
+ * levels can be previewed before the table exists.
+ */
+const BLIND_PRESET_STRUCTURES = {
+    turbo: { progression: "double", startSmallBlind: "25", startBigBlind: "50", durationMinutes: 5, ante: { startLevel: 4, bps: 1000 } },
+    standard: { progression: "double", startSmallBlind: "25", startBigBlind: "50", durationMinutes: 10, ante: { startLevel: 5, bps: 1000 } },
+    deep_stack: {
+        progression: "percentage",
+        startSmallBlind: "25",
+        startBigBlind: "50",
+        factorBps: 15000,
+        roundTo: "25",
+        durationMinutes: 15,
+        ante: { startLevel: 6, bps: 1250 }
+    },
+    hyper_turbo: { progression: "double", startSmallBlind: "50", startBigBlind: "100", durationMinutes: 3, ante: { startLevel: 3, bps: 1000 } }
+};
+/** Replaces a preset with its concrete structure (a deep copy); anything else is returned as is. */
+function resolveBlindPreset(structure) {
+    if (!("preset" in structure))
+        return structure;
+    const preset = BLIND_PRESET_STRUCTURES[structure.preset];
+    if (!preset)
+        fail(`"${structure.preset}" is not a preset (${BLIND_PRESETS.join(", ")})`);
+    return JSON.parse(JSON.stringify(preset));
+}
+function algorithmicSmallBlind(structure, n) {
+    const sb0 = BigInt(structure.startSmallBlind);
+    switch (structure.progression) {
+        case "double":
+            return sb0 << BigInt(n);
+        case "linear":
+            return sb0 + BigInt(structure.step) * BigInt(n);
+        case "percentage": {
+            const roundTo = BigInt(structure.roundTo);
+            const factor = BigInt(structure.factorBps);
+            let sb = sb0;
+            for (let i = 0; i < n; i++) {
+                const raw = (sb * factor) / BPS;
+                let q = raw / roundTo;
+                const r = raw % roundTo;
+                if (r * 2n >= roundTo)
+                    q += 1n;
+                let rounded = q * roundTo;
+                const floor = sb + roundTo;
+                if (rounded < floor)
+                    rounded = floor;
+                sb = rounded;
+            }
+            return sb;
+        }
+    }
+}
+/**
+ * Level n (0-based) of a structure, exactly as the engine expands it: the cap
+ * (`maxLevel`) freezes the blinds while the level number keeps counting; a
+ * table schedule repeats its last row once it runs out; the ante rule applies
+ * from its start level. A preset must be resolved first (`resolveBlindPreset`).
+ */
+function expandBlindLevel(structure, n) {
+    if (!Number.isInteger(n) || n < 0)
+        fail(`blind level ${n} must be a non-negative integer`);
+    if ("preset" in structure)
+        fail(`resolve the "${structure.preset}" preset before expanding it (resolveBlindPreset)`);
+    const m = structure.maxLevel !== undefined && n > structure.maxLevel ? structure.maxLevel : n;
+    if (structure.progression === "table") {
+        const rows = structure.levels;
+        if (rows.length === 0)
+            fail("a table structure needs at least one level");
+        const row = { ...rows[Math.min(m, rows.length - 1)] };
+        row.level = n;
+        row.durationMinutes = n >= rows.length ? rows[rows.length - 1].durationMinutes : rows[n].durationMinutes;
+        return row;
+    }
+    const sb = algorithmicSmallBlind(structure, m);
+    const bb = sb * 2n;
+    let ante = 0n;
+    if (structure.ante && n >= structure.ante.startLevel)
+        ante = (bb * BigInt(structure.ante.bps)) / BPS;
+    return { level: n, smallBlind: sb.toString(), bigBlind: bb.toString(), ante: ante.toString(), durationMinutes: structure.durationMinutes, isBreak: false };
+}
+
 /**
  * Poker hand types in order of strength (weakest to strongest)
  */
@@ -71184,8 +71645,8 @@ class SigningCosmosClient extends CosmosClient {
             if (sngConfig.startingStack <= 0n) {
                 throw new Error(`${gameFormat} games require a positive startingStack; got ${sngConfig.startingStack}.`);
             }
-            if (!sngConfig.blindLevelDuration || sngConfig.blindLevelDuration <= 0) {
-                throw new Error(`${gameFormat} games require a positive blindLevelDuration; got ${sngConfig.blindLevelDuration}.`);
+            if (!sngConfig.blindStructure && (!sngConfig.blindLevelDuration || sngConfig.blindLevelDuration <= 0)) {
+                throw new Error(`${gameFormat} games require a positive blindLevelDuration (or a blindStructure); got ${sngConfig.blindLevelDuration}.`);
             }
             assertCreatableSngField(minPlayers, maxPlayers, sngConfig);
         }
@@ -71228,6 +71689,9 @@ class SigningCosmosClient extends CosmosClient {
             // Scheduled start (poker-vm#2680), unix seconds. 0 = unscheduled, and
             // a zero proto3 int64 is not encoded at all.
             startTime: sngConfig?.startTime ? Long.fromNumber(sngConfig.startTime) : Long.ZERO,
+            // Blind structure (block52/pokerchain#434) as JSON; "" = doubling, and
+            // an empty proto3 string is not encoded at all.
+            blindStructure: sngConfig?.blindStructure ? JSON.stringify(sngConfig.blindStructure) : "",
         });
         // Create the transaction message
         const msg = {
@@ -71257,7 +71721,8 @@ class SigningCosmosClient extends CosmosClient {
             ...(sngConfig && {
                 startingStack: sngConfig.startingStack.toString(),
                 blindLevelDuration: sngConfig.blindLevelDuration,
-                entryFee: sngConfig.entryFee?.toString() ?? "0"
+                entryFee: sngConfig.entryFee?.toString() ?? "0",
+                ...(sngConfig.blindStructure && { blindStructure: sngConfig.blindStructure })
             })
         });
         try {
@@ -72178,5 +72643,5 @@ const registry = new Registry([
     ...msgTypes,
 ]);
 
-export { AllPlayerActions, BLIND_PRESETS, BLIND_PROGRESSIONS, 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 };
+export { AllPlayerActions, BLIND_PRESETS, BLIND_PRESET_STRUCTURES, BLIND_PROGRESSIONS, 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, expandBlindLevel, formatBlindStructure, formatGameFormatDisplay, formatGameVariantDisplay, generateWallet, getActionByType, getAddressFromMnemonic, getBettingLimit, getDefaultCosmosConfig, getGameFormat, getGameFormatForCosmos, getGameFormatFromObject, getGameVariant, hasAction, holeCardsPerPlayer, isCashFormat, isEmptyAddress, isPotLimit, isSitAndGoFormat, isTournamentFormat, isValidMnemonic, isValidPlayerAddress, parseBlindStructure, parseGameFormat, parseGameVariant, registry, resolveBlindPreset, toValoperAddress, txFailureHash, txFailurePhase };
 //# sourceMappingURL=index.esm.js.map