@xgamesfun/solana 0.20.1 → 0.25.0

package/js/economy/schema.json

@@ -4,9 +4,7 @@
   "title": "A loot economy (spec version 2)",
   "description": "One project's economy on the shared loot program: its currencies, collectibles, pools and the mechanics that move them. Kept as xsolana.json in a project (or as the `economy` section of a games.fun game). Amounts are in whole units of their token, percents are percents, durations are like \"7d\".",
   "type": "object",
-  "required": [
-    "version"
-  ],
+  "required": ["version"],
   "additionalProperties": false,
   "properties": {
     "version": {
@@ -56,7 +54,6 @@
     },
     "tokens": {
       "type": "array",
-      "maxItems": 16,
       "items": {
         "$ref": "#/$defs/token"
       }
@@ -74,7 +71,6 @@
     },
     "items": {
       "type": "array",
-      "maxItems": 64,
       "items": {
         "$ref": "#/$defs/item"
       }
@@ -88,93 +84,85 @@
     },
     "stashes": {
       "type": "array",
-      "maxItems": 32,
       "items": {
         "$ref": "#/$defs/stash"
       },
       "description": "NFTs the game holds to give away as prizes: a box's outcome `{ \"gives\": \"stash\" }` gives one of a stash's at random. The owner's wallet hands each listed NFT to the game when the economy goes live, so it must hold them then."
     },
+    "tables": {
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/table"
+      },
+      "description": "Tables of weighted rows the project writes once and seals: a fresh item's trait draws a row of one per unit (its label, or its number), by weight among the rows still in stock. Written when the economy goes live, a batch of rows a transaction."
+    },
     "boxes": {
       "type": "array",
-      "maxItems": 32,
       "items": {
         "$ref": "#/$defs/box"
       }
     },
     "payments": {
       "type": "array",
-      "maxItems": 32,
       "items": {
         "$ref": "#/$defs/payment"
       }
     },
     "recipes": {
       "type": "array",
-      "maxItems": 64,
       "items": {
         "$ref": "#/$defs/recipe"
       }
     },
     "schedules": {
       "type": "array",
-      "maxItems": 32,
       "items": {
         "$ref": "#/$defs/schedule"
       }
     },
     "lotteries": {
       "type": "array",
-      "maxItems": 16,
       "items": {
         "$ref": "#/$defs/lottery"
       }
     },
     "farms": {
       "type": "array",
-      "maxItems": 32,
       "items": {
         "$ref": "#/$defs/farm"
       }
     },
     "contests": {
       "type": "array",
-      "maxItems": 16,
       "items": {
         "$ref": "#/$defs/contest"
       }
     },
     "auctions": {
       "type": "array",
-      "maxItems": 16,
       "items": {
         "$ref": "#/$defs/auction"
       }
     },
     "holds": {
       "type": "array",
-      "maxItems": 16,
       "items": {
         "$ref": "#/$defs/hold"
       }
     },
     "grants": {
       "type": "array",
-      "maxItems": 64,
       "items": {
         "$ref": "#/$defs/grant"
       }
     },
     "traits": {
       "type": "array",
-      "maxItems": 16,
       "description": "Traits the game vouches for from NFTs' off-chain metadata (a background, a class), so rules can read them: the root of a Merkle tree of each NFT's traits (`loot.traitsTree`), set when the economy goes live. Anyone then writes an NFT's traits into its Sheet with its proof (`app.proveTraits`), and boosts, gates and odds read them like any attribute.",
       "items": {
         "type": "object",
         "additionalProperties": false,
-        "required": [
-          "collection",
-          "root"
-        ],
+        "required": ["collection", "root"],
         "properties": {
           "collection": {
             "$ref": "#/$defs/address",
@@ -193,7 +181,6 @@
     },
     "decisions": {
       "type": "array",
-      "maxItems": 32,
       "items": {
         "$ref": "#/$defs/decision"
       }
@@ -213,12 +200,11 @@
     },
     "collections": {
       "type": "array",
-      "maxItems": 7,
       "uniqueItems": true,
       "items": {
         "$ref": "#/$defs/address"
       },
-      "description": "Core collections the owner already controls (their update authority) that the project takes too, besides the one it makes: up to eight in all. An NFT of any of them is the project's own: it reads and writes it as one, and an item may be minted into it (with the project as its update delegate)."
+      "description": "Core collections the owner already controls (their update authority) that the project takes too, besides the one it makes: as many as the project's setup transaction carries (about 25 in all). An NFT of any of them is the project's own: it reads and writes it as one, and an item may be minted into it (with the project as its update delegate)."
     },
     "compressedTree": {
       "type": "object",
@@ -247,8 +233,7 @@
     },
     "link": {
       "type": "string",
-      "pattern": "^https://",
-      "maxLength": 200
+      "pattern": "^https://"
     },
     "words": {
       "type": "string",
@@ -293,15 +278,12 @@
     },
     "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), 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.",
-      "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}|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})$"
+      "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.",
+      "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": {
       "type": "object",
-      "required": [
-        "to",
-        "percent"
-      ],
+      "required": ["to", "percent"],
       "additionalProperties": false,
       "properties": {
         "to": {
@@ -314,7 +296,6 @@
     },
     "split": {
       "type": "array",
-      "maxItems": 4,
       "items": {
         "$ref": "#/$defs/share"
       },
@@ -335,10 +316,7 @@
     },
     "fall": {
       "type": "object",
-      "required": [
-        "step",
-        "every"
-      ],
+      "required": ["step", "every"],
       "additionalProperties": false,
       "description": "The price falls by `step` every `every`, from `start`, never below `floor`. A sale does not put the price back up: it stays at what was paid. By default (\"clock\": \"sale\") the next step comes `every` after that sale, so steady sales hold the price where it is. With \"clock\": \"shared\" the steps keep their own clock, sales or not: a Dutch drop that keeps falling however often it sells.",
       "properties": {
@@ -355,10 +333,7 @@
           "$ref": "#/$defs/time"
         },
         "clock": {
-          "enum": [
-            "sale",
-            "shared"
-          ],
+          "enum": ["sale", "shared"],
           "default": "sale"
         }
       }
@@ -366,7 +341,7 @@
     "life": {
       "type": "object",
       "additionalProperties": false,
-      "description": "When a recipe may take a collectible of this item. 0 switches a rule off. Fixed once one is issued.",
+      "description": "When a recipe may take a collectible of this item. The kit writes it into each recipe that takes the item, as needs and raises on the collectible (a recipe line that burns, uses, renews or takes it staked): `readyAfter` (its `made` time at least that long ago) and `lasts` (made less than that long ago) on every such line; `uses` (its `used` count raised by one, up to it: the craft is refused past it, MaxedOut) and `cooldown` (its `next_use` time passed, then set that far from now) on a line that uses it or takes it staked; a renew line counts its uses from zero again. 0 switches a rule off. A recipe can be edited at any time, and so can the life it carries.",
       "properties": {
         "readyAfter": {
           "$ref": "#/$defs/duration"
@@ -386,10 +361,7 @@
     },
     "token": {
       "type": "object",
-      "required": [
-        "key",
-        "source"
-      ],
+      "required": ["key", "source"],
       "additionalProperties": false,
       "description": "A currency. `sol`: SOL (players pay in wrapped SOL). `existing`: any mint by address, launched anywhere, classic or Token-2022, pump.fun included (games.fun takes no share of its fees). `project` (`game` is its older spelling): a token made when the economy goes live: the project mints it as its rules say (points, tickets, shards), or, with `supply`, a fixed supply minted once to the owner (a community token you keep).",
       "properties": {
@@ -397,12 +369,7 @@
           "$ref": "#/$defs/key"
         },
         "source": {
-          "enum": [
-            "sol",
-            "existing",
-            "project",
-            "game"
-          ],
+          "enum": ["sol", "existing", "project", "game"],
           "description": "`project` (`game` is its older spelling): a token made when the economy goes live, which the project mints. Such a token names no `mint`: the setup makes it."
         },
         "name": {
@@ -423,22 +390,14 @@
           "description": "`project` only: a fixed supply. Going live makes the token, mints all of it to the owner's wallet and turns minting off for good, so nobody (the project included) can ever make more. Pools are seeded from it. Leave it out for a token the project mints as its rules say (points, rewards, an emission)."
         },
         "program": {
-          "enum": [
-            "spl-token",
-            "token-2022"
-          ],
+          "enum": ["spl-token", "token-2022"],
           "default": "spl-token"
         },
         "mint": {
           "$ref": "#/$defs/address"
         },
         "venue": {
-          "enum": [
-            "games.fun",
-            "pump.fun",
-            "meteora",
-            "other"
-          ],
+          "enum": ["games.fun", "pump.fun", "meteora", "other"],
           "description": "Where the token trades, recorded for the app and not read or enforced by the tools: loot doesn't launch or trade tokens. A token launched elsewhere is `existing`, by its mint."
         },
         "uri": {
@@ -454,12 +413,7 @@
           "description": "What the mint's own keys can do, as far as the creator knows. The checker warns about each one.",
           "properties": {
             "mintAuthority": {
-              "enum": [
-                "game",
-                "someone else",
-                "none",
-                "project"
-              ]
+              "enum": ["game", "someone else", "none", "project"]
             },
             "freeze": {
               "type": "boolean"
@@ -496,9 +450,7 @@
     },
     "collection": {
       "type": "object",
-      "required": [
-        "name"
-      ],
+      "required": ["name"],
       "additionalProperties": false,
       "description": "The Metaplex Core collection the game's collectibles are minted into.",
       "properties": {
@@ -526,10 +478,7 @@
     },
     "item": {
       "type": "object",
-      "required": [
-        "key",
-        "name"
-      ],
+      "required": ["key", "name"],
       "additionalProperties": false,
       "properties": {
         "key": {
@@ -542,31 +491,20 @@
           "description": "The program's number for it. Written when it goes live; never change it after."
         },
         "name": {
-          "type": "string",
-          "maxLength": 32
+          "type": "string"
         },
         "description": {
           "$ref": "#/$defs/words"
         },
         "kind": {
-          "enum": [
-            "collectible",
-            "normal"
-          ],
+          "enum": ["collectible", "normal"],
           "default": "collectible",
           "description": "A collectible is minted to the player's wallet; a normal item lives in the project's own backend and the chain records the sale."
         },
         "rarity": {
           "anyOf": [
             {
-              "enum": [
-                "Common",
-                "Uncommon",
-                "Rare",
-                "Epic",
-                "Legendary",
-                "Mythic"
-              ]
+              "enum": ["Common", "Uncommon", "Rare", "Epic", "Legendary", "Mythic"]
             },
             {
               "type": "integer",
@@ -662,15 +600,38 @@
         "collection": {
           "$ref": "#/$defs/address",
           "description": "A collectible's collection: one of `collections`. Default: the one the setup makes."
+        },
+        "drawn": {
+          "type": "array",
+          "description": "A fresh collectible: at most 64 traits drawn for each unit, in order, written on it, each attribute's name at most 64 bytes. Each from a table (`\"table\": key`, a row by weight among those in stock, drawn atomically with the box's roll) or a range (`\"min\"`/`\"max\"`, every whole number as likely, drawn at the mint from the same answer). Its name and link may contain `{attribute}` for each, and its link `{serial}` (the name always ends with “ #<serial>”). A fresh item is given only by a box's roll.",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["attribute"],
+            "properties": {
+              "attribute": {
+                "type": "string",
+                "minLength": 1
+              },
+              "table": {
+                "$ref": "#/$defs/key"
+              },
+              "min": {
+                "type": "integer",
+                "minimum": 0
+              },
+              "max": {
+                "type": "integer",
+                "minimum": 0
+              }
+            }
+          }
         }
       }
     },
     "pool": {
       "type": "object",
-      "required": [
-        "key",
-        "currency"
-      ],
+      "required": ["key", "currency"],
       "additionalProperties": false,
       "description": "A vault only the game can spend from: a prize pool, a lottery's pot, stakers' rewards.",
       "properties": {
@@ -697,25 +658,12 @@
     },
     "outcome": {
       "type": "object",
-      "required": [
-        "gives"
-      ],
+      "required": ["gives"],
       "additionalProperties": false,
-      "description": "One way a box can land: an item, tokens from a pool (`pay`, `share`) or minted (`tokens`), an NFT of a stash at random (`stash`) or a named one (`nft`), a roll of another box (`roll`), up to three of them together (`bundle`), a burn of the payment, or nothing. Give every outcome a `chance` (percents that add up to 100) or every one a `weight`. In a box that rolls on an NFT (`rollsOn`), an outcome can also move numbers on it (`shifts`) and say where it goes (`then`). A box of one outcome that needs no chance sells in one step (`buy`): no order, no settle.",
+      "description": "One way a box can land: an item, a fixed amount of tokens from a pool (`pay`) or minted (`tokens`), all of it or none, an NFT of a stash at random (`stash`) or a named one (`nft`), a roll of another box (`roll`), any number of them together (`bundle`), or nothing. Give every outcome a `chance` (percents that add up to 100) or every one a `weight`. In a box that rolls on an NFT (`rollsOn`), an outcome can also move numbers on it (`shifts`) and say where it goes (`then`). A box of one outcome that needs no chance sells in one step (`buy`): no order, no settle. A box burns its price with a \"burn\" share in its `split`, whatever the roll gives.",
       "properties": {
         "gives": {
-          "enum": [
-            "item",
-            "pay",
-            "share",
-            "stash",
-            "tokens",
-            "nft",
-            "roll",
-            "bundle",
-            "burn",
-            "nothing"
-          ]
+          "enum": ["item", "pay", "stash", "tokens", "nft", "roll", "bundle", "nothing"]
         },
         "chance": {
           "type": "number",
@@ -736,25 +684,17 @@
         "amount": {
           "$ref": "#/$defs/amount"
         },
-        "percent": {
-          "$ref": "#/$defs/percent"
-        },
         "shifts": {
           "type": "array",
-          "maxItems": 2,
           "description": "For a box that rolls on an NFT (`rollsOn`): numbers this outcome moves on it (+1 level, -2 affection), never below 0, and never above `upTo` when raising. Written on the NFT when the game has authority over it, in its Sheet otherwise. With `fromNow`, a time: a day in jail from now.",
           "items": {
             "type": "object",
             "additionalProperties": false,
-            "required": [
-              "attribute",
-              "by"
-            ],
+            "required": ["attribute", "by"],
             "properties": {
               "attribute": {
                 "type": "string",
-                "minLength": 1,
-                "maxLength": 32
+                "minLength": 1
               },
               "by": {
                 "anyOf": [
@@ -784,7 +724,7 @@
                     "$ref": "#/$defs/duration"
                   }
                 ],
-                "description": "The most it reaches when raising. With `fromNow`, how far past now."
+                "description": "The most it reaches when raising; left out, no cap. With `fromNow`, how far past now."
               },
               "fromNow": {
                 "type": "boolean",
@@ -798,18 +738,12 @@
           "description": "For a box that rolls on an NFT: where the NFT goes after this outcome. \"back\" (the default) to whoever brought it; \"burn\" (a Core asset burned; any other kind sent to the incinerator's address, where nobody can move it); \"treasury\" to the game's treasury wallet; { \"giveTo\": \"<wallet>\" } to that wallet. A box with any outcome that burns or gives the NFT away takes it into the game's hands when it is rolled, until the roll is settled (a custodial route). { \"stash\": \"<key>\" }: into one of the spec's stashes, a trade-in that becomes another player's prize.",
           "anyOf": [
             {
-              "enum": [
-                "back",
-                "burn",
-                "treasury"
-              ]
+              "enum": ["back", "burn", "treasury"]
             },
             {
               "type": "object",
               "additionalProperties": false,
-              "required": [
-                "giveTo"
-              ],
+              "required": ["giveTo"],
               "properties": {
                 "giveTo": {
                   "$ref": "#/$defs/address"
@@ -819,9 +753,7 @@
             {
               "type": "object",
               "additionalProperties": false,
-              "required": [
-                "stash"
-              ],
+              "required": ["stash"],
               "properties": {
                 "stash": {
                   "$ref": "#/$defs/key"
@@ -854,13 +786,10 @@
         "prizes": {
           "type": "array",
           "minItems": 1,
-          "maxItems": 3,
-          "description": "For bundle: what it gives together, at most three: each { gives: item | pay | share | stash | tokens | nft | roll, … } as an outcome of one says.",
+          "description": "For bundle: what it gives together, any number: each { gives: item | pay | share | stash | tokens | nft | roll, … } as an outcome of one says.",
           "items": {
             "type": "object",
-            "required": [
-              "gives"
-            ],
+            "required": ["gives"],
             "additionalProperties": false,
             "properties": {
               "item": {
@@ -872,9 +801,6 @@
               "amount": {
                 "$ref": "#/$defs/amount"
               },
-              "percent": {
-                "$ref": "#/$defs/percent"
-              },
               "stash": {
                 "$ref": "#/$defs/key",
                 "description": "For stash: the stash one NFT of which this outcome gives, picked at random when the box is rolled (a box of one such outcome is still rolled by the oracle). For nft: the stash that lists `nft`."
@@ -897,34 +823,24 @@
                 "description": "For roll: the box rolled for the player when the order settles."
               },
               "gives": {
-                "enum": [
-                  "item",
-                  "pay",
-                  "share",
-                  "stash",
-                  "tokens",
-                  "nft",
-                  "roll"
-                ]
+                "enum": ["item", "pay", "stash", "tokens", "nft", "roll"]
+              },
+              "compressed": {
+                "type": "boolean",
+                "description": "For item: a compressed NFT of the collectible (Bubblegum v2), minted at the settle into the project's tree (`compressedTree`) instead of a Core asset. A plain one holds no collectible's rent; a fresh one's drawn traits are written in the project's Sheet for it, its rent held by the order until the settle."
               }
             }
           }
         },
-        "burns": {
+        "compressed": {
           "type": "boolean",
-          "default": false,
-          "description": "For bundle: the payment is burned, all of it, in place of the box's split."
+          "description": "For item: a compressed NFT of the collectible (Bubblegum v2), minted at the settle into the project's tree (`compressedTree`) instead of a Core asset. A plain one holds no collectible's rent; a fresh one's drawn traits are written in the project's Sheet for it, its rent held by the order until the settle."
         }
       }
     },
     "box": {
       "type": "object",
-      "required": [
-        "key",
-        "name",
-        "price",
-        "outcomes"
-      ],
+      "required": ["key", "name", "price", "outcomes"],
       "additionalProperties": false,
       "properties": {
         "key": {
@@ -958,6 +874,11 @@
           "default": false,
           "description": "Each item's chance shrinks with what is left of its supply."
         },
+        "whenOut": {
+          "enum": ["stopSales", "drawLeft"],
+          "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\"."
+        },
         "active": {
           "type": "boolean",
           "default": true,
@@ -969,7 +890,6 @@
         "outcomes": {
           "type": "array",
           "minItems": 1,
-          "maxItems": 8,
           "items": {
             "$ref": "#/$defs/outcome"
           }
@@ -980,7 +900,6 @@
         },
         "odds": {
           "type": "array",
-          "maxItems": 4,
           "items": {
             "$ref": "#/$defs/odds"
           }
@@ -1010,18 +929,12 @@
           "description": "Where the NFT it rolls on goes after an outcome that names no `then` of its own: a box that takes an NFT as its price (`rollsOn` its rule, `then` \"burn\", \"treasury\", { giveTo } or { stash }).",
           "anyOf": [
             {
-              "enum": [
-                "back",
-                "burn",
-                "treasury"
-              ]
+              "enum": ["back", "burn", "treasury"]
             },
             {
               "type": "object",
               "additionalProperties": false,
-              "required": [
-                "giveTo"
-              ],
+              "required": ["giveTo"],
               "properties": {
                 "giveTo": {
                   "$ref": "#/$defs/address"
@@ -1031,9 +944,7 @@
             {
               "type": "object",
               "additionalProperties": false,
-              "required": [
-                "stash"
-              ],
+              "required": ["stash"],
               "properties": {
                 "stash": {
                   "$ref": "#/$defs/key"
@@ -1041,16 +952,44 @@
               }
             }
           ]
+        },
+        "slots": {
+          "type": "array",
+          "description": "What one open draws: each slot `count` draws among the outcomes it names (`from`: their places in `outcomes`, from 0; all when left out), and with `distinct` no outcome twice in the open. Left out, an open is one draw among every outcome. A pack of five is `[{ \"count\": 5 }]`; a guaranteed rare `[{ \"count\": 4 }, { \"count\": 1, \"from\": [8, 9, 10] }]`. A player may open several packs in one purchase.",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["count"],
+            "properties": {
+              "count": {
+                "type": "integer",
+                "minimum": 1
+              },
+              "from": {
+                "type": "array",
+                "items": {
+                  "type": "integer",
+                  "minimum": 0,
+                  "maximum": 65535
+                }
+              },
+              "distinct": {
+                "type": "boolean"
+              },
+              "share": {
+                "type": "number",
+                "minimum": 0,
+                "maximum": 100,
+                "description": "What this slot's draws are worth, as a percent of an open's price. Needed on every slot of a box whose slots name outcomes (`from`), 100 together: a draw that can't be made (its slot sold out) gives this share back, so a guaranteed rare keeps its value when the commons run out. Leave it out when every slot draws among all the outcomes."
+              }
+            }
+          }
         }
       }
     },
     "payment": {
       "type": "object",
-      "required": [
-        "key",
-        "name",
-        "amount"
-      ],
+      "required": ["key", "name", "amount"],
       "additionalProperties": false,
       "description": "A payment a player signs for something the game gives off chain: an entry fee, an attempt at a level, a tip.",
       "properties": {
@@ -1079,22 +1018,12 @@
     },
     "input": {
       "type": "object",
-      "required": [
-        "takes"
-      ],
+      "required": ["takes"],
       "additionalProperties": false,
-      "description": "burn: `count` collectibles of `item`, burned. use: one collectible of `item`, kept (counts a use). renew: one kept, its uses counted from zero again. staked: one collectible of `item`, kept as `use` keeps it, that must be staked in `farm`: on its own seat in that farm of this spec, which escrows or freezes it (a watched one could be sold). A set bound into a badge takes its pieces this way and moves that farm's `lockAttribute` far ahead, so they stay staked while the badge exists; a recipe that raises anything on a staked piece must raise its farm's `lockAttribute` (to raise a stat and leave the lock alone, use `use`). show: one NFT of `collection` the player holds, kept (any Core NFT, or a Token Metadata NFT verified in it; the game's own collection when left out), read with what the game wrote in its Sheet. pay: `amount` of `currency`, sent `to` a destination. trade: one NFT of `collection` the player holds, any kind, traded in: burned, given on, or put in a stash (`then`).",
+      "description": "burn: `count` collectibles of `item`, burned. use: one collectible of `item`, kept (counts a use of its life). renew: one kept, its uses counted from zero again (its `used` count). staked: one collectible of `item`, kept as `use` keeps it, that must be staked in `farm`: on its own seat in that farm of this spec, which escrows or freezes it (a watched one could be sold). A set bound into a badge takes its pieces this way and moves that farm's `lockAttribute` far ahead, so they stay staked while the badge exists; a recipe that raises anything on a staked piece must raise its farm's `lockAttribute` (to raise a stat and leave the lock alone, use `use`). show: one NFT of `collection` the player holds, kept (any Core NFT, or a Token Metadata NFT verified in it; the game's own collection when left out), read with what the game wrote in its Sheet. pay: `amount` of `currency`, sent `to` a destination. trade: one NFT of `collection` the player holds, any kind, traded in: burned, given on, or put in a stash (`then`).",
       "properties": {
         "takes": {
-          "enum": [
-            "burn",
-            "use",
-            "renew",
-            "show",
-            "staked",
-            "pay",
-            "trade"
-          ]
+          "enum": ["burn", "use", "renew", "show", "staked", "pay", "trade"]
         },
         "item": {
           "$ref": "#/$defs/key"
@@ -1106,7 +1035,7 @@
         "count": {
           "type": "integer",
           "minimum": 1,
-          "maximum": 8
+          "maximum": 255
         },
         "amount": {
           "$ref": "#/$defs/amount"
@@ -1129,20 +1058,12 @@
     },
     "output": {
       "type": "object",
-      "required": [
-        "gives"
-      ],
+      "required": ["gives"],
       "additionalProperties": false,
-      "description": "A prize (see `prize`), or a roll on a collectible the recipe keeps: { \"gives\": \"roll\", \"box\": key, \"on\": place } (a risky upgrade; anyone asks the oracle and settles it). A craft refuses a prize it can't give (a pool that holds less, an item sold out or switched off, an NFT gone).",
+      "description": "A prize (see `prize`), or a roll on a collectible the recipe keeps: { \"gives\": \"roll\", \"box\": key, \"on\": place } (a risky upgrade; the player or the project’s keys ask the oracle and settle it). A craft refuses a prize it can't give (a pool that holds less, an item sold out or switched off, an NFT gone).",
       "properties": {
         "gives": {
-          "enum": [
-            "item",
-            "tokens",
-            "share",
-            "nft",
-            "roll"
-          ]
+          "enum": ["item", "tokens", "nft", "roll"]
         },
         "item": {
           "$ref": "#/$defs/key"
@@ -1162,12 +1083,6 @@
           "type": "string",
           "pattern": "^(mint|pool:[a-z][a-z0-9-]{0,31})$"
         },
-        "pool": {
-          "$ref": "#/$defs/key"
-        },
-        "percent": {
-          "$ref": "#/$defs/percent"
-        },
         "box": {
           "$ref": "#/$defs/key",
           "description": "For `roll`: the box rolled, free, for the player."
@@ -1175,7 +1090,7 @@
         "on": {
           "type": "integer",
           "minimum": 0,
-          "maximum": 7,
+          "maximum": 254,
           "description": "For `roll`: the collectible handed in and kept (its place, the first is 0) the box rolls on (a risky upgrade); left out, it rolls on nothing (a merge whose result is left to chance). One a recipe."
         },
         "stash": {
@@ -1190,11 +1105,7 @@
     },
     "recipe": {
       "type": "object",
-      "required": [
-        "key",
-        "name",
-        "in"
-      ],
+      "required": ["key", "name", "in"],
       "additionalProperties": false,
       "properties": {
         "key": {
@@ -1215,40 +1126,32 @@
         },
         "in": {
           "type": "array",
-          "maxItems": 8,
           "items": {
             "$ref": "#/$defs/input"
           }
         },
         "out": {
           "type": "array",
-          "maxItems": 8,
           "items": {
             "$ref": "#/$defs/output"
           }
         },
         "needs": {
           "type": "array",
-          "maxItems": 8,
           "items": {
             "type": "object",
-            "required": [
-              "place",
-              "key",
-              "atLeast"
-            ],
+            "required": ["place", "key", "atLeast"],
             "additionalProperties": false,
             "description": "The collectible handed in at `place` (the first is 0) must carry a number `key` the authority wrote of at least `atLeast`.",
             "properties": {
               "place": {
                 "type": "integer",
                 "minimum": 0,
-                "maximum": 7
+                "maximum": 254
               },
               "key": {
                 "type": "string",
-                "minLength": 1,
-                "maxLength": 32
+                "minLength": 1
               },
               "atLeast": {
                 "type": "integer",
@@ -1260,58 +1163,46 @@
         },
         "keeps": {
           "type": "array",
-          "maxItems": 8,
           "items": {
             "type": "object",
-            "required": [
-              "key",
-              "from",
-              "to"
-            ],
+            "required": ["key", "from", "to"],
             "additionalProperties": false,
             "description": "The new collectible `to` (the first made is 0) takes attribute `key` from the one handed in at `from`.",
             "properties": {
               "key": {
                 "type": "string",
-                "minLength": 1,
-                "maxLength": 32
+                "minLength": 1
               },
               "from": {
                 "type": "integer",
                 "minimum": 0,
-                "maximum": 7
+                "maximum": 254
               },
               "to": {
                 "type": "integer",
                 "minimum": 0,
-                "maximum": 7
+                "maximum": 254
               }
             }
           }
         },
         "raises": {
           "type": "array",
-          "maxItems": 8,
           "description": "Numbers the recipe moves on collectibles handed in and kept (use, renew, show): a level or a stat bought with the recipe's own payment, or one it costs (a negative `by`: a merge that costs a level, never below 0). Written on the NFT when the game has authority over it, in its Sheet otherwise. One already at `upTo` is refused (MaxedOut) when raising. With `fromNow`, it moves a time: fuel for a day more (\"by\": \"1d\", \"upTo\": \"3d\"), a day off a lock (\"by\": \"-1d\").",
           "items": {
             "type": "object",
-            "required": [
-              "place",
-              "key",
-              "by"
-            ],
+            "required": ["place", "key", "by"],
             "additionalProperties": false,
             "properties": {
               "place": {
                 "type": "integer",
                 "minimum": 0,
-                "maximum": 7,
+                "maximum": 254,
                 "description": "Which collectible handed in (the first is 0); one that is kept."
               },
               "key": {
                 "type": "string",
-                "minLength": 1,
-                "maxLength": 32
+                "minLength": 1
               },
               "by": {
                 "anyOf": [
@@ -1341,7 +1232,7 @@
                     "$ref": "#/$defs/duration"
                   }
                 ],
-                "description": "The most it reaches; needed when raising. With `fromNow`, how far past now: \"3d\". On a farm's `lockAttribute` or `upkeepAttribute` moved without `fromNow` (by a duration, from the time as written: a bound set's \"20000d\"), left out: no cap."
+                "description": "The most it reaches; left out, no cap. With `fromNow`, how far past now: \"3d\"."
               },
               "fromNow": {
                 "type": "boolean",
@@ -1372,11 +1263,7 @@
     },
     "schedule": {
       "type": "object",
-      "required": [
-        "key",
-        "does",
-        "every"
-      ],
+      "required": ["key", "does", "every"],
       "additionalProperties": false,
       "description": "issue: mint `amount` of a game token into `pool`, halving every `halveEvery` runs. burn: burn `percent` (or `amount`) of what `pool` holds. move: move `percent` (or `amount`) of what pool `from` holds into pool `to`. pay: pay `amount` (or `percent`) from pool `from` `to` a wallet (\"wallet:<address>\"), a token account (\"account:<token account>\") or a collectible's holder (\"holder:<asset>\") on each run: a payroll, a vesting drip, a landlord's rent. Anyone may run it when it is due.",
       "properties": {
@@ -1393,12 +1280,7 @@
           "maxLength": 40
         },
         "does": {
-          "enum": [
-            "issue",
-            "burn",
-            "move",
-            "pay"
-          ]
+          "enum": ["issue", "burn", "move", "pay"]
         },
         "currency": {
           "$ref": "#/$defs/key"
@@ -1418,7 +1300,7 @@
               "$ref": "#/$defs/destination"
             }
           ],
-          "description": "move: the pool it fills. pay: \"wallet:<address>\", \"account:<token account address>\" or \"holder:<asset address>\", or \"lottery:<key>\" (that lottery's pot: a sponsored or no-loss prize stream)."
+          "description": "move: the pool it fills. issue: \"farm:<key>\" to mint into that farm's rewards vault instead of a `pool` (an emission its stakers share). pay: \"wallet:<address>\", \"account:<token account address>\" or \"holder:<asset address>\", \"lottery:<key>\" (that lottery's pot: a sponsored or no-loss prize stream) or \"farm:<key>\" (that farm's rewards vault). A sealed one pays only \"wallet:<address>\", \"treasury\" or \"burn\"."
         },
         "amount": {
           "$ref": "#/$defs/amount"
@@ -1452,7 +1334,7 @@
         },
         "sealed": {
           "type": "boolean",
-          "description": "A sealed schedule (does \"pay\", in `currency`): it pays from a vault of its own that nothing else can touch, and once written nobody, the owner included, can change it, switch it off or take its tokens back. It needs `maxRuns`; its last run pays whatever is left. Vesting, an unlock, a sponsored prize stream with a real guarantee."
+          "description": "A sealed schedule (does \"pay\", in `currency`): it pays from a vault of its own that nothing else can touch, and once written nobody, the owner included, can change it, switch it off or take its tokens back. It needs `maxRuns`; its last run pays whatever is left. It pays a wallet, the treasury or a burn (a stream into a pool, a pot or a farm is only as safe as where it lands: leave it unsealed). Vesting, an unlock."
         },
         "fund": {
           "$ref": "#/$defs/amount",
@@ -1468,9 +1350,14 @@
     },
     "lottery": {
       "type": "object",
-      "required": [
-        "key",
-        "name"
+      "required": ["key", "name"],
+      "oneOf": [
+        {
+          "required": ["pot"]
+        },
+        {
+          "required": ["rest"]
+        }
       ],
       "additionalProperties": false,
       "properties": {
@@ -1488,20 +1375,29 @@
         },
         "price": {
           "$ref": "#/$defs/amount",
-          "description": "One ticket, in the pot's currency (or in `ticketCurrency`). Leave it out for a lottery whose tickets cost an NFT (`ticketNft`)."
+          "description": "One ticket, in the lottery's currency (or in `ticketCurrency`). Leave it out for a lottery whose tickets cost an NFT (`ticketNft`)."
         },
         "ticketCurrency": {
           "$ref": "#/$defs/key",
-          "description": "Tickets paid in another token are burned, and the pot is filled from elsewhere."
+          "description": "Tickets paid in another token are burned, and no ticket money reaches the places: they are paid from what reaches the pot from elsewhere (\"pot\")."
         },
         "cutPercent": {
           "$ref": "#/$defs/percent",
-          "description": "The share of ticket money that goes to the treasury instead of the pot (the same as a split share to \"treasury\")."
+          "description": "The share of ticket money that goes to the treasury before the places (the same as a split share to \"treasury\")."
+        },
+        "pot": {
+          "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."
+        },
+        "rest": {
+          "$ref": "#/$defs/destination",
+          "description": "Pays each round's places from that round's own ticket money only, and sends what they leave here: \"treasury\", \"burn\", \"wallet:<address>\", \"account:<token account>\", \"holder:<collectible>\", a pool, a farm or another lottery (\"lottery:<key>\"), never \"chosen\" or itself; a pool, farm or lottery named here counts the leftover only once someone pulls it. Nothing from outside can change a round's prizes: no seed, no gifts, no carry-over. Write exactly one of \"pot\" or \"rest\"."
         },
         "places": {
           "type": "array",
           "minItems": 1,
-          "maxItems": 8,
           "items": {
             "anyOf": [
               {
@@ -1520,13 +1416,19 @@
                   },
                   "prize": {
                     "$ref": "#/$defs/prize",
-                    "description": "What its winner gets besides its share of the pot: a raffled NFT, a collectible, tokens, a roll of a box."
+                    "description": "What its winner gets besides its percent of the money: a raffled NFT, a collectible, tokens, a roll of a box."
+                  },
+                  "times": {
+                    "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": "What each place wins, first place first: a percent of the pot, or { \"percent\", \"prize\" }: a share of the pot and a prize for its winner (either, or both). Default: one winner takes all."
+          "description": "What each place wins, first place first: a percent of what the round pays from (its pot with the round's ticket money, or with \"rest\" that round's ticket money alone), or { \"percent\", \"prize\", \"times\" }: a percent and a prize for its winner (either, or both), for `times` places in a row. Default: one winner takes all."
         },
         "every": {
           "$ref": "#/$defs/duration",
@@ -1540,15 +1442,36 @@
         },
         "currency": {
           "$ref": "#/$defs/key",
-          "description": "The pot's token. Default: the game's currency."
+          "description": "The token tickets are paid in and the places are paid in (and the pot's, with \"pot\"). Default: the game's currency."
         },
         "seed": {
           "$ref": "#/$defs/amount",
-          "description": "What the owner puts in the pot at go-live."
+          "description": "What the owner puts in the pot at go-live (a lottery with \"pot\" only)."
+        },
+        "roundRent": {
+          "$ref": "#/$defs/amount",
+          "description": "SOL the owner puts in the lottery at go-live to pay each round's record, its token accounts and every purchase's entry (lent to the round, back to the lottery when it closes): buyers then pay no program rent for a ticket. On by default, sized from `expect` (its rounds open or paying out at once, and a round's purchases); give an amount to set it, 0 to turn it off. When it runs short, a round's first buyer fronts its record, back to them at the close, and each buyer pays their own entry's bytes."
+        },
+        "expect": {
+          "type": "object",
+          "additionalProperties": false,
+          "description": "What the default `roundRent` is sized for: `rounds`, the rounds open or still paying out at once (default 2 for a lottery that draws again, 1 for one that draws once), and `entries`, the purchases a round takes (default: the scenario's purchases a day over a round, else 100).",
+          "properties": {
+            "rounds": {
+              "type": "integer",
+              "minimum": 1,
+              "maximum": 100
+            },
+            "entries": {
+              "type": "integer",
+              "minimum": 0,
+              "maximum": 262000
+            }
+          }
         },
         "split": {
           "$ref": "#/$defs/split",
-          "description": "Where ticket money goes before the pot (the rest goes into the pot): a charity, a referrer the buyer names (\"chosen\"), the treasury."
+          "description": "Where ticket money goes before the places (the rest is the round's money for its places): a charity, a referrer the buyer names (\"chosen\"), the treasury."
         },
         "perWallet": {
           "type": "integer",
@@ -1558,11 +1481,11 @@
         },
         "ticketNft": {
           "$ref": "#/$defs/nftPrice",
-          "description": "A ticket costs one NFT that passes the rule, in place of tokens: held until the draw, then burned, given on or stashed; back to its buyer if the draw is cancelled. Such a lottery has no price and no split; its pot is what the owner and its places' prizes put in."
+          "description": "A ticket costs one NFT that passes the rule, in place of tokens: held until the draw, then burned, given on or stashed; back to its buyer if the draw is cancelled. Such a lottery has no price and no split; its places are paid from what the owner and others put in its pot (\"pot\"), and its places' prizes."
         },
         "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>\"). 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>\"). It needs \"pot\". No split, no cut and no `ticketCurrency`; NFT tickets come back too."
         },
         "minSold": {
           "type": "integer",
@@ -1578,9 +1501,7 @@
             {
               "type": "object",
               "additionalProperties": false,
-              "required": [
-                "nft"
-              ],
+              "required": ["nft"],
               "properties": {
                 "nft": {
                   "$ref": "#/$defs/address"
@@ -1593,17 +1514,38 @@
             }
           ],
           "description": "A raffle: this NFT (one the owner holds, put in the lottery's own stash at go-live) is first place's prize, held so that nothing but the draw can give it, and the lottery draws once. The same as a first place { \"prize\": { \"gives\": \"nft\", \"nft\": <address>, \"held\": true } }. An NFT of another collection is { \"nft\", \"collection\" }."
+        },
+        "nfts": {
+          "type": "array",
+          "maxItems": 500,
+          "items": {
+            "anyOf": [
+              {
+                "$ref": "#/$defs/address"
+              },
+              {
+                "type": "object",
+                "additionalProperties": false,
+                "required": ["nft"],
+                "properties": {
+                  "nft": {
+                    "$ref": "#/$defs/address"
+                  },
+                  "collection": {
+                    "$ref": "#/$defs/address"
+                  }
+                }
+              }
+            ]
+          },
+          "description": "NFTs the lottery's own stash holds for its places that give { \"gives\": \"raffled\" } (each draws one at random with the round's answer): a raffle of many NFTs. Your wallet puts them in at go-live, a group a transaction, before the lottery is written; at least as many as such places. The lottery draws once."
         }
       },
-      "description": "Tickets into a pot of the lottery's own, one random draw, the winners paid. Nothing but its winners' payouts takes from the pot: not the authority, a schedule, a farm or a recipe. Anything sold or paid can send it a share (\"lottery:<key>\" in a split); a schedule can't pay a lottery."
+      "description": "Tickets sold in rounds, one random draw a round, the winners paid. It names where its places are paid from, exactly one of: \"pot\", a pot of its own kept from round to round that anything can add to (a seed, a share of a sale or payment, \"lottery:<key>\" in a split, a schedule that pays \"lottery:<key>\"); or \"rest\", each round's own ticket money alone, what the places leave going to that destination. Nothing but its winners' payouts takes from a pot: not the authority, a schedule, a farm or a recipe."
     },
     "contest": {
       "type": "object",
-      "required": [
-        "key",
-        "name",
-        "sides"
-      ],
+      "required": ["key", "name", "sides"],
       "additionalProperties": false,
       "description": "Players put money on a side; the side that wins shares the pot. The authority opens each one while the game runs, and the authority or one of its `deciders` (a results server's key) names the side that won. One side and a `minPot` is an all-or-nothing crowdfund; a wallet gate and a `stake` is a duel.",
       "properties": {
@@ -1620,11 +1562,11 @@
         "sides": {
           "type": "integer",
           "minimum": 1,
-          "maximum": 255
+          "maximum": 1024
         },
         "sideNames": {
           "type": "array",
-          "maxItems": 255,
+          "maxItems": 1024,
           "items": {
             "type": "string",
             "maxLength": 40
@@ -1654,7 +1596,6 @@
         },
         "deciders": {
           "type": "array",
-          "maxItems": 3,
           "items": {
             "$ref": "#/$defs/address"
           },
@@ -1675,17 +1616,17 @@
         "stakeNft": {
           "$ref": "#/$defs/rule",
           "description": "Each entry stakes one NFT that passes this rule, in place of tokens, and the NFTs are the pot: each winning entry takes its own back and one of the losers', in the order they are claimed; what the winners leave goes to whoever opened it. Called off, each takes its own back. No split and no stake."
+        },
+        "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."
         }
       }
     },
     "auction": {
       "type": "object",
-      "required": [
-        "key",
-        "name",
-        "lot",
-        "runs"
-      ],
+      "required": ["key", "name", "lot", "runs"],
       "additionalProperties": false,
       "description": "An English auction, opened when the economy goes live: the highest bid when the time runs out wins the lot. Each bid must reach the reserve and top the last by the least raise; a bid that is topped goes back to its bidder at once. A late bid moves the end. With no bid the lot goes home.",
       "properties": {
@@ -1715,9 +1656,7 @@
           "oneOf": [
             {
               "type": "object",
-              "required": [
-                "item"
-              ],
+              "required": ["item"],
               "additionalProperties": false,
               "properties": {
                 "item": {
@@ -1727,9 +1666,7 @@
             },
             {
               "type": "object",
-              "required": [
-                "asset"
-              ],
+              "required": ["asset"],
               "additionalProperties": false,
               "properties": {
                 "asset": {
@@ -1743,9 +1680,7 @@
             },
             {
               "type": "object",
-              "required": [
-                "roll"
-              ],
+              "required": ["roll"],
               "additionalProperties": false,
               "properties": {
                 "roll": {
@@ -1791,11 +1726,7 @@
     },
     "hold": {
       "type": "object",
-      "required": [
-        "key",
-        "name",
-        "item"
-      ],
+      "required": ["key", "name", "item"],
       "additionalProperties": false,
       "description": "A player hands a collectible to the game for a time they choose; until it is up the authority says where it goes, after it anyone can send it home.",
       "properties": {
@@ -1825,11 +1756,7 @@
     },
     "decision": {
       "type": "object",
-      "required": [
-        "key",
-        "when",
-        "does"
-      ],
+      "required": ["key", "when", "does"],
       "additionalProperties": false,
       "description": "A rule only the game can carry out, signed by the authority while the game runs.",
       "properties": {
@@ -1840,18 +1767,7 @@
           "$ref": "#/$defs/words"
         },
         "does": {
-          "enum": [
-            "payout",
-            "burn",
-            "issue",
-            "make",
-            "unmake",
-            "set",
-            "award",
-            "decide",
-            "roll",
-            "open_contest"
-          ]
+          "enum": ["payout", "burn", "issue", "make", "unmake", "set", "award", "decide", "roll", "open_contest"]
         },
         "pool": {
           "$ref": "#/$defs/key"
@@ -1884,19 +1800,14 @@
           "description": "How often it happens, for the simulation."
         },
         "signedBy": {
-          "enum": [
-            "page",
-            "server"
-          ],
+          "enum": ["page", "server"],
           "default": "page",
           "description": "page: the authority approves each one in its own wallet. server: a server you run holds the authority key (keys.authority is its public address)."
         },
         "proof": {
           "type": "object",
           "additionalProperties": false,
-          "required": [
-            "payment"
-          ],
+          "required": ["payment"],
           "description": "What a claim must show before the keeper or the page acts on it: a payment the receiver made on chain (an attempt), not claimed before, at least `after` and at most `within` before the claim. The game's word alone is never proof: it runs in the player's browser. The checker only checks that `payment` is one of the economy's payments; `after` and `within` are recorded for the server that acts on claims, and neither the tools nor the program enforce them.",
           "properties": {
             "payment": {
@@ -1990,6 +1901,13 @@
           "$ref": "#/$defs/address",
           "description": "The project's tree of compressed NFTs, once the setup opened it."
         },
+        "tables": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/address"
+          },
+          "description": "The project's standing lookup tables, made at go-live (the owner their authority): a transaction too big for a legacy one goes as v0 with them, in one approval."
+        },
         "treasury": {
           "$ref": "#/$defs/address"
         },
@@ -2063,10 +1981,7 @@
           "items": {
             "type": "object",
             "additionalProperties": false,
-            "required": [
-              "signature",
-              "steps"
-            ],
+            "required": ["signature", "steps"],
             "properties": {
               "signature": {
                 "type": "string",
@@ -2122,7 +2037,7 @@
       "type": "object",
       "additionalProperties": false,
       "required": [],
-      "description": "What an NFT the player shows must be: of an `item` the game mints, or of a `collection` (a Core collection, or a Token Metadata collection mint it is verified in; with neither, the game's own collection, the one it has authority over); and, when `attribute` is given, its attribute at least `atLeast`, equal to `equals`, a time still `ahead` or `passed` (`time`), or present. `{ \"item\": \"pass\" }` alone means \"holds a Member Pass\". An NFT's attributes are read as they are; for one the game has no authority over, what the game wrote about it in its Sheet counts over them.",
+      "description": "What an NFT the player shows must be: of an `item` the game mints, or of a `collection` (a Core collection, or a Token Metadata collection mint it is verified in; with neither, the game's own collection, the one it has authority over); and, when `attribute` is given, its attribute at least `atLeast`, equal to `equals`, one of `oneOf`, a time still `ahead` or `passed` (`time`), or present. `{ \"item\": \"pass\" }` alone means \"holds a Member Pass\"; `{ \"items\": [\"oak\", \"pine\"] }` means any of them. An NFT's attributes are read as they are; for one the game has no authority over, what the game wrote about it in its Sheet counts over them.",
       "properties": {
         "item": {
           "$ref": "#/$defs/key",
@@ -2130,12 +2045,11 @@
         },
         "collection": {
           "$ref": "#/$defs/address",
-          "description": "Any NFT of this collection: a Metaplex Core collection, or the mint of a Token Metadata collection its NFTs are verified in. Leave it and `item` out for the game's own collection."
+          "description": "Any NFT of this collection: a Metaplex Core collection, or the mint of a Token Metadata collection its NFTs are verified in (a print of a master, which its holder makes without the collection's authority, counts as in no collection). Leave it and `item` out for the game's own collection."
         },
         "attribute": {
           "type": "string",
-          "minLength": 1,
-          "maxLength": 32
+          "minLength": 1
         },
         "atLeast": {
           "type": "integer",
@@ -2143,14 +2057,24 @@
           "maximum": 4294967295
         },
         "equals": {
-          "type": "string",
-          "maxLength": 32
+          "type": "string"
+        },
+        "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."
+        },
+        "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`."
         },
         "time": {
-          "enum": [
-            "ahead",
-            "passed"
-          ],
+          "enum": ["ahead", "passed"],
           "description": "The attribute is a time (Unix seconds) still to come (\"ahead\": fuel left, a pass still good) or past, or missing (\"passed\": out of jail, no cooldown). In a farm's gate it is read as an NFT comes in; after that, the farm's `upkeepAttribute` says how long it earns."
         }
       }
@@ -2182,17 +2106,13 @@
     "odds": {
       "type": "object",
       "additionalProperties": false,
-      "required": [
-        "outcome",
-        "when",
-        "add"
-      ],
+      "required": ["outcome", "when", "add"],
       "description": "A box outcome that grows more likely for a player who shows a collectible.",
       "properties": {
         "outcome": {
           "type": "integer",
           "minimum": 0,
-          "maximum": 7,
+          "maximum": 65535,
           "description": "Which outcome (0 is the first)."
         },
         "when": {
@@ -2206,9 +2126,7 @@
     "tier": {
       "type": "object",
       "additionalProperties": false,
-      "required": [
-        "lock"
-      ],
+      "required": ["lock"],
       "properties": {
         "lock": {
           "$ref": "#/$defs/duration",
@@ -2227,23 +2145,23 @@
         },
         "roll": {
           "$ref": "#/$defs/key",
-          "description": "A mission's result: a box with `rollsOn` the collectible leaving after this tier's lock is rolled on (success, failure, a stat lost, the NFT lost; its odds read the NFT's stats). Growth stops at the lock's end. Anyone asks for the roll and settles it; it is never refunded while it waits. A chest it brings back is its `prize` instead. Only in a farm of collectibles, with a lock."
+          "description": "A mission's result: a box with `rollsOn` the collectible leaving after this tier's lock is rolled on (success, failure, a stat lost, the NFT lost; its odds read the NFT's stats). Growth stops at the lock's end. Its player or the project’s keys ask for the roll and settle it; it is never refunded while it waits. A chest it brings back is its `prize` instead. Only in a farm of collectibles, with a lock."
         },
         "exitFee": {
           "$ref": "#/$defs/percent",
           "description": "A farm of tokens: a stake may leave before this tier's lock has run by leaving this percent of what it takes out (to the farm's `exitFeeTo`). Absent: no early exit. A farm of collectibles leaves early by a recipe that lowers its `lockAttribute`."
+        },
+        "earnsFor": {
+          "$ref": "#/$defs/duration",
+          "description": "A term: a seat at this tier earns and grows only this long after its lock started (a stake, or a booster put on, starts it again), however late it is touched; its prize is still given once its lock has run. Absent: no end."
         }
       }
     },
     "farm": {
       "type": "object",
       "additionalProperties": false,
-      "required": [
-        "key",
-        "name",
-        "stakes"
-      ],
-      "description": "Players stake a token or collectibles. Rewards are whatever arrives in the rewards pool, shared by weight (what they stake, times their lock tier, plus boosts from what a collectible says), or a fixed `rate` for each seat. A farm can also write points and levels on what is staked (`growth`), and pay a mission's `prize` to a collectible that stays its tier's lock. It cannot be edited once open. A farm of collectibles can keep two times on the NFT itself: its lock (`lockAttribute`) and an upkeep (`upkeepAttribute`), which recipes and rolls move like any number.",
+      "required": ["key", "name", "stakes"],
+      "description": "Players stake a token or collectibles. Rewards are whatever lands in the farm's own rewards vault (\"farm:<key>\" in a split or a schedule, its `seed`), shared by weight (what they stake, times their lock tier, plus boosts from what a collectible says), or a fixed `rate`. A farm can also write points and levels on what is staked (`growth`), and pay a mission's `prize` to a collectible that stays its tier's lock. It cannot be edited once open. A farm of collectibles can keep two times on the NFT itself: its lock (`lockAttribute`) and an upkeep (`upkeepAttribute`), which recipes and rolls move like any number.",
       "properties": {
         "key": {
           "$ref": "#/$defs/key"
@@ -2274,46 +2192,47 @@
         },
         "rewards": {
           "$ref": "#/$defs/key",
-          "description": "The pool rewards come from, and whose token they are in. Without a `rate`, the farm takes all of it, so it must be this farm's alone; with a `rate` that isn't minted, it pays from it while it lasts. Leave it out for a farm that pays nothing (staking only to qualify, for a stake gate): the setup opens an empty pool for it."
+          "description": "The token its rewards are in (a token key). They land in the farm's own rewards vault: send it a share (\"farm:<key>\" in a split), pay it with a schedule (\"to\": \"farm:<key>\"), or `seed` it; with a minted `rate` nothing waits there. Left out: the staked token, or for a farm of collectibles the project's currency."
         },
-        "rewardsIndex": {
-          "type": "integer",
-          "minimum": 0,
-          "maximum": 255,
-          "description": "For a farm that names no `rewards`: the program's number for the empty pool made for it. Written when it goes live; never change it after."
+        "seed": {
+          "$ref": "#/$defs/amount",
+          "description": "What the owner puts into its rewards vault at go-live, from their wallet (anyone may add more later, with a plain transfer)."
         },
         "rate": {
           "type": "object",
           "additionalProperties": false,
-          "required": [
-            "perDay"
-          ],
-          "description": "A fixed rate instead of sharing what arrives: the same for each seat whoever else is in, times its tier and boosts (most Solana NFT staking paid this way).",
+          "required": ["perDay"],
+          "description": "A fixed rate instead of sharing what lands: for each seat whoever else is in, times its tier and boosts (most Solana NFT staking paid this way), or with `shared` the whole farm's a day, shared by weight.",
           "properties": {
             "perDay": {
               "$ref": "#/$defs/amount",
-              "description": "Reward tokens a day for each collectible at x1; for a farm of tokens, for each whole token staked. 0 pays nothing: a farm that only grows what is staked, or gives mission prizes (its \"rewards\" pool is then never touched)."
+              "description": "Reward tokens a day for each collectible at x1; for a farm of tokens, for each whole token staked; with `shared`, for the whole farm. 0 pays nothing: a farm that only grows what is staked, or gives mission prizes."
             },
             "minted": {
               "type": "boolean",
               "default": false,
-              "description": "Minted (the rewards' token must be one the game mints), or paid from the rewards pool while it lasts (what it can't cover is not owed later)."
+              "description": "Minted when a seat is paid (the rewards' token must be one the game mints), or paid from what its rewards vault holds free while it lasts (what it can't cover is not owed later)."
+            },
+            "shared": {
+              "type": "boolean",
+              "default": false,
+              "description": "`perDay` is the whole farm's a day, shared by weight while anything is staked: an emission budget, each seat's share falling as more stake."
+            },
+            "halveEvery": {
+              "$ref": "#/$defs/duration",
+              "description": "The rate halves every this long from when the farm opens, again and again (a halving emission)."
             }
           }
         },
         "custody": {
-          "enum": [
-            "freeze",
-            "escrow",
-            "watch"
-          ],
+          "enum": ["freeze", "escrow", "watch"],
           "default": "escrow",
           "description": "For staked NFTs and token-seat boosters. escrow (default): the game holds them (Core NFTs only; issuer-controlled transfer rules can block return). freeze: they stay in the wallet, frozen (Core) or locked by Token Metadata (legacy NFTs and pNFTs), the game their delegate; Core's unfreeze can fail if the issuer later enlarges metadata or plugins. Select freeze explicitly for soulbound collectibles, which need no extra freeze. watch (a farm of collectibles only): they stay in the wallet, free: an NFT can be sold while staked, and its seat earns only while its staker holds it (a staker who no longer does collects nothing, their due going back to the farm, and the next holder can take the seat over). A Token Metadata NFT is frozen or watched, never escrowed. Staked tokens always go to the farm's vault."
         },
         "tiers": {
           "type": "array",
           "minItems": 1,
-          "maxItems": 4,
+          "maxItems": 256,
           "items": {
             "$ref": "#/$defs/tier"
           },
@@ -2321,14 +2240,10 @@
         },
         "boosts": {
           "type": "array",
-          "maxItems": 4,
           "items": {
             "type": "object",
             "additionalProperties": false,
-            "required": [
-              "when",
-              "add"
-            ],
+            "required": ["when", "add"],
             "properties": {
               "when": {
                 "$ref": "#/$defs/rule"
@@ -2351,7 +2266,6 @@
             {
               "type": "array",
               "minItems": 1,
-              "maxItems": 4,
               "items": {
                 "$ref": "#/$defs/rule"
               }
@@ -2367,7 +2281,6 @@
             {
               "type": "array",
               "minItems": 1,
-              "maxItems": 4,
               "items": {
                 "$ref": "#/$defs/growth"
               }
@@ -2382,51 +2295,24 @@
         "lockAttribute": {
           "type": "string",
           "minLength": 1,
-          "maxLength": 32,
-          "description": "For a farm of collectibles: the attribute the farm writes each staked collectible's lock under, as the time it ends (Unix seconds), and reads when it leaves. Whatever moves a number moves it: a recipe `raises` it by \"-1d\" with `fromNow` for a price (a way out early; the price can be burned, or paid into this farm's rewards pool, shared by the seats there at the next move), a roll's `shifts` add a day (jail). A mission's prize still needs the tier's own lock to have run, and a tier that rolls rolls whenever the collectible leaves. A recipe reaches a collectible staked in escrow (the default) on its seat."
+          "description": "For a farm of collectibles: the attribute the farm writes each staked collectible's lock under, as the time it ends (Unix seconds), and reads when it leaves. Whatever moves a number moves it: a recipe `raises` it by \"-1d\" with `fromNow` for a price (a way out early; the price can be burned, or paid into this farm's rewards vault (\"farm:<key>\"), shared by the seats there), a roll's `shifts` add a day (jail). A mission's prize still needs the tier's own lock to have run, and a tier that rolls rolls whenever the collectible leaves. A recipe reaches a collectible staked in escrow (the default) on its seat."
         },
         "upkeepAttribute": {
           "type": "string",
           "minLength": 1,
-          "maxLength": 32,
-          "description": "For a farm of collectibles: an upkeep. The attribute that says until when (Unix seconds) a staked collectible earns and grows: fuel, food, a license. A recipe sells it (`raises` with `fromNow`: \"+1d\" for 10 FUEL, up to \"3d\" ahead), and it runs out by itself. Run dry, the seat earns and grows nothing more, and what it was credited after it ran out goes back to the farm (split by time), shared by the seats there. Fuel bought counts once the seat is refreshed (anyone sends `refresh`; the play page sends it with the recipe). A mission's prize needs the upkeep to last its tier's lock."
+          "description": "For a farm of collectibles: an upkeep. The attribute that says until when (Unix seconds) a staked collectible earns and grows: fuel, food, a license. A recipe sells it (`raises` with `fromNow`: \"+1d\" for 10 FUEL, up to \"3d\" ahead), and it runs out by itself. Run dry, the seat earns and grows nothing more from that time, however late it is next touched. Fuel bought counts once the seat is refreshed (anyone sends `refresh`; the play page sends it with the recipe). A mission's prize needs the upkeep to last its tier's lock."
         },
         "exitFeeTo": {
           "type": "string",
-          "pattern": "^(burn|pool:[a-z][a-z0-9-]{0,31})$",
-          "description": "Where early-exit fees go: \"burn\", or \"pool:<key>\" (the farm's own rewards pool shares them with the stakers who stay). Needed when a tier has `exitFee`."
-        },
-        "unbond": {
-          "$ref": "#/$defs/duration",
-          "description": "A farm of tokens: what a player takes out waits this long first, earning nothing (an unbonding wait), then any later unstake takes it out."
-        },
-        "toll": {
-          "type": "object",
-          "additionalProperties": false,
-          "required": [
-            "percent",
-            "to"
-          ],
-          "description": "A share of every payout of rewards (harvest, compound, unstake), burned or sent to a pool. Not on mission prizes.",
-          "properties": {
-            "percent": {
-              "$ref": "#/$defs/percent"
-            },
-            "to": {
-              "type": "string",
-              "pattern": "^(burn|pool:[a-z][a-z0-9-]{0,31})$"
-            }
-          }
+          "pattern": "^(burn|rewards|pool:[a-z][a-z0-9-]{0,31})$",
+          "description": "Where early-exit fees go: \"burn\", \"rewards\" (the farm's own rewards vault, shared by the stakers who stay: a farm whose rewards are its staked token), or \"pool:<key>\". Needed when a tier has `exitFee`."
         }
       }
     },
     "grant": {
       "type": "object",
       "additionalProperties": false,
-      "required": [
-        "key",
-        "name"
-      ],
+      "required": ["key", "name"],
       "description": "A reward handed out to wallets that earned it: one collectible of an item, a fixed amount from a pool, or a roll of a box (any random prize). A voucher key signs who earned it (one of `vouchers`, or of `keys`), or the wallet is on an approved list. With none of them the grant is open: any wallet claims, within its limits (with a gate, a collectible shown claims once too). The program keeps every claim within the limits. Each wallet can receive at most 256 distinct voucher rounds per grant incarnation, retained permanently; open claims do not consume round slots, and a list written in xsolana.json pays each wallet once. Closing and recreating starts a new incarnation with separate vouchers and receipts.",
       "properties": {
         "key": {
@@ -2480,9 +2366,7 @@
               {
                 "type": "object",
                 "additionalProperties": false,
-                "required": [
-                  "wallet"
-                ],
+                "required": ["wallet"],
                 "properties": {
                   "wallet": {
                     "$ref": "#/$defs/address"
@@ -2568,6 +2452,16 @@
         "prize": {
           "$ref": "#/$defs/prize",
           "description": "What each claim gives (a prize). The grant's funds pay what it opens."
+        },
+        "wallets": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "About how many wallets will claim it over its life (with `rounds`, how many rounds each): it sizes how its records are kept (one list up to ~100,000, more lists above). Default: its list's length."
+        },
+        "rounds": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "About how many rounds each wallet will be paid over its life. Default 1."
         }
       }
     },
@@ -2580,14 +2474,11 @@
         {
           "type": "object",
           "additionalProperties": false,
-          "required": [
-            "wallets"
-          ],
+          "required": ["wallets"],
           "properties": {
             "wallets": {
               "type": "array",
               "minItems": 0,
-              "maxItems": 16,
               "items": {
                 "$ref": "#/$defs/address"
               }
@@ -2597,9 +2488,7 @@
         {
           "type": "object",
           "additionalProperties": false,
-          "required": [
-            "list"
-          ],
+          "required": ["list"],
           "properties": {
             "list": {
               "type": "array",
@@ -2616,17 +2505,12 @@
         {
           "type": "object",
           "additionalProperties": false,
-          "required": [
-            "staked"
-          ],
+          "required": ["staked"],
           "properties": {
             "staked": {
               "type": "object",
               "additionalProperties": false,
-              "required": [
-                "farm",
-                "atLeast"
-              ],
+              "required": ["farm", "atLeast"],
               "description": "A stake to enter: the wallet’s seat in `farm` (a farm of a token in this spec) holds at least `atLeast` of its token, staked before this second (launchpad tiers, stake to play).",
               "properties": {
                 "farm": {
@@ -2645,9 +2529,7 @@
     "perWalletEach": {
       "type": "object",
       "additionalProperties": false,
-      "required": [
-        "count"
-      ],
+      "required": ["count"],
       "description": "How many one wallet may do in each window of time: `{ \"count\": 1, \"every\": \"1d\" }` is once a day (windows counted from the Unix epoch, a UTC day for \"1d\").",
       "properties": {
         "count": {
@@ -2664,15 +2546,12 @@
     "growth": {
       "type": "object",
       "additionalProperties": false,
-      "required": [
-        "perDay"
-      ],
+      "required": ["perDay"],
       "description": "Points a collectible earns by staying in, written under `attribute`, with the level they reach under `level` when there are `levels`. Without `levels` the points themselves can be the level: { \"attribute\": \"level\", \"perDay\": 1 } is a level a day.",
       "properties": {
         "attribute": {
           "type": "string",
           "minLength": 1,
-          "maxLength": 32,
           "default": "xp",
           "description": "The attribute the points are written under."
         },
@@ -2685,13 +2564,11 @@
         "level": {
           "type": "string",
           "minLength": 1,
-          "maxLength": 32,
           "default": "level",
           "description": "The attribute the level is written under, when there are `levels`."
         },
         "levels": {
           "type": "array",
-          "maxItems": 16,
           "items": {
             "type": "integer",
             "minimum": 1,
@@ -2709,11 +2586,7 @@
     "stash": {
       "type": "object",
       "additionalProperties": false,
-      "required": [
-        "key",
-        "name",
-        "nfts"
-      ],
+      "required": ["key", "name", "nfts"],
       "description": "A stash: NFTs of any collection the game holds until a prize names one or a roll gives one away. Any kind: a Core asset (with or without the game's authority), a Token Metadata NFT, a compressed NFT. A roll takes the one it picks out of the stash at once, so two winners never get the same one, and an empty stash can't be won. The game's owner or authority can put more in, or take one out, at any time (`loot.stashIx`).",
       "properties": {
         "key": {
@@ -2735,7 +2608,6 @@
         },
         "nfts": {
           "type": "array",
-          "maxItems": 256,
           "items": {
             "anyOf": [
               {
@@ -2744,9 +2616,7 @@
               {
                 "type": "object",
                 "additionalProperties": false,
-                "required": [
-                  "asset"
-                ],
+                "required": ["asset"],
                 "properties": {
                   "asset": {
                     "$ref": "#/$defs/address"
@@ -2754,15 +2624,19 @@
                   "collection": {
                     "$ref": "#/$defs/address",
                     "description": "Its Core collection, when it is not the stash's."
+                  },
+                  "weight": {
+                    "type": "integer",
+                    "minimum": 1,
+                    "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."
                   }
                 }
               },
               {
                 "type": "object",
                 "additionalProperties": false,
-                "required": [
-                  "mint"
-                ],
+                "required": ["mint"],
                 "properties": {
                   "mint": {
                     "$ref": "#/$defs/address"
@@ -2775,19 +2649,29 @@
                   "ruleSet": {
                     "$ref": "#/$defs/address",
                     "description": "A pNFT's rule set, when it has one."
+                  },
+                  "weight": {
+                    "type": "integer",
+                    "minimum": 1,
+                    "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."
                   }
                 }
               },
               {
                 "type": "object",
                 "additionalProperties": false,
-                "required": [
-                  "compressed"
-                ],
+                "required": ["compressed"],
                 "properties": {
                   "compressed": {
                     "$ref": "#/$defs/address",
                     "description": "A compressed NFT's asset id."
+                  },
+                  "weight": {
+                    "type": "integer",
+                    "minimum": 1,
+                    "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."
                   }
                 }
               }
@@ -2803,20 +2687,12 @@
     },
     "prize": {
       "type": "object",
-      "required": [
-        "gives"
-      ],
+      "required": ["gives"],
       "additionalProperties": false,
-      "description": "A prize, given the same way on every route that gives one (a grant, a lottery's place, a contest's winners, a mission's tier, a recipe's line), in the transaction that wins it; only a roll is settled after, by the oracle. item: one of `item` (a collectible minted to the winner, or with `compressed` a compressed NFT of it; a normal item is the game's backend's to deliver). tokens: `amount`, minted (`from`: \"mint\", in `currency`, a token the game mints) or paid from a pool (\"pool:<key>\", in what it holds). share: `percent` of what `pool` holds then (a jackpot). nft: the NFT `nft`, which the stash `stash` lists (given once: the first winner takes it). roll: a roll of `box` for the winner: chance (a box can give a stash's NFT at random).",
+      "description": "A prize, given the same way on every route that gives one (a grant, a lottery's place, a contest's winners, a mission's tier, a recipe's line), in the transaction that wins it; only a roll is settled after, by the oracle. item: one of `item` (a collectible minted to the winner, or with `compressed` a compressed NFT of it; a normal item is the game's backend's to deliver). tokens: `amount`, minted (`from`: \"mint\", in `currency`, a token the game mints) or paid from a pool (\"pool:<key>\", in what it holds). share: `percent` of what `pool` holds then (a jackpot). nft: the NFT `nft`, which the stash `stash` lists (given once: the first winner takes it). roll: a roll of `box` for the winner: chance (a box can give a stash's NFT at random). raffled (a lottery's place only, of a lottery that draws once): one NFT drawn at random from the lottery's own stash (its `nfts`).",
       "properties": {
         "gives": {
-          "enum": [
-            "item",
-            "tokens",
-            "share",
-            "nft",
-            "roll"
-          ]
+          "enum": ["item", "tokens", "nft", "roll", "raffled"]
         },
         "item": {
           "$ref": "#/$defs/key"
@@ -2836,12 +2712,6 @@
           "type": "string",
           "pattern": "^(mint|pool:[a-z][a-z0-9-]{0,31})$"
         },
-        "pool": {
-          "$ref": "#/$defs/key"
-        },
-        "percent": {
-          "$ref": "#/$defs/percent"
-        },
         "stash": {
           "$ref": "#/$defs/key",
           "description": "For nft: the stash that lists it."
@@ -2872,17 +2742,12 @@
       "description": "Where an NFT paid goes: \"burn\" (a Core asset burned, any other kind sent to the incinerator's address), \"treasury\" (the treasury wallet), { \"giveTo\": \"<wallet>\" }, or { \"stash\": \"<key>\" } (into one of this spec's stashes, to be given away as a prize).",
       "anyOf": [
         {
-          "enum": [
-            "burn",
-            "treasury"
-          ]
+          "enum": ["burn", "treasury"]
         },
         {
           "type": "object",
           "additionalProperties": false,
-          "required": [
-            "giveTo"
-          ],
+          "required": ["giveTo"],
           "properties": {
             "giveTo": {
               "$ref": "#/$defs/address"
@@ -2892,9 +2757,7 @@
         {
           "type": "object",
           "additionalProperties": false,
-          "required": [
-            "stash"
-          ],
+          "required": ["stash"],
           "properties": {
             "stash": {
               "$ref": "#/$defs/key"
@@ -2906,9 +2769,7 @@
     "nftPrice": {
       "type": "object",
       "additionalProperties": false,
-      "required": [
-        "rule"
-      ],
+      "required": ["rule"],
       "description": "An NFT as the price: one the player holds that passes `rule`, sent where `then` says (default \"burn\").",
       "properties": {
         "rule": {
@@ -2918,6 +2779,51 @@
           "$ref": "#/$defs/spend"
         }
       }
+    },
+    "table": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["key", "rows"],
+      "description": "A table (`table.rs`): rows, each a weight and an optional stock, and a label (`\"labels\"`, up to 32 bytes each) or nothing (`\"numbers\"`: a row gives its own number, from 0). Sealed once written: its weights never change and its stock only goes down. A row with a stock leaves the draws once it is used up.",
+      "properties": {
+        "key": {
+          "$ref": "#/$defs/key"
+        },
+        "id": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 4294967295
+        },
+        "kind": {
+          "enum": ["labels", "numbers"],
+          "default": "labels"
+        },
+        "rows": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["weight"],
+            "properties": {
+              "label": {
+                "type": "string"
+              },
+              "weight": {
+                "type": "integer",
+                "minimum": 1,
+                "maximum": 4294967295
+              },
+              "stock": {
+                "type": "integer",
+                "minimum": 1,
+                "maximum": 4294967294,
+                "description": "How many units may draw it: left out, never runs out."
+              }
+            }
+          }
+        }
+      }
     }
   }
 }