@xgamesfun/solana 0.28.1 → 0.28.3

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.3 <guide|examples|check|simulate|cost|explain|review|publish|status> [xsolana.json]`,
+`npx -y @xgamesfun/solana@0.28.3 token <mint>` for a coin made elsewhere,
+or `npx -y @xgamesfun/solana@0.28.3 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.3 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.3 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

package/types/chain/borsh.d.ts

@@ -15,9 +15,11 @@ export declare function isAccount(idl: any, name: any, data: any): boolean;
  * [{ name, data }]. Only lines the program itself printed count: the log names which program each line comes from
  * (`Program <id> invoke [n]` … `success`), and any program can print a line that looks like an event. Logs alone
  * cannot say whether the transaction succeeded (the runtime can fail it after every instruction logged success), so
- * the caller decides that from the transaction's `meta.err` and reads events only when it is null.
+ * the caller decides that from the transaction's `meta.err` and reads events only when it is null. `program` is the
+ * address the program runs at: the IDL's own unless the caller names another (the program has an address of its own on
+ * each cluster, and an IDL holds one).
  */
-export declare function decodeEvents(idl: any, logs: any): {
+export declare function decodeEvents(idl: any, logs: any, program?: any): {
     name: any;
     data: any;
 }[];

package/types/chain/rpc.d.ts

@@ -19,13 +19,19 @@ export declare const GENESIS: Readonly<{
     mainnet: "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d";
     testnet: "4uhcVJyU9pJkvQyS88uRDiswHXSCkY3zQawwpjk2NsNY";
 }>;
+/**
+ * Refuses an RPC URL that names another cluster than the one the caller works on (`devnet` or `mainnet`). Returns the
+ * URL. A URL names nothing for certain: `checkCluster` reads the chain itself.
+ */
+export declare function rightCluster(url: any, cluster?: string): any;
 /** Refuses an RPC URL that names mainnet. Returns the URL. */
-export declare function notMainnet(url: any): any;
+export declare const notMainnet: (url: any) => any;
 /**
- * Refuses a chain that is mainnet or testnet, by its genesis block, whatever its URL says (a local validator is
- * let through). `rpc` has `call`. Returns the genesis hash.
+ * Refuses a chain that is not the cluster the caller works on, by its genesis block, whatever its URL says. On
+ * devnet, mainnet and testnet are refused and a local validator is let through; on mainnet, only mainnet itself
+ * passes. `rpc` has `call`. Returns the genesis hash.
  */
-export declare function checkCluster(rpc: any): Promise<any>;
+export declare function checkCluster(rpc: any, cluster?: string): Promise<any>;
 /** The program's own words for a failed run (`AnchorError … Error Message: …`), else the last error log line. A program
  * built without its errors' text logs the error's name as its message: then the name alone (the client's IDL has
  * the sentence: `loot.lootError`). */

package/types/client/cluster.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Each cluster: loot's program there (devnet's is the IDL's own address), the chain as a wallet names it (Wallet
+ * Standard), and the RPC used when none is given. Mainnet has none: its public RPC refuses or limits what loot reads
+ * (a program's accounts, a compressed NFT's proof), so a mainnet RPC is always named (XSOLANA_RPC_URL, or `rpcUrl`).
+ */
+export declare const CLUSTERS: Readonly<{
+    devnet: Readonly<{
+        program: string;
+        chain: "solana:devnet";
+        rpc: "https://api.devnet.solana.com";
+    }>;
+    mainnet: Readonly<{
+        program: "xgames8C758PyweWB9sDw8evvwsTVwyA2fGRUeAXVPy";
+        chain: "solana:mainnet";
+        rpc: null;
+    }>;
+}>;
+/**
+ * loot's program on this process's own cluster. A live binding: it follows `useCluster`. It knows nothing of
+ * `withCluster`: code that may run for either cluster asks `lootProgram()`, as the client itself does.
+ * @type {string}
+ */
+export declare let LOOT_PROGRAM: string;
+/**
+ * For a server's own set-up (js/mcp/with-cluster.mjs does it): `current()` answers the cluster of the work being done now,
+ * or nothing outside any. While it answers one, the client is on that cluster.
+ * @param {(() => string | undefined | null) | null} current
+ */
+export declare function scopeClusters(current: (() => string | undefined | null) | null): void;
+/**
+ * Names the cluster this process works on (`devnet` or `mainnet`) and returns it. Call it first, before any address
+ * is derived: it throws when the process already works on another cluster. Inside `withCluster` it names nothing: it
+ * throws unless the cluster named is the one that work is on.
+ * @param {'devnet' | 'mainnet'} cluster
+ * @returns {'devnet' | 'mainnet'}
+ */
+export declare function useCluster(cluster: 'devnet' | 'mainnet'): 'devnet' | 'mainnet';
+/**
+ * The cluster the client works on now: inside `withCluster` that work's, else the process's own (asking settles it).
+ * @returns {'devnet' | 'mainnet'}
+ */
+export declare function cluster(): 'devnet' | 'mainnet';
+/**
+ * loot's program on the cluster the client works on now (`cluster()`): what derives an address, builds an
+ * instruction or reads who owns an account calls this.
+ * @returns {string}
+ */
+export declare function lootProgram(): string;
+/** Whether the client works on mainnet now: what is paid and won there is real money. */
+export declare const realMoney: () => boolean;
+/** The cluster an economy is on: the `network` its file names, devnet when it names none. */
+export declare const networkOf: (economy: any) => any;
+/**
+ * The RPC URL this process reads and sends through: the one given, else XSOLANA_RPC_URL, else the cluster's own
+ * (devnet's public RPC; mainnet has none). A URL that names another cluster is refused.
+ */
+export declare function clusterRpcUrl(url?: any): any;
+/** Refuses a chain that is not this process's cluster, by its genesis block (`rpc.js`, `checkCluster`). */
+export declare const checkOnCluster: (rpc: any) => Promise<any>;
+/** This process's cluster as a wallet names it (Wallet Standard): `solana:devnet` or `solana:mainnet`. */
+export declare const walletChain: () => "solana:devnet" | "solana:mainnet";

package/types/client/idl/loot.d.ts

@@ -3613,8 +3613,8 @@ declare const _default: {
                     };
                 }[];
             } | {
-                fields?: undefined;
                 name: string;
+                fields?: undefined;
             })[];
             fields?: undefined;
         };
@@ -3862,7 +3862,6 @@ declare const _default: {
         name: string;
         docs: string[];
         type: {
-            fields?: undefined;
             kind: string;
             variants: ({
                 name: string;
@@ -3888,6 +3887,7 @@ declare const _default: {
                     type: string;
                 })[];
             })[];
+            fields?: undefined;
         };
     } | {
         name: string;
@@ -4041,11 +4041,11 @@ declare const _default: {
         docs?: undefined;
         name: string;
         type: {
-            fields?: undefined;
             kind: string;
             variants: {
                 name: string;
             }[];
+            fields?: undefined;
         };
     } | {
         name: string;
@@ -4378,7 +4378,6 @@ declare const _default: {
         name: string;
         docs: string[];
         type: {
-            fields?: undefined;
             kind: string;
             variants: ({
                 name: string;
@@ -4397,9 +4396,10 @@ declare const _default: {
                 name: string;
                 fields: string[];
             } | {
-                fields?: undefined;
                 name: string;
+                fields?: undefined;
             })[];
+            fields?: undefined;
         };
     } | {
         name: string;
@@ -4485,11 +4485,10 @@ declare const _default: {
         name: string;
         docs: string[];
         type: {
-            fields?: undefined;
             kind: string;
             variants: ({
-                fields?: undefined;
                 name: string;
+                fields?: undefined;
             } | {
                 name: string;
                 fields: string[];
@@ -4502,16 +4501,16 @@ declare const _default: {
                     };
                 }[];
             })[];
+            fields?: undefined;
         };
     } | {
         name: string;
         docs: string[];
         type: {
-            fields?: undefined;
             kind: string;
             variants: ({
-                fields?: undefined;
                 name: string;
+                fields?: undefined;
             } | {
                 name: string;
                 fields: string[];
@@ -4524,6 +4523,7 @@ declare const _default: {
                     };
                 }[];
             })[];
+            fields?: undefined;
         };
     })[];
     constants: ({

package/types/client/pda.d.ts

@@ -1,5 +1,5 @@
 import { MPL_CORE_PROGRAM } from '../chain/pda.js';
-export declare const LOOT_PROGRAM: string;
+export { checkOnCluster, CLUSTERS, cluster, clusterRpcUrl, LOOT_PROGRAM, lootProgram, networkOf, realMoney, scopeClusters, useCluster, walletChain, } from './cluster.js';
 /** MagicBlock's VRF program and its default queue, the only queue the program accepts. */
 export declare const VRF_PROGRAM = "Vrf1RNUjXmQGjmQrQLvJHs9SNkvDJEsRVFPkfSQUwGz";
 export declare const VRF_QUEUE = "Cuj97ggrhhidhbu39TijNVqE74xvKJ69gDervRUXAxGh";

package/types/economy/check.d.mts

@@ -93,8 +93,7 @@ export declare function dateWords(seconds: any): string;
  * (`ASSUMED_TRIES`).
  * Returns { ok, refusals: [{ code, where, message, fix }], warnings: [{ code, where, message, fix? }] }.
  */
-export declare function check(economy: any, { network, now, project }?: {
-    network?: string | undefined;
+export declare function check(economy: any, { now, project }?: {
     now?: number | undefined;
     project?: any;
 }): {

package/types/economy/plan.d.mts

@@ -30,11 +30,11 @@ export declare function tableBatches(t: any): never[][];
 export declare function partPrize(o: any, m: any): "Raffled" | {
     Stash: any[];
 } | {
+    Item?: undefined;
     Compressed: {
         item: any;
         tree: string;
     };
-    Item?: undefined;
     Held?: undefined;
     Nft?: undefined;
     Roll?: undefined;
@@ -137,8 +137,8 @@ export declare function boxArgs(b: any, m: any): {
                 Item: any[];
                 Collection?: undefined;
             } | {
-                Collection: any[];
                 Item?: undefined;
+                Collection: any[];
             };
             key: any;
             test: any;
@@ -159,8 +159,8 @@ export declare function boxArgs(b: any, m: any): {
             Item: any[];
             Collection?: undefined;
         } | {
-            Collection: any[];
             Item?: undefined;
+            Collection: any[];
         };
         key: any;
         test: any;
@@ -341,11 +341,11 @@ export declare function scheduleArgs(s: any, m: any): {
  * of the pool), an item (a compressed NFT of it into the project's tree, "@tree"), one NFT of a stash, or a roll of a box.
  */
 export declare function prizeArgs(p: any, m: any): "Raffled" | {
+    Item?: undefined;
     Compressed: {
         item: any;
         tree: string;
     };
-    Item?: undefined;
     Held?: undefined;
     Nft?: undefined;
     Roll?: undefined;
@@ -464,8 +464,8 @@ export declare function lotteryArgs(l: any, m: any): {
                     Item: any[];
                     Collection?: undefined;
                 } | {
-                    Collection: any[];
                     Item?: undefined;
+                    Collection: any[];
                 };
                 key: any;
                 test: any;
@@ -514,8 +514,8 @@ export declare function lotteryArgs(l: any, m: any): {
                 Item: any[];
                 Collection?: undefined;
             } | {
-                Collection: any[];
                 Item?: undefined;
+                Collection: any[];
             };
             key: any;
             test: any;
@@ -608,8 +608,8 @@ export declare function contestArgs(c: any, m: any, at?: any): {
                 Item: any[];
                 Collection?: undefined;
             } | {
-                Collection: any[];
                 Item?: undefined;
+                Collection: any[];
             };
             key: any;
             test: any;
@@ -619,11 +619,11 @@ export declare function contestArgs(c: any, m: any, at?: any): {
     min_pot: bigint;
     stake: bigint;
     prize: string | {
+        Item?: undefined;
         Compressed: {
             item: any;
             tree: string;
         };
-        Item?: undefined;
         Held?: undefined;
         Nft?: undefined;
         Roll?: undefined;
@@ -682,8 +682,8 @@ export declare function contestArgs(c: any, m: any, at?: any): {
             Item: any[];
             Collection?: undefined;
         } | {
-            Collection: any[];
             Item?: undefined;
+            Collection: any[];
         };
         key: any;
         test: any;
@@ -700,8 +700,8 @@ export declare function farmArgs(f: any, m: any): {
             Item: any[];
             Collection?: undefined;
         } | {
-            Collection: any[];
             Item?: undefined;
+            Collection: any[];
         };
         key: any;
         test: any;
@@ -780,8 +780,8 @@ export declare function auctionArgs(a: any, m: any): {
                 Item: any[];
                 Collection?: undefined;
             } | {
-                Collection: any[];
                 Item?: undefined;
+                Collection: any[];
             };
             key: any;
             test: any;
@@ -792,8 +792,8 @@ export declare function auctionArgs(a: any, m: any): {
             Item: any[];
             Collection?: undefined;
         } | {
-            Collection: any[];
             Item?: undefined;
+            Collection: any[];
         };
         key: any;
         test: any;
@@ -801,11 +801,11 @@ export declare function auctionArgs(a: any, m: any): {
 };
 export declare function grantArgs(g: any, m: any): {
     gives: string | {
+        Item?: undefined;
         Compressed: {
             item: any;
             tree: string;
         };
-        Item?: undefined;
         Held?: undefined;
         Nft?: undefined;
         Roll?: undefined;
@@ -911,8 +911,8 @@ export declare function grantArgs(g: any, m: any): {
                 Item: any[];
                 Collection?: undefined;
             } | {
-                Collection: any[];
                 Item?: undefined;
+                Collection: any[];
             };
             key: any;
             test: any;

package/types/mcp/server.d.mts

@@ -352,7 +352,7 @@ export declare function runTool(name: any, input?: {}, ctx?: {}): Promise<{
     text: string;
 } | {
     program: string;
-    cluster: "devnet";
+    cluster: "devnet" | "mainnet";
     version: string;
     idl: "@xgamesfun/solana/idl.json";
     package: `@xgamesfun/solana@${any}`;

package/types/mcp/tools.d.mts

@@ -22,12 +22,14 @@ export declare function approveCommand(file?: string, paths?: any): string;
 export declare function keyFileFor(name: any): string;
 /** The command that makes a project's key file (it prints the key's address, never the key). */
 export declare const keygenCommand: (keyFile: any) => string;
-export declare const CLUSTER = "devnet";
 export declare const DEVNET_RPC = "https://api.devnet.solana.com";
-/** What every answer carries, so an agent never has to remember the program's address. */
+/**
+ * What every answer carries, so an agent never has to remember the program's address. The program and the cluster are
+ * read when asked for: this process's cluster (`client/cluster.js`).
+ */
 export declare const PROGRAM_INFO: Readonly<{
-    program: string;
-    cluster: "devnet";
+    readonly program: string;
+    readonly cluster: "devnet" | "mainnet";
     version: string;
     idl: "@xgamesfun/solana/idl.json";
     package: `@xgamesfun/solana@${any}`;
@@ -90,7 +92,7 @@ export declare const tools: ({
     };
     handler({ part }?: Readonly<Record<string, any>>): Promise<{
         program: string;
-        cluster: "devnet";
+        cluster: "devnet" | "mainnet";
         version: string;
         idl: "@xgamesfun/solana/idl.json";
         package: `@xgamesfun/solana@${any}`;
@@ -743,10 +745,10 @@ export declare const tools: ({
         additionalProperties: boolean;
     };
     handler(input: any, ctx: any): Promise<{
+        token?: undefined;
         mint?: undefined;
         ok: boolean;
         text: string;
-        token?: undefined;
     } | {
         mint?: undefined;
         ok: boolean;
@@ -823,7 +825,7 @@ export declare const tools: ({
     };
     handler(): Promise<{
         program: string;
-        cluster: "devnet";
+        cluster: "devnet" | "mainnet";
         version: string;
         idl: "@xgamesfun/solana/idl.json";
         package: `@xgamesfun/solana@${any}`;

package/types/mcp/with-cluster.d.mts

@@ -0,0 +1,8 @@
+/**
+ * Runs `fn` on `cluster` (`devnet` or `mainnet`) and returns what it returns. A cluster loot does not know is refused.
+ * @template T
+ * @param {'devnet' | 'mainnet'} cluster
+ * @param {() => T} fn
+ * @returns {T}
+ */
+export declare function withCluster<T>(cluster: 'devnet' | 'mainnet', fn: () => T): T;

package/types/play/index.d.ts

@@ -4,7 +4,7 @@ export { checkSponsored, httpSponsor, sponsoredCost, sponsorGiveBack, sponsorHan
  * `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 declare function walletStandardSigner(wallet: any, account: any, chain?: string): {
+export declare function walletStandardSigner(wallet: any, account: any, chain?: "solana:devnet" | "solana:mainnet"): {
     address: any;
     signTransaction(wire: any): Promise<any>;
     signMessage?: ((message: any) => Promise<any>) | undefined;
@@ -34,7 +34,7 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
     now?: (() => number) | undefined;
     programs?: {} | undefined;
     rpc?: null | undefined;
-    rpcUrl?: string | undefined;
+    rpcUrl?: null | undefined;
     spec: any;
     sponsor?: null | undefined;
     wallet: any;

package/types/results/index.d.ts

@@ -1,5 +1,5 @@
 export { canonicalJson, CERT_KINDS, CLUSTERS, drawText, entryText, giveawayHostText, hostCertText, lockText, NO_GRANT, RESULT_DOMAIN, resultBytes, revokeGiveawayText, revokeText, 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 declare const RESULTS_SERVER = "https://play.xgames.fun/xsolana";
 /** A fresh round id: 16 random bytes, in hex. Make it when the round starts. */
 export declare const newRound: () => string;
@@ -19,7 +19,7 @@ export declare function keyFromSecret(secret: any): Promise<{
     sign: (message: any) => Promise<Uint8Array<ArrayBuffer>>;
 }>;
 /** One signer's signature of a result: { key, signature }. `signer` is a key from newKey, or anything with sign(). */
-export declare function signResult(signer: any, result: any, cluster?: string): Promise<{
+export declare function signResult(signer: any, result: any, cluster?: "devnet" | "mainnet"): Promise<{
     key: any;
     signature: string;
 }>;
@@ -30,7 +30,7 @@ export declare function signResult(signer: any, result: any, cluster?: string):
  */
 export declare function report({ server, cert, signer, game, round, endedAt, winners, cluster, fetchImpl, }: {
     cert: any;
-    cluster?: string | undefined;
+    cluster?: "devnet" | "mainnet" | undefined;
     endedAt: any;
     fetchImpl?: typeof fetch | undefined;
     game: any;
@@ -40,7 +40,8 @@ export declare function report({ server, cert, signer, game, round, endedAt, win
     winners: any;
 }): Promise<any>;
 /** A wallet's vouchers for a round it won: [{ grant, publicKey, signature, round, expires, … }]. */
-export declare function fetchVouchers({ server, game, round, wallet, fetchImpl }: {
+export declare function fetchVouchers({ server, game, round, wallet, cluster, fetchImpl, }: {
+    cluster?: "devnet" | "mainnet" | undefined;
     fetchImpl?: typeof fetch | undefined;
     game: any;
     round: any;
@@ -80,6 +81,12 @@ export declare function signVoucher({ signer, game, grant, incarnation, wallet,
     personHash: string;
     amount: string;
 }>;
+/**
+ * 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 declare function serverUrl(server: any, path: any, cluster?: "devnet" | "mainnet"): string;
 /**
  * A draw, from the organizer's side and the players'. `signMessage(text) → signature bytes` is the organizer's wallet
  * (its signMessage) or a host key's sign; `by` its address; `cert` the owner's host certificate when `by` is a host key.
@@ -96,7 +103,7 @@ export declare const draws: {
     }) => Promise<any>;
     /** A player enters with their play-host token, or with their wallet's signature (`wallet`, `signMessage`). */
     enter: ({ server, game, draw, token, wallet, signMessage, cluster, fetchImpl, }: {
-        cluster?: string | undefined;
+        cluster?: "devnet" | "mainnet" | undefined;
         draw: any;
         fetchImpl?: typeof fetch | undefined;
         game: any;
@@ -110,7 +117,7 @@ export declare const draws: {
         beacon: any;
         by: any;
         cert?: null | undefined;
-        cluster?: string | undefined;
+        cluster?: "devnet" | "mainnet" | undefined;
         draw: any;
         fetchImpl?: typeof fetch | undefined;
         game: any;
@@ -142,7 +149,7 @@ export declare const giveaways: {
     }) => Promise<any>;
     /** Reports its result, signed by its session key. `grant`: the host's grant (each winner is paid from it). */
     report: ({ server, game, giveaway, session, endedAt, winners, grant, cluster, fetchImpl, }: {
-        cluster?: string | undefined;
+        cluster?: "devnet" | "mainnet" | undefined;
         endedAt: any;
         fetchImpl?: typeof fetch | undefined;
         game: any;

package/types/results/server.d.ts

@@ -35,7 +35,7 @@ export declare function holds({ rpc, spec, wallet, item, atLeast, attribute, min
 }): Promise<number>;
 /** 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 declare const proofText: ({ cluster, game, wallet, purpose, nonce, expires }: {
-    cluster?: string | undefined;
+    cluster?: "devnet" | "mainnet" | undefined;
     expires: any;
     game: any;
     nonce: any;
@@ -47,7 +47,7 @@ export declare const proofText: ({ cluster, game, wallet, purpose, nonce, expire
  * (unix seconds, `seconds` from now) and takes each nonce once, so a signed proof can't be replayed.
  */
 export declare function proofRequest({ cluster, game, wallet, purpose, seconds, now, }: {
-    cluster?: string | undefined;
+    cluster?: "devnet" | "mainnet" | undefined;
     game: any;
     now?: number | undefined;
     purpose?: string | undefined;
@@ -69,7 +69,7 @@ export declare function readProof(text: any): {
  * `fields.nonce` against the ones the server handed out and not yet used.
  */
 export declare function verifyProof({ text, signature, wallet, game, purpose, cluster, now, }: {
-    cluster?: string | undefined;
+    cluster?: "devnet" | "mainnet" | undefined;
     game: any;
     now?: number | undefined;
     purpose?: null | undefined;