@xgamesfun/solana 0.26.2 → 0.26.4

package/js/chain/token2022.js

@@ -20,10 +20,16 @@ export const EXECUTE_DISCRIMINATOR = Uint8Array.of(105, 37, 101, 197, 75, 251, 1
 
 const ACCOUNT_TYPE_MINT = 1;
 const EXTENSION = {
+  TransferFeeConfig: 1,
+  MintCloseAuthority: 3,
+  ConfidentialTransferMint: 4,
   DefaultAccountState: 6,
   MemoTransfer: 8,
+  NonTransferable: 9,
+  InterestBearingConfig: 10,
   PermanentDelegate: 12,
   TransferHook: 14,
+  ScaledUiAmount: 25,
   PausableConfig: 26,
 };
 const META_BYTES = 35;
@@ -109,6 +115,89 @@ export function mintPowers({ owner, data }) {
   return out;
 }
 
+/**
+ * What a mint's own keys can do, as an economy spec's `powers` says it (schema `token.powers`), read from the mint's
+ * account (`owner`, its token program; `data`), so nobody has to look it up and type it in. Only what is so is named:
+ * a plain mint nobody can mint more of reads `{ mintAuthority: 'none' }`. `project`: the loot project's address, when
+ * known, whose own tokens read `mintAuthority: 'project'`; any other minter is `'someone else'`.
+ *   freeze: a freeze authority; permanentDelegate; transferHook (a hook program, or an authority who can name one);
+ *   transferFeePercent and feeChangeable (its authority is still there); closeAuthority; pausable; defaultState (the
+ *   mint sets what new accounts start as) and defaultFrozen (they start frozen); nonTransferable;
+ *   confidentialTransfers.
+ * A mint holds two transfer fees: the one in force until an epoch, and the one from that epoch on. With `epoch` (the
+ * chain's current one) the fee read is the one that applies: the newer once its epoch has come, else the higher of
+ * the two (the fee today, or the one already set to follow). Without it, the higher of the two: never less than what
+ * a transfer pays, and a fee since lowered still reads at its old rate.
+ * Returns null when the account is not a mint of either token program.
+ */
+export function powersOf({ owner, data }, { project = null, epoch = null } = {}) {
+  const classic = owner === TOKEN_PROGRAM;
+  if (!classic && owner !== TOKEN_2022_PROGRAM) return null;
+  const extended = !classic && data.length > TOKEN_ACCOUNT_BYTES && data[TOKEN_ACCOUNT_BYTES] === ACCOUNT_TYPE_MINT;
+  if (data.length !== MINT_BYTES && !extended) return null;
+  if (data[45] !== 1) return null;
+  const minter = readUintLE(data, 0, 4) === 1n ? encodeBase58(data.subarray(4, 36)) : null;
+  const out = { mintAuthority: !minter ? 'none' : project && minter === project ? 'project' : 'someone else' };
+  if (readUintLE(data, 46, 4) === 1n) out.freeze = true;
+  if (!extended) return out;
+  /** An address a Token-2022 extension holds at `at`, or null when it holds none (all zeros). */
+  const held = (value, at = 0) => {
+    const a = value && value.length >= at + 32 ? encodeBase58(value.subarray(at, at + 32)) : null;
+    return a === NO_ADDRESS ? null : a;
+  };
+  if (held(extension(data, EXTENSION.PermanentDelegate))) out.permanentDelegate = true;
+  const hook = extension(data, EXTENSION.TransferHook);
+  if (held(hook, 0) || held(hook, 32)) out.transferHook = true;
+  // TransferFeeConfig: its authority, the withdraw authority, what is withheld, then the fee in force and the one to
+  // come, each { epoch u64, most u64, basis points u16 }.
+  const fee = extension(data, EXTENSION.TransferFeeConfig);
+  if (fee && fee.length >= 108) {
+    const older = Number(readUintLE(fee, 88, 2)),
+      newer = Number(readUintLE(fee, 106, 2));
+    const since = readUintLE(fee, 90, 8);
+    const points = epoch !== null && BigInt(epoch) >= since ? newer : Math.max(older, newer);
+    if (points > 0) out.transferFeePercent = points / 100;
+    if (held(fee, 0)) out.feeChangeable = true;
+  }
+  if (held(extension(data, EXTENSION.MintCloseAuthority))) out.closeAuthority = true;
+  const pause = extension(data, EXTENSION.PausableConfig);
+  if (pause && (held(pause) || (pause.length > 32 && pause[32] !== 0))) out.pausable = true;
+  const state = extension(data, EXTENSION.DefaultAccountState);
+  if (state) {
+    out.defaultState = true;
+    if (state[0] === 2) out.defaultFrozen = true;
+  }
+  if (extension(data, EXTENSION.NonTransferable)) out.nonTransferable = true;
+  if (extension(data, EXTENSION.ConfidentialTransferMint)) out.confidentialTransfers = true;
+  return out;
+}
+
+/**
+ * What a Token-2022 mint's state does today that its powers don't say: `paused` (a pause is on: nothing moves),
+ * `scaled` (ScaledUiAmount or InterestBearing: wallets show amounts multiplied by a rate, not the base units the
+ * program moves and an economy counts in) and `scaler` (somebody can still change that rate). All false for a classic
+ * mint, or one with none of them.
+ */
+export function mintState({ owner, data }) {
+  const out = { paused: false, scaled: false, scaler: false };
+  if (
+    owner !== TOKEN_2022_PROGRAM ||
+    data.length <= TOKEN_ACCOUNT_BYTES ||
+    data[TOKEN_ACCOUNT_BYTES] !== ACCOUNT_TYPE_MINT
+  )
+    return out;
+  const set = value => Boolean(value) && value.length >= 32 && encodeBase58(value.subarray(0, 32)) !== NO_ADDRESS;
+  const pause = extension(data, EXTENSION.PausableConfig);
+  out.paused = Boolean(pause) && pause.length > 32 && pause[32] !== 0;
+  for (const kind of [EXTENSION.ScaledUiAmount, EXTENSION.InterestBearingConfig]) {
+    const value = extension(data, kind);
+    if (!value) continue;
+    out.scaled = true;
+    if (set(value)) out.scaler = true;
+  }
+  return out;
+}
+
 /** Whether a token account requires a memo on every transfer into it. */
 export function requiresMemo(accountData) {
   const value = accountData.length > TOKEN_ACCOUNT_BYTES ? extension(accountData, EXTENSION.MemoTransfer) : null;

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';
@@ -996,7 +997,7 @@ export function check(
         'E-TOKEN',
         where,
         `“${t.key}” is an existing token, so the economy needs its mint address and its decimals.`,
-        'Add "mint" (the token’s address) and "decimals", read from the mint (an explorer shows them): `xsolana approve` reads the mint and refuses decimals that differ.',
+        'Add "mint" (the token’s address) and "decimals": `xsolana token <mint>` (xsolana_token) reads the mint and gives the whole entry. `xsolana approve` reads the mint too and refuses decimals that differ.',
       );
     if (source === 'game' && t.program === 'token-2022')
       refuse(
@@ -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'],
@@ -1110,7 +1118,7 @@ export function check(
         'W-MINT-POWERS',
         where,
         `The checker cannot read the mint of “${t.key}” from here, so it does not know what its owner can do (freeze, a permanent delegate, a transfer hook, which no rolled box can give a prize in, or fee).`,
-        'Look the mint up on an explorer and list what it can do under "powers".',
+        `Run \`xsolana token ${t.mint ?? '<mint>'}\` (xsolana_token): it reads the mint and gives this entry with "powers" filled in.`,
       );
   }
   if (!m.currency) {
@@ -5003,11 +5011,41 @@ export function check(
         `${label(c)} splits a prize of 0 among its winners: the program opens the contest but can never name its winner (PrizeNotCovered), so it runs past its result and is called off, every entry refunded.`,
         'Give the prize an amount above 0, or leave the prize out.',
       );
+    // A presale: one side, entries paid in money (SOL, or a coin made elsewhere), and another token split among the
+    // backers by what each put in: people pay for a share of a token, which is what the law on selling securities
+    // looks at first. The prize's own token is read (a pool's is what the pool holds), and entries paid in points
+    // the project mints are no sale.
+    const sold = cp?.gives === 'tokens' ? prizeToken(c.prize, m) : null;
+    if (
+      c.prize?.split &&
+      c.sides === 1 &&
+      sold &&
+      !sold.wsol &&
+      sold.source !== 'sol' &&
+      tok &&
+      tok.source !== 'game' &&
+      sold.key !== tok.key
+    )
+      warn(
+        'W-TOKEN-SALE',
+        `${where}.prize`,
+        `${label(c)} sells ${sold.symbol ?? sold.key} for ${tok.symbol ?? tok.key}: each backer pays in and takes a share of the tokens by what they put in. Selling a token to raise money is what securities law looks at first, and many places limit who may buy.`,
+        'Fine on devnet. Before mainnet, ask counsel.',
+      );
     // One NFT, the last units of an item, a pool's prize: the winning entries share it in the order they are claimed.
     const scarce =
       cp &&
       (cp.gives === 'nft' || (cp.gives === 'item' && Number(m.item.get(cp.item)?.supply ?? 0) > 0) || prizePool(cp));
-    if (scarce)
+    // A prize split by stake is set aside whole when the winner is named, or that decision is refused: no entry takes
+    // another's part, but the pool must hold all of it by then.
+    if (scarce && c.prize.split && prizePool(cp))
+      warn(
+        'W-CONTEST-PRIZE',
+        `${where}.prize`,
+        `${label(c)} splits ${prizeWords(cp, m)} among its winners: all of it is set aside when the winner is named, and naming one is refused while “${prizePool(cp)}” holds less (PrizeNotCovered), so the contest would run past its result and be called off.`,
+        'Keep the pool holding the whole prize until the winner is named: seed it with that much, and let nothing else pay out of it.',
+      );
+    else if (scarce)
       warn(
         'W-CONTEST-PRIZE',
         `${where}.prize`,

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.`,
       ),
   );
 
@@ -603,7 +604,7 @@ export function explainEconomy(economy, { now = Math.floor(Date.now() / 1000) }
   );
   for (const n of sim.notes) lines.push(`- ${n}`);
 
-  const flagged = verdict.warnings.filter(w => w.code === 'W-CHANCE-PRIZE' || w.code === 'W-REVENUE-SHARE');
+  const flagged = verdict.warnings.filter(w => ['W-CHANCE-PRIZE', 'W-REVENUE-SHARE', 'W-TOKEN-SALE'].includes(w.code));
   const others = verdict.warnings.filter(w => !flagged.includes(w));
   if (flagged.length) section('Flagged for the law, once it is real money', [...new Set(flagged.map(w => w.message))]);
   section(

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.',
+    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: {
@@ -160,7 +160,7 @@ export const CANNOT = [
     words: 'bonding curve market trading fees launch pump.fun meteora swap liquidity sell back creator coin',
     why: 'loot runs no market: it moves and sells what the game owns, it doesn’t trade between strangers',
     nearest: [
-      'launch the coin on a token launchpad or an AMM (a launchpad’s creator fees pay on trades), then name its mint as an existing token: loot’s shops, boxes, farms and gates use it; gives up nothing on loot’s side',
+      'launch the coin on a token launchpad or an AMM (a launchpad’s creator fees pay on trades), then name its mint as an existing token (`xsolana token <mint>` reads it into its entry): loot’s shops, boxes, farms and gates use it; gives up minting, since a coin launched this way usually has nobody left who can mint it, so the economy pays out only what its owner puts into its pools',
       'a shop listing whose price rises after each sale (`rise`), and a recipe that buys the token back at a fixed price from a reserve pool a share of each sale fills (`in`: a `pay` line burned; `out`: tokens from the pool): a one-way curve with a floor; gives up a market price, and the reserve is the authority’s to spend',
       'a game token with a fixed `supply` minted once to the owner, minting off for good: a community token the owner keeps and hands out; gives up a public market',
     ],

package/js/economy/legal.mjs

@@ -12,6 +12,8 @@ export const LEGAL = Object.freeze({
     'Anyone, the seller included, can bid to push an auction’s price up (shill bidding): a reserve is the honest way to set a floor.',
   'W-REVENUE-SHARE':
     'Stakers are paid from what players spend, which regulators look at when they decide whether a token is a security: before real money, get a lawyer, or pay rewards from emissions instead.',
+  'W-TOKEN-SALE':
+    'People pay for a share of a new token (a presale). Selling a token to raise money is what securities law looks at first, and many places limit who may buy: before real money, get a lawyer.',
 });
 
 /** The legal flags a checker verdict raises, each once, in the order the checker raised them: [{ code, says }]. */

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()]

package/js/economy/schema.json

@@ -363,7 +363,7 @@
       "type": "object",
       "required": ["key", "source"],
       "additionalProperties": false,
-      "description": "A currency. `sol`: SOL (players pay in wrapped SOL). `existing`: any mint by address, launched anywhere, classic or Token-2022, pump.fun included (xgames.fun takes no share of its fees). `project` (`game` is its older spelling): a token made when the economy goes live: the project mints it as its rules say (points, tickets, shards), or, with `supply`, a fixed supply minted once to the owner (a community token you keep). A token made this way is named on chain as it is made (its `name`, `symbol` and `uri`), which is what wallets show. Only the owner's wallet can change that later, and a change to them in a spec that is already live changes nothing on chain yet.",
+      "description": "A currency. `sol`: SOL (players pay in wrapped SOL). `existing`: any mint by address, launched anywhere, classic or Token-2022, pump.fun included (xgames.fun takes no share of its fees). `project` (`game` is its older spelling): a token made when the economy goes live: the project mints it as its rules say (points, tickets, shards), or, with `supply`, a fixed supply minted once to the owner (a community token you keep). A token made this way is named on chain as it is made (its `name`, `symbol` and `uri`), which is what wallets show. Only the owner's wallet can change that later: a change to them in a spec that is live is written to the token's name record at the next approve, when it has one its owner can still change (a token that went live before setups named tokens has none).",
       "properties": {
         "key": {
           "$ref": "#/$defs/key"
@@ -2037,6 +2037,12 @@
                   "tree": {
                     "$ref": "#/$defs/address"
                   },
+                  "tables": {
+                    "type": "array",
+                    "items": {
+                      "$ref": "#/$defs/address"
+                    }
+                  },
                   "mints": {
                     "type": "object",
                     "additionalProperties": {