@xgamesfun/solana 0.24.0 → 0.25.1

package/types/mcp/tools.d.mts

@@ -451,6 +451,68 @@ export declare const tools: ({
         from: any;
         text: string;
     }>;
+} | {
+    name: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            spec: {
+                type: string;
+                description: string;
+            };
+            file: {
+                type: string;
+                description: string;
+            };
+            example: {
+                type: string;
+                description: string;
+            };
+        };
+        additionalProperties: boolean;
+        required?: undefined;
+    };
+    handler(input: any, ctx: any): Promise<{
+        ok: boolean;
+        from: any;
+        refusals: any;
+        warnings: any;
+        text: string;
+    } | {
+        ok: boolean;
+        from: any;
+        routes: ({
+            kind: string;
+            key: any;
+            name: any;
+            trigger: string;
+            enforced: any[];
+            trusts: any[];
+            trust: any;
+            ceiling: string;
+            feeds: any[];
+        } | {
+            kind: string;
+            key: any;
+            name: any;
+            trigger: string;
+            enforced: any[];
+            trusts: any;
+            trust: null;
+            ceiling: string;
+            feeds: any[];
+        })[];
+        findings: any[];
+        tradeoffs: string;
+        text: string;
+    }>;
 } | {
     name: string;
     annotations: {

package/types/play/index.d.ts

@@ -22,7 +22,7 @@ export declare const units: (amount: any, decimals: any) => bigint;
  * be made again from the wallet's signature is kept, encrypted (`browserStore()` in a browser; null keeps keys in memory
  * only).
  */
-export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, keyStore }: {
+export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, keyStore, }: {
     keyStore?: {
         get: (k: any) => string | null;
         set: (k: any, v: any) => void;
@@ -691,7 +691,9 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
      * nothing but the lottery can take it while a place names it; the winner gets it before any ticket money moves.
      * `price` (whole units of `currency`) a ticket, `drawsAt` (Unix seconds) its one draw, `minSold` the least tickets
      * (fewer: the round is cancelled and refunded), `shares` where the ticket money goes (the seller's own wallet by
-     * default: the treasury). A seller runs it in a project of their own, whose owner they are.
+     * default: the treasury). Its one place takes no money, so it keeps no pot: the round pays from its own ticket
+     * money, and what the shares leave goes to the treasury too. A seller runs it in a project of their own, whose
+     * owner they are.
      */
     raffle(id: any, nft: any, { price, currency, drawsAt, minSold, perWallet, shares, ...others }?: Readonly<Record<string, any>>): Promise<any>;
     /** The raffle's owner takes the NFT back out of lottery `id`'s own stash once nothing promises it (the lottery ended, or no place names it). */
@@ -729,65 +731,60 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
      * collectible to take home, an auction they won (or one off by the clock: their bid back), a lottery place they
      * won, a draw that is due (anyone may reveal it, or ask again when the oracle never answered; it takes 0.0008
      * SOL), and a drawn lottery's unpaid places, which anyone may pay so the next round can open. [{ kind, says, … }];
-     * pass one to `claim`.
+     * a winner's first claim of a contest of tokens carries `potUnits` and `prizeUnits`, its part as the decision wrote
+     * it (base units, as text). Pass one to `claim`.
      */
     claims(): Promise<({
-        key?: undefined;
         tree?: undefined;
         kind: string;
         order: any;
         says: string;
-        id?: undefined;
-        side?: undefined;
         hold?: undefined;
+        key?: undefined;
         round?: undefined;
         pulls?: undefined;
         asset?: undefined;
         table?: undefined;
     } | {
-        key?: undefined;
         tree?: undefined;
         order?: undefined;
         kind: string;
         id: any;
         side: any;
         says: string;
+        potUnits?: string | undefined;
+        prizeUnits?: string | undefined;
         hold?: undefined;
+        key?: undefined;
         round?: undefined;
         pulls?: undefined;
         asset?: undefined;
         table?: undefined;
     } | {
-        key?: undefined;
         tree?: undefined;
         order?: undefined;
-        id?: undefined;
-        side?: undefined;
         kind: string;
         asset: any;
         hold: any;
         says: string;
+        key?: undefined;
         round?: undefined;
         pulls?: undefined;
         table?: undefined;
     } | {
-        key?: undefined;
         order?: undefined;
-        id?: undefined;
-        side?: undefined;
         hold?: undefined;
         kind: string;
         asset: string;
         tree: string;
         says: string;
+        key?: undefined;
         round?: undefined;
         pulls?: undefined;
         table?: undefined;
     } | {
         tree?: undefined;
         order?: undefined;
-        id?: undefined;
-        side?: undefined;
         hold?: undefined;
         kind: string;
         key: any;
@@ -799,8 +796,6 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
     } | {
         tree?: undefined;
         order?: undefined;
-        id?: undefined;
-        side?: undefined;
         hold?: undefined;
         kind: string;
         key: any;
@@ -812,8 +807,6 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
     } | {
         tree?: undefined;
         order?: undefined;
-        id?: undefined;
-        side?: undefined;
         hold?: undefined;
         kind: string;
         key: any;
@@ -823,12 +816,10 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
         asset?: undefined;
         table?: undefined;
     } | {
-        key?: undefined;
         tree?: undefined;
         order?: undefined;
-        id?: undefined;
-        side?: undefined;
         hold?: undefined;
+        key?: undefined;
         round?: undefined;
         pulls?: undefined;
         kind: string;
@@ -836,12 +827,10 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
         says: string;
         table?: undefined;
     } | {
-        key?: undefined;
         tree?: undefined;
         order?: undefined;
-        id?: undefined;
-        side?: undefined;
         hold?: undefined;
+        key?: undefined;
         round?: undefined;
         pulls?: undefined;
         asset?: undefined;

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';
-/** games.fun's results server, on its play host (devnet until the program's audit). */
+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). */
 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;
@@ -28,7 +28,7 @@ export declare function signResult(signer: any, result: any, cluster?: string):
  * with the same result is safe: it is the same answer. Returns the server's answer, { result, vouchers }, or throws its
  * { code, why }.
  */
-export declare function report({ server, cert, signer, game, round, endedAt, winners, cluster, fetchImpl }: {
+export declare function report({ server, cert, signer, game, round, endedAt, winners, cluster, fetchImpl, }: {
     cert: any;
     cluster?: string | undefined;
     endedAt: any;
@@ -58,7 +58,7 @@ export declare function fetchVouchers({ server, game, round, wallet, fetchImpl }
  * Returns { wallet, grant, incarnation, publicKey, signature, round, expires, personHash, amount } for js/play claimGrant,
  * plain JSON (`incarnation` and `amount` as decimal text), so a server can send it as it is.
  */
-export declare function signVoucher({ signer, game, grant, incarnation, wallet, round, now, seconds, personHash, amount }: {
+export declare function signVoucher({ signer, game, grant, incarnation, wallet, round, now, seconds, personHash, amount, }: {
     amount?: bigint | undefined;
     game: any;
     grant: any;
@@ -95,7 +95,7 @@ export declare const draws: {
         signMessage: any;
     }) => 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 }: {
+    enter: ({ server, game, draw, token, wallet, signMessage, cluster, fetchImpl, }: {
         cluster?: string | undefined;
         draw: any;
         fetchImpl?: typeof fetch | undefined;
@@ -106,7 +106,7 @@ export declare const draws: {
         wallet?: null | undefined;
     }) => Promise<any>;
     /** Locks the players the server holds now to `beacon`, a drand round still to come. Checks their hash itself. */
-    lock: ({ server, game, draw, beacon, signMessage, by, cert, cluster, net, fetchImpl }: {
+    lock: ({ server, game, draw, beacon, signMessage, by, cert, cluster, net, fetchImpl, }: {
         beacon: any;
         by: any;
         cert?: null | undefined;
@@ -141,7 +141,7 @@ export declare const giveaways: {
         winners: any;
     }) => 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 }: {
+    report: ({ server, game, giveaway, session, endedAt, winners, grant, cluster, fetchImpl, }: {
         cluster?: string | undefined;
         endedAt: any;
         fetchImpl?: typeof fetch | undefined;
@@ -153,3 +153,4 @@ export declare const giveaways: {
         winners: any;
     }) => Promise<any>;
 };
+export { codeAddresses, codeKey, codeVoucher, collectiblesOf, holds, makeCodes, normalizeCode, proofRequest, proofText, readProof, verifyProof, } from './server.js';

package/types/results/server.d.ts

@@ -0,0 +1,126 @@
+/**
+ * The game's collectibles `wallet` holds now, read from the chain (Metaplex Core assets of the live spec's collection
+ * and of the collections it names): [{ asset, item (its key in the spec, or null), itemId, name, uri, attributes,
+ * frozen }]. `rpc`: an RPC link or a `rpcClient`. Token Metadata and compressed NFTs are not read here.
+ */
+export declare function collectiblesOf({ rpc, spec, wallet }: {
+    rpc: any;
+    spec: any;
+    wallet: any;
+}): Promise<{
+    owner: string;
+    collection: string | null;
+    name: string;
+    uri: string;
+    attributes: {};
+    frozen: boolean;
+    soulbound: boolean;
+    asset: any;
+    itemId: number | null;
+    item: any;
+}[]>;
+/**
+ * Whether `wallet` holds at least `atLeast` of the game's collectible `item` (its key in the spec), or of any of the
+ * game's collectibles when `item` is left out. With `attribute`, only those whose number under it is at least
+ * `minimum` count (a level, a rarity). → the count it holds when that is enough, else 0.
+ */
+export declare function holds({ rpc, spec, wallet, item, atLeast, attribute, minimum }: {
+    atLeast?: number | undefined;
+    attribute?: null | undefined;
+    item?: null | undefined;
+    minimum?: number | undefined;
+    rpc: any;
+    spec: any;
+    wallet: any;
+}): 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;
+    expires: any;
+    game: any;
+    nonce: any;
+    purpose: any;
+    wallet: any;
+}) => string;
+/**
+ * A proof to ask of `wallet`, made by the server: { text, nonce, expires }. The server keeps `nonce` until `expires`
+ * (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;
+    game: any;
+    now?: number | undefined;
+    purpose?: string | undefined;
+    seconds?: number | undefined;
+    wallet: any;
+}): {
+    text: string;
+    nonce: string;
+    expires: number;
+};
+/** A proof text's fields, or null when it is not one. */
+export declare function readProof(text: any): {
+    expires: any;
+} | null;
+/**
+ * Checks a wallet's signed proof: the text is a proof for this `game` (and `purpose`, when given), for `wallet`, not
+ * expired at `now`, and `signature` (base58, or 64 bytes) is that wallet's Ed25519 signature of it. → the proof's
+ * fields ({ wallet, nonce, expires, … }), or throws in words. Taking each nonce once is the caller's: check
+ * `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;
+    game: any;
+    now?: number | undefined;
+    purpose?: null | undefined;
+    signature: any;
+    text: any;
+    wallet: any;
+}): Promise<{
+    expires: any;
+}>;
+/**
+ * `n` fresh promo codes, each `bits` of randomness (80 by default, 16 characters of Crockford base32, in groups of 4).
+ * A code's key is in the spec for anyone to read, so a short code can be found by trying them all offline: fewer than
+ * 64 bits is refused.
+ */
+export declare function makeCodes(n: any, { bits, group }?: {
+    bits?: number | undefined;
+    group?: number | undefined;
+}): string[];
+/** A code as typed, read the forgiving way (Crockford): case, spaces and dashes don't matter, O reads 0, I and L read 1. */
+export declare const normalizeCode: (code: any) => string;
+/** The key a code stands for: { address, sign } (Ed25519, its seed sha256 of the domain and the code). */
+export declare function codeKey(code: any, { domain }?: {
+    domain?: string | undefined;
+}): Promise<{
+    address: string;
+    sign: (message: any) => Promise<Uint8Array<ArrayBuffer>>;
+}>;
+/** The public keys for a grant's `keys`, one per code, in order. */
+export declare const codeAddresses: (codes: any, options: any) => Promise<any[]>;
+/**
+ * A voucher a typed code signs for `wallet` (the page, or a server, makes it): the grant pays it once per code with
+ * `limits.perKey: 1`. Its round is the code's own, so one wallet can't use one code twice either. `incarnation` is the
+ * grant's, read from the chain; `now` the cluster's clock.
+ */
+export declare function codeVoucher({ code, game, grant, incarnation, wallet, now, seconds, domain, }: {
+    code: any;
+    domain?: string | undefined;
+    game: any;
+    grant: any;
+    incarnation: any;
+    now: any;
+    seconds?: number | undefined;
+    wallet: any;
+}): Promise<{
+    wallet: any;
+    grant: any;
+    incarnation: string;
+    publicKey: any;
+    signature: string;
+    round: any;
+    expires: number;
+    personHash: string;
+    amount: string;
+}>;

package/types/results/wire.d.ts

@@ -56,7 +56,7 @@ export declare const revokeText: ({ cluster, game, host }: {
  * `slug`: the game's play-host name (its tokens' audience), or '-'; `rates`: the sha256 of the engine's rates (canonical
  * JSON), or 'default'.
  */
-export declare const drawText: ({ cluster, game, draw, engine, winners, prizes, payout, identity, slug, rates }: {
+export declare const drawText: ({ cluster, game, draw, engine, winners, prizes, payout, identity, slug, rates, }: {
     cluster?: string | undefined;
     draw: any;
     engine: any;