@xgamesfun/solana 0.26.3 → 0.26.4

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

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

package/types/chain/metadata.d.ts

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

package/types/economy/cost.d.mts

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

package/types/economy/live.d.mts

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

package/types/economy/model.d.mts

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

package/types/economy/plan.d.mts

@@ -929,12 +929,20 @@ export declare function grantArgs(g: any, m: any): {
  * seats there as it is released, its clock stopped while nobody is in. A seed that lands
  * before the first stake or after it is released the same way from that stake on, so seeding first would change nothing.
  */
-export declare function setupSteps(economy: any, { now, only, live: given }?: {
+export declare function setupSteps(economy: any, { now, only, live: given, renames }?: {
     live?: null | undefined;
     now?: number | undefined;
     only?: null | undefined;
+    renames?: null | undefined;
 }): {
-    steps: any[];
+    steps: {
+        creates: never[];
+        signers: string[];
+        id: string;
+        part: string;
+        says: string;
+        build: {};
+    }[];
     model: {
         now: number;
         name: any;
@@ -1026,6 +1034,7 @@ export declare function setupContext(m: any, { owner: ownerKey, keys, live: give
     project: any;
     treasury: any;
     mints: {};
+    tables: any;
     keys: any;
     rent: any;
 };
@@ -1051,11 +1060,12 @@ export declare function pack(steps: any, ctx: any): {
  * The plan for a spec: refusals, or every step packed into transactions. With `ctx` the transactions carry the
  * real instructions; without it they are built on stand-in addresses (for sizing, cost and showing).
  */
-export declare function plan(economy: any, { now, ctx, only, live }?: {
+export declare function plan(economy: any, { now, ctx, only, live, renames }?: {
     ctx?: null | undefined;
     live?: null | undefined;
     now?: number | undefined;
     only?: null | undefined;
+    renames?: null | undefined;
 }): {
     ok: boolean;
     refusals: any[];
@@ -1068,7 +1078,14 @@ export declare function plan(economy: any, { now, ctx, only, live }?: {
     refusals?: undefined;
     ok: boolean;
     warnings: any[];
-    steps: any[];
+    steps: {
+        creates: never[];
+        signers: string[];
+        id: string;
+        part: string;
+        says: string;
+        build: {};
+    }[];
     transactions: {
         signer: string;
         steps: any[];
@@ -1079,7 +1096,7 @@ export declare function plan(economy: any, { now, ctx, only, live }?: {
         alone: boolean;
     }[];
     approvals: number;
-    freshKeys: any[];
+    freshKeys: string[];
 };
 /** What each part needs while the economy runs: the instruction, and who signs it. */
 export declare function playSteps(economy: any): any[];