@xgamesfun/solana 0.26.3 → 0.27.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xgamesfun/solana",
-  "version": "0.26.3",
+  "version": "0.27.0",
   "mcpName": "io.github.XGamesFun/solana-kit",
   "description": "Loot boxes, gacha, shops, lotteries, auctions, NFT staking, crafting and rewards on Solana without writing a smart contract: one shared program, its JS client, a CLI, and an MCP server and skill so Claude Code, Codex or any AI agent can design, check, simulate and launch an economy.",
   "license": "Apache-2.0",

package/release.json

@@ -1,8 +1,8 @@
 {
-  "version": "0.26.1",
+  "version": "0.27.0",
   "programId": "9cwqM1TXytPnFZsLfmUyv2dg4uW6Ch9C6UJVPns7NFQ",
-  "sbfBytes": 1783800,
-  "sbfSha256": "af318ccfa4d2901076b85fcd1b4467b03253adf0de16e73a9dfc1ef8077b2c14",
-  "idlSha256": "0e88fc826a585cf17917cbc654e33b68232771769fe9aae1d5899a257940ff47",
-  "clientSha256": "8c8c89bfca22961d24379b2cc63964dfa2e68d3b65cdcbb33d52352677464533"
+  "sbfBytes": 1794664,
+  "sbfSha256": "3b11c460548a4fec865fd902431a94ac13a71c3a1013e4516783515e5d266bd6",
+  "idlSha256": "62364c5fd5be8aa001f4d72fb87b121b045dea07668f9b5ec9856d323d6cf445",
+  "clientSha256": "179b7ff59398a39cce70df059c1781e91a3d0366791797b368d8030169a507ad"
 }

package/skills/xsolana-economy/SKILL.md

@@ -9,9 +9,9 @@ An economy is one JSON spec (`xsolana.json` in the project) on **loot**, a Solan
 writes or deploys a contract: the spec is checked, simulated and priced by the `xsolana_*` tools, and the project's
 owner puts it live by approving in their own wallet. It runs on **devnet** until the program is audited.
 
-The tools are the `xsolana_*` MCP tools. Without MCP, the same from a terminal: `npx -y @xgamesfun/solana@0.26.3 <guide|examples|check|simulate|cost|explain|review|publish|status> [xsolana.json]`,
-`npx -y @xgamesfun/solana@0.26.3 token <mint>` for a coin made elsewhere,
-or `npx -y @xgamesfun/solana@0.26.3 tool <name> '<json>'` for any tool (always with the exact version).
+The tools are the `xsolana_*` MCP tools. Without MCP, the same from a terminal: `npx -y @xgamesfun/solana@0.27.0 <guide|examples|check|simulate|cost|explain|review|publish|status> [xsolana.json]`,
+`npx -y @xgamesfun/solana@0.27.0 token <mint>` for a coin made elsewhere,
+or `npx -y @xgamesfun/solana@0.27.0 tool <name> '<json>'` for any tool (always with the exact version).
 
 ## Rules (always)
 
@@ -123,7 +123,7 @@ or `npx -y @xgamesfun/solana@0.26.3 tool <name> '<json>'` for any tool (always w
    level would cost. Run it again after every change that touches a route that pays.
 9. **When they say "put it live"**: `xsolana_publish` lists every step and its cost and gives the command. Tell them to
    run it themselves in the project folder, exactly as `xsolana_publish` gives it (it names the exact version:
-   `npx -y @xgamesfun/solana@0.26.3 approve xsolana.json`; never drop the version). It opens a page on their computer where
+   `npx -y @xgamesfun/solana@0.27.0 approve xsolana.json`; never drop the version). It opens a page on their computer where
    they connect a devnet wallet and approve; what lands is written back into `xsolana.json`. You publish nothing.
 10. **After it is live**: `xsolana_status` shows each part on chain; read it before acting on what the person says
     happened. A later change is the same loop: save, publish, and the approval sends only what changed. What only the

package/skills/xsolana-economy/references/apps.md

@@ -178,6 +178,12 @@ assetId, tree }` after a `loot.proveLeafIx` in the same transaction. `app.stakeN
   of its `mint`), then `app.repay(asset, due, { repay })` pays exactly that, in the payer's one prompt (a loan whose
   debt changed since is refused); a throwaway key that transaction funds sends the NFT home to its borrower, a pNFT's
   or a compressed NFT's too (one prompt). A lender sees an overdue unpaid loan in `claims()` (`release`, to them).
+- **An NFT its collection took back.** Whoever controls a collection the project does not can take an NFT out of a
+  hold, a loan or a listing, or burn it there. `claims()` then lists that hold or loan, for its player and for its
+  lender, as a `release` flagged `gone`: show `c.says` (closing it sends nothing, and a loan ends unpaid) and let
+  `app.claim(c)` close it. `app.listing(asset)` and `app.listings()` flag such a listing `gone`: show it as not for
+  sale. Its maker's `app.unlist` closes it, and `app.closeGone(asset)` lets anyone close it. Before a deposit, the
+  play module closes what an earlier owner left of the NFT, in the same prompt.
 - **A grant that pays by rank**: a voucher with an `amount` (base units of the grant's token) pays that much, up to
   the grant's; `app.claimGrant(key, { voucher })` passes it, and `{ proof, round, personHash, amount }` for a list.
 - **The price the player saw is the most they pay**: `app.buy` and `app.openBox` need the listing `shop()` or

package/skills/xsolana-economy/references/telling-the-person.md

@@ -122,8 +122,10 @@ Don'ts:
 - **A token the setup makes is named on chain as it goes live**: its `name`, its `symbol` and its `uri` (a link to a
   JSON file the project hosts, `{ "name", "symbol", "image": "https://…" }`), which is what wallets and explorers show.
   Ask for the name, the ticker and a picture before going live: with no `uri` it shows by name and ticker with no
-  picture. Only the owner's wallet can change the three later (Token Metadata's rule, not loot's), and these tools
-  don't change a live token's yet, so get them right first. The record costs about 0.014 SOL (`xsolana_cost` says it:
+  picture. Only the owner's wallet can change the three later (Token Metadata's rule, not loot's): change them in the
+  spec and approve again, and the record is written again for the price of a transaction (approving reads the record
+  first: one its owner handed to another wallet, made unchangeable or gave a royalty or creators outside these tools
+  is left as it is, and the page says so at each approve until the spec gives the old name back). The record costs about 0.014 SOL (`xsolana_cost` says it:
   rent, and 0.01 SOL Token Metadata keeps). A token that went live before the tools wrote one has none and
   can't be given one: only a mint's own authority can name it, and its minting was handed on or turned off.
 - **NFTs the project has no authority over** (any collection but its own): they count as they are. Say that

package/skills/xsolana-economy/references/trust-and-cheating.md

@@ -119,9 +119,10 @@ Run `xsolana_review` and go through what it reports; these are the points behind
     enter: keep contests for results the server decides, or that anyone can check outside the game. A prize to each
     winning entry with no stake and no gate pays one person with many wallets once a wallet.
 15. **NFTs the project doesn't control.** The creator of an NFT with a permanent delegate can pull it back out of a
-    hold, a stake, a loan or a listing, and a collection the project is only an update delegate of lets its owner and
-    every other delegate mint NFTs that read as the project's own items. Name only collections whose every writer the
-    project trusts.
+    hold, a stake, a loan or a listing, or burn it there. Its record then closes without it (anyone may, and nothing
+    is paid: a lender is out what they lent), and `js/play` closes what an earlier owner left before the next owner's
+    deposit. A collection the project is only an update delegate of lets its owner and every other delegate mint NFTs
+    that read as the project's own items. Name only collections whose every writer the project trusts.
 
 ## Telling the person
 

package/types/chain/metadata.d.ts

@@ -36,5 +36,50 @@ export declare function createFungibleMetadataIx({ mint, authority, payer, name,
     }[];
     data: Uint8Array<any>;
 };
+/**
+ * Token Metadata's UpdateMetadataAccountV2 for a fungible token's record: a new name, ticker and link ('' for none),
+ * all three written as given. `authority` is the record's update authority (for a token a setup made: the project's
+ * owner) and signs; it stays the update authority, and the record stays changeable. The record's words are written
+ * whole, with no royalty, creators, collection or uses: as a record a setup made has them. One that was given any of
+ * those outside these tools would lose them (or refuse the write), so the approval sends this only to a record that
+ * has none (`parseRecord`'s `plain`; approve/live-check.mjs readRenames). The mint is untouched, and it costs only the
+ * transaction: the record keeps its size.
+ */
+export declare function updateFungibleMetadataIx({ mint, authority, name, symbol, uri }: {
+    authority: any;
+    mint: any;
+    name: any;
+    symbol: any;
+    uri?: string | undefined;
+}): {
+    programId: string;
+    keys: {
+        pubkey: any;
+        isSigner: any;
+        isWritable: any;
+    }[];
+    data: Uint8Array<any>;
+};
+/**
+ * A Token Metadata record as the chain holds it, or null when the data is not one (its first byte says a metadata
+ * record; the strings are padded with NULs to their full length):
+ * { updateAuthority, mint, name, symbol, uri, royalty, creators, mutable, collection, uses, plain }.
+ * `royalty`: its resale royalty, in hundredths of a percent. `creators`: how many it lists. `mutable`: its update
+ * authority can still change it. `collection`, `uses`: whether it names one. `plain`: none of royalty, creators,
+ * collection or uses, as a setup's own record is: writing its words again changes nothing else of it.
+ */
+export declare function parseRecord(data: any): {
+    updateAuthority: string;
+    mint: string;
+    name: string;
+    symbol: string;
+    uri: string;
+    royalty: number;
+    creators: number;
+    mutable: boolean;
+    collection: boolean;
+    uses: boolean;
+    plain: boolean;
+} | null;
 /** The update authority a Token Metadata record names (who can change its name, ticker and link). */
 export declare const metadataUpdateAuthority: (data: any) => string | null;

package/types/client/compressed.d.ts

@@ -6,8 +6,10 @@ export declare function proofLength(treeData: any): number;
 /**
  * A compressed NFT from an indexer's answers: `asset` (DAS `getAsset`), `proof` (DAS `getAssetProof`) and the tree
  * account's bytes (`treeData`, for how much of the proof to pass). Returns { id, tree, nonce, owner, delegate,
- * collection (or null), dataHash, creatorHash, assetDataHash (or null), flags, root, proof: [node, …] }. The proof
- * must be against the tree's current root when it lands: fetch it just before sending.
+ * collection (or null), dataHash, creatorHash, assetDataHash (or null), flags, root, proof: [node, …], burnt }. The
+ * proof must be against the tree's current root when it lands: fetch it just before sending. A burned NFT (DAS says
+ * `burnt`) is described as the program takes one: a data hash of all zeros, which `proveLeafIx` then proves against
+ * the leaf's empty slot, so its record names no owner (a record that holds it lets go of it on that proof).
  */
 export declare function compressedFromDas({ asset, proof, treeData }: {
     asset: any;
@@ -26,4 +28,5 @@ export declare function compressedFromDas({ asset, proof, treeData }: {
     flags: number;
     root: Uint8Array<ArrayBuffer> | null;
     proof: any;
+    burnt: boolean;
 };

package/types/client/ix.d.ts

@@ -3877,6 +3877,10 @@ export declare const SETTLE_LAST = 4294967295;
  * them (one its collection won't let move). `giveUp`: the places in `won` of tokens or collectibles the player,
  * signing, gives up because they can't receive them (an account its issuer froze, a collection that refuses the mint),
  * so the rest of the order is not held up: tokens given up stay in the project's vault (`PrizeForgone` says which).
+ * An NFT proven gone from the project is passed over the same way, with no choice of the player's (`piece`: the Core
+ * asset itself, `tokenMetadata.evidence` in its kind, a compressed NFT's record proven again): the NFT the order rolled
+ * on is not sent back, burned, given or stashed (`NftGone`), and a stash's NFT it won is not given (`PrizeForgone`
+ * for it beside `NftGone`: read it as not given); everything else settles as rolled.
  * `handBack`: the wallet the box's fate gives the NFT rolled on to
  * (`receiverOf`) is an account of the loot program (`handsBack` of it as read), so the program gives it back to the
  * player, and a Token Metadata NFT's `token` is the player's. `extra`: a hook's or a memo's accounts.
@@ -3931,6 +3935,8 @@ export declare const INCINERATOR = "1nc1nerator11111111111111111111111111111111"
  * (`orderRefundable`). A purchase counted against a box's limit for each
  * wallet is given back. A purchase that counts its draws in its box's `in_flight` (`order.reserved`, a box that stops
  * selling when an entry runs out) names the box, whose count it leaves. `extra`: a hook's or a memo's accounts.
+ * An NFT the order holds that is proven gone from the project (`subject`, as `piece` takes it) is not looked for: the
+ * whole payment goes back all the same (`NftGone` beside `OrderRefunded`).
  */
 export declare function refundIx({ signer, orderAddress, order, subject, programs, extra }: {
     extra?: never[] | undefined;
@@ -4083,6 +4089,10 @@ export declare const madeAssets: (project: any, item: any, itemState: any, count
  * NFT is any kind
  * (`piece`): `asset` and `collection` for a Core asset, with `tokenMetadata` for a Token Metadata NFT, or `compressed`
  * (after a `proveLeafIx`).
+ * A hold whose NFT is proven gone from the project (`piece`: the Core asset itself, `tokenMetadata.evidence`, a
+ * compressed NFT's record proven again) closes instead: anyone sends it, at any time, also while the hold runs and for
+ * a loan before it is due, for no project fee. Nothing moves and `to` is not read; the hold's rent goes to whoever paid
+ * it, and a loan's debt ends unpaid. Its receipt is `NftGone`, with no `Released`.
  */
 export declare function releaseIx({ signer, project, collection, asset, tokenMetadata: tm, compressed, hold, address, to, treasury, reference: ref, more, }: {
     address?: null | undefined;
@@ -4344,6 +4354,8 @@ export declare function pullAssigns(r: any, stash: any, upto: any): number;
  * close, and the next carries on. Every pull of one entry's places names the same `nonce`: a place's roll is made at
  * `prizeRollNonce(nonce + place)`, so a later pull with another nonce can land on an order an earlier pull made and fail
  * ("already in use"). js/play names `prizeNonce(round, entry)` for every pull of an entry, whoever sends it.
+ * An NFT ticket proven gone from the project (`ticket`, as `piece` takes it) goes nowhere: its part settles and
+ * nothing moves (`LotteryPulled` with amount 0 beside `NftGone`).
  */
 export declare function pullIx({ payer, project, roundAddress: key, round: r, entry, part, projectState, ticket, handBack, hold, nonce, prize, holders, toTreasury, lotteryClosed, programs, extra, }: {
     entry?: number | undefined;
@@ -4424,14 +4436,17 @@ export declare const farmKeepsEnds: (args: any) => any;
  * little compute, so a farm idle past many ends may leave a move no room: `farmNeedsWalk`.
  */
 export declare function endsToWalk(farm: any, ends: any, now: any): any;
-/** How many ends `walk_farm` walks in one transaction at `WALK_COMPUTE_UNITS`: an end takes at most some 2,300 units, with a
- * halving rate (`js/test/farm-ends.test.mjs` measures it). */
-export declare const WALK_PER_TX = 500;
+/** How many ends `walk_farm` walks in one transaction at `WALK_COMPUTE_UNITS`: an end takes up to some 3,150 units at
+ * the dearest farm, a halving rate and seats of 4 × 10^16 base units at a ×100 tier (`js/test/farm-ends.test.mjs`
+ * measures it: 400 ends take 1,260,730 units, 2,270 an end with light seats). Since loot 0.27 each end walked also
+ * frees the leaving weight's share of the carry, some 300 units more at that farm; it was 500 until then, measured
+ * with light seats only. */
+export declare const WALK_PER_TX = 400;
 /** The compute units a transaction that walks ends asks for: `walk_farm`, or a move with ends to walk first. */
 export declare const WALK_COMPUTE_UNITS = 1400000;
-/** How many ends a move can walk first at `WALK_COMPUTE_UNITS` and still do its own work: past this, the farm is walked
- * first (`farmNeedsWalk`). */
-export declare const MOVE_WALK_ROOM = 400;
+/** How many ends a move can walk first at `WALK_COMPUTE_UNITS` and still do its own work (some 400,000 units are left
+ * for it at the dearest farm): past this, the farm is walked first (`farmNeedsWalk`). 400 until loot 0.27. */
+export declare const MOVE_WALK_ROOM = 300;
 /**
  * Whether a farm has passed more ends than a move can walk in its own transaction (`endsToWalk`, `MOVE_WALK_ROOM`): such
  * a move fails on compute until `walk_farm` has caught the farm up. Nothing is lost by waiting: what a seat earned by
@@ -4553,6 +4568,11 @@ export declare const AUTH_RULES_PROGRAM = "auth9SigNpDKz4sJJ1DfCTuZrZNSAgh9sFD3r
  *     token account of `wallet` (its holder, or whoever the project sends it to) and the project's own;
  *   a compressed NFT (`compressed`, from `compressedFromDas`), proven by a `proveLeafIx` earlier in the transaction.
  * A Token Metadata or compressed NFT passes its Sheet: the project writes nothing on it.
+ * An NFT proven gone from the project (whoever controls its collection took it out of the project's hands or burned
+ * it) is let go by the record that holds it, on these same accounts (loot 0.27, receipt `NftGone`): a Core asset shows
+ * it by itself; a compressed NFT by its record, proven again as the leaf is now; a Token Metadata NFT by
+ * `tokenMetadata.evidence`, the token account that holds it now, or its mint when it was burned, which goes in the
+ * place of `wallet`'s token account. Anything else shows nothing, and the route goes its usual way.
  * What the route does with it, so only the accounts it takes are passed (each true when left out):
  *   `moves`: hands it to the project or sends it on; `locks`: locks or unlocks it in its wallet; `writes`: writes on it;
  *   `burns`: burns a Core asset (false when left out); `reads`: reads its Sheet; `held`: reads it in the project's token
@@ -5062,6 +5082,10 @@ export declare function holdIx({ player, project, collection, asset, tokenMetada
  * by, and gets back the rent it no longer needs. `drop`: the NFT leaves the stash and stays where it is, owed to the
  * treasury in its hold (`["hold", nft, 0]`, the signer paying its rent until anyone `release`s it to the treasury, one
  * NFT a call). `out` is never the project's own address nor another account of the program (`ToTheProject`).
+ * Taking out of a project's stash an NFT proven gone from the project (`piece`: the Core asset itself,
+ * `tokenMetadata.evidence`, a compressed NFT's record proven again) only takes its row off the list: anyone may send
+ * it (`signer`), for no fee, nothing moves and no hold is made (`NftGone`, no `Stashed`); the rent the stash no longer
+ * needs goes to the signer only when it is one of the project's keys. A lottery's own stash stays the project's keys'.
  */
 export declare function stashIx({ signer, project, id, lottery, lotteryState, asset, out, drop, weight, collection, tokenMetadata: tm, compressed, more, }: {
     asset: any;
@@ -5444,6 +5468,10 @@ export declare function openListingIx({ maker, project, asset, mint, deal, share
  * takes none of the NFT's accounts but its address. `holders`, `programs`, `treasury` as for any split. After the
  * take's own accounts come a sale's compressed NFT's proof, then the shares' accounts, then (in `extra`) Core's
  * transfer adapters and any transfer hook's accounts, which the program finds by address after the shares'.
+ * A listing whose NFT is proven gone from the project (`piece`: the Core asset itself, `tokenMetadata.evidence`, a
+ * compressed NFT's record proven again) closes instead, whoever sends this: the taker pays nothing and no fee, the
+ * listing's rent goes to its maker, and the receipt is `NftGone`. It is refused while a rental runs (`Rented`), and
+ * closes once the rental has run.
  */
 export declare function takeListingIx({ taker, project, projectState, listing, periods, collection, hasAuthority, tokenMetadata: tm, compressed, holders, programs, takerToken, extra, }: {
     collection: any;
@@ -5466,7 +5494,10 @@ export declare function takeListingIx({ taker, project, projectState, listing, p
 };
 /**
  * Its maker closes a listing (`listing` the decoded Listing): the NFT goes home. While a rental runs it only stops (no
- * renter takes it again), and the same call once the rental is over takes it home. Free.
+ * renter takes it again), and the same call once the rental is over takes it home. Free. A listing whose NFT is proven
+ * gone from the project (`piece`: the Core asset itself, `tokenMetadata.evidence`, a compressed NFT's record proven
+ * again) closes without it once no rental runs, its rent to its maker (`NftGone`, no `Unlisted`); anyone else closes
+ * such a listing with `takeListingIx`.
  */
 export declare function closeListingIx({ maker, project, listing, collection, hasAuthority, tokenMetadata: tm, compressed, extra, }: {
     collection: any;

package/types/economy/cost.d.mts

@@ -19,10 +19,11 @@ export declare function setupCost(plan: any, economy: any): {
 export declare function actionCosts(economy: any, { now }?: Readonly<Record<string, any>>): any[];
 /** Setup and play costs for a spec, or its refusals. */
 /** `only` and `live`: a change to a live economy, priced as only what it publishes (live.mjs `changedParts`). */
-export declare function cost(economy: any, { now, only, live }?: {
+export declare function cost(economy: any, { now, only, live, renames }?: {
     live?: null | undefined;
     now?: number | undefined;
     only?: null | undefined;
+    renames?: null | undefined;
 }): {
     ok: boolean;
     refusals: any[];
@@ -35,7 +36,14 @@ export declare function cost(economy: any, { now, only, live }?: {
     refusals?: undefined;
     ok: boolean;
     warnings: any[];
-    steps: any[];
+    steps: {
+        creates: never[];
+        signers: string[];
+        id: string;
+        part: string;
+        says: string;
+        build: {};
+    }[];
     transactions: {
         signer: string;
         steps: any[];
@@ -46,7 +54,7 @@ export declare function cost(economy: any, { now, only, live }?: {
         alone: boolean;
     }[];
     approvals: number;
-    freshKeys: any[];
+    freshKeys: string[];
 } | {
     ok: boolean;
     setup: {

package/types/economy/live.d.mts

@@ -7,12 +7,13 @@ export declare function freshAddresses(names: any, random?: typeof randomBytes):
  * The transactions that put `economy` live for `owner`, with `keys` the addresses of the fresh accounts (each signs
  * the transaction that creates it). `live`: what is already live (a change publishes only what differs).
  */
-export declare function prepare(economy: any, { owner, keys, live, now, rent, only, slot }: {
+export declare function prepare(economy: any, { owner, keys, live, now, rent, only, slot, renames }: {
     keys: any;
     live?: null | undefined;
     now?: number | undefined;
     only?: null | undefined;
     owner: any;
+    renames?: null | undefined;
     rent: any;
     slot?: null | undefined;
 }): {
@@ -27,7 +28,14 @@ export declare function prepare(economy: any, { owner, keys, live, now, rent, on
     refusals?: undefined;
     ok: boolean;
     warnings: any[];
-    steps: any[];
+    steps: {
+        creates: never[];
+        signers: string[];
+        id: string;
+        part: string;
+        says: string;
+        build: {};
+    }[];
     transactions: {
         signer: string;
         steps: any[];
@@ -38,7 +46,7 @@ export declare function prepare(economy: any, { owner, keys, live, now, rent, on
         alone: boolean;
     }[];
     approvals: number;
-    freshKeys: any[];
+    freshKeys: string[];
 } | {
     ok: boolean;
     refusals: any[];
@@ -55,6 +63,7 @@ export declare function prepare(economy: any, { owner, keys, live, now, rent, on
         project: any;
         treasury: any;
         mints: {};
+        tables: any;
         keys: any;
         rent: any;
         slot: null;
@@ -63,7 +72,14 @@ export declare function prepare(economy: any, { owner, keys, live, now, rent, on
     refusals?: undefined;
     ok: boolean;
     warnings: any[];
-    steps: any[];
+    steps: {
+        creates: never[];
+        signers: string[];
+        id: string;
+        part: string;
+        says: string;
+        build: {};
+    }[];
     transactions: {
         signer: string;
         steps: any[];
@@ -74,7 +90,7 @@ export declare function prepare(economy: any, { owner, keys, live, now, rent, on
         alone: boolean;
     }[];
     approvals: number;
-    freshKeys: any[];
+    freshKeys: string[];
     ctx: {
         owner: any;
         authority: any;
@@ -83,6 +99,7 @@ export declare function prepare(economy: any, { owner, keys, live, now, rent, on
         project: any;
         treasury: any;
         mints: {};
+        tables: any;
         keys: any;
         rent: any;
         slot: null;
@@ -118,9 +135,16 @@ export declare function changedParts(economy: any): {
     fixed: never[];
     removed: never[];
     settings: never[];
+    renames: never[];
 } | {
     only: Set<any>;
     fixed: string[];
     removed: string[];
     settings: string[];
+    renames: any[];
 };
+/**
+ * In words, for a tool that does not read the chain: the spec changes what these tokens are called, and what becomes
+ * of that is decided when the change is approved.
+ */
+export declare const renamesNote: (renames: any) => string;

package/types/economy/model.d.mts

@@ -196,6 +196,12 @@ export declare const spendOf: (then: any, m: any) => "Burn" | {
     Stash?: undefined;
     Give: any[];
 };
+/**
+ * What a token the setup makes is called on chain, from its entry in a spec as written: [name, ticker, link], with
+ * the names it gets when the spec gives none (`tokenOf`: its key in capitals for a ticker, its ticker or key for a
+ * name). Two entries with the same labels write the same record, however they are spelled.
+ */
+export declare function tokenLabels(t: any): any[];
 /**
  * The spec with references resolved and ids given. Unknown references stay as they are (the checker reports
  * them); call `check` first when it matters.

package/types/economy/plan.d.mts

@@ -929,12 +929,20 @@ export declare function grantArgs(g: any, m: any): {
  * 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.
  */
-export declare function setupSteps(economy: any, { now, only, live: given }?: {
+export declare function setupSteps(economy: any, { now, only, live: given, renames }?: {
     live?: null | undefined;
     now?: number | undefined;
     only?: null | undefined;
+    renames?: null | undefined;
 }): {
-    steps: any[];
+    steps: {
+        creates: never[];
+        signers: string[];
+        id: string;
+        part: string;
+        says: string;
+        build: {};
+    }[];
     model: {
         now: number;
         name: any;
@@ -1026,6 +1034,7 @@ export declare function setupContext(m: any, { owner: ownerKey, keys, live: give
     project: any;
     treasury: any;
     mints: {};
+    tables: any;
     keys: any;
     rent: any;
 };
@@ -1051,11 +1060,12 @@ export declare function pack(steps: any, ctx: any): {
  * The plan for a spec: refusals, or every step packed into transactions. With `ctx` the transactions carry the
  * real instructions; without it they are built on stand-in addresses (for sizing, cost and showing).
  */
-export declare function plan(economy: any, { now, ctx, only, live }?: {
+export declare function plan(economy: any, { now, ctx, only, live, renames }?: {
     ctx?: null | undefined;
     live?: null | undefined;
     now?: number | undefined;
     only?: null | undefined;
+    renames?: null | undefined;
 }): {
     ok: boolean;
     refusals: any[];
@@ -1068,7 +1078,14 @@ export declare function plan(economy: any, { now, ctx, only, live }?: {
     refusals?: undefined;
     ok: boolean;
     warnings: any[];
-    steps: any[];
+    steps: {
+        creates: never[];
+        signers: string[];
+        id: string;
+        part: string;
+        says: string;
+        build: {};
+    }[];
     transactions: {
         signer: string;
         steps: any[];
@@ -1079,7 +1096,7 @@ export declare function plan(economy: any, { now, ctx, only, live }?: {
         alone: boolean;
     }[];
     approvals: number;
-    freshKeys: any[];
+    freshKeys: string[];
 };
 /** What each part needs while the economy runs: the instruction, and who signs it. */
 export declare function playSteps(economy: any): any[];