@xgamesfun/solana 0.28.1 → 0.28.2

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) };
       });
@@ -5050,7 +5055,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 +5073,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 +5081,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 +5139,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 +5162,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 +5340,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 +5540,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 +5622,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,7 +130,7 @@ export async function report({
   round,
   endedAt,
   winners,
-  cluster = 'devnet',
+  cluster = onCluster(),
   fetchImpl = globalThis.fetch,
 }) {
   const result = { game, round, endedAt, winners };
@@ -274,7 +275,7 @@ 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);
@@ -295,7 +296,7 @@ export const draws = {
     signMessage,
     by,
     cert = null,
-    cluster = 'devnet',
+    cluster = onCluster(),
     net = 'quicknet',
     fetchImpl = globalThis.fetch,
   }) => {
@@ -345,7 +346,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 }));

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.2",
   "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"
+  }
 }

package/skills/xsolana-economy/SKILL.md

@@ -8,11 +8,12 @@ description: Build a web3, token or NFT economy on Solana without writing a smar
 An economy is one JSON spec (`xsolana.json` in the project) on **loot**, a Solana program every project shares. Nobody
 writes or deploys a contract: the spec is checked, simulated and priced by the `xsolana_*` tools, and it goes live
 signed by a key file on the owner's own machine, once they have read what will be sent and said yes. It runs on
-**devnet** until the program is audited.
+**devnet**, where nothing is real money, and on **mainnet**, where everything is: an economy is on devnet unless its
+file says `"network": "mainnet"`.
 
-The tools are the `xsolana_*` MCP tools. Without MCP, the same from a terminal: `npx -y @xgamesfun/solana@0.28.1 <guide|examples|check|simulate|cost|explain|review|publish|status> [xsolana.json]`,
-`npx -y @xgamesfun/solana@0.28.1 token <mint>` for a coin made elsewhere,
-or `npx -y @xgamesfun/solana@0.28.1 tool <name> '<json>'` for any tool (always with the exact version).
+The tools are the `xsolana_*` MCP tools. Without MCP, the same from a terminal: `npx -y @xgamesfun/solana@0.28.2 <guide|examples|check|simulate|cost|explain|review|publish|status> [xsolana.json]`,
+`npx -y @xgamesfun/solana@0.28.2 token <mint>` for a coin made elsewhere,
+or `npx -y @xgamesfun/solana@0.28.2 tool <name> '<json>'` for any tool (always with the exact version).
 
 ## Rules (always)
 
@@ -33,7 +34,10 @@ or `npx -y @xgamesfun/solana@0.28.1 tool <name> '<json>'` for any tool (always w
    owner: whoever can read it controls the project. Never open it, copy it or print it, and never put it in a chat, a
    spec, a repository or a page. Never ask for a seed phrase or the key of a wallet the person already has; if they
    paste one, tell them to treat it as exposed and move its funds, and write it nowhere.
-3. **Devnet only.** Nothing here is real money yet; say so.
+3. **Devnet first; mainnet only on the person's own word.** Build, check and try every economy on devnet, and say
+   that nothing there is real money. Write `"network": "mainnet"` only when the person asks for mainnet in their own
+   words, never to make something feel real. Tell them then, before anything is sent: it is real money, loot has not
+   been independently audited, what is sent can be lost, and what the review and the checker's legal warnings say.
 4. **The checker decides.** Never save or publish a spec with refusals. Fix each refusal the way its `fix` says.
 5. **Numbers come from the tools.** What a box gives back, how long a pool lasts, what going live costs: quote
    `xsolana_simulate`, `xsolana_cost` and `xsolana_explain`, never your own arithmetic. What a player pays is the tools'
@@ -137,7 +141,7 @@ or `npx -y @xgamesfun/solana@0.28.1 tool <name> '<json>'` for any tool (always w
 9. **When they say "put it live"**: `xsolana_publish` lists every step and its cost and gives the commands, which you
    run in the project folder exactly as given (they name the exact version; never drop it):
    - **A new economy gets a key file**, unless the project has one:
-     `npx -y @xgamesfun/solana@0.28.1 keygen ~/.config/xsolana/<name>.json`. Give the person the address it prints. A
+     `npx -y @xgamesfun/solana@0.28.2 keygen ~/.config/xsolana/<name>.json`. Give the person the address it prints. A
      Solana key file they already have and name themselves (`~/.config/solana/id.json`) works the same; never go
      looking for one.
    - **Say what the key file is** before anything is sent: the project's owner, and, unless the spec says otherwise,
@@ -148,11 +152,11 @@ or `npx -y @xgamesfun/solana@0.28.1 tool <name> '<json>'` for any tool (always w
      set `"treasury": "wallet:<address>"` first: it can't be changed through the spec once live. Tell them to back
      the file up themselves (a USB stick, a password manager): if it is lost, nobody can change the economy, decide
      a contest or move what its address holds, and nothing restores it. You never open or copy it.
-   - **Everything the setup takes from the owner must be at the key's address first**: the devnet SOL
-     (`xsolana_cost`), any seed in a coin that already exists, and every NFT a stash, a raffle or an auction names. A
+   - **Everything the setup takes from the owner must be at the key's address first**: the SOL (`xsolana_cost`;
+     devnet SOL for an economy on devnet, real SOL for one on mainnet), any seed in a coin that already exists, and every NFT a stash, a raffle or an auction names. A
      collection they already have needs the key's address as its update authority. If they would rather not move
      those, offer the browser wallet.
-   - **Show it**: `npx -y @xgamesfun/solana@0.28.1 approve xsolana.json --keypair <key file>` prints every step with
+   - **Show it**: `npx -y @xgamesfun/solana@0.28.2 approve xsolana.json --keypair <key file>` prints every step with
      what it pays and trusts, the warnings, the notice and a code, and sends nothing. Give the person that printout as
      it is, not a summary of it, and ask.
    - **On their yes**, the same command with `--yes <code>`. What lands is written back into `xsolana.json`. If it

package/skills/xsolana-economy/references/apps.md

@@ -76,7 +76,8 @@ await app.balances(); // what they hold of each of the economy's tokens
     }
   </script>
   ```
-  Tell the person the one command that starts it, and that it serves on devnet.
+  Tell the person the one command that starts it, and which cluster its economy is on (devnet unless its file says
+  mainnet).
 - **What a roll looks like**: a box of several outcomes is rolled by the oracle a few seconds after the open; `openBox`
   waits for it. Show the player that it is rolling.
 - **A page that closes before the settle**: the SOL its settle key holds is not lost in the same browser (on another device, with nothing stored, it can't be found yet). Build the wallet with

package/skills/xsolana-economy/references/telling-the-person.md

@@ -29,7 +29,7 @@ and the spec differ (a limit, an amount, a key not set yet), change one of them
    a score): "Checking that a player really did it is up to you, on your own server: a game runs in the player's
    browser, and the program trusts the authority's signature."
 6. **Flags for the law, once.** `W-CHANCE-PRIZE`: "Players pay for a chance at money. That is gambling in many places once
-   it is real money; this runs on devnet only." `W-CHANCE-ITEMS`: "Players pay for random items they can resell: some
+   it is real money; this one is on devnet, which is not." (On mainnet: "this one is on mainnet, so it is.") `W-CHANCE-ITEMS`: "Players pay for random items they can resell: some
    places treat that as gambling, and many require the odds to be shown." `W-REVENUE-SHARE`: "Stakers are paid from
    what players spend; regulators look at that when they decide whether a token is a security." `W-TOKEN-SALE`:
    "People pay for a share of a new token; selling a token to raise money is what securities law looks at first."

package/skills/xsolana-economy/references/trust-and-cheating.md

@@ -104,7 +104,7 @@ Run `xsolana_review` and go through what it reports; these are the points behind
 11. **The authority and the treasury.** The owner's wallet alone changes every price, rate, grant, limit and voucher
     key; the authority mints, moves pool funds, decides contests and releases holds, with no caps. On devnet the
     owner's key is the key file the setup was signed with: readable by its user alone, outside any repository, never
-    pasted anywhere. With real money (mainnet is not open) those keys belong in a hardware wallet or a multisig; a
+    pasted anywhere. With real money (an economy on mainnet) those keys belong in a hardware wallet or a multisig; a
     server that signs gets an authority key of its own, never the owner's.
 12. **The page is untrusted.** A page builds the player's transactions, and a cheater builds their own: the program's
     checks are what count, never the page's. Anything the page decides (a score, a reward amount, who won) is only as