@playmos/sdk 0.3.2 → 0.3.3

package/dist/index.d.cts

@@ -437,6 +437,8 @@ declare class Playmos {
      *
      * Operator txs are signed by the Playmos service (OPERATOR_ROLE key).
      */
+    /** Offline mock store for rounds.open/lock/settle/get when `mock: true` (3-game dogfood). */
+    private readonly mockRounds;
     readonly rounds: {
         open: (input: RoundOpenInput) => Promise<RoundState>;
         lock: (input: {
@@ -579,7 +581,8 @@ declare class Playmos {
             entryUnits: bigint;
         }): Promise<{
             paymentId: string;
-            status: "CONFIRMED" | "FAILED" | "PENDING";
+            /** Lowercase product status (matches Payment.status) — 0.3.3+; kits should compare case-insensitively. */
+            status: "confirmed" | "failed" | "pending";
             txHash?: string;
             onchain: boolean;
             /** The on-chain identity actually entered — reconcile with `hasEntered`. */

package/dist/index.d.ts

@@ -437,6 +437,8 @@ declare class Playmos {
      *
      * Operator txs are signed by the Playmos service (OPERATOR_ROLE key).
      */
+    /** Offline mock store for rounds.open/lock/settle/get when `mock: true` (3-game dogfood). */
+    private readonly mockRounds;
     readonly rounds: {
         open: (input: RoundOpenInput) => Promise<RoundState>;
         lock: (input: {
@@ -579,7 +581,8 @@ declare class Playmos {
             entryUnits: bigint;
         }): Promise<{
             paymentId: string;
-            status: "CONFIRMED" | "FAILED" | "PENDING";
+            /** Lowercase product status (matches Payment.status) — 0.3.3+; kits should compare case-insensitively. */
+            status: "confirmed" | "failed" | "pending";
             txHash?: string;
             onchain: boolean;
             /** The on-chain identity actually entered — reconcile with `hasEntered`. */

package/dist/index.js

@@ -929,6 +929,8 @@ var Playmos = class {
      *
      * Operator txs are signed by the Playmos service (OPERATOR_ROLE key).
      */
+    /** Offline mock store for rounds.open/lock/settle/get when `mock: true` (3-game dogfood). */
+    this.mockRounds = /* @__PURE__ */ new Map();
     this.rounds = {
       open: async (input) => {
         requireField(input?.gameId, "gameId");
@@ -938,6 +940,34 @@ var Playmos = class {
           throw new ConfigError("payout rule is required (winner-take-all | top-n | custom)");
         }
         validateAmount(input.entryAmount);
+        if (this.config.mock) {
+          const roundKey = input.roundKey ?? input.roundId;
+          const existing = this.mockRounds.get(input.roundId);
+          if (existing?.status === "open" || existing?.status === "locked") {
+            return existing;
+          }
+          if (existing?.status === "settled") {
+            throw new ApiError(`round ${input.roundId} already settled`, {
+              status: 409,
+              code: "conflict"
+            });
+          }
+          const round2 = {
+            roundId: input.roundId,
+            gameId: input.gameId,
+            roundKey,
+            status: "open",
+            entryAmount: input.entryAmount,
+            pool: null,
+            entrants: 0,
+            payout: input.payout,
+            closeAt: input.closeAt,
+            openTxHash: "0x000000000000000000000000000000000000000000000000000000000000mock",
+            prizePoolAddress: this.config.contracts?.prizePool ?? "0x0000000000000000000000000000000000000002"
+          };
+          this.mockRounds.set(input.roundId, round2);
+          return round2;
+        }
         const { round } = await this.http.post("/rounds", {
           gameId: input.gameId,
           roundId: input.roundId,
@@ -951,6 +981,29 @@ var Playmos = class {
       },
       lock: async (input) => {
         requireField(input?.roundId, "roundId");
+        if (this.config.mock) {
+          const existing = this.mockRounds.get(input.roundId);
+          if (!existing) {
+            throw new ApiError(`unknown round: ${input.roundId}`, { status: 404, code: "not_found" });
+          }
+          if (existing.status === "locked" || existing.status === "settled") return existing;
+          if (existing.status !== "open") {
+            throw new ApiError(`round ${input.roundId} is not open (status=${existing.status})`, {
+              status: 409,
+              code: "conflict"
+            });
+          }
+          const locked = {
+            ...existing,
+            status: "locked",
+            // Mock payable pool ≈ 60% of entry × max(1, entrants) for shape only — not money truth.
+            pool: existing.pool ?? existing.entryAmount,
+            entrants: existing.entrants ?? 0,
+            lockTxHash: "0x000000000000000000000000000000000000000000000000000000000000loc1"
+          };
+          this.mockRounds.set(input.roundId, locked);
+          return locked;
+        }
         const { round } = await this.http.post(
           `/rounds/${encodeURIComponent(input.roundId)}/lock`,
           { gameId: input.gameId }
@@ -960,6 +1013,51 @@ var Playmos = class {
       settle: async (input) => {
         requireField(input?.roundId, "roundId");
         if (!input?.results) throw new ConfigError("results are required (ranking or winners)");
+        if (this.config.mock) {
+          const existing = this.mockRounds.get(input.roundId);
+          if (!existing) {
+            throw new ApiError(`unknown round: ${input.roundId}`, { status: 404, code: "not_found" });
+          }
+          if (existing.status === "settled" && existing.settleTxHash) {
+            return {
+              roundId: input.roundId,
+              txHash: existing.settleTxHash,
+              poolPaid: existing.pool ?? "0",
+              winners: "winners" in input.results ? input.results.winners : input.results.ranking.map((wallet) => ({
+                wallet,
+                amount: existing.pool ?? existing.entryAmount
+              })),
+              status: "settled"
+            };
+          }
+          if (existing.status !== "locked" && existing.status !== "open") {
+            throw new ApiError(`round ${input.roundId} cannot settle (status=${existing.status})`, {
+              status: 409,
+              code: "conflict"
+            });
+          }
+          const winners = "winners" in input.results ? input.results.winners : input.results.ranking.map((wallet, i) => ({
+            wallet,
+            // Winner-take-all mock shape when ranking only.
+            amount: i === 0 ? existing.pool ?? existing.entryAmount : "0"
+          }));
+          const settleTxHash = "0x000000000000000000000000000000000000000000000000000000000000set1";
+          const poolPaid = existing.pool ?? existing.entryAmount;
+          const settled = {
+            ...existing,
+            status: "settled",
+            settleTxHash,
+            pool: poolPaid
+          };
+          this.mockRounds.set(input.roundId, settled);
+          return {
+            roundId: input.roundId,
+            txHash: settleTxHash,
+            poolPaid,
+            winners,
+            status: "settled"
+          };
+        }
         const { settle } = await this.http.post(
           `/rounds/${encodeURIComponent(input.roundId)}/settle`,
           { gameId: input.gameId, results: input.results }
@@ -968,6 +1066,13 @@ var Playmos = class {
       },
       get: async (input) => {
         requireField(input?.roundId, "roundId");
+        if (this.config.mock) {
+          const existing = this.mockRounds.get(input.roundId);
+          if (!existing) {
+            throw new ApiError(`unknown round: ${input.roundId}`, { status: 404, code: "not_found" });
+          }
+          return existing;
+        }
         const { round } = await this.http.get(
           `/rounds/${encodeURIComponent(input.roundId)}`
         );
@@ -1332,12 +1437,13 @@ var Playmos = class {
           amount: formatMicroToUsd(req.entryUnits),
           playerId: req.wallet
         });
-        const status = entry.status === "confirmed" ? "CONFIRMED" : entry.status === "failed" ? "FAILED" : "PENDING";
+        const raw = String(entry.status ?? "pending").toLowerCase();
+        const status = raw === "confirmed" ? "confirmed" : raw === "failed" ? "failed" : "pending";
         const onchain = !entry.mock;
         return {
           paymentId: entry.id,
           status,
-          txHash: entry.txHash,
+          ...entry.txHash ? { txHash: entry.txHash } : {},
           onchain,
           identity: entry.identity ?? req.identity
         };