@xgamesfun/solana 0.25.4 → 0.26.1

package/js/economy/plan.mjs

@@ -21,7 +21,12 @@ import {
 } from '../chain/pda.js';
 import { createTableIx, extendTableIx } from '../chain/lookup.js';
 import { MEMO_PROGRAM } from '../chain/token2022.js';
-import { createAssociatedTokenAccountIdempotent, syncNative, transferLamports } from '../chain/programs.js';
+import {
+  computeUnitLimit,
+  createAssociatedTokenAccountIdempotent,
+  syncNative,
+  transferLamports,
+} from '../chain/programs.js';
 import {
   createAccountIx,
   initializeMint2Ix,
@@ -34,7 +39,7 @@ import { compileMessage, transactionSize } from '../chain/tx.js';
 import { sha256 } from '../chain/sha256.js';
 import { utf8 } from '../chain/bytes.js';
 import * as loot from '../client/index.js';
-import { check } from './check.mjs';
+import { check, MAX_COMPUTE_UNITS } from './check.mjs';
 import {
   ACCOUNT_OVERHEAD,
   boxBuys,
@@ -187,7 +192,7 @@ export function boxArgs(b, m) {
     rise: rise(b.rise, t),
     fall: fall(b.fall, t, m.now),
     stock_odds: !!b.stockOdds,
-    when_out: b.whenOut === 'drawLeft' ? 'DrawLeft' : 'StopSales',
+    when_out: WHEN_OUT[b.whenOut ?? 'stopSales'],
     active: b.active !== false,
     shares: shares(b.split, m),
     // What one open draws: each slot so many draws among the outcomes it names (all, when none), no outcome twice
@@ -371,9 +376,13 @@ export function lotteryArgs(l, m) {
       shares: shares(lotterySplit(l), m),
       // A place takes a share of the pot, a prize for its winner, or both.
       // A run of `times` places alike: "places 2 to 201 each take 1%" is one.
-      places: (l.places ?? [])
-        .map(placeOf)
-        .map(p => ({ bps: Math.round(p.percent * 100), prize: prizeOrNull(p.prize, m), times: p.times })),
+      places: (l.places ?? []).map(placeOf).map(p => ({
+        bps: Math.round(p.percent * 100),
+        prize: prizeOrNull(p.prize, m),
+        // What a place of tokens from a pool gets when the pool holds less than the places with a winner win.
+        when_short: WHEN_SHORT[p.whenShort ?? 'inOrder'],
+        times: p.times,
+      })),
       ticket_mint: l.ticketCurrency ? `@mint:${l.ticketCurrency}` : '11111111111111111111111111111111',
       draws_at: BigInt(l.firstDraw ? toTime(l.firstDraw, m.now) : m.now + every),
       // A ticket paid with one NFT that passes the rule, in place of tokens.
@@ -382,6 +391,10 @@ export function lotteryArgs(l, m) {
       returns: Boolean(l.noLoss),
       // A least sale: a round that sold fewer tickets is cancelled at its draw and refunded.
       min_sold: BigInt(l.minSold ?? 0),
+      // Sales close this long before the draw (0: at the draw).
+      closes_before: BigInt(toSeconds(l.closesBefore ?? 0)),
+      // A no-loss lottery's purchase counts for its tickets times the seconds from it to the close of sales.
+      time_weighted: Boolean(l.timeWeighted),
     },
     every: BigInt(every),
     gate: gateOf(l.gate, m),
@@ -389,6 +402,14 @@ export function lotteryArgs(l, m) {
   };
 }
 
+/** 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 const WHEN_OUT = { stopSales: 'StopSales', drawLeft: 'DrawLeft', giveNothing: 'GiveNothing' };
+/** 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 const WHEN_SHORT = { inOrder: 'InOrder', inProportion: 'InProportion', nothing: 'Nothing' };
+
 /**
  * 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
@@ -405,15 +426,17 @@ export function roundSize(l, m) {
     .reduce((n, p) => n + Number(p.times ?? 1), 0);
   const termsBytes = encodeBorsh(IDL, { defined: { name: 'LotteryTerms' } }, terms).length;
   // The tag; project, lottery, id, incarnation, round, bump, opener, lent, head, status, revision; the terms; fee, sold,
-  // to_pot; common; owns, owed, the draw's slots and times, answer and first ticket, the pot's four numbers; paid; prizes (59
+  // to_pot; the weight sold (1 byte in a round that doesn't weigh, 17 in one that does); common; owns, owed, the draw's
+  // slots and times, answer and first place's point (16), the pot's four numbers; paid; prizes (59
   // bytes each); accounts (64 each); nfts; assigned.
   const head =
     1 +
     130 +
     termsBytes +
     17 +
+    (terms.time_weighted ? 17 : 1) +
     (4 + 8 * terms.shares.length) +
-    112 +
+    120 +
     (4 + Math.ceil((2 * places) / 8)) +
     (4 + 59 * tokens) +
     (4 + 64 * (2 + pools)) +
@@ -424,6 +447,15 @@ export function roundSize(l, m) {
   return { head, accounts };
 }
 
+/** 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 const entryShape = l => {
+  const weighted = Boolean(l.timeWeighted);
+  const chosen = lotterySplit(l).some(s => String(s.to).startsWith('chosen'));
+  return [chosen || (weighted && !l.ticketNft), Boolean(l.ticketNft), weighted];
+};
+
 /** 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. */
@@ -449,10 +481,7 @@ export function roundRentOf(l, m) {
   if (l.roundRent !== undefined) return toUnits(l.roundRent, 9);
   const { head, accounts } = roundSize(l, m);
   const { rounds, entries } = roundsExpected(l, m);
-  const width = loot.entryWidth(
-    lotterySplit(l).some(s => String(s.to).startsWith('chosen')),
-    Boolean(l.ticketNft),
-  );
+  const width = loot.entryWidth(...entryShape(l));
   // The header and its entries' list head (6 bytes), each token account, each entry's bytes.
   const one = rent(head + 6) + BigInt(accounts) * rent(165) + BigInt(entries * width) * RENT_PER_BYTE;
   const all = BigInt(rounds) * one;
@@ -496,7 +525,7 @@ export function contestArgs(c, m, at = m.now) {
     // Each entry stakes one NFT that passes this rule, and the NFTs are the pot: each winner shares the losers', at most
     // `losersEach` of them (none: no cap).
     nft: c.stakeNft ? ruleOf(c.stakeNft, m) : null,
-    cap: c.stakeNft && c.losersEach ? c.losersEach : null,
+    cap: c.stakeNft && c.losersEach !== undefined ? c.losersEach : null,
   };
 }
 
@@ -920,6 +949,10 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
       id: `${part}:${kind}`,
       part,
       says,
+      // A box's write finds each of its pools' and stashes' addresses (1,500 units a try) and compares its entries
+      // pair by pair: a box of 16 stashes takes some 170,000 units, more where its addresses take more tries, past
+      // the 200,000 an instruction has by default. Its transaction asks for all a transaction can have.
+      compute: Boolean(def.Box),
       creates: [{ what, bytes }, ...pot],
       build: ctx => [
         loot.upsertIx({ owner: ctx.owner, project: project(ctx), def: resolve(def, ctx), ...options(ctx) }),
@@ -1598,6 +1631,7 @@ export const recordBytesOf = (kind, body) => {
       revision: 0,
       ...placeholders(loot.withDefaults({ Lottery: { args } }).Lottery.args),
       round: 0,
+      last: 0,
       pots: 0,
       owing: NOBODY,
     }),
@@ -1760,7 +1794,18 @@ export function setupContext(m, { owner: ownerKey, keys, live: given = {}, rent
 export const stepBytes = (instructions, ctx) =>
   transactionSize(compileMessage({ payer: ctx.owner, blockhash: placeholderKey('blockhash'), instructions }));
 
-/** Packs steps into transactions under the size budget, one signer set at a time; each step whole. */
+/** `instructions`, led by a compute limit of all a transaction can have when `compute` (a box's write is in them). */
+const budgeted = (instructions, compute) =>
+  compute ? [computeUnitLimit(MAX_COMPUTE_UNITS), ...instructions] : instructions;
+
+/** The bytes of a transaction of `step` alone, as `pack` sends it (its compute limit included). */
+export const stepAloneBytes = (step, ctx) => stepBytes(budgeted(step.build(ctx), Boolean(step.compute)), ctx);
+
+/**
+ * Packs steps into transactions under the size budget, one signer set at a time; each step whole. A transaction that
+ * carries a step needing more compute than an instruction has by default (`compute`: a box's write) asks for all a
+ * transaction can have, first.
+ */
 export function pack(steps, ctx) {
   const transactions = [];
   let current = null;
@@ -1770,25 +1815,28 @@ export function pack(steps, ctx) {
     // A step with nothing to send (the lookup table of a plan built with no recent slot) is left out.
     if (!instructions.length) continue;
     const signerKind = step.signers.includes('authority') ? 'authority' : 'owner';
-    // A write that names boxes to roll takes all the compute a transaction has: alone.
     if (current && current.signer === signerKind && !step.alone && !current.alone) {
-      const next = [...current.instructions, ...instructions];
+      const compute = current.compute || Boolean(step.compute);
+      const next = budgeted([...current.built.flat(), ...instructions], compute);
       if (sizeOf(next) <= BUDGET) {
         current.instructions = next;
+        current.compute = compute;
         current.steps.push(step);
         current.built.push(instructions);
         current.signers = [...new Set([...current.signers, ...step.signers])];
         continue;
       }
     }
-    const size = sizeOf(instructions);
+    const alone = budgeted(instructions, Boolean(step.compute));
+    const size = sizeOf(alone);
     if (size > BUDGET) throw new Error(`The step “${step.says}” is ${size} bytes: too big for one transaction.`);
     // `built`: each step's own instructions, in the order of `steps`.
     current = {
       signer: signerKind,
       steps: [step],
       built: [instructions],
-      instructions,
+      instructions: alone,
+      compute: Boolean(step.compute),
       signers: [...step.signers],
       alone: Boolean(step.alone),
     };
@@ -1803,7 +1851,8 @@ export function pack(steps, ctx) {
  * real instructions; without it they are built on stand-in addresses (for sizing, cost and showing).
  */
 export function plan(economy, { now = Math.floor(Date.now() / 1000), ctx = null, only = null, live = null } = {}) {
-  const checked = check(economy, { now });
+  // With a real context the project is known: a box's write is checked with its own address searches counted.
+  const checked = check(economy, { now, ...(ctx?.project ? { project: ctx.project } : {}) });
   if (!checked.ok) return { ok: false, refusals: checked.refusals, warnings: checked.warnings };
   const { steps, model: m } = setupSteps(economy, { now, only, live });
   if (ctx)

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."
               }
             }
           }