@xgamesfun/solana 0.20.1 → 0.25.0

package/types/economy/plan.d.mts

@@ -1,6 +1,6 @@
 /** Most transactions one wallet approval carries. */
 export declare const PER_APPROVAL = 12;
-export declare function itemArgs(it: any): {
+export declare function itemArgs(it: any, m: any): {
     kind: string;
     rarity: number;
     soulbound: boolean;
@@ -8,24 +8,33 @@ export declare function itemArgs(it: any): {
     name: any;
     uri: any;
     max_supply: any;
-    life: {
-        ready_after: number;
-        lasts: number;
-        uses: any;
-        cooldown: number;
-    } | null;
     active: boolean;
     collection: any;
+    traits: any;
 };
+/**
+ * The bytes of an order of box `b` (`orderBytes`), its spec's names standing in as addresses, with the shares its split
+ * stores. `opened`: an open's (`open_box`, `Order::sized`: each draw at its dearest outcome's prizes as they are kept,
+ * rows only for the tables its fresh items draw); otherwise a roll made inside another call (a craft, a grant's claim,
+ * a mission, a lottery's place, a roll lot: `Order::space_for`, the box's whole table budget a draw).
+ */
+export declare const boxOrderBytes: (b: any, m: any, opens?: number, { opened }?: {
+    opened?: boolean | undefined;
+}) => number;
+/** The most bytes of rows one table write carries: what a 1,232-byte transaction leaves after the upsert's accounts,
+ * its signature and its own bytes. */
+export declare const TABLE_BATCH_BYTES = 800;
+/** A spec table's rows as the program takes them ({ weight, left, label }), in batches that fit a transaction each. */
+export declare function tableBatches(t: any): never[][];
 /** The program's `Prize` for one part of a box outcome (`model.outcomeParts`). */
-export declare function partPrize(o: any, m: any): {
+export declare function partPrize(o: any, m: any): "Raffled" | {
     Stash: any[];
 } | {
-    Item?: undefined;
     Compressed: {
         item: any;
         tree: string;
     };
+    Item?: undefined;
     Held?: undefined;
     Nft?: undefined;
     Roll?: undefined;
@@ -38,15 +47,15 @@ export declare function partPrize(o: any, m: any): {
     Roll?: undefined;
     Tokens?: undefined;
 } | {
-    Item?: undefined;
     Compressed?: undefined;
+    Item?: undefined;
     Held: any[];
     Nft?: undefined;
     Roll?: undefined;
     Tokens?: undefined;
 } | {
-    Item?: undefined;
     Compressed?: undefined;
+    Item?: undefined;
     Held?: undefined;
     Nft: {
         stash: any;
@@ -55,34 +64,15 @@ export declare function partPrize(o: any, m: any): {
     Roll?: undefined;
     Tokens?: undefined;
 } | {
-    Item?: undefined;
     Compressed?: undefined;
+    Item?: undefined;
     Held?: undefined;
     Nft?: undefined;
     Roll: any[];
     Tokens?: undefined;
 } | {
-    Item?: undefined;
     Compressed?: undefined;
-    Held?: undefined;
-    Nft?: undefined;
-    Roll?: undefined;
-    Tokens: {
-        from: {
-            Pool: any[];
-            Mint?: undefined;
-        } | {
-            Pool?: undefined;
-            Mint: string[];
-        };
-        amount: {
-            Bps: number[];
-            Fixed?: undefined;
-        };
-    };
-} | {
     Item?: undefined;
-    Compressed?: undefined;
     Held?: undefined;
     Nft?: undefined;
     Roll?: undefined;
@@ -94,10 +84,7 @@ export declare function partPrize(o: any, m: any): {
             Pool?: undefined;
             Mint: string[];
         };
-        amount: {
-            Bps?: undefined;
-            Fixed: bigint[];
-        };
+        amount: bigint;
     };
 };
 export declare function boxArgs(b: any, m: any): {
@@ -115,8 +102,10 @@ export declare function boxArgs(b: any, m: any): {
         shared: boolean;
     } | null;
     stock_odds: boolean;
+    when_out: string;
     active: boolean;
     shares: any;
+    slots: any;
     entries: any;
     gate: {
         Wallets: any[];
@@ -148,8 +137,8 @@ export declare function boxArgs(b: any, m: any): {
                 Item: any[];
                 Collection?: undefined;
             } | {
-                Item?: undefined;
                 Collection: any[];
+                Item?: undefined;
             };
             key: any;
             test: any;
@@ -170,29 +159,29 @@ export declare function boxArgs(b: any, m: any): {
             Item: any[];
             Collection?: undefined;
         } | {
-            Item?: undefined;
             Collection: any[];
+            Item?: undefined;
         };
         key: any;
         test: any;
     } | null;
     fates: any;
 };
-/** Where an outcome sends the NFT a box rolls on: back, burned, given (the treasury's wallet is filled in when the economy goes live), or into a stash. */
-export declare const thenOf: (then: any, m: any) => "Back" | "Burn" | {
+/** Where an outcome sends the NFT a box rolls on: back (null), burned, given (the treasury's wallet is filled in when the economy goes live), or into a stash. */
+export declare const thenOf: (then: any, m: any) => "Burn" | {
     Give?: undefined;
     Stash: any[];
 } | {
     Stash?: undefined;
     Give: any[];
-};
+} | null;
 export declare function recipeArgs(r: any, m: any): {
     active: boolean;
     inputs: any;
     outputs: any;
-    needs: any;
+    needs: any[];
     keeps: any;
-    raises: any;
+    raises: any[];
     window: {
         opens_at: bigint;
         closes_at: bigint;
@@ -207,12 +196,42 @@ export declare function scheduleArgs(s: any, m: any): {
     active: boolean;
     action: {
         from: {
-            Pool?: undefined;
             Mint: string[];
             Vest?: undefined;
+            Pool?: undefined;
         };
-        to: {
+        to: string | {
             Pool: any[];
+            Account?: undefined;
+            Wallet?: undefined;
+            Chosen?: undefined;
+            Holder?: undefined;
+        } | {
+            Account: (string | undefined)[];
+            Wallet?: undefined;
+            Chosen?: undefined;
+            Holder?: undefined;
+            Pool?: undefined;
+        } | {
+            Account?: undefined;
+            Wallet: (string | undefined)[];
+            Chosen?: undefined;
+            Holder?: undefined;
+            Pool?: undefined;
+        } | {
+            Account?: undefined;
+            Wallet?: undefined;
+            Chosen: {
+                item: any;
+            };
+            Holder?: undefined;
+            Pool?: undefined;
+        } | {
+            Account?: undefined;
+            Wallet?: undefined;
+            Chosen?: undefined;
+            Holder: (string | undefined)[];
+            Pool?: undefined;
         };
         amount: {
             Fixed: bigint[];
@@ -220,8 +239,8 @@ export declare function scheduleArgs(s: any, m: any): {
         halve_every: any;
     } | {
         from: {
-            Pool?: undefined;
             Vest: string[];
+            Pool?: undefined;
             Mint?: undefined;
         };
         to: string | {
@@ -231,38 +250,38 @@ export declare function scheduleArgs(s: any, m: any): {
             Chosen?: undefined;
             Holder?: undefined;
         } | {
-            Pool?: undefined;
             Account: (string | undefined)[];
             Wallet?: undefined;
             Chosen?: undefined;
             Holder?: undefined;
-        } | {
             Pool?: undefined;
+        } | {
             Account?: undefined;
             Wallet: (string | undefined)[];
             Chosen?: undefined;
             Holder?: undefined;
-        } | {
             Pool?: undefined;
+        } | {
             Account?: undefined;
             Wallet?: undefined;
             Chosen: {
                 item: any;
             };
             Holder?: undefined;
-        } | {
             Pool?: undefined;
+        } | {
             Account?: undefined;
             Wallet?: undefined;
             Chosen?: undefined;
             Holder: (string | undefined)[];
+            Pool?: undefined;
         };
         amount: {
             Bps: number[];
             Fixed?: undefined;
         } | {
-            Fixed: bigint[];
             Bps?: undefined;
+            Fixed: bigint[];
         };
         halve_every: any;
     } | {
@@ -278,38 +297,38 @@ export declare function scheduleArgs(s: any, m: any): {
             Chosen?: undefined;
             Holder?: undefined;
         } | {
-            Pool?: undefined;
             Account: (string | undefined)[];
             Wallet?: undefined;
             Chosen?: undefined;
             Holder?: undefined;
-        } | {
             Pool?: undefined;
+        } | {
             Account?: undefined;
             Wallet: (string | undefined)[];
             Chosen?: undefined;
             Holder?: undefined;
-        } | {
             Pool?: undefined;
+        } | {
             Account?: undefined;
             Wallet?: undefined;
             Chosen: {
                 item: any;
             };
             Holder?: undefined;
-        } | {
             Pool?: undefined;
+        } | {
             Account?: undefined;
             Wallet?: undefined;
             Chosen?: undefined;
             Holder: (string | undefined)[];
+            Pool?: undefined;
         };
         amount: {
-            Bps: number[];
             Fixed?: undefined;
+            Bps: number[];
         } | {
-            Fixed: bigint[];
             Bps?: undefined;
+            Fixed: bigint[];
         };
         halve_every: any;
     };
@@ -321,12 +340,12 @@ export declare function scheduleArgs(s: any, m: any): {
  * The program's `Prize` for a prize line (`model.prizeLine`): tokens minted or from a pool (a fixed amount, or a share
  * of the pool), an item (a compressed NFT of it into the project's tree, "@tree"), one NFT of a stash, or a roll of a box.
  */
-export declare function prizeArgs(p: any, m: any): {
-    Item?: undefined;
+export declare function prizeArgs(p: any, m: any): "Raffled" | {
     Compressed: {
         item: any;
         tree: string;
     };
+    Item?: undefined;
     Held?: undefined;
     Nft?: undefined;
     Roll?: undefined;
@@ -339,15 +358,15 @@ export declare function prizeArgs(p: any, m: any): {
     Roll?: undefined;
     Tokens?: undefined;
 } | {
-    Item?: undefined;
     Compressed?: undefined;
+    Item?: undefined;
     Held: any[];
     Nft?: undefined;
     Roll?: undefined;
     Tokens?: undefined;
 } | {
-    Item?: undefined;
     Compressed?: undefined;
+    Item?: undefined;
     Held?: undefined;
     Nft: {
         stash: any;
@@ -356,34 +375,15 @@ export declare function prizeArgs(p: any, m: any): {
     Roll?: undefined;
     Tokens?: undefined;
 } | {
-    Item?: undefined;
     Compressed?: undefined;
+    Item?: undefined;
     Held?: undefined;
     Nft?: undefined;
     Roll: any[];
     Tokens?: undefined;
 } | {
-    Item?: undefined;
     Compressed?: undefined;
-    Held?: undefined;
-    Nft?: undefined;
-    Roll?: undefined;
-    Tokens: {
-        from: {
-            Pool: any[];
-            Mint?: undefined;
-        } | {
-            Pool?: undefined;
-            Mint: string[];
-        };
-        amount: {
-            Bps: number[];
-            Fixed?: undefined;
-        };
-    };
-} | {
     Item?: undefined;
-    Compressed?: undefined;
     Held?: undefined;
     Nft?: undefined;
     Roll?: undefined;
@@ -395,10 +395,7 @@ export declare function prizeArgs(p: any, m: any): {
             Pool?: undefined;
             Mint: string[];
         };
-        amount: {
-            Bps?: undefined;
-            Fixed: bigint[];
-        };
+        amount: bigint;
     };
 };
 /**
@@ -408,17 +405,83 @@ export declare function prizeArgs(p: any, m: any): {
  */
 export declare const listLeaves: (list: any, t: any) => any;
 /**
- * A lottery's args: its own pot in `currency` (the project's by default), ticket money split by `split` (and
- * `cutPercent` to the treasury) with the rest into the pot. No `every` draws once, at `firstDraw`.
+ * A lottery's args: its money in `currency` (the project's by default), ticket money split by `split` (and
+ * `cutPercent` to the treasury) with the rest for the places, which are paid from its pot (`pot`) or from each round's
+ * own money, what they leave going to `rest` (`paysFromOf`). No `every` draws once, at `firstDraw`.
  */
 export declare function lotteryArgs(l: any, m: any): {
-    price: bigint;
-    mint: string;
-    shares: any;
-    places: any;
-    ticket_mint: string;
+    terms: {
+        price: bigint;
+        mint: string;
+        pays_from: {
+            Pot: any[];
+            Round?: undefined;
+        } | {
+            Pot?: undefined;
+            Round: {
+                rest: string | {
+                    Pool: any[];
+                    Account?: undefined;
+                    Wallet?: undefined;
+                    Chosen?: undefined;
+                    Holder?: undefined;
+                } | {
+                    Account: (string | undefined)[];
+                    Wallet?: undefined;
+                    Chosen?: undefined;
+                    Holder?: undefined;
+                    Pool?: undefined;
+                } | {
+                    Account?: undefined;
+                    Wallet: (string | undefined)[];
+                    Chosen?: undefined;
+                    Holder?: undefined;
+                    Pool?: undefined;
+                } | {
+                    Account?: undefined;
+                    Wallet?: undefined;
+                    Chosen: {
+                        item: any;
+                    };
+                    Holder?: undefined;
+                    Pool?: undefined;
+                } | {
+                    Account?: undefined;
+                    Wallet?: undefined;
+                    Chosen?: undefined;
+                    Holder: (string | undefined)[];
+                    Pool?: undefined;
+                };
+            };
+        };
+        shares: any;
+        places: any;
+        ticket_mint: string;
+        draws_at: bigint;
+        nft_ticket: {
+            rule: {
+                of: {
+                    Item: any[];
+                    Collection?: undefined;
+                } | {
+                    Collection: any[];
+                    Item?: undefined;
+                };
+                key: any;
+                test: any;
+            } | null;
+            then: string | {
+                Stash: any[];
+                Give?: undefined;
+            } | {
+                Stash?: undefined;
+                Give: any[];
+            };
+        } | null;
+        returns: boolean;
+        min_sold: bigint;
+    };
     every: bigint;
-    draws_at: bigint;
     gate: {
         Wallets: any[];
         Staked?: undefined;
@@ -449,37 +512,41 @@ export declare function lotteryArgs(l: any, m: any): {
                 Item: any[];
                 Collection?: undefined;
             } | {
-                Item?: undefined;
                 Collection: any[];
+                Item?: undefined;
             };
             key: any;
             test: any;
         } | null)[];
     } | null;
     per_wallet: any;
-    nft_ticket: {
-        rule: {
-            of: {
-                Item: any[];
-                Collection?: undefined;
-            } | {
-                Item?: undefined;
-                Collection: any[];
-            };
-            key: any;
-            test: any;
-        } | null;
-        then: string | {
-            Stash: any[];
-            Give?: undefined;
-        } | {
-            Stash?: undefined;
-            Give: any[];
-        };
-    } | null;
-    returns: boolean;
-    min_sold: bigint;
 };
+/**
+ * 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
+ * header holds a copy of the terms, a total for each share, two bits a place, a record for each run of tokens and an
+ * NFT slot for each place of the lottery's own stash.
+ */
+export declare function roundSize(l: any, m: any): {
+    head: number;
+    accounts: any;
+};
+/** 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. */
+export declare function roundsExpected(l: any, m: any): {
+    rounds: any;
+    entries: any;
+};
+/**
+ * The SOL, in lamports, a lottery holds for its rounds' rent: the spec's `roundRent` (0 turns it off), or by default
+ * what its expected rounds take at once (`roundsExpected`), each its header, its token accounts and its expected
+ * entries' bytes (`LotteryRound.lent`: in a round the lottery opened, its spare SOL pays each entry while it covers
+ * them, so buyers pay no program rent for a ticket), at devnet's and mainnet's rent, rounded up to 0.001 SOL. Short
+ * of it (a busier round, a cluster that charges more), the first buyer fronts the header and later buyers pay their
+ * own entries. Each round gives back what it took when it closes; the lottery gives the rest back to the owner when it closes.
+ */
+export declare function roundRentOf(l: any, m: any): bigint;
 /**
  * The args the authority opens a contest with, `at` (Unix seconds) its opening: its sides, when entries close and the
  * result is due, its split, its gate (a list of wallets for a duel), the keys that may decide it, the least pot (an
@@ -520,8 +587,8 @@ export declare function contestArgs(c: any, m: any, at?: any): {
                 Item: any[];
                 Collection?: undefined;
             } | {
-                Item?: undefined;
                 Collection: any[];
+                Item?: undefined;
             };
             key: any;
             test: any;
@@ -530,12 +597,12 @@ export declare function contestArgs(c: any, m: any, at?: any): {
     deciders: any;
     min_pot: bigint;
     stake: bigint;
-    prize: {
-        Item?: undefined;
+    prize: string | {
         Compressed: {
             item: any;
             tree: string;
         };
+        Item?: undefined;
         Held?: undefined;
         Nft?: undefined;
         Roll?: undefined;
@@ -548,15 +615,15 @@ export declare function contestArgs(c: any, m: any, at?: any): {
         Roll?: undefined;
         Tokens?: undefined;
     } | {
-        Item?: undefined;
         Compressed?: undefined;
+        Item?: undefined;
         Held: any[];
         Nft?: undefined;
         Roll?: undefined;
         Tokens?: undefined;
     } | {
-        Item?: undefined;
         Compressed?: undefined;
+        Item?: undefined;
         Held?: undefined;
         Nft: {
             stash: any;
@@ -565,34 +632,15 @@ export declare function contestArgs(c: any, m: any, at?: any): {
         Roll?: undefined;
         Tokens?: undefined;
     } | {
-        Item?: undefined;
         Compressed?: undefined;
+        Item?: undefined;
         Held?: undefined;
         Nft?: undefined;
         Roll: any[];
         Tokens?: undefined;
     } | {
-        Item?: undefined;
         Compressed?: undefined;
-        Held?: undefined;
-        Nft?: undefined;
-        Roll?: undefined;
-        Tokens: {
-            from: {
-                Pool: any[];
-                Mint?: undefined;
-            } | {
-                Pool?: undefined;
-                Mint: string[];
-            };
-            amount: {
-                Bps: number[];
-                Fixed?: undefined;
-            };
-        };
-    } | {
         Item?: undefined;
-        Compressed?: undefined;
         Held?: undefined;
         Nft?: undefined;
         Roll?: undefined;
@@ -604,10 +652,7 @@ export declare function contestArgs(c: any, m: any, at?: any): {
                 Pool?: undefined;
                 Mint: string[];
             };
-            amount: {
-                Bps?: undefined;
-                Fixed: bigint[];
-            };
+            amount: bigint;
         };
     } | null;
     prize_split: boolean;
@@ -616,16 +661,16 @@ export declare function contestArgs(c: any, m: any, at?: any): {
             Item: any[];
             Collection?: undefined;
         } | {
-            Item?: undefined;
             Collection: any[];
+            Item?: undefined;
         };
         key: any;
         test: any;
     } | null;
+    cap: any;
 };
 export declare function farmArgs(f: any, m: any): {
     custody: any;
-    rewards_pool: any;
     tiers: any;
     boosts: any;
     max_boost_bps: number;
@@ -634,8 +679,8 @@ export declare function farmArgs(f: any, m: any): {
             Item: any[];
             Collection?: undefined;
         } | {
-            Item?: undefined;
             Collection: any[];
+            Item?: undefined;
         };
         key: any;
         test: any;
@@ -643,6 +688,8 @@ export declare function farmArgs(f: any, m: any): {
     rate: {
         per_day: bigint;
         mints: boolean;
+        shared: boolean;
+        halve_every: number;
     } | null;
     growth: {
         key: any;
@@ -650,6 +697,8 @@ export declare function farmArgs(f: any, m: any): {
         level: any;
         steps: any;
         streak: boolean;
+        profile: boolean;
+        at_least: bigint;
     }[];
     ends_at: bigint;
     lock_key: any;
@@ -657,18 +706,14 @@ export declare function farmArgs(f: any, m: any): {
     exit_to: string | {
         Pool: any[];
     } | null;
-    unbond: number;
-    toll: {
-        bps: number;
-        to: string | {
-            Pool: any[];
-        };
-    } | null;
 };
-/** A fee's sink (`Sink`): "burn", or "pool:<key>", one of the project's pools. */
-export declare const sinkOf: (to: any, m: any) => "Burn" | {
+/** A fee's sink (`Sink`): "burn", "rewards" (the farm's own vault), or "pool:<key>", one of the project's pools. */
+export declare const sinkOf: (to: any, m: any) => "Burn" | "Rewards" | {
     Pool: any[];
 };
+/** Whether a spec's farm keeps a record of when its seats stop earning (`loot.farmKeepsEnds`): a tier's term or an upkeep,
+ * and it pays something. Each different time waiting costs whoever writes it `loot.END_BYTES` of rent. */
+export declare const farmEnds: (f: any) => any;
 /** An auction's args: its lot, reserve, least raise, times and split. "start" is when it goes live unless it says. */
 export declare function auctionArgs(a: any, m: any): {
     lot: {
@@ -714,8 +759,8 @@ export declare function auctionArgs(a: any, m: any): {
                 Item: any[];
                 Collection?: undefined;
             } | {
-                Item?: undefined;
                 Collection: any[];
+                Item?: undefined;
             };
             key: any;
             test: any;
@@ -726,20 +771,20 @@ export declare function auctionArgs(a: any, m: any): {
             Item: any[];
             Collection?: undefined;
         } | {
-            Item?: undefined;
             Collection: any[];
+            Item?: undefined;
         };
         key: any;
         test: any;
     } | null;
 };
 export declare function grantArgs(g: any, m: any): {
-    gives: {
-        Item?: undefined;
+    gives: string | {
         Compressed: {
             item: any;
             tree: string;
         };
+        Item?: undefined;
         Held?: undefined;
         Nft?: undefined;
         Roll?: undefined;
@@ -752,15 +797,15 @@ export declare function grantArgs(g: any, m: any): {
         Roll?: undefined;
         Tokens?: undefined;
     } | {
-        Item?: undefined;
         Compressed?: undefined;
+        Item?: undefined;
         Held: any[];
         Nft?: undefined;
         Roll?: undefined;
         Tokens?: undefined;
     } | {
-        Item?: undefined;
         Compressed?: undefined;
+        Item?: undefined;
         Held?: undefined;
         Nft: {
             stash: any;
@@ -769,34 +814,15 @@ export declare function grantArgs(g: any, m: any): {
         Roll?: undefined;
         Tokens?: undefined;
     } | {
-        Item?: undefined;
         Compressed?: undefined;
+        Item?: undefined;
         Held?: undefined;
         Nft?: undefined;
         Roll: any[];
         Tokens?: undefined;
     } | {
-        Item?: undefined;
         Compressed?: undefined;
-        Held?: undefined;
-        Nft?: undefined;
-        Roll?: undefined;
-        Tokens: {
-            from: {
-                Pool: any[];
-                Mint?: undefined;
-            } | {
-                Pool?: undefined;
-                Mint: string[];
-            };
-            amount: {
-                Bps: number[];
-                Fixed?: undefined;
-            };
-        };
-    } | {
         Item?: undefined;
-        Compressed?: undefined;
         Held?: undefined;
         Nft?: undefined;
         Roll?: undefined;
@@ -808,10 +834,7 @@ export declare function grantArgs(g: any, m: any): {
                 Pool?: undefined;
                 Mint: string[];
             };
-            amount: {
-                Bps?: undefined;
-                Fixed: bigint[];
-            };
+            amount: bigint;
         };
     };
     vouchers: any[];
@@ -826,8 +849,11 @@ export declare function grantArgs(g: any, m: any): {
         };
         per_person: any;
         per_key: any;
-        per_day: any;
-        total: any;
+        all: {
+            total: any;
+            per_window: any;
+            window: number;
+        };
         window: {
             opens_at: bigint;
             closes_at: bigint;
@@ -864,20 +890,21 @@ export declare function grantArgs(g: any, m: any): {
                 Item: any[];
                 Collection?: undefined;
             } | {
-                Item?: undefined;
                 Collection: any[];
+                Item?: undefined;
             };
             key: any;
             test: any;
         } | null)[];
     } | null;
+    shard_bits: number;
 };
 /**
  * Every step that sets the economy up, in order: the tokens the project mints, the collection, the project, the pools, items, boxes (the shop's too), recipes, schedules, lotteries, grants,
  * farms, auctions, then the seeds and the grants' funds. `only` limits it to these part ids (a change to a live economy).
  *
- * A farm opens before the seed of its rewards pool lands, and anyone may stake in between. That is safe: a sharing
- * farm credits nothing at once, and releases what lands in its pool over its longest lock (a day at least) to the
+ * A farm opens before its seed lands in its rewards vault, and anyone may stake in between. That is safe: a sharing
+ * farm credits nothing at once, and releases what lands in its vault over its longest lock (a day at least) to the
  * seats there as it is released, its clock stopped while nobody is in. A seed that lands
  * before the first stake or after it is released the same way from that stake on, so seeding first would change nothing.
  */
@@ -900,8 +927,9 @@ export declare function setupSteps(economy: any, { now, only, live: given }?: {
         treeHolds: any;
         projectNumber: any;
         items: any;
-        pools: any[];
+        pools: any;
         stashes: any;
+        tables: any;
         boxes: never[];
         payments: any;
         recipes: any;
@@ -918,11 +946,23 @@ export declare function setupSteps(economy: any, { now, only, live: given }?: {
         live: any;
     };
 };
-/** A stash's bytes before its NFTs: its tag, its project, its id and its count (`stash.rs`); each NFT adds 32. */
-export declare const STASH_HEAD_BYTES = 41;
+/** The token accounts going live opens (`setupSteps`): [{ who ('the treasury', 'the project' or a wallet), token }], each
+ * once, for the coins the economy takes in. */
+export declare function goLiveAccounts(m: any): any[];
+/**
+ * The addresses a project's transactions name most, for its standing lookup table: loot's own fixed accounts (the
+ * platform, the oracle's), the project and its fee box, its treasury and collections, each coin's mint, its vault and
+ * the treasury's account of it, then each pool, item, box and stash. Each a function of the go-live context.
+ */
+export declare function standingAddresses(m: any): any[];
+/** A stash's bytes with `n` NFTs: a table of NFTs (`table.rs`): its 51-byte header, a total for each group of 4,096
+ * rows and each block of 64, and 36 bytes an NFT (its weight and its address). */
+export declare const stashBytes: (n: any) => number;
 /** Who puts a spec's auction up, and so is named in its address: the owner for a collectible it holds, the authority for a new unit of an item. */
 export declare const auctionSeller: (a: any, ctx: any) => any;
 export declare const recordBytesOf: (kind: any, body: any) => number;
+/** A farm's bytes as `open_farm` writes it: its args and its numbers. */
+export declare const farmBytes: (f: any, m: any) => number;
 /** Exact initial contest record size for its configured shares, gate, sides and deciders. */
 export declare const contestBytes: (contest: any, m: any) => number;
 /** Stand-in addresses for every name a plan uses, so it can be built and sized without a wallet. */
@@ -941,6 +981,7 @@ export declare function placeholderContext(m: any, { rent }?: {
         'new:tree'?: string | undefined;
     };
     rent: (bytes: any) => bigint;
+    slot: bigint;
 };
 /**
  * What of `live` is made. While a setup is landing (`partial`), the project, its collection, its tree and each mint the
@@ -976,6 +1017,7 @@ export declare function pack(steps: any, ctx: any): {
     built: any[];
     instructions: any;
     signers: any[];
+    alone: boolean;
 }[];
 /**
  * The plan for a spec: refusals, or every step packed into transactions. With `ctx` the transactions carry the
@@ -1005,6 +1047,7 @@ export declare function plan(economy: any, { now, ctx, only, live }?: {
         built: any[];
         instructions: any;
         signers: any[];
+        alone: boolean;
     }[];
     approvals: number;
     freshKeys: any[];