@xgamesfun/solana 0.28.1 → 0.28.3

package/js/play/index.js

@@ -40,7 +40,7 @@ import {
   withComputeBudget,
   withSolWrap,
 } from '../chain/programs.js';
-import { checkCluster, notMainnet, rpcClient } from '../chain/rpc.js';
+import { rightCluster, rpcClient } from '../chain/rpc.js';
 import { extension, mayStartFrozen, mintPowers, resolveTransfers } from '../chain/token2022.js';
 import {
   compileFitting,
@@ -84,14 +84,13 @@ const LOTTERY_STEPS = new Set(['reveal', 'cancel-draw', 'pull', 'payout']);
 const BATCHED = new Set(['contest', 'release', 'lookup-table', 'close-leaf', ...LOTTERY_STEPS]);
 const NO_OPTIONS = Object.freeze(/** @type {Record<string, any>} */ ({}));
 
-const CHAIN = 'solana:devnet';
 const sleep = ms => new Promise(r => setTimeout(r, ms));
 const MPL_CORE = loot.MPL_CORE_PROGRAM;
 const NOBODY = '11111111111111111111111111111111';
 /** A table made this many slots ago whose transaction never landed was never sent: its blockhashes ran out long since. */
 const TABLE_UNSENT_SLOTS = 300n;
 /** A compressed NFT's `prove_leaf`: its record stays good while the leaf is unchanged, so it may go in a transaction of its own first. */
-const isProveLeaf = ix => ix.programId === loot.LOOT_PROGRAM && loot.instructionOf(ix.data)?.name === 'prove_leaf';
+const isProveLeaf = ix => ix.programId === loot.lootProgram() && loot.instructionOf(ix.data)?.name === 'prove_leaf';
 /** A system account must keep this much (rent for 0 bytes) or be emptied. */
 const RENT_EMPTY = 890_880n;
 const SIGNATURE_FEE = 5_000n;
@@ -101,7 +100,7 @@ const SIGNATURE_FEE = 5_000n;
  * `solana:signMessage`, also `signMessage(bytes)`: the app's settle keys are made from one signature of it a session,
  * so a page that closes can make them again (`recover`).
  */
-export function walletStandardSigner(wallet, account, chain = CHAIN) {
+export function walletStandardSigner(wallet, account, chain = loot.walletChain()) {
   const feature = wallet.features?.['solana:signTransaction'];
   if (!feature) throw new Error(`${wallet.name} cannot sign transactions.`);
   const messages = wallet.features?.['solana:signMessage'];
@@ -165,18 +164,18 @@ const show = (u, decimals) => {
 };
 
 /**
- * `client`, kept to devnet: a URL that names mainnet is refused at once, and before its first request goes out the
- * chain's genesis block is checked, once (`checkCluster`), so an RPC whose URL hides mainnet or testnet is refused
+ * `client`, kept to this page's cluster: a URL that names another is refused at once, and before its first request goes
+ * out the chain's genesis block is checked, once (`checkCluster`), so an RPC whose URL hides another cluster is refused
  * whatever it says. Every RPC reached over http(s) is checked: the app's own client, and one given whose `url` is
  * http(s). A client with no such URL (a local chain of the caller's own, like the tests' LiteSVM) is used as it is.
  */
-function devnetOnly(client) {
-  if (typeof client.url === 'string') notMainnet(client.url);
+function onCluster(client) {
+  if (typeof client.url === 'string') rightCluster(client.url, loot.cluster());
   if (!/^(https?|wss?):/i.test(String(client.url ?? ''))) return client;
   let checked = null;
   // A check that could not be made (the network did not answer) is made again on the next request.
   const ready = () =>
-    (checked ??= checkCluster(client).catch(e => {
+    (checked ??= loot.checkOnCluster(client).catch(e => {
       checked = null;
       throw e;
     }));
@@ -203,7 +202,7 @@ function devnetOnly(client) {
  */
 export function solanaApp({
   spec,
-  rpcUrl = 'https://api.devnet.solana.com',
+  rpcUrl = null,
   rpc = null,
   wallet,
   programs = {},
@@ -217,7 +216,13 @@ export function solanaApp({
     throw new Error(
       'The rpc given has no call(method, params): a custom rpc needs it (the devnet check, the slot and compressed NFTs are read through it), as well as accounts, account, latestBlockhash, send, confirm and programAccounts.',
     );
-  const client = devnetOnly(rpc ?? rpcClient(notMainnet(rpcUrl)));
+  // The economy's file names its cluster (devnet when it names none), and this page works on it and no other.
+  loot.useCluster(loot.networkOf(spec));
+  if (live.program && live.program !== loot.lootProgram())
+    throw new Error(
+      `This economy went live on the program ${live.program}, which is not loot’s on ${loot.cluster()} (${loot.lootProgram()}): its "network" and its "live" section name two clusters.`,
+    );
+  const client = onCluster(rpc ?? rpcClient(loot.clusterRpcUrl(rpcUrl)));
   const project = live.project;
   /** The settle keys, each named by its job's account (`keys.js`): made again after a reload (`recover`). */
   const keys = wallet?.address ? keyring({ wallet, project, store: keyStore }) : null;
@@ -252,13 +257,13 @@ export function solanaApp({
   const read = async (name, address) => {
     const a = await client.account(address);
     if (!a) throw new Error(`Nothing at ${address}: is the economy live on this cluster?`);
-    if (a.owner !== loot.LOOT_PROGRAM) throw new Error(`${address} is not a loot account.`);
+    if (a.owner !== loot.lootProgram()) throw new Error(`${address} is not a loot account.`);
     return loot.decode(name, a.data);
   };
   /** A loot account, or null when there is none yet. */
   const readMaybe = async (name, address) => {
     const a = await client.account(address);
-    return a?.owner === loot.LOOT_PROGRAM ? loot.decode(name, a.data) : null;
+    return a?.owner === loot.lootProgram() ? loot.decode(name, a.data) : null;
   };
   /** The key of the token a lottery's tickets are paid in: the spec's `ticketCurrency`, or the token of its mint. */
   const ticketCurrencyOf = (l, lottery) =>
@@ -530,7 +535,7 @@ export function solanaApp({
   const sheetOf = async nft => {
     const found = await client.account(loot.pda.sheet(project, nft));
     return Object.fromEntries(
-      (loot.decodeSheet(found?.owner === loot.LOOT_PROGRAM ? found.data : null)?.attributes ?? []).map(a => [
+      (loot.decodeSheet(found?.owner === loot.lootProgram() ? found.data : null)?.attributes ?? []).map(a => [
         a.key,
         a.value,
       ]),
@@ -653,7 +658,7 @@ export function solanaApp({
     if (loot.readsProfile(rule)) {
       const found = await client.account(loot.pda.profile(project, wallet.address));
       const attributes = Object.fromEntries(
-        (loot.decodeProfile(found?.owner === loot.LOOT_PROGRAM ? found.data : null)?.attributes ?? []).map(a => [
+        (loot.decodeProfile(found?.owner === loot.lootProgram() ? found.data : null)?.attributes ?? []).map(a => [
           a.key,
           a.value,
         ]),
@@ -925,7 +930,7 @@ export function solanaApp({
     const said = String(e?.message ?? '');
     const m = /custom program error: 0x([0-9a-f]+)/i.exec(said);
     const failed = e?.logs?.find(line => / failed: custom program error: 0x/i.test(line));
-    const known = m && (!failed || failed.includes(loot.LOOT_PROGRAM)) ? loot.ERRORS[parseInt(m[1], 16)] : null;
+    const known = m && (!failed || failed.includes(loot.lootProgram())) ? loot.ERRORS[parseInt(m[1], 16)] : null;
     if (!known) throw e;
     throw Object.assign(new Error(`${known.msg} (${known.name}).`, { cause: e }), {
       code: parseInt(m[1], 16),
@@ -1080,14 +1085,14 @@ export function solanaApp({
     const watch = [
       ...new Set(
         instructions
-          .filter(ix => ix.programId === loot.LOOT_PROGRAM)
+          .filter(ix => ix.programId === loot.lootProgram())
           .flatMap(ix => ix.keys.filter(k => k.isWritable && !k.isSigner).map(k => k.pubkey)),
       ),
     ];
     const after = (await dryRun(wallet.address, instructions, watch)).accounts;
     const waiting = watch.flatMap((address, i) => {
       const a = after[i];
-      if (a?.owner !== loot.LOOT_PROGRAM || loot.accountKind(a.data) !== 'Order') return [];
+      if (a?.owner !== loot.lootProgram() || loot.accountKind(a.data) !== 'Order') return [];
       const order = loot.decode('Order', a.data);
       return order.status === 'Waiting' && order.player === wallet.address ? [[address, order]] : [];
     });
@@ -1191,7 +1196,7 @@ export function solanaApp({
     // `landed`: the slot one's own open landed in; the order is read from a node that has seen it.
     const current = async () => {
       const account = await client.account(orderAddress, 'confirmed', landed != null ? { minContextSlot: landed } : {});
-      return account?.owner === loot.LOOT_PROGRAM ? loot.decode('Order', account.data) : null;
+      return account?.owner === loot.lootProgram() ? loot.decode('Order', account.data) : null;
     };
     let order = await current();
     // Right after one's own confirmed open, no order is "not seen yet", never "settled already": a node of the RPC may
@@ -2298,7 +2303,7 @@ export function solanaApp({
     const listing = await readMaybe('Listing', listingAt);
     if (listing) out.push({ kind: 'listing', address: listingAt, record: listing });
     const tag = { memcmp: { offset: 0, bytes: encodeBase58(Uint8Array.of(loot.TAGS.Hold)) } };
-    const holds = await client.programAccounts(loot.LOOT_PROGRAM, [
+    const holds = await client.programAccounts(loot.lootProgram(), [
       tag,
       { memcmp: { offset: 1, bytes: project } },
       { memcmp: { offset: 33, bytes: asset } },
@@ -2317,7 +2322,7 @@ export function solanaApp({
    */
   async function stashesOf(asset) {
     const at = (offset, bytes) => ({ memcmp: { offset, bytes } });
-    const found = await client.programAccounts(loot.LOOT_PROGRAM, [
+    const found = await client.programAccounts(loot.lootProgram(), [
       at(0, encodeBase58(Uint8Array.of(loot.TAGS.Table))),
       at(1, project),
       at(37, encodeBase58(Uint8Array.of(loot.PAYLOAD.Nft))),
@@ -2532,7 +2537,7 @@ export function solanaApp({
     const found = await client.accounts(keys);
     const rounds = keys.map((key, i) => ({
       address: key,
-      round: found[i]?.owner === loot.LOOT_PROGRAM ? loot.decodeRound(found[i].data) : null,
+      round: found[i]?.owner === loot.lootProgram() ? loot.decodeRound(found[i].data) : null,
     }));
     return { address, lottery, current: rounds[0].round, rounds: rounds.filter(r => r.round) };
   }
@@ -2587,7 +2592,7 @@ export function solanaApp({
       first && lottery?.owing && lottery.owing !== NOBODY && loot.potIdOf(terms) != null
         ? await client.account(lottery.owing)
         : null;
-    const owing = owingAt?.owner === loot.LOOT_PROGRAM ? loot.decodeRound(owingAt.data) : null;
+    const owing = owingAt?.owner === loot.lootProgram() ? loot.decodeRound(owingAt.data) : null;
     // That round's answer says what it left the pot: until it lands (or the round is cancelled), this draw waits.
     if (owing?.status === 'Drawing')
       throw new Error(
@@ -3000,13 +3005,13 @@ export function solanaApp({
       const tag = t => ({ memcmp: { offset: 0, bytes: encodeBase58(Uint8Array.of(loot.TAGS[t])) } });
       const at = (offset, bytes) => ({ memcmp: { offset, bytes } });
       const orders = new Map();
-      for (const { pubkey, account } of await client.programAccounts(loot.LOOT_PROGRAM, [
+      for (const { pubkey, account } of await client.programAccounts(loot.lootProgram(), [
         tag('Order'),
         at(1, project),
         at(33, me),
       ]))
         orders.set(pubkey, loot.decode('Order', account.data));
-      const holds = (await client.programAccounts(loot.LOOT_PROGRAM, [tag('Hold'), at(1, project), at(65, me)])).map(
+      const holds = (await client.programAccounts(loot.lootProgram(), [tag('Hold'), at(1, project), at(65, me)])).map(
         h => h.pubkey,
       );
       // Keys are named by an order of the wallet's, a hold (a loan's release), or an auction (the releases after its end).
@@ -3140,7 +3145,7 @@ export function solanaApp({
     async payNft(asset, { to = null, reference, ...others } = NO_OPTIONS) {
       only(others, ['to', 'reference'], 'payNft');
       // An NFT paid goes to a wallet: never the project's address or an account of the program (ToTheProject).
-      if (to && (to === project || (await client.account(to))?.owner === loot.LOOT_PROGRAM))
+      if (to && (to === project || (await client.account(to))?.owner === loot.lootProgram()))
         throw new Error('An NFT paid can’t go to the project or an account of the program: name a wallet, or burn it.');
       const { before, ...nft } = await nftOf(asset);
       return send([...before, loot.payNftIx({ player: wallet.address, project, asset, to, ...nft, reference })]);
@@ -3158,7 +3163,7 @@ export function solanaApp({
         const there = await client.account(loot.pda.lottery(project, l.id));
         // The terms on sale are the round's own copy once someone bought into it, the lottery's before.
         const { lottery, current } =
-          there?.owner === loot.LOOT_PROGRAM ? await roundOf(l) : { lottery: null, current: null };
+          there?.owner === loot.lootProgram() ? await roundOf(l) : { lottery: null, current: null };
         const copy = current ?? lottery;
         const terms = copy?.terms;
         const currency = lottery ? ticketCurrencyOf(l, lottery) : (l.ticketCurrency ?? currencyKey);
@@ -3718,7 +3723,7 @@ export function solanaApp({
       const nfts = f.stakes === 'collectibles';
       // A seat names its player (offset 1), not its farm: a seat of this farm is the one at its own address here.
       const found = (
-        await client.programAccounts(loot.LOOT_PROGRAM, [
+        await client.programAccounts(loot.lootProgram(), [
           { memcmp: { offset: 0, bytes: encodeBase58(Uint8Array.of(loot.TAGS.Seat)) } },
           { memcmp: { offset: 1, bytes: player } },
         ])
@@ -4545,7 +4550,7 @@ export function solanaApp({
         ...(maker ? [{ memcmp: { offset: 33, bytes: maker } }] : []),
       ];
       const time = await chainNow();
-      const found = (await client.programAccounts(loot.LOOT_PROGRAM, filters)).map(({ pubkey, account }) => {
+      const found = (await client.programAccounts(loot.lootProgram(), filters)).map(({ pubkey, account }) => {
         const listing = loot.decode('Listing', account.data);
         return { listing: pubkey, ...listing, renter: loot.renterOf(listing, time) };
       });
@@ -4917,7 +4922,12 @@ export function solanaApp({
       only(others, ['server', 'token', 'fetchImpl'], 'claimWins');
       const base = server.replace(/\/$/, '');
       const ask = async (path, init) => {
-        const r = await fetchImpl(path.startsWith('http') ? path : `${base}${path}`, init);
+        // (one server answers for both clusters: a request for mainnet says so, one for devnet names none, as before)
+        const at = path.startsWith('http') ? path : `${base}${path}`;
+        const on = loot.cluster();
+        const url =
+          on === 'devnet' || /[?&]cluster=/.test(at) ? at : `${at}${at.includes('?') ? '&' : '?'}cluster=${on}`;
+        const r = await fetchImpl(url, init);
         // The status first: a proxy's error page is no JSON, and says nothing a player can act on but its status.
         const body = await r.json().catch(() => null);
         if (!r.ok)
@@ -5050,7 +5060,7 @@ export function solanaApp({
       const slot = await slotNow();
       const time = BigInt(now());
       const chainTime = await chainNow();
-      for (const { pubkey, account } of await client.programAccounts(loot.LOOT_PROGRAM, [
+      for (const { pubkey, account } of await client.programAccounts(loot.lootProgram(), [
         tag('Order'),
         at(1, project),
         at(33, me),
@@ -5068,7 +5078,7 @@ export function solanaApp({
             says: 'A roll you won (a mission’s, a recipe’s, a prize’s): ask for it and see what it gives (one whose box has nothing left to give waits until it has).',
           });
       }
-      for (const { pubkey, account } of await client.programAccounts(loot.LOOT_PROGRAM, [
+      for (const { pubkey, account } of await client.programAccounts(loot.lootProgram(), [
         tag('Contest'),
         at(1, project),
       ])) {
@@ -5076,7 +5086,7 @@ export function solanaApp({
         const off = loot.contestOff(contest, time);
         if (!(off || contest.verdict === 'Won')) continue;
         const list = await client.account(loot.contestEntries(pubkey, contest));
-        const entries = list?.owner === loot.LOOT_PROGRAM ? loot.decodeEntries(list.data) : [];
+        const entries = list?.owner === loot.lootProgram() ? loot.decodeEntries(list.data) : [];
         const entry = entries.find(e => e.player === me);
         if (!entry) continue;
         const won = !off && Number(contest.winner) === Number(entry.side);
@@ -5134,7 +5144,7 @@ export function solanaApp({
       // wallet made: one search of the project's holds finds them all.
       const g = await projectNow();
       const holdsOf = [me, ...(g.treasury === me ? [project] : [])];
-      const holds = (await client.programAccounts(loot.LOOT_PROGRAM, [tag('Hold'), at(1, project)]))
+      const holds = (await client.programAccounts(loot.lootProgram(), [tag('Hold'), at(1, project)]))
         .map(({ pubkey, account }) => ({ pubkey, hold: loot.decode('Hold', account.data) }))
         .filter(({ hold }) => holdsOf.includes(hold.player) || hold.debt?.lender === me);
       // Whether the project still holds each one's NFT: whoever controls its collection can take it back or burn it.
@@ -5157,7 +5167,7 @@ export function solanaApp({
           out.push({ ...claim, says: 'A loan you made is overdue and unpaid: take its NFT.' });
       }
       // A compressed NFT's proof record this wallet paid for and left open: closing it brings its rent back.
-      for (const { account } of await client.programAccounts(loot.LOOT_PROGRAM, [tag('Proven')])) {
+      for (const { account } of await client.programAccounts(loot.lootProgram(), [tag('Proven')])) {
         const leaf = (() => {
           try {
             return loot.decodeProven(account.data);
@@ -5335,7 +5345,7 @@ export function solanaApp({
           out.push({ kind: 'vest', key: sc.key, says: `What has vested of “${sc.name ?? sc.key}”: claim it.` });
       }
       // The player's listings whose rental is over: their NFT can go home (or wait for the next renter).
-      const mineListed = await client.programAccounts(loot.LOOT_PROGRAM, [tag('Listing'), at(1, project), at(33, me)]);
+      const mineListed = await client.programAccounts(loot.lootProgram(), [tag('Listing'), at(1, project), at(33, me)]);
       for (const { account } of mineListed) {
         const listing = loot.decode('Listing', account.data);
         if (listing.deal.Rent && listing.user !== NOBODY && !loot.renterOf(listing, chainTime))
@@ -5535,7 +5545,7 @@ export function solanaApp({
         : await read('Lottery', loot.pda.lottery(project, l.id));
       const key = c.round ?? loot.currentRound(loot.pda.lottery(project, l.id), lottery);
       const found = await client.account(key);
-      const r = found?.owner === loot.LOOT_PROGRAM ? loot.decodeRound(found.data) : null;
+      const r = found?.owner === loot.lootProgram() ? loot.decodeRound(found.data) : null;
       // The ask: the current round's once due, or an older round's again (after the timeout, it cancels the round).
       if (c.kind === 'reveal' || c.kind === 'cancel-draw') {
         const steps = await drawStep(l, lottery, c.round ?? null, r, me);
@@ -5617,7 +5627,7 @@ export function solanaApp({
       const carryOn = async signature => {
         if (build || !partial) return signature;
         const after = await client.account(key);
-        const r2 = after?.owner === loot.LOOT_PROGRAM ? loot.decodeRound(after.data) : null;
+        const r2 = after?.owner === loot.lootProgram() ? loot.decodeRound(after.data) : null;
         const moved = r2 && (Number(r2.assigned) > Number(r.assigned) || Number(r2.owed) < Number(r.owed));
         if (!moved) return signature;
         const left =

package/js/play/sponsor.js

@@ -36,7 +36,7 @@ import { transferLamports } from '../chain/programs.js';
 import { encodeBase58 } from '../chain/base58.js';
 import { fromBase64, toBase64 } from '../chain/bytes.js';
 import { readMessage, readTransaction, withSignature } from '../chain/tx.js';
-import { LOOT_PROGRAM, MPL_CORE_PROGRAM, pda, VRF_PROGRAM } from '../client/index.js';
+import { lootProgram, MPL_CORE_PROGRAM, pda, VRF_PROGRAM } from '../client/index.js';
 
 const SYSTEM_PROGRAM = '11111111111111111111111111111111';
 /** What a signature costs the fee payer, in lamports. */
@@ -82,7 +82,7 @@ export function sponsoredCost({ addresses, pre, post, project, skip = [], progra
     }
     if (before) continue;
     const opened =
-      after.owner === LOOT_PROGRAM ||
+      after.owner === lootProgram() ||
       (after.owner === MPL_CORE_PROGRAM && !programs.includes(MPL_CORE_PROGRAM)) ||
       ((after.owner === TOKEN_PROGRAM || after.owner === TOKEN_2022_PROGRAM) &&
         after.data?.length >= 32 &&
@@ -97,7 +97,7 @@ export function stepShape(instructions) {
   return {
     programs: [...new Set(instructions.map(ix => ix.programId))],
     lootNamed: [
-      ...new Set(instructions.filter(ix => ix.programId === LOOT_PROGRAM).flatMap(ix => ix.keys.map(k => k.pubkey))),
+      ...new Set(instructions.filter(ix => ix.programId === lootProgram()).flatMap(ix => ix.keys.map(k => k.pubkey))),
     ],
   };
 }
@@ -180,7 +180,7 @@ export async function checkSponsored(
     if (program === COMPUTE_BUDGET_PROGRAM && ix.data[0] === 2 && ix.data.length >= 5)
       units = BigInt(u32At(ix.data, 1));
     if (program === COMPUTE_BUDGET_PROGRAM && ix.data[0] === 3 && ix.data.length >= 9) price = u64At(ix.data, 1);
-    if (program === LOOT_PROGRAM && accounts.includes(project)) ours = true;
+    if (program === lootProgram() && accounts.includes(project)) ours = true;
   }
   if (!ours) return no('It does nothing in this project.');
   if (price > BigInt(maxPriorityMicroLamports)) return no('Its priority fee is more than this sponsor pays.');

package/js/results/index.js

@@ -22,6 +22,7 @@ import { decodeBase58, encodeBase58 } from '../chain/base58.js';
 import { toHex } from '../chain/bytes.js';
 import { pda, voucherBytes } from '../client/index.js';
 import { canonicalJson, drawText, entryText, lockText, resultBytes, rosterHash } from './wire.js';
+import { cluster as onCluster } from '../client/cluster.js';
 
 export {
   canonicalJson,
@@ -40,7 +41,7 @@ export {
   rosterHash,
 } from './wire.js';
 
-/** xgames.fun's results server, on its play host (devnet until the program's audit). */
+/** xgames.fun's results server, on its play host. One host answers for devnet and for mainnet: each request names its cluster. */
 export const RESULTS_SERVER = 'https://play.xgames.fun/xsolana';
 
 const subtle = () => globalThis.crypto.subtle;
@@ -112,7 +113,7 @@ function base64url(text) {
 }
 
 /** One signer's signature of a result: { key, signature }. `signer` is a key from newKey, or anything with sign(). */
-export async function signResult(signer, result, cluster = 'devnet') {
+export async function signResult(signer, result, cluster = onCluster()) {
   return { key: signer.address, signature: encodeBase58(await signer.sign(resultBytes({ ...result, cluster }))) };
 }
 
@@ -129,12 +130,12 @@ export async function report({
   round,
   endedAt,
   winners,
-  cluster = 'devnet',
+  cluster = onCluster(),
   fetchImpl = globalThis.fetch,
 }) {
   const result = { game, round, endedAt, winners };
   const all = [await signResult(signer, result, cluster)];
-  const response = await fetchImpl(`${server.replace(/\/$/, '')}/v1/results`, {
+  const response = await fetchImpl(serverUrl(server, '/v1/results', cluster), {
     method: 'POST',
     headers: { 'content-type': 'application/json' },
     body: JSON.stringify({ ...result, cert, signatures: all }),
@@ -164,9 +165,16 @@ async function answerOf(response) {
 }
 
 /** A wallet's vouchers for a round it won: [{ grant, publicKey, signature, round, expires, … }]. */
-export async function fetchVouchers({ server, game, round, wallet, fetchImpl = globalThis.fetch }) {
+export async function fetchVouchers({
+  server,
+  game,
+  round,
+  wallet,
+  cluster = onCluster(),
+  fetchImpl = globalThis.fetch,
+}) {
   const response = await fetchImpl(
-    `${server.replace(/\/$/, '')}/v1/vouchers?game=${q(game)}&round=${q(round)}&wallet=${q(wallet)}`,
+    serverUrl(server, `/v1/vouchers?game=${q(game)}&round=${q(round)}&wallet=${q(wallet)}`, cluster),
   );
   return (await answerOf(response)).vouchers;
 }
@@ -225,9 +233,19 @@ export async function signVoucher({
   };
 }
 
+/**
+ * A path on a results server, for the cluster the request is on. One server answers for both clusters, and a request
+ * that names none is devnet's: so nothing is added on devnet (as every request was before), and `cluster=mainnet` on
+ * mainnet.
+ */
+export function serverUrl(server, path, cluster = onCluster()) {
+  const url = `${String(server).replace(/\/$/, '')}${path}`;
+  return cluster === 'devnet' ? url : `${url}${url.includes('?') ? '&' : '?'}cluster=${encodeURIComponent(cluster)}`;
+}
+
 /** Posts JSON to the server and answers its body, or throws its { code, why }. */
-async function post(server, path, body, fetchImpl) {
-  const response = await fetchImpl(`${server.replace(/\/$/, '')}${path}`, {
+async function post(server, path, body, fetchImpl, cluster = onCluster()) {
+  const response = await fetchImpl(serverUrl(server, path, cluster), {
     method: 'POST',
     headers: { 'content-type': 'application/json' },
     body: JSON.stringify(body),
@@ -236,7 +254,8 @@ async function post(server, path, body, fetchImpl) {
 }
 
 /** Gets JSON from the server and answers its body, or throws its { code, why }. */
-const fetchJson = async (server, path, fetchImpl) => answerOf(await fetchImpl(`${server.replace(/\/$/, '')}${path}`));
+const fetchJson = async (server, path, fetchImpl, cluster = onCluster()) =>
+  answerOf(await fetchImpl(serverUrl(server, path, cluster)));
 
 /**
  * A draw, from the organizer's side and the players'. `signMessage(text) → signature bytes` is the organizer's wallet
@@ -274,16 +293,17 @@ export const draws = {
     token = null,
     wallet = null,
     signMessage = null,
-    cluster = 'devnet',
+    cluster = onCluster(),
     fetchImpl = globalThis.fetch,
   }) => {
-    if (token) return post(server, `/v1/draws/${seg(game)}/${seg(draw)}/entries`, { token }, fetchImpl);
+    if (token) return post(server, `/v1/draws/${seg(game)}/${seg(draw)}/entries`, { token }, fetchImpl, cluster);
     const text = entryText({ cluster, game, draw });
     return post(
       server,
       `/v1/draws/${seg(game)}/${seg(draw)}/entries`,
       { wallet, text, signature: encodeBase58(await signMessage(new TextEncoder().encode(text))) },
       fetchImpl,
+      cluster,
     );
   },
   /** Locks the players the server holds now to `beacon`, a drand round still to come. Checks their hash itself. */
@@ -295,11 +315,11 @@ export const draws = {
     signMessage,
     by,
     cert = null,
-    cluster = 'devnet',
+    cluster = onCluster(),
     net = 'quicknet',
     fetchImpl = globalThis.fetch,
   }) => {
-    const { draw: view } = await fetchJson(server, `/v1/draws/${seg(game)}/${seg(draw)}`, fetchImpl);
+    const { draw: view } = await fetchJson(server, `/v1/draws/${seg(game)}/${seg(draw)}`, fetchImpl, cluster);
     const text = lockText({
       cluster,
       game,
@@ -319,6 +339,7 @@ export const draws = {
         ...(cert ? { cert } : {}),
       },
       fetchImpl,
+      cluster,
     );
   },
   /** The draw as anyone may check it; settled, with its result, once its beacon round is out. */
@@ -345,7 +366,7 @@ export const giveaways = {
     endedAt,
     winners,
     grant,
-    cluster = 'devnet',
+    cluster = onCluster(),
     fetchImpl = globalThis.fetch,
   }) => {
     const signed = winners.map(w => ({ wallet: w.wallet, place: w.place, grant }));
@@ -357,6 +378,7 @@ export const giveaways = {
       `/v1/giveaways/${seg(game)}/${seg(giveaway)}/result`,
       { endedAt, winners: winners.map(({ wallet, place }) => ({ wallet, place })), signature },
       fetchImpl,
+      cluster,
     );
   },
 };

package/js/results/server.js

@@ -19,6 +19,7 @@ import { MPL_CORE_PROGRAM, ownedAssetFilters, parseCoreAsset } from '../chain/co
 import { rpcClient } from '../chain/rpc.js';
 import { sha256 } from '../chain/sha256.js';
 import { signVoucher } from './index.js';
+import { cluster as onCluster } from '../client/cluster.js';
 
 const subtle = () => globalThis.crypto.subtle;
 const rpcOf = rpc => (typeof rpc === 'string' ? rpcClient(rpc) : rpc);
@@ -70,7 +71,7 @@ const oneLine = (name, value) => {
 };
 
 /** The exact text a wallet signs to prove it is its owner's: fixed lines, so nothing else can be passed off as it. */
-export const proofText = ({ cluster = 'devnet', game, wallet, purpose, nonce, expires }) =>
+export const proofText = ({ cluster = onCluster(), game, wallet, purpose, nonce, expires }) =>
   [
     PROOF_TITLE,
     ...PROOF_FIELDS.map(f => `${f}: ${oneLine(f, { cluster, game, wallet, purpose, nonce, expires }[f])}`),
@@ -83,7 +84,7 @@ export const proofText = ({ cluster = 'devnet', game, wallet, purpose, nonce, ex
  * (unix seconds, `seconds` from now) and takes each nonce once, so a signed proof can't be replayed.
  */
 export function proofRequest({
-  cluster = 'devnet',
+  cluster = onCluster(),
   game,
   wallet,
   purpose = 'sign in',
@@ -127,7 +128,7 @@ export async function verifyProof({
   wallet,
   game,
   purpose = null,
-  cluster = 'devnet',
+  cluster = onCluster(),
   now = Math.floor(Date.now() / 1000),
 }) {
   const fields = readProof(text);

package/js/results/wire.js

@@ -2,6 +2,7 @@
 // with whoever signs them: a host server, a player's game page, an owner's wallet. Browser-safe: no Node imports.
 import { addressBytes } from '../chain/base58.js';
 import { concat, fromHex, uintLE, utf8 } from '../chain/bytes.js';
+import { cluster as onCluster } from '../client/cluster.js';
 
 export const RESULT_DOMAIN = 'loot-result-v1';
 export const NO_GRANT = 0xffff;
@@ -31,10 +32,10 @@ const write = (kind, values) =>
   [CERT_KINDS[kind].title, ...CERT_KINDS[kind].fields.map(f => `${f}: ${field(f, values[f])}`)].join('\n');
 
 /** The text the owner signs to let `host` report `game`'s results until `until` (unix seconds). */
-export const hostCertText = ({ cluster = 'devnet', game, host, until }) =>
+export const hostCertText = ({ cluster = onCluster(), game, host, until }) =>
   write('host', { cluster, game, host, until });
 /** The text the owner signs to take `host` back. */
-export const revokeText = ({ cluster = 'devnet', game, host }) => write('revoke', { cluster, game, host });
+export const revokeText = ({ cluster = onCluster(), game, host }) => write('revoke', { cluster, game, host });
 
 /**
  * The text the organizer (the game's owner or authority, or a host key they certified) signs to open a draw: a round
@@ -45,7 +46,7 @@ export const revokeText = ({ cluster = 'devnet', game, host }) => write('revoke'
  * JSON), or 'default'.
  */
 export const drawText = ({
-  cluster = 'devnet',
+  cluster = onCluster(),
   game,
   draw,
   engine,
@@ -69,19 +70,19 @@ export const drawText = ({
     rates,
   });
 /** The text the organizer signs to lock a draw's players (`roster`: rosterHash) to a beacon round still to come. */
-export const lockText = ({ cluster = 'devnet', game, draw, roster, players, beacon, net = 'quicknet' }) =>
+export const lockText = ({ cluster = onCluster(), game, draw, roster, players, beacon, net = 'quicknet' }) =>
   write('lock', { cluster, game, draw, roster, players, beacon: `${net} ${beacon}` });
 /** The text a player's wallet signs to enter a draw (identity 'wallet'). */
-export const entryText = ({ cluster = 'devnet', game, draw }) => write('entry', { cluster, game, draw });
+export const entryText = ({ cluster = onCluster(), game, draw }) => write('entry', { cluster, game, draw });
 
 /**
  * The text the owner (or authority) signs to appoint a giveaway host: `who` is "x:<X account id>" (the host signs in
  * with that X account through the play host) or a wallet address; their giveaways pay from grant `grant` alone.
  */
-export const giveawayHostText = ({ cluster = 'devnet', game, who, slug, grant, until }) =>
+export const giveawayHostText = ({ cluster = onCluster(), game, who, slug, grant, until }) =>
   write('giveaway', { cluster, game, who, slug, grant, until });
 /** The text the owner (or authority) signs to take a giveaway host back. */
-export const revokeGiveawayText = ({ cluster = 'devnet', game, who }) =>
+export const revokeGiveawayText = ({ cluster = onCluster(), game, who }) =>
   write('revokeGiveaway', { cluster, game, who });
 
 /** A draw's players, as one hash: each `id<TAB>wallet`, sorted by id, one a line; sha256, hex. */
@@ -113,7 +114,7 @@ export function canonicalJson(value) {
  * Every field has one length, so one set of bytes means one result: an unknown cluster, a round that is not 16 bytes, a
  * place past 255 and more than 255 winners are refused, never written as something else.
  */
-export function resultBytes({ cluster = 'devnet', game, round, endedAt, winners }) {
+export function resultBytes({ cluster = onCluster(), game, round, endedAt, winners }) {
   if (!Object.hasOwn(CLUSTERS, cluster))
     throw new RangeError(
       `Unknown cluster ${JSON.stringify(cluster)}: a result names ${Object.keys(CLUSTERS).join(' or ')}.`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xgamesfun/solana",
-  "version": "0.28.1",
+  "version": "0.28.3",
   "mcpName": "io.github.XGamesFun/solana-kit",
   "description": "Loot boxes, gacha, shops, lotteries, auctions, NFT staking, crafting and rewards on Solana without writing a smart contract: one shared program, its JS client, a CLI, and an MCP server and skill so Claude Code, Codex or any AI agent can design, check, simulate and launch an economy.",
   "license": "Apache-2.0",
@@ -80,6 +80,10 @@
     "./mcp/http": {
       "types": "./types/mcp/http.d.mts",
       "default": "./js/mcp/http.mjs"
+    },
+    "./with-cluster": {
+      "types": "./types/mcp/with-cluster.d.mts",
+      "default": "./js/mcp/with-cluster.mjs"
     }
   },
   "sideEffects": [
@@ -102,6 +106,7 @@
   ],
   "scripts": {
     "test": "node --test \"js/test/**/*.test.mjs\"",
+    "test:mainnet": "node scripts/test-mainnet.mjs",
     "lint": "eslint . && prettier --check .",
     "format": "prettier --write .",
     "types": "tsc -p tsconfig.types.json",

package/release.json

@@ -4,5 +4,10 @@
   "sbfBytes": 1794616,
   "sbfSha256": "ac8b09ed2c3a3f7daa2dfab55d2f6dea19fa43e4c98b44a82da2a68a7bc8ebbe",
   "idlSha256": "ef3b8043d62c606e850df75773b4535cdb08206216e17aca653111a77403abd7",
-  "clientSha256": "3ef11453089e952e50d9d5a7199d9629b3417a091a071ea6dfd90f42746a2421"
+  "clientSha256": "164ed8ee25b5a2714f6c8f5de243d6b650ba0741637ee3dd4c2886f15af3a6c5",
+  "mainnet": {
+    "programId": "xgames8C758PyweWB9sDw8evvwsTVwyA2fGRUeAXVPy",
+    "sbfBytes": 1794616,
+    "sbfSha256": "f78e4f0ef38b5f1673936044263293e91172b4bac92c741cc7bb9567617bbdf6"
+  }
 }