@playmos/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,732 @@
+'use strict';
+
+var viem = require('viem');
+var crypto = require('crypto');
+
+// src/errors.ts
+var PlaymosError = class extends Error {
+  constructor(code, message, detail) {
+    super(message);
+    this.name = new.target.name;
+    this.code = code;
+    this.detail = detail;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var InvalidAmountError = class extends PlaymosError {
+  constructor(amount) {
+    super(
+      "invalid_amount",
+      `Invalid amount: ${JSON.stringify(amount)}. Provide a positive USD decimal string with at most 2 decimals, e.g. "4.99".`,
+      { amount }
+    );
+  }
+};
+var MissingFieldError = class extends PlaymosError {
+  constructor(field) {
+    super("missing_field", `Missing required field: "${field}".`, { field });
+  }
+};
+var InsufficientGasError = class extends PlaymosError {
+  constructor(detail) {
+    super(
+      "insufficient_gas",
+      `The player's wallet has too little ETH to pay gas. Ask them to add a little ETH, or switch to gas.mode: "sponsored".`,
+      detail
+    );
+  }
+};
+var WalletConnectionError = class extends PlaymosError {
+  constructor(message = "Could not connect the player's wallet.", detail) {
+    super("wallet_connection", message, detail);
+  }
+};
+var PaymentFailedError = class extends PlaymosError {
+  constructor(message = "The on-chain payment did not complete.", detail) {
+    super("payment_failed", message, detail);
+  }
+};
+var AuthError = class extends PlaymosError {
+  constructor(message = "Invalid or missing API key.", detail) {
+    super("auth", message, detail);
+  }
+};
+var ApiError = class extends PlaymosError {
+  constructor(message, detail) {
+    super("api_error", message, detail);
+  }
+};
+var ConfigError = class extends PlaymosError {
+  constructor(message, detail) {
+    super("config", message, detail);
+  }
+};
+
+// src/config.ts
+var CHAIN_ID = {
+  base: 8453,
+  "base-sepolia": 84532
+};
+var USDC_ADDRESS = {
+  base: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  "base-sepolia": "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
+};
+var DEFAULT_API_BASE_URL = {
+  base: "https://api.playmos.io/v1",
+  "base-sepolia": "https://api.sandbox.playmos.io/v1"
+};
+function resolveEnv(apiKey, networkOverride, apiBaseUrlOverride) {
+  if (typeof apiKey !== "string" || apiKey.trim() === "") {
+    throw new AuthError("Missing apiKey. Pass a pk_test_\u2026 or pk_live_\u2026 key.");
+  }
+  const isTest = apiKey.startsWith("pk_test_") || apiKey.startsWith("sk_test_");
+  const isLive = apiKey.startsWith("pk_live_") || apiKey.startsWith("sk_live_");
+  if (!isTest && !isLive) {
+    throw new AuthError(
+      'Malformed apiKey. Expected a "pk_test_", "pk_live_", "sk_test_", or "sk_live_" prefix.',
+      { keyPreview: apiKey.slice(0, 8) }
+    );
+  }
+  const network = networkOverride ?? (isTest ? "base-sepolia" : "base");
+  return {
+    network,
+    chainId: CHAIN_ID[network],
+    apiBaseUrl: apiBaseUrlOverride ?? DEFAULT_API_BASE_URL[network],
+    isTest
+  };
+}
+
+// src/ids.ts
+var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var TIME_LEN = 10;
+var RANDOM_LEN = 16;
+function getCrypto() {
+  const c = globalThis.crypto;
+  if (!c || typeof c.getRandomValues !== "function") {
+    throw new Error("Web Crypto (crypto.getRandomValues) is not available in this runtime.");
+  }
+  return c;
+}
+function encodeTime(now, len) {
+  let mod;
+  let str = "";
+  for (let i = len - 1; i >= 0; i--) {
+    mod = now % 32;
+    str = ENCODING[mod] + str;
+    now = (now - mod) / 32;
+  }
+  return str;
+}
+var lastTime = -1;
+var lastRandom = [];
+function randomBytes(len) {
+  const bytes = new Uint8Array(len);
+  getCrypto().getRandomValues(bytes);
+  return Array.from(bytes, (b) => b % 32);
+}
+function incrementRandom(arr) {
+  const out = arr.slice();
+  for (let i = out.length - 1; i >= 0; i--) {
+    const v = out[i] ?? 0;
+    if (v < 31) {
+      out[i] = v + 1;
+      return out;
+    }
+    out[i] = 0;
+  }
+  return randomBytes(out.length);
+}
+function ulid(seedTime) {
+  const now = seedTime ?? Date.now();
+  let random;
+  if (now === lastTime) {
+    random = incrementRandom(lastRandom);
+  } else {
+    random = randomBytes(RANDOM_LEN);
+  }
+  lastTime = now;
+  lastRandom = random;
+  return encodeTime(now, TIME_LEN) + random.map((r) => ENCODING[r]).join("");
+}
+function prefixedId(prefix) {
+  return `${prefix}_${ulid()}`;
+}
+
+// src/money.ts
+var USDC_DECIMALS = 6;
+var MICRO_PER_USDC = 1000000n;
+var AMOUNT_RE = /^\d+(\.\d{1,2})?$/;
+function parseUsdToMicro(amount) {
+  if (typeof amount !== "string" || amount.trim() === "" || !AMOUNT_RE.test(amount)) {
+    throw new InvalidAmountError(amount);
+  }
+  const parts = amount.split(".");
+  const whole = parts[0] ?? "0";
+  const frac = parts[1] ?? "";
+  const fracPadded = (frac + "000000").slice(0, USDC_DECIMALS);
+  const micro = BigInt(whole) * MICRO_PER_USDC + BigInt(fracPadded);
+  if (micro <= 0n) throw new InvalidAmountError(amount);
+  return micro;
+}
+function formatMicroToUsd(micro) {
+  const neg = micro < 0n;
+  const abs = neg ? -micro : micro;
+  const whole = abs / MICRO_PER_USDC;
+  const frac = abs % MICRO_PER_USDC;
+  let fracStr = frac.toString().padStart(USDC_DECIMALS, "0").replace(/0+$/, "");
+  if (fracStr.length < 2) fracStr = fracStr.padEnd(2, "0");
+  return `${neg ? "-" : ""}${whole.toString()}.${fracStr}`;
+}
+function computeIapSplit(amountMicro, feeBps) {
+  const feeMicro = amountMicro * BigInt(feeBps) / 10000n;
+  const netMicro = amountMicro - feeMicro;
+  return { feeMicro, netMicro };
+}
+function computePoolSplit(amountMicro, poolBps, seedBps, rakeBps) {
+  if (poolBps + seedBps + rakeBps !== 1e4) {
+    throw new Error(`pool/seed/rake bps must sum to 10000, got ${poolBps + seedBps + rakeBps}`);
+  }
+  const seedMicro = amountMicro * BigInt(seedBps) / 10000n;
+  const rakeMicro = amountMicro * BigInt(rakeBps) / 10000n;
+  const poolMicro = amountMicro - seedMicro - rakeMicro;
+  return { poolMicro, seedMicro, rakeMicro };
+}
+
+// src/validation.ts
+function validateAmount(amount) {
+  if (typeof amount !== "string") throw new InvalidAmountError(amount);
+  return parseUsdToMicro(amount);
+}
+function requireField(value, field) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new MissingFieldError(field);
+  }
+  return value;
+}
+function validateMetadata(metadata) {
+  if (metadata == null) return void 0;
+  if (typeof metadata !== "object" || Array.isArray(metadata)) {
+    throw new MissingFieldError("metadata (must be an object of string values)");
+  }
+  const entries = Object.entries(metadata);
+  if (entries.length > 20) {
+    throw new InvalidAmountError(`metadata: at most 20 keys allowed, got ${entries.length}`);
+  }
+  const out = {};
+  for (const [k, v] of entries) {
+    if (typeof v !== "string") {
+      throw new MissingFieldError(`metadata.${k} (values must be strings)`);
+    }
+    out[k] = v;
+  }
+  return out;
+}
+
+// src/http.ts
+function createHttpClient(baseUrl, apiKey) {
+  const base = baseUrl.replace(/\/+$/, "");
+  async function handle(res) {
+    const text = await res.text();
+    let json;
+    try {
+      json = text ? JSON.parse(text) : {};
+    } catch {
+      throw new ApiError(`Non-JSON response (${res.status}) from ${res.url}`, { status: res.status, body: text });
+    }
+    if (res.ok) return json;
+    const errBody = json;
+    const message = errBody?.error?.message ?? `Request failed with ${res.status}`;
+    if (res.status === 401 || res.status === 403 || errBody?.error?.code === "auth") {
+      throw new AuthError(message, { status: res.status });
+    }
+    throw new ApiError(message, { status: res.status, code: errBody?.error?.code });
+  }
+  return {
+    async post(path, body, opts) {
+      const headers = {
+        "content-type": "application/json",
+        authorization: `Bearer ${apiKey}`
+      };
+      if (opts?.idempotencyKey) headers["idempotency-key"] = opts.idempotencyKey;
+      const res = await fetch(`${base}${path}`, { method: "POST", headers, body: JSON.stringify(body) });
+      return handle(res);
+    },
+    async get(path) {
+      const res = await fetch(`${base}${path}`, {
+        method: "GET",
+        headers: { authorization: `Bearer ${apiKey}` }
+      });
+      return handle(res);
+    }
+  };
+}
+
+// src/wallet.ts
+function resolveProvider(wallet) {
+  if (wallet?.provider) return wallet.provider;
+  const injected = globalThis.ethereum;
+  const connector = wallet?.connector ?? "base-account";
+  if (connector === "injected") {
+    if (!injected) {
+      throw new WalletConnectionError(
+        "No injected wallet found (globalThis.ethereum is undefined). Open in a wallet browser or pass wallet.provider."
+      );
+    }
+    return injected;
+  }
+  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."
+  );
+}
+async function getAccount(provider) {
+  try {
+    const accounts = await provider.request({ method: "eth_requestAccounts" });
+    const addr = accounts?.[0];
+    if (!addr) throw new Error("no account");
+    return addr;
+  } catch (e) {
+    throw new WalletConnectionError("Could not read the player's wallet account.", {
+      cause: e?.message
+    });
+  }
+}
+
+// src/chain/abis.ts
+var erc20Abi = [
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ type: "uint256" }]
+  }
+];
+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: "hasEntered",
+    stateMutability: "view",
+    inputs: [
+      { name: "roundId", type: "bytes32" },
+      { name: "identity", type: "bytes32" }
+    ],
+    outputs: [{ type: "bool" }]
+  }
+];
+async function sendCalls(provider, from, chainId, calls, paymasterUrl) {
+  const params = {
+    version: "2.0.0",
+    from,
+    chainId: viem.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) {
+    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) {
+    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 };
+    await new Promise((r) => setTimeout(r, 900));
+  }
+  return { status: "PENDING" };
+}
+function encodeApprove(spender, amountUnits) {
+  return viem.encodeFunctionData({ abi: erc20Abi, functionName: "approve", args: [spender, amountUnits] });
+}
+async function assertEnoughGas(provider, from, minWei = 200000000000000n) {
+  let balance;
+  try {
+    const hex = await provider.request({ method: "eth_getBalance", params: [from, "latest"] });
+    balance = BigInt(hex);
+  } catch {
+    return;
+  }
+  if (balance < minWei) {
+    throw new InsufficientGasError({ balanceWei: balance.toString(), minWei: minWei.toString() });
+  }
+}
+var toBytes32 = (s) => viem.keccak256(viem.toBytes(s));
+function buildIapCalls(args) {
+  const payData = viem.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 = viem.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 }
+  ];
+}
+
+// src/mock.ts
+var MOCK_TX = "0x000000000000000000000000000000000000000000000000000000000000mock";
+function mockIapPayment(args) {
+  const { feeMicro, netMicro } = computeIapSplit(args.amountMicro, args.feeBps);
+  return {
+    id: prefixedId("pay"),
+    status: "confirmed",
+    kind: "iap",
+    amount: formatMicroToUsd(args.amountMicro),
+    fee: formatMicroToUsd(feeMicro),
+    net: formatMicroToUsd(netMicro),
+    sku: args.sku,
+    playerId: args.playerId,
+    txHash: MOCK_TX,
+    chain: args.chain,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    metadata: args.metadata,
+    mock: true
+  };
+}
+function mockEntryPayment(args) {
+  const { poolMicro, seedMicro, rakeMicro } = computePoolSplit(
+    args.amountMicro,
+    args.poolBps,
+    args.seedBps,
+    args.rakeBps
+  );
+  return {
+    id: prefixedId("entry"),
+    status: "confirmed",
+    kind: "entry",
+    amount: formatMicroToUsd(args.amountMicro),
+    fee: formatMicroToUsd(rakeMicro),
+    // the 10% take
+    net: formatMicroToUsd(poolMicro + seedMicro),
+    // escrowed to the pool
+    split: {
+      pool: formatMicroToUsd(poolMicro),
+      seed: formatMicroToUsd(seedMicro),
+      rake: formatMicroToUsd(rakeMicro)
+    },
+    gameId: args.gameId,
+    roundId: args.roundId,
+    playerId: args.playerId,
+    txHash: MOCK_TX,
+    chain: args.chain,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    metadata: args.metadata,
+    mock: true
+  };
+}
+var WebhookSignatureError = class extends PlaymosError {
+  constructor(message) {
+    super("api_error", `Webhook signature verification failed: ${message}`);
+  }
+};
+function parseHeader(header) {
+  const parts = Object.fromEntries(
+    header.split(",").map((kv) => {
+      const [k, v] = kv.split("=");
+      return [k?.trim(), v?.trim()];
+    })
+  );
+  const t = Number(parts["t"]);
+  const v1 = parts["v1"];
+  if (!Number.isFinite(t) || !v1) throw new WebhookSignatureError("malformed signature header");
+  return { t, v1 };
+}
+function computeSignature(secret, t, rawBody) {
+  return crypto.createHmac("sha256", secret).update(`${t}.${rawBody}`).digest("hex");
+}
+function verifyWebhook(rawBody, signatureHeader, secret, opts = {}) {
+  if (!signatureHeader || Array.isArray(signatureHeader)) {
+    throw new WebhookSignatureError("missing signature header");
+  }
+  if (!secret) throw new WebhookSignatureError("missing signing secret");
+  const body = typeof rawBody === "string" ? rawBody : rawBody.toString("utf8");
+  const { t, v1 } = parseHeader(signatureHeader);
+  const tolerance = opts.toleranceSeconds ?? 300;
+  const nowSec = Math.floor(Date.now() / 1e3);
+  if (Math.abs(nowSec - t) > tolerance) {
+    throw new WebhookSignatureError(`timestamp outside tolerance (${tolerance}s)`);
+  }
+  const expected = computeSignature(secret, t, body);
+  const a = Buffer.from(expected, "hex");
+  const b = Buffer.from(v1, "hex");
+  if (a.length !== b.length || !crypto.timingSafeEqual(a, b)) {
+    throw new WebhookSignatureError("signature mismatch");
+  }
+  return JSON.parse(body);
+}
+
+// src/client.ts
+var IAP_FEE_BPS = 100;
+var POOL_BPS = 6e3;
+var SEED_BPS = 3e3;
+var RAKE_BPS = 1e3;
+var Playmos = class {
+  constructor(config) {
+    this.webhooks = {
+      /** Verify a webhook signature and return the parsed event (server-side). */
+      verify: (rawBody, signatureHeader, secret) => verifyWebhook(rawBody, signatureHeader, secret)
+    };
+    this.payouts = {
+      /** Choose how the studio is paid: "usdc" (default) or "fiat" (Bridge). */
+      setMode: (mode) => this.http.post("/payouts/mode", { mode }),
+      /** Create a Bridge KYC onboarding link (fiat payout). */
+      createOnboardingLink: () => this.http.post("/payouts/onboarding_link", {})
+    };
+    this.agents = {
+      /** Assign a wallet to any identity (incl. an AI NPC). Idempotent by agentId. */
+      createWallet: (input) => {
+        requireField(input?.agentId, "agentId");
+        return this.http.post("/agents/wallets", { agentId: input.agentId });
+      },
+      /** Agent↔agent USDC transfer; the configured taxBps is skimmed to Playmos. */
+      pay: (input) => {
+        requireField(input?.from, "from");
+        requireField(input?.to, "to");
+        validateAmount(input?.amount);
+        return this.http.post("/agents/pay", input);
+      }
+    };
+    this.config = config;
+    this.env = resolveEnv(config.apiKey, config.network, config.apiBaseUrl);
+    this.http = createHttpClient(this.env.apiBaseUrl, config.apiKey);
+  }
+  /** 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");
+    if (this.config.mock) {
+      return mockIapPayment({
+        amountMicro,
+        feeBps: IAP_FEE_BPS,
+        sku: input.sku,
+        playerId: input.playerId,
+        chain: this.env.network,
+        metadata
+      });
+    }
+    const intent = await this.http.post(
+      "/payments",
+      { kind: "iap", amount: input.amount, sku: input.sku, playerId: input.playerId, gameId: input.gameId, studio: input.studio, metadata },
+      { idempotencyKey }
+    );
+    const provider = resolveProvider(this.config.wallet);
+    if (this.config.gas?.mode === "player") {
+      const from0 = await getAccount(provider);
+      await assertEnoughGas(provider, from0);
+    }
+    const from = await getAccount(provider);
+    const usdc = intent.clientParams?.usdc ?? this.config.contracts?.usdc ?? USDC_ADDRESS[this.env.network];
+    const playmosPay = intent.clientParams?.contractAddress ?? this.config.contracts?.playmosPay;
+    const studio = intent.clientParams?.studio ?? input.studio;
+    if (!playmosPay) throw new ConfigError("No PlaymosPay contract address (service intent + config.contracts both empty).");
+    if (!studio) throw new ConfigError("No studio payout address for this payment.");
+    const amountUnits = this.resolveUnits(intent, amountMicro);
+    const calls = buildIapCalls({ usdc, playmosPay, paymentId: intent.payment.id, studio, amountUnits });
+    const { id: callsId } = await sendCalls(provider, from, this.env.chainId, calls, this.sponsorUrl(intent));
+    const { txHash } = await waitForCalls(provider, callsId);
+    return this.settle(intent.payment.id, txHash);
+  }
+  /** Playmos-owned skill-game entry (10%, 60/30/10 prize pool). Closes #343. */
+  async enterRound(input) {
+    const amountMicro = validateAmount(input.amount);
+    requireField(input.gameId, "gameId");
+    requireField(input.roundId, "roundId");
+    requireField(input.playerId, "playerId");
+    const metadata = validateMetadata(input.metadata);
+    const idempotencyKey = input.idempotencyKey ?? prefixedId("idem");
+    if (this.config.mock) {
+      return mockEntryPayment({
+        amountMicro,
+        poolBps: POOL_BPS,
+        seedBps: SEED_BPS,
+        rakeBps: RAKE_BPS,
+        gameId: input.gameId,
+        roundId: input.roundId,
+        playerId: input.playerId,
+        chain: this.env.network,
+        metadata
+      });
+    }
+    const intent = await this.http.post(
+      "/payments",
+      { kind: "entry", amount: input.amount, gameId: input.gameId, roundId: input.roundId, playerId: input.playerId, metadata },
+      { idempotencyKey }
+    );
+    const provider = resolveProvider(this.config.wallet);
+    if (this.config.gas?.mode === "player") {
+      const from0 = await getAccount(provider);
+      await assertEnoughGas(provider, from0);
+    }
+    const from = await getAccount(provider);
+    const usdc = intent.clientParams?.usdc ?? this.config.contracts?.usdc ?? USDC_ADDRESS[this.env.network];
+    const prizePool = intent.clientParams?.contractAddress ?? this.config.contracts?.prizePool;
+    if (!prizePool) throw new ConfigError("No PrizePool contract address for this game (service intent + config.contracts both empty).");
+    const roundKey = intent.clientParams?.roundKey ?? intent.clientParams?.roundId ?? `${input.gameId}:${input.roundId}`;
+    const identity = intent.clientParams?.identity ?? `${from}#${idempotencyKey}`;
+    const amountUnits = this.resolveUnits(intent, amountMicro);
+    const calls = buildEntryCalls({ usdc, prizePool, roundKey, identity, amountUnits });
+    const { id: callsId } = await sendCalls(provider, from, this.env.chainId, calls, this.sponsorUrl(intent));
+    const { txHash } = await waitForCalls(provider, callsId);
+    return this.settle(intent.payment.id, txHash);
+  }
+  /** Verify a payment by the service's on-chain read (spec §6.1). Idempotent. */
+  async verify(paymentId) {
+    requireField(paymentId, "paymentId");
+    return this.http.get(`/payments/${encodeURIComponent(paymentId)}`);
+  }
+  // ---- internals ---------------------------------------------------------
+  /** Prefer the service's authoritative micro-USDC amount; fall back to the
+   *  locally-parsed value if the service didn't echo one. */
+  resolveUnits(intent, local) {
+    const fromServer = intent.clientParams?.amountUnits ?? intent.clientParams?.amountMicro;
+    return fromServer ? BigInt(fromServer) : local;
+  }
+  sponsorUrl(intent) {
+    if (this.config.gas?.mode === "player") return void 0;
+    return this.config.gas?.paymasterUrl ?? intent.clientParams?.paymasterUrl;
+  }
+  /**
+   * After the batch lands, resolve the authoritative status via the service's
+   * on-chain read. Polls briefly; returns the merged Payment with the real txHash.
+   */
+  async settle(paymentId, txHash, timeoutMs = 3e4) {
+    if (txHash) {
+      try {
+        await this.http.post(`/payments/${encodeURIComponent(paymentId)}/tx`, { txHash });
+      } catch {
+      }
+    }
+    const deadline = Date.now() + timeoutMs;
+    let last;
+    while (Date.now() < deadline) {
+      last = await this.verify(paymentId);
+      if (last.status === "confirmed" || last.status === "failed") break;
+      if (last.chainReads === "degraded" || last.verifiedVia === "degraded") break;
+      await new Promise((r) => setTimeout(r, 1200));
+    }
+    return {
+      id: paymentId,
+      status: last?.status ?? "pending",
+      kind: last?.roundId ? "entry" : "iap",
+      amount: last?.amount ?? "0",
+      fee: last?.fee ?? "0",
+      net: last?.net ?? "0",
+      sku: last?.sku,
+      roundId: last?.roundId,
+      playerId: last?.playerId ?? "",
+      txHash: last?.txHash ?? txHash,
+      chain: this.env.network,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+};
+function previewIapSplit(amount) {
+  const micro = validateAmount(amount);
+  const { feeMicro, netMicro } = computeIapSplit(micro, IAP_FEE_BPS);
+  return { amount: formatMicroToUsd(micro), fee: formatMicroToUsd(feeMicro), net: formatMicroToUsd(netMicro) };
+}
+function previewPoolSplit(amount) {
+  const micro = validateAmount(amount);
+  const { poolMicro, seedMicro, rakeMicro } = computePoolSplit(micro, POOL_BPS, SEED_BPS, RAKE_BPS);
+  return {
+    amount: formatMicroToUsd(micro),
+    pool: formatMicroToUsd(poolMicro),
+    seed: formatMicroToUsd(seedMicro),
+    rake: formatMicroToUsd(rakeMicro)
+  };
+}
+
+exports.ApiError = ApiError;
+exports.AuthError = AuthError;
+exports.CHAIN_ID = CHAIN_ID;
+exports.ConfigError = ConfigError;
+exports.DEFAULT_API_BASE_URL = DEFAULT_API_BASE_URL;
+exports.InsufficientGasError = InsufficientGasError;
+exports.InvalidAmountError = InvalidAmountError;
+exports.MICRO_PER_USDC = MICRO_PER_USDC;
+exports.MissingFieldError = MissingFieldError;
+exports.PaymentFailedError = PaymentFailedError;
+exports.Playmos = Playmos;
+exports.PlaymosError = PlaymosError;
+exports.USDC_ADDRESS = USDC_ADDRESS;
+exports.USDC_DECIMALS = USDC_DECIMALS;
+exports.WalletConnectionError = WalletConnectionError;
+exports.WebhookSignatureError = WebhookSignatureError;
+exports.computeIapSplit = computeIapSplit;
+exports.computePoolSplit = computePoolSplit;
+exports.formatMicroToUsd = formatMicroToUsd;
+exports.parseUsdToMicro = parseUsdToMicro;
+exports.prefixedId = prefixedId;
+exports.previewIapSplit = previewIapSplit;
+exports.previewPoolSplit = previewPoolSplit;
+exports.ulid = ulid;
+exports.verifyWebhook = verifyWebhook;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map