@xgamesfun/solana 0.24.0 → 0.25.0

package/types/economy/model.d.mts

@@ -111,7 +111,7 @@ export declare const STOCK_WORDS = "The odds stay as written whatever is in stoc
  */
 export declare function whenOutWords(b: any, { sold }?: {
     sold?: boolean | undefined;
-}): "The odds stay as written whatever is in stock: a draw that lands on an outcome that can’t be given then (its pool short of the whole amount, its item or stash gone) is not made, no other outcome takes its place, and that draw’s worth of the price goes back at the settle; with no draw made at all, a paid open fails and is refunded, and a free roll goes back to waiting" | "When an outcome runs out (an item sold out, a pool short of its prize, a stash empty), a roll draws among the outcomes still there by their written weights, so the others’ chances rise; with nothing left at all, a free roll waits to be asked again and a paid one is refunded" | "When an outcome runs out (an item sold out, a pool short of its prize, a stash empty), the box keeps selling while its first draw has anything left, and a roll draws among the outcomes still there by their written weights: the others’ chances rise as one runs out, so a player can empty a common outcome to make a rare one likelier (a box selling a rare prize should stop selling instead, the default)" | "When an outcome runs out, the box stops selling: it isn’t sold while any outcome couldn’t cover this purchase’s draws and those of purchases still waiting for the oracle (an item’s units left, a pool’s tokens, a stash’s NFTs), so every roll is on the odds as written and nobody can buy their way to a refund on every miss; it sells again once the project restocks or edits the box (an outcome whose odds shrink with stock needs no cover). An outcome emptied another way all the same (another route sharing its pool, item or stash) makes no draw, no other outcome taking its place, and gives back that draw’s worth of the price at the settle; with no draw made at all, the open is refunded";
+}): "The odds stay as written whatever is in stock: a draw that lands on an outcome that can’t be given then (its pool short of the whole amount, its item or stash gone) is not made, no other outcome takes its place, and that draw’s worth of the price goes back at the settle; with no draw made at all, a paid open fails and is refunded, and a free roll goes back to waiting. A free roll (a prize, a recipe’s, a mission’s chest) is on the odds as written too: a draw on an outcome that is out misses and gives nothing back (a pack keeps what its other draws won; a roll that drew nothing waits to be asked again), so emptying a shared source before asking steers nothing. A pack that should draw among what is left needs \"whenOut\": \"drawLeft\"" | "When an outcome runs out (an item sold out, a pool short of its prize, a stash empty), a roll draws among the outcomes still there by their written weights, so the others’ chances rise; with nothing left at all, a free roll waits to be asked again and a paid one is refunded" | "When an outcome runs out (an item sold out, a pool short of its prize, a stash empty), the box keeps selling while its first draw has anything left, and a roll draws among the outcomes still there by their written weights: the others’ chances rise as one runs out, so a player can empty a common outcome to make a rare one likelier (a box selling a rare prize should stop selling instead, the default)" | "When an outcome runs out, the box stops selling: it isn’t sold while anything an outcome takes (an item’s units left, a pool’s tokens, a stash’s NFTs) couldn’t cover, at the most any outcome sharing it takes in one draw, this purchase’s draws and those of purchases still waiting for the oracle, so every roll is on the odds as written and nobody can buy their way to a refund on every miss; it sells again once the project restocks or edits the box (an outcome whose odds shrink with stock needs no cover). An outcome emptied another way all the same (another route sharing its pool, item or stash) makes no draw, no other outcome taking its place, and gives back that draw’s worth of the price at the settle; with no draw made at all, the open is refunded";
 /**
  * What the end of a sharing farm that `runs` means, in words, or null (no end, or a fixed rate): its release keeps its
  * pace, so what it has not let go by the end stays in its vault, free for the authority to take back, and so does what
@@ -275,7 +275,7 @@ export declare function lifeLines(r: any, m: any): {
     needs: any[];
     raises: any[];
 };
-/** A lottery's place as { percent, prize }: a number is a share of the pot and no prize. */
+/** A lottery's place as { percent, prize }: a number is a percent of what the round pays from, and no prize. */
 export declare const placeOf: (p: any) => {
     percent: any;
     prize: any;
@@ -295,7 +295,7 @@ export declare const sharesOf: (split: any) => any;
  * The program's `To` for a destination, with pool indexes resolved (the IDL's own shape). A wallet ("wallet:<address>")
  * is paid at its own token account of the part's currency (the program opens it when it is not there); "treasury" is the game's treasury wallet's; "chosen"
  * (or "chosen:<item>") is the one the buyer names when they buy; "lottery:<key>" is that lottery's pot
- * ("@pot:<id>") and "farm:<key>" that farm's rewards vault ("@rewards:<id>"), which the plan resolves once the game is
+ * ("@pot:<lottery id>:<pot id>") and "farm:<key>" that farm's rewards vault ("@rewards:<id>"), which the plan resolves once the game is
  * known.
  */
 export declare function toEnum(to: any, m: any): "Burn" | "Treasury" | {
@@ -401,6 +401,51 @@ export declare const windowOf: (part: any, now: any) => {
     opens_at: bigint;
     closes_at: bigint;
 };
+/** Whether lottery `l` pays its places from a pot it keeps (`"pot"`, `PaysFrom::Pot`); false when each round pays from
+ * its own ticket money and sends what its places leave to `"rest"` (`PaysFrom::Round`). */
+export declare const keepsPot: (l: any) => boolean;
+/** The program's `PaysFrom` for a lottery: `{ Pot: [id] }` or `{ Round: { rest } }` (its `rest` as `toEnum` gives it). */
+export declare const paysFromOf: (l: any, m: any) => {
+    Pot: any[];
+    Round?: undefined;
+} | {
+    Pot?: undefined;
+    Round: {
+        rest: string | {
+            Pool: any[];
+            Account?: undefined;
+            Wallet?: undefined;
+            Chosen?: undefined;
+            Holder?: undefined;
+        } | {
+            Pool?: undefined;
+            Account: (string | undefined)[];
+            Wallet?: undefined;
+            Chosen?: undefined;
+            Holder?: undefined;
+        } | {
+            Pool?: undefined;
+            Account?: undefined;
+            Wallet: (string | undefined)[];
+            Chosen?: undefined;
+            Holder?: undefined;
+        } | {
+            Pool?: undefined;
+            Account?: undefined;
+            Wallet?: undefined;
+            Chosen: {
+                item: any;
+            };
+            Holder?: undefined;
+        } | {
+            Pool?: undefined;
+            Account?: undefined;
+            Wallet?: undefined;
+            Chosen?: undefined;
+            Holder: (string | undefined)[];
+        };
+    };
+};
 /** A lottery's split of ticket money: its own, and "cutPercent" as a share to the treasury. */
 export declare const lotterySplit: (l: any) => any[];
 /** The program's `Effect` for a spec effect: a flat share, or a share per point of the attribute. */

package/types/economy/plan.d.mts

@@ -405,13 +405,55 @@ export declare function prizeArgs(p: any, m: any): "Raffled" | {
  */
 export declare const listLeaves: (list: any, t: any) => any;
 /**
- * A lottery's args: its own pot in `currency` (the project's by default), ticket money split by `split` (and
- * `cutPercent` to the treasury) with the rest into the pot. No `every` draws once, at `firstDraw`.
+ * A lottery's args: its money in `currency` (the project's by default), ticket money split by `split` (and
+ * `cutPercent` to the treasury) with the rest for the places, which are paid from its pot (`pot`) or from each round's
+ * own money, what they leave going to `rest` (`paysFromOf`). No `every` draws once, at `firstDraw`.
  */
 export declare function lotteryArgs(l: any, m: any): {
     terms: {
         price: bigint;
         mint: string;
+        pays_from: {
+            Pot: any[];
+            Round?: undefined;
+        } | {
+            Pot?: undefined;
+            Round: {
+                rest: string | {
+                    Pool: any[];
+                    Account?: undefined;
+                    Wallet?: undefined;
+                    Chosen?: undefined;
+                    Holder?: undefined;
+                } | {
+                    Account: (string | undefined)[];
+                    Wallet?: undefined;
+                    Chosen?: undefined;
+                    Holder?: undefined;
+                    Pool?: undefined;
+                } | {
+                    Account?: undefined;
+                    Wallet: (string | undefined)[];
+                    Chosen?: undefined;
+                    Holder?: undefined;
+                    Pool?: undefined;
+                } | {
+                    Account?: undefined;
+                    Wallet?: undefined;
+                    Chosen: {
+                        item: any;
+                    };
+                    Holder?: undefined;
+                    Pool?: undefined;
+                } | {
+                    Account?: undefined;
+                    Wallet?: undefined;
+                    Chosen?: undefined;
+                    Holder: (string | undefined)[];
+                    Pool?: undefined;
+                };
+            };
+        };
         shares: any;
         places: any;
         ticket_mint: string;

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,7 +731,8 @@ 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;
@@ -737,8 +740,6 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
         kind: string;
         order: any;
         says: string;
-        id?: undefined;
-        side?: undefined;
         hold?: undefined;
         round?: undefined;
         pulls?: undefined;
@@ -752,6 +753,8 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
         id: any;
         side: any;
         says: string;
+        potUnits?: string | undefined;
+        prizeUnits?: string | undefined;
         hold?: undefined;
         round?: undefined;
         pulls?: undefined;
@@ -761,8 +764,6 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
         key?: undefined;
         tree?: undefined;
         order?: undefined;
-        id?: undefined;
-        side?: undefined;
         kind: string;
         asset: any;
         hold: any;
@@ -773,8 +774,6 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
     } | {
         key?: undefined;
         order?: undefined;
-        id?: undefined;
-        side?: undefined;
         hold?: undefined;
         kind: string;
         asset: string;
@@ -786,8 +785,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;
@@ -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;
@@ -826,8 +819,6 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
         key?: undefined;
         tree?: undefined;
         order?: undefined;
-        id?: undefined;
-        side?: undefined;
         hold?: undefined;
         round?: undefined;
         pulls?: undefined;
@@ -839,8 +830,6 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
         key?: undefined;
         tree?: undefined;
         order?: undefined;
-        id?: undefined;
-        side?: undefined;
         hold?: undefined;
         round?: undefined;
         pulls?: undefined;

package/types/results/index.d.ts

@@ -1,4 +1,4 @@
-export { canonicalJson, CERT_KINDS, CLUSTERS, drawText, entryText, giveawayHostText, hostCertText, lockText, NO_GRANT, RESULT_DOMAIN, resultBytes, revokeGiveawayText, revokeText, rosterHash } from './wire.js';
+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 declare const RESULTS_SERVER = "https://play.xgames.fun/xsolana";
 /** A fresh round id: 16 random bytes, in hex. Make it when the round starts. */
@@ -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;