@xgamesfun/solana 0.25.3 → 0.26.0

package/types/economy/model.d.mts

@@ -37,8 +37,8 @@ export declare const SIGNATURE_FEE = 5000n;
 export declare const LAMPORTS_PER_SOL = 1000000000n;
 export declare const WSOL = "So11111111111111111111111111111111111111112";
 /** The limits a spec meets: the chain's (the oracle's answer carries 21 accounts; a farm names a tier and a recipe a
- * collectible's place in a byte; Bubblegum keeps a compressed NFT's link in 200 bytes and its name in 32) and the two
- * caps that keep a farm's numbers from overflowing. Since loot 0.22 the program caps no count or size of its own. */
+ * collectible's place in a byte; Bubblegum keeps a compressed NFT's link in 200 bytes and its name in 32), the two
+ * caps that keep a farm's numbers from overflowing, and the lists the program still bounds. */
 export declare const LIMITS: Readonly<{
     callbackAccounts: 21;
     tiers: 256;
@@ -46,23 +46,44 @@ export declare const LIMITS: Readonly<{
     vouchers: 3;
     compressedNameBytes: 32;
     compressedUriBytes: 200;
-    maxBoostBps: 1000000;
-    maxTierBps: 110000;
-    boxEntries: 128;
-    boxSlots: 32;
-    boxOdds: 32;
-    boxFates: 64;
-    entryPrizes: 14;
+    maxBoostBps: 10000000;
+    maxTierBps: 1000000;
     itemTraits: 64;
     traitKeyBytes: 64;
-    recipeLines: 48;
     farmRules: 32;
     growthSteps: 128;
     contestSides: 1024;
     deciders: 32;
     collections: 32;
     lotteryRuns: 64;
-    farmEnds: 100000;
+    entryPrizes: 255;
+    ownStashPlaces: 256;
+    ticketOneOf: 170;
+}>;
+/**
+ * What one answer of the oracle's holds, as measured on the program: a box is refused when it is written
+ * (PackTooLarge, or TooManyAccounts) when one answer can't hold a draw of it, a box of one draw included. Each number is
+ * the most of that one thing in a box that is otherwise small: `entriesOfNothing` outcomes that give nothing,
+ * `entriesOfTokens` outcomes of token amounts, `entriesOfItems` outcomes each of its own item, `slots`, `odds` rules,
+ * `entryTokens` token prizes or `entryCollectibles` collectibles in one outcome, `gateTexts` "one of" texts in a box's
+ * gate. A box that mixes them fits less. A recipe: `recipePayments` payments in one coin, `recipeCoins` in different
+ * coins, `recipePoolOutputs` outputs from a pool, `recipeRaises` raises or needs; past those it is written but never
+ * crafts. `recipeRolls`: the rolls whose receipts a transaction's log still holds.
+ */
+export declare const ANSWER_HOLDS: Readonly<{
+    entriesOfNothing: 128;
+    entriesOfTokens: 29;
+    entriesOfItems: 18;
+    slots: 41;
+    odds: 72;
+    entryTokens: 16;
+    entryCollectibles: 18;
+    gateTexts: 340;
+    recipePayments: 60;
+    recipeCoins: 26;
+    recipePoolOutputs: 59;
+    recipeRaises: 108;
+    recipeRolls: 15;
 }>;
 /** Attribute names the program writes itself, which a recipe cannot copy and `Set` cannot change (craft.rs, make.rs),
  * and the two a collectible's life keeps (`lifeLines`: its uses and its next use). */
@@ -111,7 +132,43 @@ 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. 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";
+}): string;
+/** Whether a box stops selling while an outcome is out (`whenOut` "stopSales", the default). */
+export declare const stopsSales: (b: any) => boolean;
+/** The largest weight an outcome has (a `u32`). */
+export declare const MOST_WEIGHT = 4294967295n;
+/**
+ * An outcome's weight grown by `bps` basis points (rules.rs `boosted`): rounded down, and never past the largest weight.
+ * Counted in BigInt: the largest weight times the largest boost passes 2^53. Two outcomes boosted past the largest
+ * weight are equally likely.
+ */
+export declare function boostedWeight(weight: any, bps: any): bigint;
+/**
+ * Box `b`'s weights for a player who passes every one of its odds rules at their most (order.rs): the rules' boosts on
+ * one outcome add up, and stop at the largest `u32`; each outcome's weight is then boosted (`boostedWeight`). A boost
+ * per point counts its `upTo` points. BigInt weights, outcome by outcome.
+ */
+export declare function boostedWeights(b: any): any;
+/**
+ * What places of tokens paid from one pool get when it holds `holds` and they win more (lottery.rs `WhenShort`), as a
+ * pull pays them: `runs` are [{ each, places }] in place order (base units, BigInt), `whenShort` the setting they all
+ * say. Each run gets [{ each, sent }]. "inOrder": whole prizes, first to last, while what is left covers one;
+ * "inProportion": every place the same share of its prize, rounded down; "nothing": no place, and the pool keeps it.
+ * Prizes of 1,000, 500 and 500 from a pool holding 1,700: 1,000, 500 and 0; 850, 425 and 425; or nothing.
+ */
+export declare function shortPays(runs: any, holds: any, whenShort?: string): any;
+/**
+ * What a purchase of `count` tickets at `at` weighs in a lottery that weighs tickets by time (lottery.rs
+ * `time_weighted`): each ticket the seconds from it to the close of sales (`drawsAt` less `closesBefore`), at least 1.
+ * Off, a ticket weighs one. BigInt.
+ */
+export declare function purchaseWeight(count: any, at: any, drawsAt: any, closesBefore?: number, weighted?: boolean): bigint;
+/**
+ * The entry that wins each place of a round (lottery.rs `ticket_of_place`): place `k` is at `first + k × (total /
+ * winners)`, rounding the end, and its winner is the entry whose slice of the draw holds that point. `entries` are each
+ * purchase's weight in order (BigInt), `first` the answer's point below the total. The entry's index for each place.
+ */
+export declare function placeWinners(entries: any, winners: any, first: any): number[];
 /**
  * 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
@@ -280,6 +337,12 @@ export declare const placeOf: (p: any) => {
     percent: any;
     prize: any;
     times: any;
+    whenShort: any;
+} | {
+    whenShort?: undefined;
+    percent: any;
+    prize: null;
+    times: number;
 };
 /** "pool:house" → { kind: 'pool', key: 'house' }; "burn" → { kind: 'burn' }. */
 export declare function destination(to: any): {

package/types/economy/plan.d.mts

@@ -102,7 +102,7 @@ export declare function boxArgs(b: any, m: any): {
         shared: boolean;
     } | null;
     stock_odds: boolean;
-    when_out: string;
+    when_out: any;
     active: boolean;
     shares: any;
     slots: any;
@@ -480,6 +480,8 @@ export declare function lotteryArgs(l: any, m: any): {
         } | null;
         returns: boolean;
         min_sold: bigint;
+        closes_before: bigint;
+        time_weighted: boolean;
     };
     every: bigint;
     gate: {
@@ -521,6 +523,21 @@ export declare function lotteryArgs(l: any, m: any): {
     } | null;
     per_wallet: any;
 };
+/** A box's `whenOut` in the spec, and the program's `WhenOut`: stop selling while an outcome is out (a paid miss is
+ * refunded), draw among what is left, or give nothing for a draw on an outcome that is out. */
+export declare const WHEN_OUT: {
+    stopSales: string;
+    drawLeft: string;
+    giveNothing: string;
+};
+/** A place's `whenShort` in the spec, and the program's `WhenShort`: what places of tokens from one pool get when the
+ * pool holds less than they win. Prizes of 1,000, 500 and 500 from a pool holding 1,700: 1,000, 500 and 0 in order;
+ * 850, 425 and 425 in proportion; or nothing. */
+export declare const WHEN_SHORT: {
+    inOrder: string;
+    inProportion: string;
+    nothing: string;
+};
 /**
  * A lottery round's header as its first purchase sizes it (`LotteryRound::new`: its `head`), and the token accounts a
  * round may open (`accounts`: the payment mint's, the pot's, one for each run whose prize comes from a pool). The
@@ -531,6 +548,10 @@ export declare function roundSize(l: any, m: any): {
     head: number;
     accounts: any;
 };
+/** What decides the bytes of a purchase's entry in a lottery's round (`loot.entryWidth`'s arguments): whether it keeps
+ * what arrived (a share the buyer chooses, or a weighted round of paid tickets), whether the ticket is an NFT, and
+ * whether the round weighs its tickets by time. */
+export declare const entryShape: (l: any) => boolean[];
 /** How many rounds of a lottery are open or still paying out at once, and how many purchases a round takes, as the
  * spec expects them (`expect`): by default two rounds of a lottery that draws again (one selling, one paying out) and
  * one of a lottery that draws once; a round's purchases from the scenario's purchases a day over a round, else 100. */

package/types/economy/simulate.d.mts

@@ -62,11 +62,22 @@ export declare function simulate(economy: any, { now }?: {
             holdSol: any;
         };
         limitedStock?: boolean | undefined;
-        whenOut?: string | undefined;
+        whenOut?: any;
+        oddsBoosted?: any;
         stock?: {
             whenOut: string;
             stopsSellingInDays: any;
             by: any;
+            runsOut?: undefined;
+        } | {
+            stopsSellingInDays?: undefined;
+            by?: undefined;
+            whenOut: string;
+            runsOut: {
+                inDays: any;
+                outcomes: any;
+                missPercent: any;
+            }[];
         } | {
             by?: undefined;
             whenOut: string;

package/types/mcp/server.d.mts

@@ -105,11 +105,22 @@ export declare function runTool(name: any, input?: {}, ctx?: {}): Promise<{
                 holdSol: any;
             };
             limitedStock?: boolean | undefined;
-            whenOut?: string | undefined;
+            whenOut?: any;
+            oddsBoosted?: any;
             stock?: {
                 whenOut: string;
                 stopsSellingInDays: any;
                 by: any;
+                runsOut?: undefined;
+            } | {
+                stopsSellingInDays?: undefined;
+                by?: undefined;
+                whenOut: string;
+                runsOut: {
+                    inDays: any;
+                    outcomes: any;
+                    missPercent: any;
+                }[];
             } | {
                 by?: undefined;
                 whenOut: string;

package/types/mcp/tools.d.mts

@@ -278,11 +278,22 @@ export declare const tools: ({
                     holdSol: any;
                 };
                 limitedStock?: boolean | undefined;
-                whenOut?: string | undefined;
+                whenOut?: any;
+                oddsBoosted?: any;
                 stock?: {
                     whenOut: string;
                     stopsSellingInDays: any;
                     by: any;
+                    runsOut?: undefined;
+                } | {
+                    stopsSellingInDays?: undefined;
+                    by?: undefined;
+                    whenOut: string;
+                    runsOut: {
+                        inDays: any;
+                        outcomes: any;
+                        missPercent: any;
+                    }[];
                 } | {
                     by?: undefined;
                     whenOut: string;