@xgamesfun/solana 0.25.3 → 0.26.0

package/js/economy/review.mjs

@@ -384,7 +384,7 @@ export function review(economy, { now = Math.floor(Date.now() / 1000) } = {}) {
     const free = price === 0;
     const ceiling = free
       ? `${b.perWallet ? `${b.perWallet} per wallet, and wallets are free: ` : ''}${it?.supply ? `all ${it.supply}` : 'as many as they like'}, for only the fees.`
-      : `What they pay for, at the price: ${rolls ? 'nobody, the project included, can steer the roll' : 'nothing free'}.${b.whenOut === 'drawLeft' && rolls ? ' With "whenOut": "drawLeft", someone watching the stock can empty a common outcome, then open for the rare at better odds.' : ''}`;
+      : `What they pay for, at the price: ${rolls ? 'nobody, the project included, can steer the roll' : 'nothing free'}.${b.whenOut === 'drawLeft' && rolls ? ' With "whenOut": "drawLeft", someone watching the stock can empty a common outcome, then open for the rare at better odds.' : ''}${b.whenOut === 'giveNothing' && rolls ? ' With "whenOut": "giveNothing", a draw on an outcome that is out gives nothing and is not refunded.' : ''}`;
     routes.push({
       kind,
       key,
@@ -526,15 +526,21 @@ export function review(economy, { now = Math.floor(Date.now() / 1000) } = {}) {
       ].filter(Boolean),
       trusts: ['MagicBlock’s oracle (the draw)'],
       trust: null,
-      ceiling: `A place by chance: each ticket is one chance, and "perWallet" limits a wallet, not a person. Tickets are not weighted by time, so one buyer may take most of a round’s tickets just before the draw.`,
+      ceiling: l.timeWeighted
+        ? `A place by chance, by weight: each purchase counts its tickets times the seconds left until sales close, so a ticket held longer has a better chance; "perWallet" limits a wallet, not a person.`
+        : `A place by chance: each ticket is one chance, and "perWallet" limits a wallet, not a person. Tickets are not weighted by time, so one buyer may take most of a round’s tickets just before ${l.closesBefore ? 'sales close' : 'the draw'}.`,
       feeds: [...new Set((l.places ?? []).flatMap(p => feedsOf(p.prize)))],
     });
-    find(
-      'R-LOTTERY-LATE',
-      'info',
-      `lottery:${l.key}`,
-      `Anyone may buy most of ${label(l)}’s tickets right before the draw, risking only the price and fees; the draw itself is the oracle’s, which nobody steers.`,
-    );
+    if (!l.timeWeighted)
+      find(
+        'R-LOTTERY-LATE',
+        l.noLoss && !l.closesBefore ? 'low' : 'info',
+        `lottery:${l.key}`,
+        `Anyone may buy most of ${label(l)}’s tickets right before ${l.closesBefore ? `sales close (${l.closesBefore} before the draw)` : 'the draw'}, risking only ${l.noLoss ? 'the fees: every ticket’s price comes back' : 'the price and fees'}; the draw itself is the oracle’s, which nobody steers.`,
+        l.noLoss
+          ? 'Weigh tickets by the time they are held ("timeWeighted": true), or close sales a while before the draw ("closesBefore").'
+          : undefined,
+      );
   }
   for (const c of m.contests) {
     const deciders = c.deciders ?? [];
@@ -670,6 +676,42 @@ export function review(economy, { now = Math.floor(Date.now() / 1000) } = {}) {
     const key = /^economy\.tokens\.([^.]+)/.exec(w.where)?.[1];
     find('R-MINT-POWERS', 'low', key ? `token:${key}` : 'economy', w.message, w.fix);
   }
+  // What the program takes and a player, a partner or a typo can turn against the project (loot 0.26): each warning,
+  // as a finding on its route.
+  const routeOf = where => {
+    const [, list, key] = /^economy\.([a-z]+)\.([^.[]+)/.exec(where) ?? [];
+    const kinds = {
+      boxes: 'box',
+      lotteries: 'lottery',
+      auctions: 'auction',
+      contests: 'contest',
+      farms: 'farm',
+      schedules: 'schedule',
+      recipes: 'recipe',
+      grants: 'grant',
+      holds: 'hold',
+      stashes: 'stash',
+      tokens: 'token',
+    };
+    return kinds[list] ? `${kinds[list]}:${key}` : 'economy';
+  };
+  for (const [code, id, severity] of [
+    ['W-FARM-AUTHORITY', 'R-FARM-AUTHORITY', 'high'],
+    ['W-SCHEDULE-PAYEE', 'R-SCHEDULE-PAYEE', 'medium'],
+    ['W-FAR-TIME', 'R-FAR-TIME', 'medium'],
+    ['W-HOLD-UP', 'R-HOLD-UP', 'medium'],
+    ['W-AUCTION-OUTSIDE', 'R-AUCTION-OUTSIDE', 'medium'],
+    ['W-OUTSIDE-NFT', 'R-OUTSIDE-NFT', 'medium'],
+    ['W-COLLECTION-PARTNER', 'R-COLLECTION-PARTNER', 'medium'],
+    ['W-FARM-MISSION', 'R-FARM-MISSION', 'medium'],
+    ['W-CONTEST-PRIZE', 'R-CONTEST-PRIZE', 'medium'],
+    ['W-SHARED-SOURCE', 'R-SHARED-SOURCE', 'low'],
+    ['W-LOTTERY-POOL', 'R-LOTTERY-POOL', 'low'],
+    ['W-LOTTERY-WEIGHT', 'R-LOTTERY-WEIGHT', 'info'],
+    ['W-ZERO', 'R-ZERO', 'low'],
+    ['W-ANSWER', 'R-ANSWER', 'low'],
+  ])
+    for (const w of warned(code)) find(id, severity, routeOf(w.where), w.message, w.fix);
 
   findings.sort((a, b) => SEVERITIES.indexOf(a.severity) - SEVERITIES.indexOf(b.severity));
   return {

package/js/economy/schema.json

@@ -278,7 +278,7 @@
     },
     "destination": {
       "type": "string",
-      "description": "Where a share goes: \"burn\", \"treasury\" (the game's), \"pool:<key>\", \"wallet:<address>\" (a partner, a creator, a charity: the program pays their own account for the currency, and opens it when it is not there), \"account:<token account address>\" (an existing token account of that currency), \"holder:<collectible address>\" (whoever holds that collectible at the time), \"lottery:<key>\" (that lottery's pot), \"farm:<key>\" (that farm's rewards vault, shared by its stakers), or, in a box's or a lottery's split, \"chosen\" (a wallet the buyer names when they buy: a referrer, a streamer) or \"chosen:<item key>\" (whoever holds the collectible of that item the buyer names: the plot they build on; the buyer must name one a player holds, or the purchase is refused); in a payment's split, \"chosen\" only (a wallet the payer names each time they pay, never their own). A share that can't be paid (its wallet has no account, nobody holds the collectible) goes to the treasury instead; a sale never fails over it.",
+      "description": "Where a share goes: \"burn\", \"treasury\" (the game's), \"pool:<key>\", \"wallet:<address>\" (a partner, a creator, a charity: the program pays their own account for the currency, and opens it when it is not there), \"account:<token account address>\" (an existing token account of that currency), \"holder:<collectible address>\" (whoever holds that collectible at the time), \"lottery:<key>\" (that lottery's pot), \"farm:<key>\" (that farm's rewards vault, shared by its stakers), or, in a box's or a lottery's split, \"chosen\" (a wallet the buyer names when they buy: a referrer, a streamer) or \"chosen:<item key>\" (whoever holds the collectible of that item the buyer names: the plot they build on; the buyer must name one a player holds, or the purchase is refused); in a payment's split, \"chosen\" only (a wallet the payer names each time they pay, their own too). A chosen share can come back to the buyer: it is a rebate they control, not a referral the program can prove. A share that can't be paid (its wallet has no account, nobody holds the collectible) goes to the treasury instead; a sale never fails over it.",
       "pattern": "^(burn|treasury|chosen|chosen:[a-z][a-z0-9-]{0,31}|pool:[a-z][a-z0-9-]{0,31}|lottery:[a-z][a-z0-9-]{0,31}|farm:[a-z][a-z0-9-]{0,31}|wallet:[1-9A-HJ-NP-Za-km-z]{32,44}|account:[1-9A-HJ-NP-Za-km-z]{32,44}|holder:[1-9A-HJ-NP-Za-km-z]{32,44})$"
     },
     "share": {
@@ -427,6 +427,14 @@
             "transferFeePercent": {
               "$ref": "#/$defs/percent"
             },
+            "feeChangeable": {
+              "type": "boolean",
+              "description": "Its issuer can still change its transfer fee (Token-2022's transfer fee config has an authority): raised to 100%, it takes every stake or payment as it leaves."
+            },
+            "closeAuthority": {
+              "type": "boolean",
+              "description": "Its mint has a close authority, who could close it and make it again with other powers."
+            },
             "pausable": {
               "type": "boolean"
             },
@@ -435,14 +443,14 @@
             },
             "defaultState": {
               "type": "boolean",
-              "description": "The mint carries Token-2022's DefaultAccountState, whatever it is set to. With a freeze authority it can be switched to frozen: auctions, contests, lotteries and sealed schedules refuse it."
+              "description": "The mint carries Token-2022's DefaultAccountState, whatever it is set to. With a freeze authority it can be switched to frozen: the checker warns what that does to an auction, a loan, a lottery or a contest in it."
             },
             "nonTransferable": {
               "type": "boolean"
             },
             "confidentialTransfers": {
               "type": "boolean",
-              "description": "Its holders can turn plain transfers away (Token-2022 confidential transfers): lotteries, contests and auctions refuse it."
+              "description": "Its holders can turn plain transfers away (Token-2022 confidential transfers): the checker warns what that does to an auction, a loan, a lottery or a contest in it."
             }
           }
         }
@@ -875,9 +883,9 @@
           "description": "Each item's chance shrinks with what is left of its supply."
         },
         "whenOut": {
-          "enum": ["stopSales", "drawLeft"],
+          "enum": ["stopSales", "drawLeft", "giveNothing"],
           "default": "stopSales",
-          "description": "What a box that rolls does once an outcome can't be given (an item sold out, a pool short of its prize, a stash empty). \"stopSales\" (the default): it isn't sold while any outcome couldn't cover this purchase's draws and those of purchases still waiting for their answer, so every roll is on the odds written, and the project restocks or edits the box to sell again. \"drawLeft\": it keeps selling, and a roll draws among the outcomes still there by their written weights, so the others' chances rise as one runs out: a player can empty a common outcome to make a rare one likelier. A box selling a rare prize keeps \"stopSales\"."
+          "description": "What a box that rolls does once an outcome can't be given (an item sold out, a pool short of its prize, a stash empty). \"stopSales\" (the default): it isn't sold while any outcome couldn't cover this purchase's draws and those of purchases still waiting for their answer, so every roll is on the odds written, a paid miss is refunded, and the project restocks or edits the box to sell again; a free roll (another box's, a recipe's, a grant's, a mission's, a lottery place's) is still given after it stops, and is asked again until it hits. \"drawLeft\": it keeps selling, and a roll draws among the outcomes still there by their written weights, so the others' chances rise as one runs out: a player can empty a common outcome to make a rare one likelier. \"giveNothing\": it keeps selling, a roll stays on the weights written, and a draw that lands on an outcome that is out gives nothing: a paid draw is not refunded, a free roll is over. A box selling a rare prize keeps \"stopSales\"."
         },
         "active": {
           "type": "boolean",
@@ -1389,7 +1397,7 @@
           "type": "integer",
           "minimum": 0,
           "maximum": 15,
-          "description": "Pays its places from a pot it keeps from round to round, this one of its 16 (0 unless it moves to a fresh one): each place takes its percent of what the pot holds at the draw with the round's ticket money, so the seed, gifts and shares sent to it (\"lottery:<key>\"), yield, and what earlier rounds' places left all count, and the next round always starts with what the round before left. Write exactly one of \"pot\" or \"rest\". A no-loss lottery needs a pot. Changing the number between rounds starts a fresh pot; every pot it opened is emptied to the owner when it closes."
+          "description": "Pays its places from a pot it keeps from round to round, this one of its 16 (0 unless it moves to a fresh one): each place takes its percent of what the pot holds at the draw with the round's ticket money, so the seed, gifts and shares sent to it (\"lottery:<key>\"), yield, and what earlier rounds' places left all count, and the next round always starts with what the round before left. Write exactly one of \"pot\" or \"rest\". Changing the number between rounds starts a fresh pot; every pot it opened is emptied to the owner when it closes."
         },
         "rest": {
           "$ref": "#/$defs/destination",
@@ -1422,7 +1430,12 @@
                     "type": "integer",
                     "minimum": 1,
                     "maximum": 40960,
-                    "description": "How many places in a row are alike (a run): \"places 2 to 201 each take 1%\" is one { \"percent\": 1, \"times\": 200 }. Not for a named NFT or a roll, which one place gives. Default 1."
+                    "description": "How many places in a row are alike (a run): \"places 2 to 201 each take 1%\" is one { \"percent\": 1, \"times\": 200 }. Not for a named NFT, which one place gives; a run of rolls gives each place its own roll. Default 1."
+                  },
+                  "whenShort": {
+                    "enum": ["inOrder", "inProportion", "nothing"],
+                    "default": "inOrder",
+                    "description": "For a prize of tokens from a pool: what each place gets when the pool holds less than the places with a winner win, read once when the draw is asked. \"inOrder\" (the default): whole prizes, first place first, while the pool covers one; \"inProportion\": every place the same share of its prize; \"nothing\": no place gets anything, and the pool keeps it. Prizes of 1,000, 500 and 500 from a pool holding 1,700 give 1,000, 500 and 0 in order, 850, 425 and 425 in proportion, or nothing. Every place paid from one pool says the same."
                   }
                 }
               }
@@ -1437,6 +1450,14 @@
         "firstDraw": {
           "$ref": "#/$defs/time"
         },
+        "closesBefore": {
+          "$ref": "#/$defs/duration",
+          "description": "Sales close this long before each draw (default 0: at the draw); for a lottery that draws again, less than \"every\". A no-loss lottery wants one, so tickets bought just before the draw don't share the pot with tickets held all period."
+        },
+        "timeWeighted": {
+          "type": "boolean",
+          "description": "No-loss lotteries only: each purchase weighs its tickets times the seconds from it to the close of sales, and a place is won by weight, so a ticket held longer has a better chance. Set a sales close you mean (\"closesBefore\"); \"perWallet\" and \"minSold\" still count tickets. Off by default: every ticket counts one."
+        },
         "gate": {
           "$ref": "#/$defs/gate"
         },
@@ -1485,7 +1506,7 @@
         },
         "noLoss": {
           "type": "boolean",
-          "description": "A no-loss lottery: every ticket goes back to its buyer once the round is drawn, and the winners take only the pot, what is paid into it (`seed`, a sponsor, a share of other sales: \"lottery:<key>\"). It needs \"pot\". No split, no cut and no `ticketCurrency`; NFT tickets come back too."
+          "description": "A no-loss lottery: every ticket goes back to its buyer once the round is drawn, and the winners take only the pot, what is paid into it (`seed`, a sponsor, a share of other sales: \"lottery:<key>\"), or with \"rest\" only its places' prizes. No split, no cut and no `ticketCurrency`; NFT tickets come back too. Set \"closesBefore\", or \"timeWeighted\", so a late buyer doesn't share the pot with tickets held all period."
         },
         "minSold": {
           "type": "integer",
@@ -1619,8 +1640,8 @@
         },
         "losersEach": {
           "type": "integer",
-          "minimum": 1,
-          "description": "In a contest of NFTs (`stakeNft`), the most losers' NFTs one winner takes; what the winners leave goes to whoever opened it. Default: no cap, the winners share every loser's NFT (the first to enter on the winning side take one more when they don't divide evenly), each picking which."
+          "minimum": 0,
+          "description": "In a contest of NFTs (`stakeNft`), the most losers' NFTs one winner takes; what the winners leave goes to whoever opened it (0: every loser's NFT goes to the opener). Default: no cap, the winners share every loser's NFT (the first to enter on the winning side take one more when they don't divide evenly), each picking which."
         }
       }
     },
@@ -2062,16 +2083,14 @@
         "oneOf": {
           "type": "array",
           "minItems": 1,
-          "maxItems": 16,
           "items": { "type": "string" },
-          "description": "The attribute is one of these texts (at most 16): a tier of two, one species of three."
+          "description": "The attribute is one of these texts: a tier of two, one species of forty. As many as the record holds; a lottery's NFT ticket takes at most 170, and a box's gate about 340 (what one answer of the oracle's reads)."
         },
         "items": {
           "type": "array",
           "minItems": 1,
-          "maxItems": 16,
           "items": { "$ref": "#/$defs/key" },
-          "description": "Any of these items the game mints (at most 16), in its own collection: a farm for three tree species, a gate for holders of any of five plots. Read by the program as the collection's `item_id` being one of theirs; not with `item`, `collection` or `attribute`."
+          "description": "Any of these items the game mints, in its own collection: a farm for three tree species, a gate for holders of any of five plots. Read by the program as the collection's `item_id` being one of theirs; not with `item`, `collection` or `attribute`."
         },
         "time": {
           "enum": ["ahead", "passed"],
@@ -2082,8 +2101,32 @@
     "boost": {
       "type": "number",
       "minimum": 0,
-      "maximum": 10000,
-      "description": "A percent added to a weight: 100 doubles it. At most 10,000 (101 times): enough for a stat that scales a rate, such as +100% a point of power up to 100."
+      "maximum": 100000,
+      "description": "A percent a farm's boost adds to a weight: 100 doubles it. At most 100,000 (1,001 times), alone and all of a farm's boosts together: enough for a stat that scales a rate, such as +100% a point of power up to 1,000."
+    },
+    "oddsBoost": {
+      "type": "number",
+      "minimum": 0,
+      "maximum": 42949672.95,
+      "description": "A percent a box's odds rule adds to an outcome's weight: 100 doubles it, 99,900 makes it a thousand times likelier. Any amount: a boosted weight stops at the largest weight (4,294,967,295), and two outcomes boosted past it are equally likely."
+    },
+    "oddsEffect": {
+      "type": "object",
+      "additionalProperties": false,
+      "description": "How much a collectible that passes the rule adds to the outcome's weight: a flat percent, or a percent per point of its attribute (up to `upTo` points).",
+      "properties": {
+        "addPercent": {
+          "$ref": "#/$defs/oddsBoost"
+        },
+        "perPointPercent": {
+          "$ref": "#/$defs/oddsBoost"
+        },
+        "upTo": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 4294967295
+        }
+      }
     },
     "effect": {
       "type": "object",
@@ -2119,7 +2162,7 @@
           "$ref": "#/$defs/rule"
         },
         "add": {
-          "$ref": "#/$defs/effect"
+          "$ref": "#/$defs/oddsEffect"
         }
       }
     },
@@ -2135,9 +2178,9 @@
         "multiplier": {
           "type": "number",
           "exclusiveMinimum": 0,
-          "maximum": 11,
+          "maximum": 100,
           "default": 1,
-          "description": "Its weight: above 0 and up to 11 times what it stakes (below 1: a flexible tier that earns less)."
+          "description": "Its weight: above 0 and up to 100 times what it stakes (below 1: a flexible tier that earns less)."
         },
         "prize": {
           "$ref": "#/$defs/prize",
@@ -2631,9 +2674,9 @@
                   },
                   "weight": {
                     "type": "integer",
-                    "minimum": 1,
+                    "minimum": 0,
                     "maximum": 4294967295,
-                    "description": "Its weight in the stash's draws (1 when left out): an NFT that weighs 10 is drawn ten times as often as one that weighs 1."
+                    "description": "Its weight in the stash's draws (1 when left out): an NFT that weighs 10 is drawn ten times as often as one that weighs 1. 0: never drawn, given only by name."
                   }
                 }
               },
@@ -2656,9 +2699,9 @@
                   },
                   "weight": {
                     "type": "integer",
-                    "minimum": 1,
+                    "minimum": 0,
                     "maximum": 4294967295,
-                    "description": "Its weight in the stash's draws (1 when left out): an NFT that weighs 10 is drawn ten times as often as one that weighs 1."
+                    "description": "Its weight in the stash's draws (1 when left out): an NFT that weighs 10 is drawn ten times as often as one that weighs 1. 0: never drawn, given only by name."
                   }
                 }
               },
@@ -2673,9 +2716,9 @@
                   },
                   "weight": {
                     "type": "integer",
-                    "minimum": 1,
+                    "minimum": 0,
                     "maximum": 4294967295,
-                    "description": "Its weight in the stash's draws (1 when left out): an NFT that weighs 10 is drawn ten times as often as one that weighs 1."
+                    "description": "Its weight in the stash's draws (1 when left out): an NFT that weighs 10 is drawn ten times as often as one that weighs 1. 0: never drawn, given only by name."
                   }
                 }
               }
@@ -2815,14 +2858,15 @@
               },
               "weight": {
                 "type": "integer",
-                "minimum": 1,
-                "maximum": 4294967295
+                "minimum": 0,
+                "maximum": 4294967295,
+                "description": "Its weight in the draws. 0: never drawn."
               },
               "stock": {
                 "type": "integer",
-                "minimum": 1,
+                "minimum": 0,
                 "maximum": 4294967294,
-                "description": "How many units may draw it: left out, never runs out."
+                "description": "How many units may draw it: left out, never runs out. 0: never drawn."
               }
             }
           }

package/js/economy/simulate.mjs

@@ -10,8 +10,9 @@
 // the day it stops, and one that draws among what is left ("drawLeft") the day each outcome runs out and the odds of
 // the rest from then (`stockWalk`). It is a guide, not a promise: the full simulation (js/sim) runs the real program.
 import { entryWidth, LIMIT_RECORD_BYTES, ROUND_RECORD_BYTES } from '../client/index.js';
-import { boxOrderBytes, roundRentOf } from './plan.mjs';
+import { boxOrderBytes, entryShape, roundRentOf } from './plan.mjs';
 import {
+  boostedWeights,
   boxBuys,
   COLLECTIBLE_RENT as COLLECTIBLE_RENT_LAMPORTS,
   drawsOf,
@@ -41,6 +42,11 @@ import {
   toBps,
   toSeconds,
   toTime,
+  purchaseWeight,
+  shortPays,
+  stashNfts,
+  stopsSales,
+  toUnits,
   weights,
   whenOutWords,
 } from './model.mjs';
@@ -59,15 +65,7 @@ const NETWORK_FEE = sol(SIGNATURE_FEE);
 const ORACLE = sol(ORACLE_FEE);
 /** A lottery purchase's entry in its round: the bytes the buyer adds (not refunded: they go to the treasury when the
  * round closes), with a wallet kept for each share the buyer's own entry names (lottery.rs `entry_width`). */
-const ticketLine = l =>
-  sol(
-    BigInt(
-      entryWidth(
-        lotterySplit(l).some(x => String(x.to).startsWith('chosen')),
-        Boolean(l.ticketNft),
-      ),
-    ) * RENT_PER_BYTE,
-  );
+const ticketLine = l => sol(BigInt(entryWidth(...entryShape(l))) * RENT_PER_BYTE);
 /** A collectible's Core account, paid from the SOL the order holds: its rent and Core's creation fee (model.mjs). */
 const COLLECTIBLE_RENT = sol(COLLECTIBLE_RENT_LAMPORTS);
 /** What a collectible a recipe burns gives back: its rent less one byte's (Core leaves a 1-byte account that keeps
@@ -369,9 +367,13 @@ export function simulate(economy, { now = 0 } = {}) {
     const stockOf = x => {
       const supply = Number(m.item.get(x.item)?.supply ?? 0);
       if (x.gives === 'item' && supply > 0 && !b.stockOdds) return [`item:${x.item}`, supply];
+      // A stash with nothing that weighs is out of stock: an NFT of weight 0 is never drawn (stash.rs `drawable`).
       if (x.gives === 'stash' && m.stash.get(x.stash))
-        return [`stash:${x.stash}`, (m.stash.get(x.stash).nfts ?? []).length];
+        return [`stash:${x.stash}`, stashNfts(m.stash.get(x.stash)).filter(n => n.weight > 0).length];
       if (x.gives === 'nft') return [`nft:${x.nft}`, 1];
+      // A minted prize is out of stock when the mint can't take it: a token the project can't mint (a fixed supply, or
+      // another's mint) mints nothing.
+      if (x.gives === 'mint' && !m.tokens.get(x.currency ?? game)?.gameMints) return [`mint:${x.currency ?? game}`, 0];
       return null;
     };
     const needs = (b.outcomes ?? []).map(o => {
@@ -383,7 +385,7 @@ export function simulate(economy, { now = 0 } = {}) {
       return need;
     });
     if (!left.size || !(opens > 0)) return null;
-    const stops = b.whenOut !== 'drawLeft';
+    const stops = stopsSales(b);
     const out = i => ({
       outcome: i,
       gives: (b.outcomes[i].gives === 'bundle'
@@ -416,6 +418,32 @@ export function simulate(economy, { now = 0 } = {}) {
         : null;
     }
     const there = i => [...needs[i]].every(([k, n]) => left.get(k) >= n);
+    if (b.whenOut === 'giveNothing') {
+      // A draw stays on the weights as written: one on an outcome that is out is made and gives nothing, never refunded
+      // (order.rs `WhenOut::GiveNothing`). The box keeps selling; what misses grows as outcomes run out.
+      const all = w.reduce((n, x) => n + x, 0);
+      if (!all) return null;
+      let alive = w.map((_, i) => i).filter(there);
+      let day = 0;
+      const runsOut = [];
+      const miss = () => round((w.reduce((n, x, i) => n + (alive.includes(i) ? 0 : x), 0) / all) * 100, 6);
+      const gone = w.map((_, i) => i).filter(i => !alive.includes(i));
+      if (gone.length) runsOut.push({ inDays: 0, outcomes: gone.map(out), missPercent: miss() });
+      while (alive.length) {
+        const rate = new Map();
+        for (const i of alive)
+          for (const [k, n] of needs[i]) rate.set(k, (rate.get(k) ?? 0) + (opens * draws * w[i] * n) / all);
+        const next = [...rate].map(([k, r]) => ({ k, t: left.get(k) / r })).sort((a, z) => a.t - z.t)[0];
+        if (!next || day + next.t > days) break;
+        day += next.t;
+        for (const [k, r] of rate) left.set(k, Math.max(0, left.get(k) - r * next.t));
+        left.set(next.k, 0);
+        const ended = alive.filter(i => !there(i));
+        alive = alive.filter(there);
+        runsOut.push({ inDays: round(day, 4), outcomes: ended.map(out), missPercent: miss() });
+      }
+      return runsOut.length ? { whenOut: 'giveNothing', runsOut } : null;
+    }
     const chances = alive => {
       const sum = alive.reduce((n, i) => n + w[i], 0);
       return w.map((x, i) => (sum && alive.includes(i) ? round((x / sum) * 100, 6) : 0));
@@ -449,6 +477,15 @@ export function simulate(economy, { now = 0 } = {}) {
   /** The walk of a box's stock in words (`stockWalk`). */
   const stockNote = (b, walk) => {
     const named = list => list.map(x => `outcome ${x.outcome} (${x.gives})`).join(', ');
+    if (walk.whenOut === 'giveNothing')
+      return `“${b.name}” keeps selling as its outcomes run out ("whenOut": "giveNothing"; its own opens alone): ${walk.runsOut
+        .map(
+          r =>
+            `${named(r.outcomes)} ${r.inDays ? `in about ${r.inDays} days` : 'from the start'}, then ${r.missPercent}% of draws give nothing`,
+        )
+        .join(
+          '; ',
+        )}. A draw on an outcome that is out is made and gives nothing: a paid one is not refunded, a free roll is over.`;
     if (walk.whenOut === 'stopSales')
       return `“${b.name}” stops selling ${walk.stopsSellingInDays ? `in about ${walk.stopsSellingInDays} days` : 'from the start'}, when ${named(walk.by)} runs out (its own opens alone): it isn’t sold while an item, a stash or a named NFT couldn’t cover, at the most any outcome takes of it in one draw, the draws of a purchase and of those still waiting for the oracle ("whenOut": "stopSales"), so every roll is on the odds as written. Restock it, or edit the box, to sell again; "drawLeft" would keep selling, the rest’s chances rising.`;
     const steps = walk.runsOut.map(
@@ -567,6 +604,16 @@ export function simulate(economy, { now = 0 } = {}) {
     // What it gives that runs out, as the box says (`whenOut`): it stops selling, or draws among what is left.
     const walk = !bought && b.active !== false ? stockWalk(b, opens) : null;
     if (walk) notes.push(stockNote(b, walk));
+    // Each outcome's chance for a player who passes every odds rule at its most (order.rs, rules.rs `boosted`): counted
+    // in BigInt, each weight stopping at the largest. The rules count on every route, read when a roll is first asked.
+    const raised = (b.odds ?? []).length ? boostedWeights(b) : null;
+    const raisedSum = raised ? raised.reduce((n, x) => n + x, 0n) : 0n;
+    const oddsBoosted =
+      raised && raisedSum > 0n ? raised.map(x => round(Number((x * 100_000_000n) / raisedSum) / 1_000_000, 6)) : null;
+    if (oddsBoosted)
+      notes.push(
+        `“${b.name}”’s odds rules raise its chances to ${oddsBoosted.map((c, i) => `outcome ${i} ${c}%`).join(', ')} for a player who passes them all at their most. They count on every route: on a purchase, and on a roll another route gives, read when the roll is first asked, not when it was won.`,
+      );
     return {
       key: b.key,
       name: b.name,
@@ -596,7 +643,8 @@ export function simulate(economy, { now = 0 } = {}) {
         )
         ? { limitedStock: true }
         : {}),
-      ...(!bought ? { whenOut: b.whenOut === 'drawLeft' ? 'drawLeft' : 'stopSales' } : {}),
+      ...(!bought ? { whenOut: b.whenOut ?? 'stopSales' } : {}),
+      ...(oddsBoosted ? { oddsBoosted } : {}),
       ...(walk ? { stock: walk } : {}),
       ...(isSol && known && price ? { returnOfRealCostPercent: round((value / (price + extrasSol)) * 100, 4) } : {}),
     };
@@ -877,6 +925,58 @@ export function simulate(economy, { now = 0 } = {}) {
       return null;
     };
     const prized = placed.filter(p => prizeLine(p.prize)).map(p => worthOf(prizeLine(p.prize)));
+    // A weighted round (`timeWeighted`): each purchase weighs its tickets times the seconds from it to the close of
+    // sales, and a place is won by weight. With purchases spread evenly over the selling time, a ticket bought at the
+    // open counts twice the average, one bought halfway the average, one in the last hour next to nothing.
+    const closesBefore = toSeconds(l.closesBefore ?? 0);
+    const selling = Math.max(1, every - closesBefore);
+    const weighted = l.timeWeighted
+      ? {
+          sellsForDays: round(selling / DAY, 4),
+          atOpen: 2,
+          halfway: 1,
+          lastHour: round(Number(purchaseWeight(1, selling - Math.min(3_600, selling), selling)) / (selling / 2), 6),
+        }
+      : null;
+    if (weighted)
+      notes.push(
+        `“${l.name}” weighs each purchase by its tickets times the seconds left until sales close: a ticket bought when a round opens counts about twice the average, one bought halfway the average, one in the last hour about ${weighted.lastHour} of it. A buyer sees what their purchase weighs before they buy.`,
+      );
+    // Places of tokens from a pool read it once, when the draw is asked: one that starts short pays as "whenShort" says.
+    const shortPools = [];
+    const fromPools = new Map();
+    for (const p of placed) {
+      const line = prizeLine(p.prize);
+      const key = line?.gives === 'tokens' ? prizePool(line) : null;
+      if (key) fromPools.set(key, [...(fromPools.get(key) ?? []), p]);
+    }
+    for (const [key, runs] of fromPools) {
+      const decimals = m.tokens.get(m.pool.get(key)?.currency)?.decimals ?? 0;
+      const units = v => {
+        try {
+          return toUnits(v ?? 0, decimals);
+        } catch {
+          return 0n;
+        }
+      };
+      const holds = units(m.pool.get(key)?.seed);
+      const rows = runs.map(p => ({ each: units(prizeLine(p.prize).amount), places: p.times ?? 1 }));
+      const wins = rows.reduce((n, r) => n + r.each * BigInt(r.places), 0n);
+      if (holds >= wins) continue;
+      const whenShort = runs[0].whenShort ?? 'inOrder';
+      const pays = shortPays(rows, holds, whenShort);
+      const scale = 10 ** decimals;
+      shortPools.push({
+        pool: key,
+        holds: Number(holds) / scale,
+        wins: Number(wins) / scale,
+        whenShort,
+        each: pays.map(x => Number(x.each) / scale),
+      });
+      notes.push(
+        `“${l.name}”’s places paid from “${key}” win ${Number(wins) / scale} and the pool starts with ${Number(holds) / scale}: if it holds no more when a draw is asked, they get ${pays.map(x => Number(x.each) / scale).join(', ')} each ("whenShort": "${whenShort}").`,
+      );
+    }
     // One ticket bought on its own: the fee and the record are per purchase, so a bundle of tickets shares them. The
     // record's rent comes back once the round is done with it, and a no-loss ticket's price after the draw: both held.
     const realCost = realCostOf({
@@ -918,6 +1018,9 @@ export function simulate(economy, { now = 0 } = {}) {
       roundRentSol: round(Number(roundRentOf(l, m)) / 1e9),
       ...(l.ticketNft ? { ticketNft: true } : {}),
       ...(l.noLoss ? { noLoss: true } : {}),
+      ...(closesBefore ? { closesBeforeDays: round(closesBefore / DAY, 4) } : {}),
+      ...(weighted ? { weighted } : {}),
+      ...(shortPools.length ? { shortPools } : {}),
       realCost,
     };
   });

package/js/mcp/tools.mjs

@@ -354,7 +354,7 @@ export const tools = [
     name: 'xsolana_check',
     annotations: READ,
     description:
-      'Check an economy spec: refusals (each with a code, what it means and its fix) stop it from going live; warnings are what the person must hear (chance that pays money, revenue paid to stakers, an unfunded prize, a grant without limits, a mint’s powers). Run it after every change. Give the spec inline (`spec`), a file, or an example.',
+      'Check an economy spec: refusals (each with a code, what it means and its fix) stop it from going live; warnings are what the person must hear (chance that pays money, revenue paid to stakers, an unfunded prize, a grant without limits, a mint’s powers, a time far off with its date in words, a token a player can hold a payment up in, a box longer than one answer of the oracle’s holds). The program refuses only what it must: much of what a project sets up is taken and warned of, never refused, so tell the person each warning in plain words. Run it after every change. Give the spec inline (`spec`), a file, or an example.',
     inputSchema: { type: 'object', properties: SOURCE, additionalProperties: false },
     async handler(input, ctx) {
       const { economy, from } = await load(input, ctx);
@@ -376,7 +376,7 @@ export const tools = [
     name: 'xsolana_simulate',
     annotations: READ,
     description:
-      'The quick simulation (expected values from the spec, instant): what each box, ticket and craft gives back against its price, the house edge, each pool’s money in and out per day and whether it runs dry, settles or grows, farm rewards per unit staked, what players, the treasury and the platform get each day. `scenario` overrides the spec’s own ({"perDay": {"box:flip": 1000}, "days": 30, "staked": {"<farm>": 1000}}). Quote its numbers; never your own arithmetic.',
+      'The quick simulation (expected values from the spec, instant): what each box, ticket and craft gives back against its price, the house edge, each pool’s money in and out per day and whether it runs dry, settles or grows, farm rewards per unit staked, what players, the treasury and the platform get each day; a box’s chances with its odds rules at their most, what a box that gives nothing for a miss misses as its outcomes run out, what a ticket weighs in a lottery weighed by time, and what places get from a pool that starts short. `scenario` overrides the spec’s own ({"perDay": {"box:flip": 1000}, "days": 30, "staked": {"<farm>": 1000}}). Quote its numbers; never your own arithmetic.',
     inputSchema: {
       type: 'object',
       properties: {