@playmos/sdk 0.3.10 → 0.3.11

package/dist/index.js

@@ -1,6 +1,6 @@
-import { AuthError, InvalidAmountError, ConfigError, MissingFieldError, NothingToWithdrawError, WalletTimeoutError, PaymentFailedError, ApiError, WalletConnectionError, InsufficientGasError, AlreadyEnteredError } from './chunk-UZECDT6F.js';
-export { AlreadyEnteredError, ApiError, AuthError, ConfigError, InsufficientGasError, InvalidAmountError, MissingFieldError, NothingToWithdrawError, PaymentFailedError, PlaymosError, WalletConnectionError, WalletTimeoutError } from './chunk-UZECDT6F.js';
-import { encodeFunctionData, decodeFunctionResult, numberToHex, keccak256, toBytes } from 'viem';
+import { AuthError, InvalidAmountError, ConfigError, MissingFieldError, NothingToWithdrawError, assertEnoughGas, buildWithdrawCall, sendCalls, waitForCalls, WalletTimeoutError, PaymentFailedError, ApiError, buildIapCalls, buildEntryCalls, prizePoolAbi, WalletConnectionError, AlreadyEnteredError } from './chunk-35WJANW4.js';
+export { AlreadyEnteredError, ApiError, AuthError, ConfigError, InsufficientGasError, InvalidAmountError, MissingFieldError, NothingToWithdrawError, PaymentFailedError, PlaymosError, WalletConnectionError, WalletTimeoutError } from './chunk-35WJANW4.js';
+import { encodeFunctionData, decodeFunctionResult } from 'viem';
 
 // src/config.ts
 var CHAIN_ID = {
@@ -183,10 +183,10 @@ function validateMetadata(metadata) {
 
 // src/payout.ts
 var PayoutError = class extends Error {
-  constructor(message) {
+  constructor(message, code = "payout_invalid") {
     super(message);
-    this.code = "payout_invalid";
     this.name = "PayoutError";
+    this.code = code;
   }
 };
 var ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
@@ -231,7 +231,8 @@ function computePayout(pool, ranking, rule) {
     }
     if (splits.length > wallets.length) {
       throw new PayoutError(
-        `top-n needs ${splits.length} ranked wallets but ranking only has ${wallets.length}`
+        `ranking_too_short: a top-n rule cannot be settled from a ranking shorter than splitsBps.length (need ${splits.length}, got ${wallets.length}) \u2014 open with winner-take-all, or settle with explicit winners[{wallet,amount}]`,
+        "ranking_too_short"
       );
     }
     let sumBps = 0;
@@ -544,7 +545,7 @@ function resolveRawProvider(wallet) {
   }
   if (injected) return injected;
   throw new WalletConnectionError(
-    "base-account connector needs a provider. In the Base App it is injected automatically; elsewhere, create one with @base-org/account and pass it as wallet.provider."
+    'base-account connector needs a provider \u2014 this is not a built-in Base Account/passkey flow in @playmos/sdk. In the Base App a provider is often injected; elsewhere install @base-org/account, construct a provider, and pass it as wallet.provider (or use connector: "injected" in a wallet browser).'
   );
 }
 function resolveProvider(wallet, opts) {
@@ -581,174 +582,6 @@ async function getAccount(provider) {
   }
 }
 
-// src/chain/abis.ts
-var erc20Abi = [
-  {
-    type: "function",
-    name: "approve",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "spender", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: [{ type: "bool" }]
-  }
-];
-var playmosPayAbi = [
-  {
-    type: "function",
-    name: "pay",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "paymentId", type: "bytes32" },
-      { name: "studio", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: []
-  }
-];
-var prizePoolAbi = [
-  {
-    type: "function",
-    name: "enter",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "roundId", type: "bytes32" },
-      { name: "identity", type: "bytes32" }
-    ],
-    outputs: []
-  },
-  {
-    type: "function",
-    name: "withdrawable",
-    stateMutability: "view",
-    inputs: [{ name: "account", type: "address" }],
-    outputs: [{ type: "uint256" }]
-  },
-  {
-    type: "function",
-    name: "withdraw",
-    stateMutability: "nonpayable",
-    inputs: [],
-    outputs: [{ name: "amount", type: "uint256" }]
-  }
-];
-async function sendCalls(provider, from, chainId, calls, paymasterUrl) {
-  const params = {
-    version: "2.0.0",
-    from,
-    chainId: numberToHex(chainId),
-    atomicRequired: true,
-    calls
-  };
-  if (paymasterUrl) {
-    params.capabilities = { paymasterService: { url: paymasterUrl } };
-  }
-  let result;
-  try {
-    result = await provider.request({ method: "wallet_sendCalls", params: [params] });
-  } catch (e) {
-    if (e instanceof WalletTimeoutError) throw e;
-    const msg = e?.message ?? String(e);
-    if (/reject|denied|cancel|closed/i.test(msg)) {
-      throw new WalletConnectionError("The player cancelled or closed the payment sheet.", { cause: msg });
-    }
-    throw new PaymentFailedError("wallet_sendCalls failed.", { cause: msg });
-  }
-  const id = typeof result === "string" ? result : result?.id ?? "";
-  if (!id) throw new PaymentFailedError("Wallet returned no calls id.");
-  return { id };
-}
-async function waitForCalls(provider, id, timeoutMs = 6e4) {
-  if (!id) return { status: "FAILED" };
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    try {
-      const res = await provider.request({
-        method: "wallet_getCallsStatus",
-        params: [id]
-      });
-      const s = String(res?.status ?? "").toUpperCase();
-      const txHash = res?.receipts?.[0]?.transactionHash;
-      if (s === "200" || s === "CONFIRMED" || s === "SUCCESS") return { status: "CONFIRMED", txHash };
-      if (s === "400" || s === "500" || s === "FAILED" || s === "REVERTED") return { status: "FAILED", txHash };
-    } catch (e) {
-      if (e instanceof WalletTimeoutError) {
-        await new Promise((r) => setTimeout(r, 900));
-        continue;
-      }
-      throw e;
-    }
-    await new Promise((r) => setTimeout(r, 900));
-  }
-  return { status: "PENDING" };
-}
-function encodeApprove(spender, amountUnits) {
-  return encodeFunctionData({ abi: erc20Abi, functionName: "approve", args: [spender, amountUnits] });
-}
-var GAS_FLOOR_WEI_DEFAULT = 200000000000000n;
-var GAS_FLOOR_WEI_BASE_SEPOLIA = 50000000000000n;
-var CHAIN_ID_BASE_SEPOLIA = 84532;
-function gasFloorWei(chainId) {
-  return chainId === CHAIN_ID_BASE_SEPOLIA ? GAS_FLOOR_WEI_BASE_SEPOLIA : GAS_FLOOR_WEI_DEFAULT;
-}
-async function assertEnoughGas(provider, from, minWei) {
-  let floor = minWei;
-  if (floor === void 0) {
-    let chainId = 0;
-    try {
-      const hex = await provider.request({ method: "eth_chainId", params: [] });
-      chainId = Number(BigInt(hex));
-    } catch {
-    }
-    floor = gasFloorWei(chainId);
-  }
-  let balance;
-  try {
-    const hex = await provider.request({ method: "eth_getBalance", params: [from, "latest"] });
-    balance = BigInt(hex);
-  } catch {
-    return;
-  }
-  if (balance < floor) {
-    throw new InsufficientGasError({
-      balanceWei: balance.toString(),
-      minWei: floor.toString()
-    });
-  }
-}
-var toBytes32 = (s) => keccak256(toBytes(s));
-function buildIapCalls(args) {
-  const payData = encodeFunctionData({
-    abi: playmosPayAbi,
-    functionName: "pay",
-    args: [toBytes32(args.paymentId), args.studio, args.amountUnits]
-  });
-  return [
-    { to: args.usdc, data: encodeApprove(args.playmosPay, args.amountUnits) },
-    { to: args.playmosPay, data: payData }
-  ];
-}
-function buildEntryCalls(args) {
-  const enterData = encodeFunctionData({
-    abi: prizePoolAbi,
-    functionName: "enter",
-    args: [toBytes32(args.roundKey), toBytes32(args.identity)]
-  });
-  return [
-    { to: args.usdc, data: encodeApprove(args.prizePool, args.amountUnits) },
-    { to: args.prizePool, data: enterData }
-  ];
-}
-function buildWithdrawCall(prizePool) {
-  const data = encodeFunctionData({
-    abi: prizePoolAbi,
-    functionName: "withdraw",
-    args: []
-  });
-  return { to: prizePool, data };
-}
-
 // src/mock.ts
 var MOCK_TX = `0x${"0".repeat(56)}deadbeef`;
 function mockIapPayment(args) {
@@ -1953,8 +1786,16 @@ var Playmos = class {
     /**
      * Offline mock payments for this client instance — so `verify(id)` after
      * `mock: true` pay/enterRound does not hit the live API (#204).
+     * Keyed by payment id for verify.
      */
     this.mockPayments = /* @__PURE__ */ new Map();
+    /**
+     * sdk#513 / residual B1–B2 — held idempotencyKey offline (live contract rehearsal).
+     * Keyed like service: `${gameId}:${key}` (IAP without gameId uses empty gameId).
+     * Stores terms so same key + different money throws (live IdempotencyConflict), not silent replay.
+     * Auto-minted keys still unique per call (not stored for cross-call replay).
+     */
+    this.mockByIdempotencyKey = /* @__PURE__ */ new Map();
     /**
      * `transfers` — read-back / confirmation for a prior `transfer()` (issues #27, #47).
      * `get` reconciles once against chain truth; `wait` polls it to a terminal state
@@ -2139,18 +1980,62 @@ var Playmos = class {
       }
     };
   }
-  rememberMock(payment) {
-    if (payment.mock) this.mockPayments.set(payment.id, payment);
+  mockIdemScopeKey(gameId, heldKey) {
+    return `${gameId ?? ""}:${heldKey}`;
+  }
+  rememberMock(payment, held) {
+    if (payment.mock) {
+      this.mockPayments.set(payment.id, payment);
+      if (held) {
+        this.mockByIdempotencyKey.set(this.mockIdemScopeKey(held.terms.gameId, held.key), {
+          payment,
+          terms: held.terms
+        });
+      }
+    }
     return payment;
   }
+  /** Live-shaped conflict when held mock key is reused with different money terms (sdk#513 residual B1). */
+  mockIdemReplayOrThrow(heldKey, terms) {
+    const prior = this.mockByIdempotencyKey.get(this.mockIdemScopeKey(terms.gameId, heldKey));
+    if (!prior) return null;
+    const t = prior.terms;
+    const same = t.kind === terms.kind && t.amount === terms.amount && t.gameId === terms.gameId && t.playerId === terms.playerId && t.roundId === terms.roundId && t.identity === terms.identity && t.sku === terms.sku;
+    if (!same) {
+      throw new ApiError(
+        `idempotencyKey was already used for a payment with DIFFERENT terms (kind/amount/gameId/playerId/roundId/identity/sku); use a fresh key (mock:true mirrors live conflict \u2014 sdk#513).`,
+        {
+          code: "idempotency_conflict",
+          idempotencyKey: heldKey,
+          priorKind: t.kind,
+          priorAmount: t.amount
+        }
+      );
+    }
+    return prior.payment;
+  }
   /** External-studio IAP (1%). Returns a real confirmed Payment with a txHash. */
   async pay(input) {
     const amountMicro = validateAmount(input.amount);
     requireField(input.sku, "sku");
     requireField(input.playerId, "playerId");
     const metadata = validateMetadata(input.metadata);
-    const idempotencyKey = input.idempotencyKey ?? prefixedId("idem");
+    const heldIdem = typeof input.idempotencyKey === "string" && input.idempotencyKey.trim() ? input.idempotencyKey.trim() : void 0;
+    const idempotencyKey = heldIdem ?? prefixedId("idem");
     if (this.config.mock) {
+      const terms = {
+        kind: "iap",
+        amount: formatMicroToUsd(amountMicro),
+        gameId: input.gameId ?? "",
+        playerId: input.playerId,
+        roundId: "",
+        identity: "",
+        sku: input.sku.trim()
+      };
+      if (heldIdem) {
+        const replay = this.mockIdemReplayOrThrow(heldIdem, terms);
+        if (replay) return replay;
+      }
       return this.rememberMock(
         mockIapPayment({
           amountMicro,
@@ -2159,7 +2044,8 @@ var Playmos = class {
           playerId: input.playerId,
           chain: this.env.network,
           metadata
-        })
+        }),
+        heldIdem ? { key: heldIdem, terms } : void 0
       );
     }
     if (this.env.isTest && !await walletAvailable(this.config.wallet, this.walletTimeoutPolicy())) {
@@ -2181,7 +2067,13 @@ var Playmos = class {
       );
       let payment = this.mapServerPayment(res.payment, "iap", amountMicro);
       if (payment.status === "pending" || payment.status === "created") {
-        payment = await this.waitForServerSettle(payment.id, "iap", amountMicro);
+        payment = await this.waitForServerSettle(
+          payment.id,
+          "iap",
+          amountMicro,
+          input.settleTimeoutMs ?? 6e4,
+          input.signal
+        );
       }
       return payment;
     }
@@ -2226,8 +2118,22 @@ var Playmos = class {
     requireField(input.roundId, "roundId");
     requireField(input.playerId, "playerId");
     const metadata = validateMetadata(input.metadata);
-    const idempotencyKey = input.idempotencyKey ?? prefixedId("idem");
+    const heldIdem = typeof input.idempotencyKey === "string" && input.idempotencyKey.trim() ? input.idempotencyKey.trim() : void 0;
+    const idempotencyKey = heldIdem ?? prefixedId("idem");
     if (this.config.mock) {
+      const terms = {
+        kind: "entry",
+        amount: formatMicroToUsd(amountMicro),
+        gameId: input.gameId,
+        playerId: input.playerId,
+        roundId: input.roundId,
+        identity: typeof input.identity === "string" ? input.identity.trim() : "",
+        sku: ""
+      };
+      if (heldIdem) {
+        const replay = this.mockIdemReplayOrThrow(heldIdem, terms);
+        if (replay) return replay;
+      }
       this.mockAccumulateEntry(input.roundId, amountMicro);
       return this.rememberMock(
         mockEntryPayment({
@@ -2243,7 +2149,8 @@ var Playmos = class {
           // B2 pins — must survive mock path for hub hasEntered parity (#204).
           roundKey: input.roundKey,
           identity: input.identity
-        })
+        }),
+        heldIdem ? { key: heldIdem, terms } : void 0
       );
     }
     const serverSettleNoWallet = this.env.isTest && !await walletAvailable(this.config.wallet, this.walletTimeoutPolicy());
@@ -2276,7 +2183,13 @@ var Playmos = class {
       );
       let payment2 = this.mapServerPayment(res.payment, "entry", amountMicro);
       if (payment2.status === "pending" || payment2.status === "created") {
-        payment2 = await this.waitForServerSettle(payment2.id, "entry", amountMicro);
+        payment2 = await this.waitForServerSettle(
+          payment2.id,
+          "entry",
+          amountMicro,
+          input.settleTimeoutMs ?? 6e4,
+          input.signal
+        );
       }
       if (input.identity) payment2.identity = input.identity;
       const pool = res.clientParams?.contractAddress ?? this.config.contracts?.prizePool;
@@ -2459,10 +2372,16 @@ var Playmos = class {
    *   until chain verify catches PaymentSettled (RPC lag) — poll so pay() matches
    *   the documented "confirmed" sandbox promise (TTFSC-T0 / cold-run).
    */
-  async waitForServerSettle(paymentId, kind, amountMicro, timeoutMs = 6e4) {
+  async waitForServerSettle(paymentId, kind, amountMicro, timeoutMs = 6e4, signal) {
     const start = Date.now();
     let delayMs = 400;
     while (Date.now() - start < timeoutMs) {
+      if (signal?.aborted) {
+        throw new ApiError(
+          `Aborted waiting for server-settle of ${paymentId}. Re-check with playmos.verify("${paymentId}").`,
+          { paymentId, aborted: true, asyncSettle: true }
+        );
+      }
       const raw = await this.http.get(
         `/payments/${encodeURIComponent(paymentId)}`
       );
@@ -2477,12 +2396,46 @@ var Playmos = class {
       { paymentId, timeout: true, asyncSettle: true }
     );
   }
+  /**
+   * sdk#509 — recover a payment after a lost response by the idempotency key you held.
+   * Requires secret sk_test_ (same as list). Returns null if not found.
+   */
+  async findPaymentByIdempotencyKey(idempotencyKey, opts) {
+    requireField(idempotencyKey, "idempotencyKey");
+    if (this.config.mock) {
+      return null;
+    }
+    const q = new URLSearchParams({ idempotencyKey });
+    if (opts?.gameId) q.set("gameId", opts.gameId);
+    try {
+      const res = await this.http.get(
+        `/payments?${q.toString()}`
+      );
+      const row = res.data?.[0];
+      if (!row || typeof row.id !== "string") return null;
+      const kind = row.kind === "entry" ? "entry" : "iap";
+      const amountMicro = validateAmount(String(row.amount ?? "0.01"));
+      return this.mapServerPayment(
+        row,
+        kind,
+        amountMicro
+      );
+    } catch (e) {
+      if (e instanceof ApiError && (e.detail?.status === 404 || e.detail?.code === "not_found" || /not found/i.test(e.message))) {
+        return null;
+      }
+      throw e;
+    }
+  }
   /**
    * Map a server-settled payment (from the `settle: "server"` response) into the
    * SDK's `Payment` shape. The service already signed + confirmed on-chain, so we
-   * pass its authoritative `status`/`txHash`/amounts straight through and, for an
-   * entry, derive the 60/30/10 USD `split` locally (exactly as the mock + the
-   * contract compute it) from the parsed amount.
+   * pass its authoritative `status`/`txHash`/amounts straight through.
+   *
+   * For entry, `Payment.split` is a **first-party 60/30/10 projection** from the
+   * request amount using SDK BPS constants (same integer math as mock) — not a
+   * chain read of pool constructor bps or post-lock payable pot (sdk#514 residual N1).
+   * Prefer `chainAmount` / on-chain `getRound` for money truth.
    */
   mapServerPayment(p, kind, amountMicro) {
     const payment = {

package/dist/server.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var crypto = require('crypto');
+var viem = require('viem');
 
 // src/webhooks.ts
 
@@ -14,6 +15,11 @@ var PlaymosError = class extends Error {
     Object.setPrototypeOf(this, new.target.prototype);
   }
 };
+var ApiError = class extends PlaymosError {
+  constructor(message, detail) {
+    super("api_error", message, detail);
+  }
+};
 
 // src/webhooks.ts
 var WebhookSignatureError = class extends PlaymosError {
@@ -56,6 +62,117 @@ function verifyWebhook(rawBody, signatureHeader, secret, opts = {}) {
   }
   return JSON.parse(body);
 }
+var toBytes32 = (s) => viem.keccak256(viem.toBytes(s));
+
+// src/hasEntered.ts
+var hasEnteredAbi = [
+  {
+    type: "function",
+    name: "hasEntered",
+    stateMutability: "view",
+    inputs: [
+      { name: "roundId", type: "bytes32" },
+      { name: "identity", type: "bytes32" }
+    ],
+    outputs: [{ type: "bool" }]
+  }
+];
+var HAS_ENTERED_DEFAULT_TIMEOUT_MS = 8e3;
+async function hasEntered(args) {
+  const rpcUrl = typeof args.rpcUrl === "string" ? args.rpcUrl.trim() : "";
+  if (!rpcUrl) {
+    throw new ApiError('hasEntered requires a non-empty "rpcUrl" (server-side only \u2014 no wallet provider)');
+  }
+  if (!args.prizePool || !/^0x[0-9a-fA-F]{40}$/.test(args.prizePool)) {
+    throw new ApiError("hasEntered requires prizePool as a 0x-prefixed 20-byte address");
+  }
+  if (!args.roundKey?.trim() || !args.identity?.trim()) {
+    throw new ApiError("hasEntered requires non-empty roundKey and identity (plain strings, same as enterRound)");
+  }
+  const roundKey = args.roundKey.trim();
+  const identity = args.identity.trim();
+  if (/^0x[0-9a-fA-F]{64}$/.test(roundKey) || /^0x[0-9a-fA-F]{64}$/.test(identity)) {
+    throw new ApiError(
+      "hasEntered requires plain-string roundKey/identity (not 0x+64 hex). Pre-hashed pins diverge from enterRound and from service GET /entered. Pass the same plain pins used at enter.",
+      { prizePool: args.prizePool, roundKey }
+    );
+  }
+  const data = viem.encodeFunctionData({
+    abi: hasEnteredAbi,
+    functionName: "hasEntered",
+    args: [toBytes32(roundKey), toBytes32(identity)]
+  });
+  const timeoutMs = typeof args.timeoutMs === "number" && Number.isFinite(args.timeoutMs) && args.timeoutMs > 0 ? args.timeoutMs : HAS_ENTERED_DEFAULT_TIMEOUT_MS;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const onExternalAbort = () => controller.abort();
+  if (args.signal) {
+    if (args.signal.aborted) controller.abort();
+    else args.signal.addEventListener("abort", onExternalAbort, { once: true });
+  }
+  let res;
+  try {
+    res = await fetch(rpcUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "eth_call",
+        params: [{ to: args.prizePool, data }, "latest"]
+      }),
+      signal: controller.signal
+    });
+  } catch (e) {
+    const msg = e.message ?? String(e);
+    const aborted = controller.signal.aborted || e.name === "AbortError" || /abort/i.test(msg);
+    throw new ApiError(
+      aborted ? `hasEntered RPC timed out after ${timeoutMs}ms (or was aborted)` : `hasEntered RPC request failed: ${msg}`,
+      { prizePool: args.prizePool, roundKey }
+    );
+  } finally {
+    clearTimeout(timer);
+    if (args.signal) args.signal.removeEventListener("abort", onExternalAbort);
+  }
+  if (!res.ok) {
+    throw new ApiError(`hasEntered RPC HTTP ${res.status}`, {
+      prizePool: args.prizePool,
+      roundKey
+    });
+  }
+  let json;
+  try {
+    json = await res.json();
+  } catch (e) {
+    throw new ApiError(`hasEntered RPC response not JSON: ${e.message}`);
+  }
+  if (json.error || json.result == null || json.result === "") {
+    throw new ApiError(
+      `hasEntered eth_call failed: ${json.error?.message ?? `HTTP ${res.status}`}`,
+      { prizePool: args.prizePool, roundKey }
+    );
+  }
+  if (json.result === "0x" || json.result === "0x0") {
+    throw new ApiError(
+      `hasEntered eth_call returned empty data for pool ${args.prizePool} \u2014 wrong address or no contract code`,
+      { prizePool: args.prizePool, roundKey }
+    );
+  }
+  try {
+    return viem.decodeFunctionResult({
+      abi: hasEnteredAbi,
+      functionName: "hasEntered",
+      data: json.result
+    });
+  } catch (e) {
+    throw new ApiError(
+      `hasEntered eth_call result malformed: ${e.message}`,
+      { prizePool: args.prizePool, roundKey }
+    );
+  }
+}
 
 exports.WebhookSignatureError = WebhookSignatureError;
+exports.enterPathToBytes32 = toBytes32;
+exports.hasEntered = hasEntered;
 exports.verifyWebhook = verifyWebhook;

package/dist/server.d.cts

@@ -1,4 +1,4 @@
-import { Z as PlaymosError, W as WebhookEvent } from './errors-Chizbb96.cjs';
+import { Z as PlaymosError, W as WebhookEvent } from './errors-Dpeesyop.cjs';
 
 /**
  * Webhook signature verification (spec §6.2) — server-side only.
@@ -23,4 +23,36 @@ declare function verifyWebhook(rawBody: string | Buffer, signatureHeader: string
     toleranceSeconds?: number;
 }): WebhookEvent;
 
-export { WebhookSignatureError, verifyWebhook };
+/**
+ * Builders for the two settling calls. Both mirror the proven entry batch:
+ * [approve(spender, amount), settle(...)] sent atomically via EIP-5792.
+ */
+
+/** The server derives these identically (keccak256 of UTF-8 bytes) so the
+ *  off-chain record and the on-chain call line up. */
+declare const toBytes32: (s: string) => `0x${string}`;
+
+interface HasEnteredArgs {
+    prizePool: `0x${string}`;
+    /** Same plain string pin as enterRound roundKey / body roundId. */
+    roundKey: string;
+    /** Same plain string pin as enterRound identity. */
+    identity: string;
+    /** Required JSON-RPC URL for eth_call (server-owned). */
+    rpcUrl: string;
+    /**
+     * Optional deadline for the RPC fetch (ms). Default 8000.
+     * On timeout throws ApiError (never returns false).
+     */
+    timeoutMs?: number;
+    /** Optional AbortSignal; combined with timeoutMs when both set. */
+    signal?: AbortSignal;
+}
+/**
+ * On-chain hasEntered for admit-to-session from a game backend.
+ * @returns true only when the chain read succeeds and returns true.
+ * @throws ApiError when eth_call fails, times out, or response is malformed.
+ */
+declare function hasEntered(args: HasEnteredArgs): Promise<boolean>;
+
+export { type HasEnteredArgs, WebhookSignatureError, toBytes32 as enterPathToBytes32, hasEntered, verifyWebhook };

package/dist/server.d.ts

@@ -1,4 +1,4 @@
-import { Z as PlaymosError, W as WebhookEvent } from './errors-Chizbb96.js';
+import { Z as PlaymosError, W as WebhookEvent } from './errors-Dpeesyop.js';
 
 /**
  * Webhook signature verification (spec §6.2) — server-side only.
@@ -23,4 +23,36 @@ declare function verifyWebhook(rawBody: string | Buffer, signatureHeader: string
     toleranceSeconds?: number;
 }): WebhookEvent;
 
-export { WebhookSignatureError, verifyWebhook };
+/**
+ * Builders for the two settling calls. Both mirror the proven entry batch:
+ * [approve(spender, amount), settle(...)] sent atomically via EIP-5792.
+ */
+
+/** The server derives these identically (keccak256 of UTF-8 bytes) so the
+ *  off-chain record and the on-chain call line up. */
+declare const toBytes32: (s: string) => `0x${string}`;
+
+interface HasEnteredArgs {
+    prizePool: `0x${string}`;
+    /** Same plain string pin as enterRound roundKey / body roundId. */
+    roundKey: string;
+    /** Same plain string pin as enterRound identity. */
+    identity: string;
+    /** Required JSON-RPC URL for eth_call (server-owned). */
+    rpcUrl: string;
+    /**
+     * Optional deadline for the RPC fetch (ms). Default 8000.
+     * On timeout throws ApiError (never returns false).
+     */
+    timeoutMs?: number;
+    /** Optional AbortSignal; combined with timeoutMs when both set. */
+    signal?: AbortSignal;
+}
+/**
+ * On-chain hasEntered for admit-to-session from a game backend.
+ * @returns true only when the chain read succeeds and returns true.
+ * @throws ApiError when eth_call fails, times out, or response is malformed.
+ */
+declare function hasEntered(args: HasEnteredArgs): Promise<boolean>;
+
+export { type HasEnteredArgs, WebhookSignatureError, toBytes32 as enterPathToBytes32, hasEntered, verifyWebhook };