@xgamesfun/solana 0.26.3 → 0.26.4

package/js/chain/metadata.js

@@ -72,5 +72,97 @@ export function createFungibleMetadataIx({ mint, authority, payer = authority, n
   };
 }
 
+const UPDATE_V2 = 15;
+/**
+ * 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 function updateFungibleMetadataIx({ mint, authority, name, symbol, uri = '' }) {
+  for (const [field, value] of Object.entries({ name, symbol, uri })) {
+    if (typeof value !== 'string') throw new TypeError(`A token's ${field} is text`);
+    if (utf8(value).length > METADATA_LIMITS[field])
+      throw new RangeError(`A token's ${field} is at most ${METADATA_LIMITS[field]} bytes`);
+  }
+  return {
+    programId: METAPLEX_METADATA_PROGRAM,
+    keys: [meta(metadataAddress(mint), false, true), meta(authority, true, false)],
+    data: concat(
+      Uint8Array.of(UPDATE_V2),
+      Uint8Array.of(1), // new data
+      text(name),
+      text(symbol),
+      text(uri),
+      uintLE(0, 2), // no resale royalty
+      NONE, // no creators
+      NONE, // no collection
+      NONE, // no uses
+      NONE, // the update authority: as it is
+      NONE, // primary sale: as it is
+      NONE, // changeable: as it is
+    ),
+  };
+}
+
+/**
+ * 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 function parseRecord(data) {
+  try {
+    if (!data || data.length < 1 + 32 + 32 + 12 || data[0] !== 4) return null;
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    let at = 65;
+    const words = [];
+    for (let i = 0; i < 3; i++) {
+      const length = view.getUint32(at, true);
+      if (at + 4 + length > data.length) return null;
+      words.push(new TextDecoder().decode(data.subarray(at + 4, at + 4 + length)).replaceAll('\0', ''));
+      at += 4 + length;
+    }
+    if (at + 3 > data.length) return null;
+    const royalty = view.getUint16(at, true);
+    at += 2;
+    let creators = 0;
+    if (data[at++] === 1) {
+      creators = view.getUint32(at, true);
+      at += 4 + 34 * creators;
+    }
+    if (at + 2 > data.length) return null;
+    const mutable = data[at + 1] === 1;
+    at += 2; // sold once, and whether it can be changed
+    // What follows is each there or not (a byte), with its value when it is: the edition's nonce, the token's standard,
+    // then the collection (verified, and its address) and the uses (a method and two counts). A record cut short
+    // before them names neither.
+    for (let i = 0; i < 2 && at < data.length; i++) at += data[at] === 1 ? 2 : 1;
+    const collection = at < data.length && data[at] === 1;
+    at += collection ? 34 : 1;
+    const uses = at < data.length && data[at] === 1;
+    return {
+      updateAuthority: encodeBase58(data.subarray(1, 33)),
+      mint: encodeBase58(data.subarray(33, 65)),
+      name: words[0],
+      symbol: words[1],
+      uri: words[2],
+      royalty,
+      creators,
+      mutable,
+      collection,
+      uses,
+      plain: royalty === 0 && creators === 0 && !collection && !uses,
+    };
+  } catch {
+    return null;
+  }
+}
+
 /** The update authority a Token Metadata record names (who can change its name, ticker and link). */
 export const metadataUpdateAuthority = data => (data?.length >= 33 ? encodeBase58(data.subarray(1, 33)) : 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';
@@ -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'],

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: {

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": {

package/js/mcp/tools.mjs

@@ -16,7 +16,7 @@ import { LOOT_PROGRAM, pda } from '../client/pda.js';
 import { check, describe } from '../economy/check.mjs';
 import { legalFlags } from '../economy/legal.mjs';
 import { cost, explainCost } from '../economy/cost.mjs';
-import { changedParts } from '../economy/live.mjs';
+import { changedParts, renamesNote } from '../economy/live.mjs';
 import { example, examples, ideas, search, partsUsed } from '../economy/examples.mjs';
 import { explainEconomy } from '../economy/explain.mjs';
 import { describeReview, review } from '../economy/review.mjs';
@@ -247,10 +247,11 @@ function flagsToTell(economy, now) {
  * what can't change or was taken out.
  */
 function liveChange(economy) {
-  if (!economy.live?.project || !economy.live?.published) return { scope: {}, notes: '', settings: [] };
-  const { only, fixed, removed, settings } = changedParts(economy);
+  if (!economy.live?.project || !economy.live?.published) return { scope: {}, notes: '', settings: [], changes: 0 };
+  const { only, fixed, removed, settings, renames } = changedParts(economy);
   const notes = [
     settings.length ? `\n${settingsNote(settings, economy.live)}` : '',
+    renames.length ? `\n${renamesNote(renames)}` : '',
     fixed.length
       ? `\nThese can't change once live, and stay as they were: ${fixed.join(', ')} (a farm, an auction or a pool's token).`
       : '',
@@ -258,7 +259,8 @@ function liveChange(economy) {
       ? `\nTaken out of the spec but still on chain: ${removed.join(', ')}. To stop one, keep it and set "active": false.`
       : '',
   ].join('');
-  return { scope: { only, live: economy.live }, notes, settings };
+  // (`changes`: whether anything is to be published at all: a part, or a token's name)
+  return { scope: { only, live: economy.live, renames }, notes, settings, changes: only.size + renames.length };
 }
 
 /** In words: the spec changes the project's own settings, which publishing never writes. */
@@ -428,11 +430,20 @@ export const tools = [
       const c = cost(economy, { now: nowOf(ctx), ...change.scope });
       if (!c.ok) return refused(c, from);
       const head = change.scope.live
-        ? change.scope.only.size
-          ? `This economy is live: this prices only the change (${[...change.scope.only].join(', ')}).\n`
+        ? change.changes
+          ? `This economy is live: this prices only the change (${[...change.scope.only, ...change.scope.renames.map(key => `the name of ${key}`)].join(', ')}).\n`
           : 'This economy is live and nothing has changed since it went live: publishing costs nothing.\n'
         : '';
-      return { ok: true, from, setup: c.setup, actions: c.actions, fees: c.fees, text: head + explainCost(c) + footer };
+      // (a name's price is a transaction's, if it is sent at all: only approving reads the token's record)
+      const names = change.scope.renames?.length ? `\n${renamesNote(change.scope.renames)}` : '';
+      return {
+        ok: true,
+        from,
+        setup: c.setup,
+        actions: c.actions,
+        fees: c.fees,
+        text: head + explainCost(c) + names + footer,
+      };
     },
   },
   {
@@ -559,7 +570,7 @@ export const tools = [
     async handler(input, ctx) {
       const { economy, from, file } = await load(input, ctx);
       const change = liveChange(economy);
-      if (change.scope.live && !change.scope.only.size && change.settings.length)
+      if (change.scope.live && !change.changes && change.settings.length)
         return {
           ok: false,
           transactions: 0,
@@ -567,7 +578,7 @@ export const tools = [
           steps: [],
           text: `${from} is live, and its parts are as they are on chain. ${settingsNote(change.settings, economy.live)}${footer}`,
         };
-      if (change.scope.live && !change.scope.only.size)
+      if (change.scope.live && !change.changes)
         return {
           ok: true,
           transactions: 0,
@@ -578,7 +589,15 @@ export const tools = [
       const p = plan(economy, { now: nowOf(ctx), ...change.scope });
       if (!p.ok) return refused(p, from);
       const c = cost(economy, { now: nowOf(ctx), ...change.scope });
-      const steps = p.transactions.flatMap(t => t.steps.map(s => s.says));
+      // A token's new name is listed as the file has it: whether it is sent is the chain's to say, as approving reads it.
+      const steps = p.transactions.flatMap(t =>
+        t.steps.map(s =>
+          s.id.startsWith('name:')
+            ? `${s.says} (sent only if the token has a name record its owner can still change, read when approving)`
+            : s.says,
+        ),
+      );
+      const renaming = Boolean(change.scope.renames?.length);
       // the file as the approve command names it, relative to the project folder (projectFile's), and plain (plainName)
       const target = file ? path.relative(realPath(path.resolve(cwdOf(ctx))), file) || DEFAULT_FILE : DEFAULT_FILE;
       if (plainName(target) === null)
@@ -592,7 +611,7 @@ export const tools = [
       const command = approveCommand(target);
       const text = [
         ...flagsToTell(economy, nowOf(ctx)),
-        `${change.scope.live ? 'Publishing this change to the live economy' : 'Going live'}: ${plural(p.transactions.length, 'transaction')}, ${plural(p.approvals, 'wallet approval')}, about ${c.setup.totalSol} SOL on devnet:`,
+        `${change.scope.live ? 'Publishing this change to the live economy' : 'Going live'}: ${renaming ? 'at most ' : ''}${plural(p.transactions.length, 'transaction')}, ${plural(p.approvals, 'wallet approval')}, about ${c.setup.totalSol} SOL on devnet:`,
         ...steps.map((s, i) => `${i + 1}. ${s}`),
         '',
         `To put it live, the person runs this in a terminal in the project folder (not you): ${command}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xgamesfun/solana",
-  "version": "0.26.3",
+  "version": "0.26.4",
   "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

@@ -4,5 +4,5 @@
   "sbfBytes": 1783800,
   "sbfSha256": "af318ccfa4d2901076b85fcd1b4467b03253adf0de16e73a9dfc1ef8077b2c14",
   "idlSha256": "0e88fc826a585cf17917cbc654e33b68232771769fe9aae1d5899a257940ff47",
-  "clientSha256": "8c8c89bfca22961d24379b2cc63964dfa2e68d3b65cdcbb33d52352677464533"
+  "clientSha256": "fcb5710a80efbff36c80d0249104c8d7c65b9d84cf70c12b8567e3a7d0af4a2b"
 }

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.26.4 <guide|examples|check|simulate|cost|explain|review|publish|status> [xsolana.json]`,
+`npx -y @xgamesfun/solana@0.26.4 token <mint>` for a coin made elsewhere,
+or `npx -y @xgamesfun/solana@0.26.4 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.26.4 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