@xgamesfun/solana 0.26.3 → 0.27.0

package/js/client/idl/loot.json

@@ -2,7 +2,7 @@
   "address": "9cwqM1TXytPnFZsLfmUyv2dg4uW6Ch9C6UJVPns7NFQ",
   "metadata": {
     "name": "loot",
-    "version": "0.26.1",
+    "version": "0.27.0",
     "spec": "0.1.0",
     "description": "Economy for Anything: one program every coin of a project passes through",
     "repository": "https://github.com/gamesfun/loot"
@@ -8399,6 +8399,19 @@
         128
       ]
     },
+    {
+      "name": "NftGone",
+      "discriminator": [
+        254,
+        200,
+        63,
+        241,
+        105,
+        40,
+        174,
+        76
+      ]
+    },
     {
       "name": "OddsRaised",
       "discriminator": [
@@ -11574,9 +11587,10 @@
             "name": "reward_remainder",
             "docs": [
               "The carry: rounding of a share over the total weight, times `PRECISION`. The next move before",
-              "the farm's end credits it to the seats there once it adds up to a share; a move that leaves no",
-              "weight, or any move once the farm is over, frees its whole tokens (`FarmSide::settle`), and so",
-              "does a walk that begins with no weight or where the weight reaches 0 (`Farm::walk`)."
+              "the farm's end credits it to the seats there once it adds up to a share. Weight that leaves",
+              "frees its share of the whole tokens (`Farm::free_share`); a move that leaves no weight, or any",
+              "move once the farm is over, frees all of them (`FarmSide::settle`), and so does a walk that",
+              "begins with no weight or where the weight reaches 0 (`Farm::walk`)."
             ],
             "type": "u128"
           },
@@ -13630,7 +13644,8 @@
       "name": "LotteryPulled",
       "docs": [
         "One part of a round's entry was settled: `amount`, the tokens it settled (0 for an NFT), to the",
-        "buyer, or for a recipient's part to the recipient."
+        "buyer, or for a recipient's part to the recipient. An NFT ticket proven gone settles its part",
+        "moving nothing, with `NftGone`."
       ],
       "type": {
         "kind": "struct",
@@ -13894,6 +13909,37 @@
         ]
       }
     },
+    {
+      "name": "NftGone",
+      "docs": [
+        "A record let go of its NFT because the NFT is proven gone from the project (`piece::still_held`):",
+        "its collection's controller took it out of the project's hands or burned it. Nothing moved; the",
+        "record closed (a hold, a listing), finished without it (an order), or lost its row (a stash), and",
+        "its rent went where that record's close sends it. `record` is the hold, listing, order or stash;",
+        "`by` who sent it, which anyone may."
+      ],
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "project",
+            "type": "pubkey"
+          },
+          {
+            "name": "record",
+            "type": "pubkey"
+          },
+          {
+            "name": "asset",
+            "type": "pubkey"
+          },
+          {
+            "name": "by",
+            "type": "pubkey"
+          }
+        ]
+      }
+    },
     {
       "name": "NftPrice",
       "docs": [
@@ -15176,8 +15222,8 @@
       "docs": [
         "A prize an order's settle did not give (`OrderSettled` lists it, an `OrderPartSettled` spans it): the one at",
         "`at` of the order's `won`. Its player, settling their own order, gave it up (tokens or a",
-        "collectible they can't receive, a stash's NFT put back), or a compressed one's collection can't",
-        "hold it (its serial voided)."
+        "collectible they can't receive, a stash's NFT put back), a compressed one's collection can't",
+        "hold it (its serial voided), or a stash's NFT is proven gone from the project (with `NftGone`)."
       ],
       "type": {
         "kind": "struct",

package/js/client/ix.js

@@ -1504,6 +1504,10 @@ export const SETTLE_LAST = 4_294_967_295;
  * 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.
@@ -1650,6 +1654,8 @@ export 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 function refundIx({ signer, orderAddress, order, subject, programs, extra = [] }) {
   const project = order.project;
@@ -1952,6 +1958,10 @@ export const madeAssets = (project, item, itemState, count = 1) =>
  * 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 function releaseIx({
   signer,
@@ -2480,6 +2490,8 @@ const treasuryAccounts = (treasury, mint, programs) => walletAccounts(treasury,
  * 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 function pullIx({
   payer,
@@ -2739,14 +2751,17 @@ export function endsToWalk(farm, ends, now) {
   return ends.filter(e => e.at > clock && e.at <= stop).length;
 }
 
-/** 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 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 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 const WALK_COMPUTE_UNITS = 1_400_000;
-/** 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 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 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
@@ -2919,6 +2934,11 @@ const NO_PIECE = {
  *     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
@@ -2963,7 +2983,8 @@ export function piece({
   }
   if (tm) {
     // `tm.into`: the token account of `wallet`'s the NFT goes into when it is not their associated one (`freshNftAccount`).
-    const token = tm.into ?? ata(wallet, asset, TOKEN_PROGRAM);
+    // `tm.evidence`: what shows the NFT gone from the project (the account that holds it now, or its mint), in its place.
+    const token = tm.evidence ?? tm.into ?? ata(wallet, asset, TOKEN_PROGRAM);
     const projectToken = ata(project, asset, TOKEN_PROGRAM);
     const pnft = Boolean(tm.programmable);
     // Token Metadata is called to lock it or move it; a move also takes the project's token account (and record) and the
@@ -4000,6 +4021,10 @@ export function holdIx({
  * 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 function stashIx({
   signer,
@@ -4922,6 +4947,10 @@ export function openListingIx({
  * 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 function takeListingIx({
   taker,
@@ -4958,7 +4987,10 @@ export function takeListingIx({
           ...piece({ project, asset: listing.asset, wallet: taker, compressed, ...ONLY_MOVES, moves: false }),
           proof: [],
         }
-      : standIn(listing.asset);
+      : tm?.evidence
+        ? // A rented Token Metadata NFT shown gone: the project's token account of it, and the one that holds it now.
+          heldPiece({ project, asset: listing.asset, tokenMetadata: tm, evidence: tm.evidence })
+        : standIn(listing.asset);
   return lootIx(
     'take_listing',
     { terms: listingTerms(listing), periods },
@@ -4989,7 +5021,10 @@ export function takeListingIx({
 
 /**
  * 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 function closeListingIx({
   maker,

package/js/economy/check.mjs

@@ -58,6 +58,7 @@ import {
   utf8Bytes,
   wholeCount,
   weights,
+  tokenLabels,
 } from './model.mjs';
 // plan.mjs imports check() in turn: each module only calls the other's functions, never at load time.
 import { boxArgs, boxOrderBytes, placeholderContext, recipeArgs, setupSteps, stepAloneBytes } from './plan.mjs';
@@ -1017,8 +1018,15 @@ export function check(
     // A token the setup makes is named on chain as it is made (its Token Metadata record), and the record takes so
     // many bytes of each, not characters: a longer one would be refused on chain, in the middle of going live. One
     // with no name or ticker at all would be written blank, and show as an unknown token for the record's price. A
-    // token that is live already is not named again: its words here stay labels, as they were.
-    if (source === 'game' && !economy.live?.mints?.[t.key])
+    // token that is live keeps its words as labels, held to nothing, until they are changed: a change is written to
+    // its record, so the new words are held to what a record takes.
+    const liveAs = economy.live?.mints?.[t.key]
+      ? (economy.live.published?.tokens ?? []).find(x => x.key === t.key)
+      : null;
+    const written =
+      !economy.live?.mints?.[t.key] ||
+      (liveAs && JSON.stringify(tokenLabels(liveAs)) !== JSON.stringify(tokenLabels(t)));
+    if (source === 'game' && written)
       for (const [field, what] of [
         ['name', 'name'],
         ['symbol', 'ticker'],
@@ -1468,8 +1476,8 @@ export function check(
       warn(
         'W-OUTSIDE-NFT',
         `${where}.collection`,
-        `${what} takes NFTs of ${r.collection}, a collection the project does not 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 record it leaves behind can later take the next owner’s deposit of the same NFT. This holds for every rule on such a collection in the spec.`,
-        'Before a player deposits one, the app looks for this project’s records that name the NFT (a listing, a hold) and warns when one is left from an earlier owner; prefer collections without a permanent delegate.',
+        `${what} takes NFTs of ${r.collection}, a collection the project does not 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, or burn it there: the record then closes without it (anyone may close it, and nothing is paid: a lender is out the loan). A record nobody closed can still take the next owner’s deposit of the same NFT. This holds for every rule on such a collection in the spec.`,
+        'Before a player deposits one, the app closes this project’s records an earlier owner left of the NFT (a listing, a hold), in the same transaction; prefer collections without a permanent delegate.',
       );
     }
     // A gate may list wallets instead (rules.rs Gate::Wallets): a duel's two players, a tournament's entrants.

package/js/economy/cost.mjs

@@ -39,9 +39,10 @@ import { inAll, round, simulate } from './simulate.mjs';
 const NO_OPTIONS = Object.freeze(/** @type {Record<string, any>} */ ({}));
 
 const sol = lamports => round(Number(lamports) / Number(LAMPORTS_PER_SOL));
-/** Setup steps that are no loot instruction, and so charge no fee: a token minted, the collection made, SOL put in a
- * grant's funds. Every other step is the owner or the authority calling loot, which charges the project fee. */
-const NO_FEE_STEP = /^(token:|collection$|fund:|rent:)/;
+/** Setup steps that are no loot instruction, and so charge no fee: a token minted, a token's name written again, the
+ * collection made, SOL put in a grant's funds. Every other step is the owner or the authority calling loot, which
+ * charges the project fee. */
+const NO_FEE_STEP = /^(token:|name:|collection$|fund:|rent:)/;
 /** Setup cost from a plan (plan.mjs `plan`). */
 export function setupCost(plan, economy) {
   const m = model(economy);
@@ -473,8 +474,8 @@ export function actionCosts(economy, { now } = NO_OPTIONS) {
 
 /** 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 function cost(economy, { now = Math.floor(Date.now() / 1000), only = null, live = null } = {}) {
-  const plan = compile(economy, { now, only, live });
+export function cost(economy, { now = Math.floor(Date.now() / 1000), only = null, live = null, renames = null } = {}) {
+  const plan = compile(economy, { now, only, live, renames });
   if (!plan.ok) return plan;
   return {
     ok: true,

package/js/economy/explain.mjs

@@ -205,14 +205,15 @@ export function explainEconomy(economy, { now = Math.floor(Date.now() / 1000) }
   if (economy.prompt) lines.push(`Asked for: “${economy.prompt}”`);
 
   // A token the setup makes is named on chain as it is made (plan.mjs): what wallets will show, and that a picture
-  // needs its link before going live. One that is live already keeps what it has.
+  // needs its link before going live. One that is live already keeps what it has until the spec changes its name,
+  // which is written at the next approve (live.mjs changedParts, approve/live-check.mjs readRenames).
   section(
     'The tokens going live makes',
     [...m.tokens.values()]
       .filter(t => t.source === 'game' && !economy.live?.mints?.[t.key])
       .map(
         t =>
-          `${t.symbol}${t.name !== t.symbol ? ` (“${t.name}”)` : ''}: ${t.fixedSupply ? `a fixed supply of ${num(t.supply)}, all of it to your wallet, and no more ever` : 'minted by the project as its rules say'}. It is named on chain as it is made, so wallets show ${t.uri ? 'its name, its ticker and the picture its link gives' : 'its name and ticker and no picture: for one, give it a `uri` (a link to a JSON file that names its `image`) before going live'}. Only your wallet can change the name, ticker and link later, and these tools don’t change a live token’s yet: get them right first.`,
+          `${t.symbol}${t.name !== t.symbol ? ` (“${t.name}”)` : ''}: ${t.fixedSupply ? `a fixed supply of ${num(t.supply)}, all of it to your wallet, and no more ever` : 'minted by the project as its rules say'}. It is named on chain as it is made, so wallets show ${t.uri ? 'its name, its ticker and the picture its link gives' : 'its name and ticker and no picture: for one, give it a `uri` (a link to a JSON file that names its `image`) before going live'}. Only your wallet can change the name, ticker and link later: change them here and approve again.`,
       ),
   );
 

package/js/economy/guide.mjs

@@ -10,7 +10,7 @@ const sol = lamports => Number(lamports) / Number(LAMPORTS_PER_SOL);
 export const PARTS = {
   tokens: {
     def: 'token',
-    says: 'The currencies: SOL, any existing mint by address (classic or Token-2022, coins from a token launchpad or an AMM included), or a token the game makes when it goes live: one the game mints as its rules say (points, tickets, shards, an emission), or one with a fixed `supply` minted once to the owner with minting turned off for good (a community token you keep). A token the game makes is named on chain as it is made (`name`, `symbol`, and `uri`: a link to a JSON file naming its picture), which is what wallets show; only the owner’s wallet can change that later, and changing them in a spec that is already live changes nothing on chain yet. loot does not put a token on a market: for trading, launch it on a token launchpad or an AMM, then name the mint. `xsolana token <mint>` (xsolana_token) reads any existing mint into its entry, with its decimals, program and `powers` (what its own keys can do), so none of it is typed by hand.',
+    says: 'The currencies: SOL, any existing mint by address (classic or Token-2022, coins from a token launchpad or an AMM included), or a token the game makes when it goes live: one the game mints as its rules say (points, tickets, shards, an emission), or one with a fixed `supply` minted once to the owner with minting turned off for good (a community token you keep). A token the game makes is named on chain as it is made (`name`, `symbol`, and `uri`: a link to a JSON file naming its picture), which is what wallets show; only the owner’s wallet can change that later, by changing them in the spec and approving again. loot does not put a token on a market: for trading, launch it on a token launchpad or an AMM, then name the mint. `xsolana token <mint>` (xsolana_token) reads any existing mint into its entry, with its decimals, program and `powers` (what its own keys can do), so none of it is typed by hand.',
     acts: 'nobody: a token is a fact',
   },
   currency: {
@@ -191,7 +191,7 @@ export const CANNOT = [
     words: 'lend lending borrow loan leverage perp perpetual options vault yield strategy collateral liquidation',
     why: 'there are no price oracles or liquidations in loot: its only loan is a fixed-term loan against an NFT',
     nearest: [
-      'a fixed-term loan against an NFT between players, with no trust in the game: a lender opens an offer with `deal: { Lend: { amount, repay, lasts } }` for any NFT that passes a rule; a holder borrows (`borrowIx`: the NFT held by the project, `amount` to them); anyone repays `repay` before it is due (`repayIx`: the money to the lender and the NFT home to the borrower in the same step; with `home: false` the money alone, for an NFT that can’t move right now, and anyone sends it home later with `releaseIx`); no repayment is taken for an NFT its collection took back or burned; unpaid once due, anyone sends it to the lender (`releaseIx` with `to` the lender). No grace period, no partial repayment, no cut of the interest; the lender trusts the NFT’s collection not to block or pull back the NFT. The borrower trusts the loan’s token: whoever holds its freeze authority, a pause, a transfer hook or a permanent delegate can make repaying fail, and a lender who holds one can take the NFT when it is due (the program takes such tokens; `app.loanOffer` names each power and its holder, and `app.borrow` needs `acceptRisks`): lend in SOL or a plain token. Made from the game’s page at run time, not in xsolana.json',
+      'a fixed-term loan against an NFT between players, with no trust in the game: a lender opens an offer with `deal: { Lend: { amount, repay, lasts } }` for any NFT that passes a rule; a holder borrows (`borrowIx`: the NFT held by the project, `amount` to them); anyone repays `repay` before it is due (`repayIx`: the money to the lender and the NFT home to the borrower in the same step; with `home: false` the money alone, for an NFT that can’t move right now, and anyone sends it home later with `releaseIx`); no repayment is taken for an NFT its collection took back or burned (anyone then closes that loan’s hold for nothing, also before it is due: the borrower keeps what they borrowed and the lender is out it; `app.claims()` lists it for both); unpaid once due, anyone sends it to the lender (`releaseIx` with `to` the lender). No grace period, no partial repayment, no cut of the interest; the lender trusts the NFT’s collection not to block or pull back the NFT. The borrower trusts the loan’s token: whoever holds its freeze authority, a pause, a transfer hook or a permanent delegate can make repaying fail, and a lender who holds one can take the NFT when it is due (the program takes such tokens; `app.loanOffer` names each power and its holder, and `app.borrow` needs `acceptRisks`): lend in SOL or a plain token. Made from the game’s page at run time, not in xsolana.json',
       'a farm whose rewards the game sends into its vault (staking rewards, not interest)',
       'otherwise nothing in loot: say so plainly (leverage, perps and options need a protocol built for them)',
     ],

package/js/economy/live.mjs

@@ -3,7 +3,7 @@
 import { encodeBase58 } from '../chain/base58.js';
 import { randomBytes } from '../chain/bytes.js';
 import { LOOT_PROGRAM } from '../client/pda.js';
-import { compressedTree, listOf, model } from './model.mjs';
+import { compressedTree, listOf, model, tokenLabels } from './model.mjs';
 import { auctionSeller, plan, setupContext } from './plan.mjs';
 
 /** A key for each fresh account the plan creates. Their secret halves are made by whoever signs (the page). */
@@ -17,12 +17,12 @@ export function freshAddresses(names, random = randomBytes) {
  */
 export function prepare(
   economy,
-  { owner, keys, live = null, now = Math.floor(Date.now() / 1000), rent, only = null, slot = null },
+  { owner, keys, live = null, now = Math.floor(Date.now() / 1000), rent, only = null, slot = null, renames = null },
 ) {
   const m = model(economy, { now });
   // `slot`: a recent slot (in the slot hashes now), which the project's standing lookup table is made at.
   const ctx = { ...setupContext(m, { owner, keys, live: live ?? {}, rent }), slot };
-  const p = plan(economy, { now, ctx, live, only });
+  const p = plan(economy, { now, ctx, live, only, renames });
   if (!p.ok) return p;
   // Going live always makes the project's standing lookup table (the plan's "table" step). Without a recent slot it
   // can't be made: refused when a part's widest transaction needs it (`wideParts`), so no player is left with a
@@ -133,10 +133,11 @@ const FIXED = new Set(['farm', 'pool', 'auction']);
  */
 export function changedParts(economy) {
   const published = economy.live?.published;
-  if (!published) return { only: null, fixed: [], removed: [], settings: [] };
+  if (!published) return { only: null, fixed: [], removed: [], settings: [], renames: [] };
   const only = new Set();
   const fixed = [];
   const removed = [];
+  const renames = [];
   // A grant's `trust` is the spec's own note about its server, never sent on chain: changing it publishes nothing.
   const strip = ({ id, index, shopBox, seller, trust, ...rest }) => JSON.stringify(rest);
   for (const [list, kind] of Object.entries(PART_LISTS)) {
@@ -155,8 +156,20 @@ export function changedParts(economy) {
     }
     for (const key of before.keys()) removed.push(`${kind}:${key}`);
   }
-  for (const t of economy.tokens ?? [])
-    if (!(published.tokens ?? []).some(x => x.key === t.key)) only.add(`token:${t.key}`);
+  // A token is made once. One whose name, ticker or link the spec now gives otherwise than it was published with
+  // (`renames`; by what they come to, not how they are spelled: model.mjs tokenLabels) has its name record written
+  // again, when it has one its owner can still change: that is read from the chain as the change is approved
+  // (approve/live-check.mjs readRenames), never taken from this file.
+  for (const t of economy.tokens ?? []) {
+    const was = (published.tokens ?? []).find(x => x.key === t.key);
+    if (!was) only.add(`token:${t.key}`);
+    else if (
+      ['project', 'game'].includes(t.source) &&
+      economy.live.mints?.[t.key] &&
+      JSON.stringify(tokenLabels(was)) !== JSON.stringify(tokenLabels(t))
+    )
+      renames.push(t.key);
+  }
   // The first compressed prize opens the project's tree.
   if (!economy.live.tree && compressedTree(model(economy))) only.add('tree');
   // A traits root set again replaces the last.
@@ -168,5 +181,12 @@ export function changedParts(economy) {
   if ((published.treasury ?? null) !== (economy.treasury ?? null)) settings.push('its treasury');
   if (JSON.stringify(published.collections ?? []) !== JSON.stringify(economy.collections ?? []))
     settings.push('the collections it takes');
-  return { only, fixed, removed, settings };
+  return { only, fixed, removed, settings, renames };
 }
+
+/**
+ * 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 const renamesNote = renames =>
+  `The spec changes what ${renames.join(', ')} ${renames.length === 1 ? 'is' : 'are'} called. A token’s name on chain is its name record: approving reads it, and writes the new name, ticker and link there when the token has a record its owner can still change (and nothing when the record says them already). A token that went live before setups named tokens has no record and can’t be given one, and a record handed on, made unchangeable or given a royalty outside these tools is left as it is: the approval page says so, sends nothing for that token, and the change stays listed here until the spec gives its old name back.`;

package/js/economy/model.mjs

@@ -392,6 +392,16 @@ export const spendOf = (then, m) => {
   return { Give: [then.giveTo] };
 };
 
+/**
+ * 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 function tokenLabels(t) {
+  const symbol = t.symbol ?? String(t.key).toUpperCase().slice(0, 10);
+  return [t.name ?? t.symbol ?? t.key, symbol, t.uri ?? ''];
+}
+
 /** What a token is on chain: its mint (or "@mint:<key>" until it exists), program, decimals, and who can mint it. */
 function tokenOf(given) {
   // "project" is the spec's word for a token the project mints; "game" is the older spelling of it.
@@ -408,10 +418,11 @@ function tokenOf(given) {
       gameMints: false,
     };
   const decimals = t.decimals ?? (t.source === 'game' ? 0 : undefined);
+  const [name, symbol] = tokenLabels(t);
   return {
     ...t,
-    symbol: t.symbol ?? t.key.toUpperCase().slice(0, 10),
-    name: t.name ?? t.symbol ?? t.key,
+    symbol,
+    name,
     decimals,
     program: t.program ?? 'spl-token',
     mint: t.mint ?? `@mint:${t.key}`,

package/js/economy/plan.mjs

@@ -21,7 +21,13 @@ import {
   TOKEN_PROGRAM,
 } from '../chain/pda.js';
 import { createTableIx, extendTableIx } from '../chain/lookup.js';
-import { createFungibleMetadataIx, METADATA_BYTES, METADATA_FEE, METADATA_LIMITS } from '../chain/metadata.js';
+import {
+  createFungibleMetadataIx,
+  METADATA_BYTES,
+  METADATA_FEE,
+  METADATA_LIMITS,
+  updateFungibleMetadataIx,
+} from '../chain/metadata.js';
 import { MEMO_PROGRAM } from '../chain/token2022.js';
 import {
   computeUnitLimit,
@@ -78,6 +84,7 @@ import {
   weights,
   wholeCount,
   windowOf,
+  tokenLabels,
 } from './model.mjs';
 import { BUDGET } from './txsize.mjs';
 
@@ -723,7 +730,7 @@ const placeholderKey = name => encodeBase58(sha256(utf8(`loot-plan:${name}`)));
  * 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 function setupSteps(economy, { now = 0, only = null, live: given = null } = {}) {
+export function setupSteps(economy, { now = 0, only = null, live: given = null, renames = null } = {}) {
   const m = model(economy, { now });
   const live = madeSoFar(given);
   const steps = [];
@@ -731,19 +738,51 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
   const landed = new Set(live?.landed ?? []);
   const add = step => want(step.part) && !landed.has(step.id) && steps.push({ creates: [], signers: [owner], ...step });
   const project = ctx => ctx.project;
-  const fresh = !live?.project;
+  // The project's own first steps (its collection, the project, the accounts it pays into, its lookup table) belong to
+  // a new setup, and to one cut short before the file was recorded as live (`partial`, with nothing `published`): gone
+  // on with, whichever of them has not landed is still made. Before, a setup cut short after the project's step never
+  // made the rest.
+  const fresh = !live?.project || Boolean(given?.partial && !given?.published);
 
   // Tokens the project mints: a classic mint with the owner as its authority, handed to the project right after.
   // Each is named on chain in the same step (its Token Metadata record: the name, the ticker and the link wallets
   // show), while the owner is still its mint authority: Token Metadata takes a record from nobody else, so a mint whose
   // minting was handed on or turned off without one can never have one. The owner stays the record's update authority.
   for (const t of m.tokens.values()) {
+    // A live token whose name record is to be written again (`renames`: its key; the approval reads the chain for
+    // which, live-check.mjs readRenames): the new name, ticker and link, signed by the owner, the record's update
+    // authority. Not a part a change scopes (`only`), and never held back as landed: the chain says when it is done.
+    const labels = [t.name, t.symbol, t.uri ?? ''];
+    const writable =
+      labels.every(
+        (v, i) => utf8(String(v)).length <= [METADATA_LIMITS.name, METADATA_LIMITS.symbol, METADATA_LIMITS.uri][i],
+      ) &&
+      String(t.name).trim() !== '' &&
+      String(t.symbol).trim() !== '';
+    if (t.source === 'game' && live?.mints?.[t.key] && renames && new Set(renames).has(t.key) && writable)
+      steps.push({
+        creates: [],
+        signers: [owner],
+        id: `name:${t.key}`,
+        part: `name:${t.key}`,
+        // (named by the ticker it was published with: the new one is what it is changed to)
+        says: `Change what the token ${tokenLabels((given?.published?.tokens ?? []).find(x => x.key === t.key) ?? t)[1]} (mint ${live.mints[t.key]}) is called on chain to “${t.name}”, ${t.symbol}, ${t.uri ? `with the link ${t.uri}` : 'no picture link'}: its name record is written again, and stays only your wallet’s to change`,
+        build: ctx => [
+          updateFungibleMetadataIx({
+            mint: ctx.mints[t.key],
+            authority: ctx.owner,
+            name: t.name,
+            symbol: t.symbol,
+            uri: t.uri ?? '',
+          }),
+        ],
+      });
     if (t.source !== 'game' || live?.mints?.[t.key] || (t.mint && !t.mint.startsWith('@'))) continue;
     const key = `new:mint/${t.key}`;
-    const named = `write its name on chain (“${t.name}”, ${t.symbol}, ${t.uri ? `with the link ${t.uri}` : 'no picture link'}: only your wallet can change it later, which these tools don’t do yet, and Token Metadata keeps ${Number(METADATA_FEE) / 1e9} SOL for it)`;
+    const named = `write its name on chain (“${t.name}”, ${t.symbol}, ${t.uri ? `with the link ${t.uri}` : 'no picture link'}: only your wallet can change it later, and Token Metadata keeps ${Number(METADATA_FEE) / 1e9} SOL for it)`;
     const record = { what: `the name of ${t.symbol} on chain`, bytes: METADATA_BYTES, fee: Number(METADATA_FEE) };
     // The checker refuses a name, ticker or link too long for a record before any plan is made, except on a token
-    // that is live already, whose words are only labels. Such a token is made here only when a live economy is
+    // that is live already and whose words were not changed. Such a token is made here only when a live economy is
     // planned as if it were new (explain's cost of the whole setup, which is never sent): its record is left out.
     const fits = ['name', 'symbol', 'uri'].every(f => utf8(String(t[f] ?? '')).length <= METADATA_LIMITS[f]);
     const name = ctx =>
@@ -926,26 +965,39 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
   // the first of its addresses, then extended a group a step.
   if (fresh) {
     const named = standingAddresses(m);
-    groupsOf(named, TABLE_GROUP).forEach((group, i) =>
-      add({
-        id: i ? `table:${i}` : 'table',
-        part: 'project',
-        says: i
-          ? `Add ${group.length} more addresses to the project’s lookup table`
-          : `Make the project’s lookup table of the ${named.length} addresses its transactions name most, so a large one takes one approval`,
-        creates: i
-          ? [{ what: `room for ${group.length} addresses in the lookup table`, bytes: 32 * group.length, grows: true }]
-          : [{ what: 'the project’s lookup table', bytes: 56 + 32 * group.length }],
-        build: ctx => {
-          // With no recent slot known (a plan built offline), there is no table to make.
-          if (ctx.slot == null) return [];
-          const { address: table, instruction } = createTableIx({ authority: ctx.owner, slot: ctx.slot });
-          return [
-            ...(i ? [] : [instruction]),
-            extendTableIx({ table, authority: ctx.owner, addresses: group.map(at => at(ctx)).filter(Boolean) }),
-          ];
-        },
-      }),
+    // A table whose making landed with no address kept (a file an earlier release left, which recorded a transaction
+    // found landed without what it made) can't be added to: its address is of a slot nobody recorded. It stays as it
+    // is, and nothing more is planned for it.
+    const lost = landed.has('table') && !given?.tables?.[0];
+    groupsOf(named, TABLE_GROUP).forEach(
+      (group, i) =>
+        (i && lost) ||
+        add({
+          id: i ? `table:${i}` : 'table',
+          part: 'project',
+          says: i
+            ? `Add ${group.length} more addresses to the project’s lookup table`
+            : `Make the project’s lookup table of the ${named.length} addresses its transactions name most, so a large one takes one approval`,
+          creates: i
+            ? [
+                {
+                  what: `room for ${group.length} addresses in the lookup table`,
+                  bytes: 32 * group.length,
+                  grows: true,
+                },
+              ]
+            : [{ what: 'the project’s lookup table', bytes: 56 + 32 * group.length }],
+          build: ctx => {
+            const addresses = group.map(at => at(ctx)).filter(Boolean);
+            // A table made already (its first step landed in an earlier batch, or before the setup was cut short) is the
+            // one the rest is added to: its address is of the slot it was made at, never of this batch's.
+            if (i && ctx.tables?.[0]) return [extendTableIx({ table: ctx.tables[0], authority: ctx.owner, addresses })];
+            // With no recent slot known (a plan built offline), there is no table to make.
+            if (ctx.slot == null) return [];
+            const { address: table, instruction } = createTableIx({ authority: ctx.owner, slot: ctx.slot });
+            return [...(i ? [] : [instruction]), extendTableIx({ table, authority: ctx.owner, addresses })];
+          },
+        }),
     );
   }
 
@@ -1809,6 +1861,8 @@ export function setupContext(m, { owner: ownerKey, keys, live: given = {}, rent
     project: own,
     treasury: live.treasury ?? m.treasuryWallet ?? ownerKey,
     mints,
+    // the project's lookup table, once its first step landed
+    tables: live.tables ?? null,
     keys,
     rent,
   };
@@ -1876,11 +1930,14 @@ export function pack(steps, ctx) {
  * 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 function plan(economy, { now = Math.floor(Date.now() / 1000), ctx = null, only = null, live = null } = {}) {
+export function plan(
+  economy,
+  { now = Math.floor(Date.now() / 1000), ctx = null, only = null, live = null, renames = null } = {},
+) {
   // With a real context the project is known: a box's write is checked with its own address searches counted.
   const checked = check(economy, { now, ...(ctx?.project ? { project: ctx.project } : {}) });
   if (!checked.ok) return { ok: false, refusals: checked.refusals, warnings: checked.warnings };
-  const { steps, model: m } = setupSteps(economy, { now, only, live });
+  const { steps, model: m } = setupSteps(economy, { now, only, live, renames });
   if (ctx)
     ctx.tokenPrograms ??= Object.fromEntries(
       [...m.tokens.values()]