@xgamesfun/solana 0.26.3 → 0.27.0

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/client/compressed.js

@@ -3,6 +3,7 @@
 // indexer (DAS `getAsset` and `getAssetProof`). Browser-safe.
 import { decodeBase58 } from '../chain/base58.js';
 
+const NOBODY = '11111111111111111111111111111111';
 /** mpl-account-compression's tree header: type, version, max buffer size (u32), max depth (u32), authority, slot, padding. */
 const HEADER = 56;
 
@@ -25,23 +26,29 @@ const bytes = value =>
 /**
  * A compressed NFT from an indexer's answers: `asset` (DAS `getAsset`), `proof` (DAS `getAssetProof`) and the tree
  * account's bytes (`treeData`, for how much of the proof to pass). Returns { id, tree, nonce, owner, delegate,
- * collection (or null), dataHash, creatorHash, assetDataHash (or null), flags, root, proof: [node, …] }. The proof
- * must be against the tree's current root when it lands: fetch it just before sending.
+ * collection (or null), dataHash, creatorHash, assetDataHash (or null), flags, root, proof: [node, …], burnt }. The
+ * proof must be against the tree's current root when it lands: fetch it just before sending. A burned NFT (DAS says
+ * `burnt`) is described as the program takes one: a data hash of all zeros, which `proveLeafIx` then proves against
+ * the leaf's empty slot, so its record names no owner (a record that holds it lets go of it on that proof).
  */
 export function compressedFromDas({ asset, proof, treeData }) {
   const c = asset.compression;
+  const burnt = asset.burnt === true || c.burnt === true;
+  // A burned leaf names nobody: any address stands in for an owner an indexer no longer gives.
+  const owner = asset.ownership?.owner || (burnt ? NOBODY : asset.ownership.owner);
   return {
     id: asset.id,
     tree: c.tree,
     nonce: BigInt(c.leaf_id),
-    owner: asset.ownership.owner,
-    delegate: asset.ownership.delegate ?? asset.ownership.owner,
+    owner,
+    delegate: asset.ownership?.delegate ?? owner,
     collection: asset.grouping?.find(g => g.group_key === 'collection')?.group_value ?? null,
-    dataHash: bytes(c.data_hash),
+    dataHash: burnt ? new Uint8Array(32) : bytes(c.data_hash),
     creatorHash: bytes(c.creator_hash),
     assetDataHash: bytes(c.asset_data_hash ?? null),
     flags: Number(c.flags ?? 0),
     root: bytes(proof.root),
     proof: proof.proof.slice(0, proofLength(treeData)),
+    burnt,
   };
 }