Updatable Metadata

clients/js-solita/package.json

@@ -17,7 +17,7 @@
     "run-tests": "jest tests --detectOpenHandles",
     "test": "start-server-and-test start-validator http://localhost:8899/health run-tests",
     "api:gen": "DEBUG='(solita|rustbin):(info|error)' solita",
-    "lint": "eslint \"{src,test}/**/*.ts\" --format stylish",
+    "lint": "eslint \"{src,tests}/**/*.ts\" --format stylish",
     "fix:lint": "yarn lint --fix",
     "prettier": "prettier \"{src,test}/**/*.ts\" --check",
     "fix:prettier": "prettier --write src/",
@@ -54,12 +54,13 @@
     "@metaplex-foundation/amman": "0.12.1",
     "@metaplex-foundation/rustbin": "^0.3.5",
     "@metaplex-foundation/solita": "0.20.0",
+    "@metaplex-foundation/js": "^0.19.4",
     "@solana/spl-account-compression": "^0.1.4",
+    "@types/bn.js": "^5.1.1",
     "@types/chai": "^4.3.0",
     "@types/jest": "^29.1.1",
     "@types/mocha": "^9.0.0",
     "@types/tape": "^4.13.2",
-    "@types/bn.js": "^5.1.1",
     "@typescript-eslint/eslint-plugin": "^5.4.0",
     "@typescript-eslint/parser": "^5.4.0",
     "chai": "^4.3.4",
@@ -80,4 +81,4 @@
     "typescript": "^4.3.5",
     "typescript-collections": "^1.3.3"
   }
-}
+}

clients/js-solita/src/generated/errors/index.ts

@@ -718,6 +718,152 @@ export class DecompressionDisabledError extends Error {
 createErrorFromCodeLookup.set(0x1791, () => new DecompressionDisabledError());
 createErrorFromNameLookup.set('DecompressionDisabled', () => new DecompressionDisabledError());
 
+/**
+ * MetadataImmutable: 'Metadata not mutable'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class MetadataImmutableError extends Error {
+  readonly code: number = 0x1792;
+  readonly name: string = 'MetadataImmutable';
+  constructor() {
+    super('Metadata not mutable');
+    if (typeof Error.captureStackTrace === 'function') {
+      Error.captureStackTrace(this, MetadataImmutableError);
+    }
+  }
+}
+
+createErrorFromCodeLookup.set(0x1792, () => new MetadataImmutableError());
+createErrorFromNameLookup.set('MetadataImmutable', () => new MetadataImmutableError());
+
+/**
+ * CollectionMismatch: 'Collection mismatch'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class CollectionMismatchError extends Error {
+  readonly code: number = 0x1793;
+  readonly name: string = 'CollectionMismatch';
+  constructor() {
+    super('Collection mismatch');
+    if (typeof Error.captureStackTrace === 'function') {
+      Error.captureStackTrace(this, CollectionMismatchError);
+    }
+  }
+}
+
+createErrorFromCodeLookup.set(0x1793, () => new CollectionMismatchError());
+createErrorFromNameLookup.set('CollectionMismatch', () => new CollectionMismatchError());
+
+/**
+ * MetadataArgsAmbiguous: 'MetadataArgs ambiguous'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class MetadataArgsAmbiguousError extends Error {
+  readonly code: number = 0x1794;
+  readonly name: string = 'MetadataArgsAmbiguous';
+  constructor() {
+    super('MetadataArgs ambiguous');
+    if (typeof Error.captureStackTrace === 'function') {
+      Error.captureStackTrace(this, MetadataArgsAmbiguousError);
+    }
+  }
+}
+
+createErrorFromCodeLookup.set(0x1794, () => new MetadataArgsAmbiguousError());
+createErrorFromNameLookup.set('MetadataArgsAmbiguous', () => new MetadataArgsAmbiguousError());
+
+/**
+ * MetadataArgsMissing: 'MetadataArgs missing'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class MetadataArgsMissingError extends Error {
+  readonly code: number = 0x1795;
+  readonly name: string = 'MetadataArgsMissing';
+  constructor() {
+    super('MetadataArgs missing');
+    if (typeof Error.captureStackTrace === 'function') {
+      Error.captureStackTrace(this, MetadataArgsMissingError);
+    }
+  }
+}
+
+createErrorFromCodeLookup.set(0x1795, () => new MetadataArgsMissingError());
+createErrorFromNameLookup.set('MetadataArgsMissing', () => new MetadataArgsMissingError());
+
+/**
+ * NFTLinkedToCollection: 'NFT linked to collection'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class NFTLinkedToCollectionError extends Error {
+  readonly code: number = 0x1796;
+  readonly name: string = 'NFTLinkedToCollection';
+  constructor() {
+    super('NFT linked to collection');
+    if (typeof Error.captureStackTrace === 'function') {
+      Error.captureStackTrace(this, NFTLinkedToCollectionError);
+    }
+  }
+}
+
+createErrorFromCodeLookup.set(0x1796, () => new NFTLinkedToCollectionError());
+createErrorFromNameLookup.set('NFTLinkedToCollection', () => new NFTLinkedToCollectionError());
+
+/**
+ * NFTNotLinkedToVerifiedCollection: 'NFT not linked to verified collection'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class NFTNotLinkedToVerifiedCollectionError extends Error {
+  readonly code: number = 0x1797;
+  readonly name: string = 'NFTNotLinkedToVerifiedCollection';
+  constructor() {
+    super('NFT not linked to verified collection');
+    if (typeof Error.captureStackTrace === 'function') {
+      Error.captureStackTrace(this, NFTNotLinkedToVerifiedCollectionError);
+    }
+  }
+}
+
+createErrorFromCodeLookup.set(0x1797, () => new NFTNotLinkedToVerifiedCollectionError());
+createErrorFromNameLookup.set(
+  'NFTNotLinkedToVerifiedCollection',
+  () => new NFTNotLinkedToVerifiedCollectionError(),
+);
+
+/**
+ * PrimarySaleCanOnlyBeFlippedToTrue: 'Can only update primary sale to true'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class PrimarySaleCanOnlyBeFlippedToTrueError extends Error {
+  readonly code: number = 0x1798;
+  readonly name: string = 'PrimarySaleCanOnlyBeFlippedToTrue';
+  constructor() {
+    super('Can only update primary sale to true');
+    if (typeof Error.captureStackTrace === 'function') {
+      Error.captureStackTrace(this, PrimarySaleCanOnlyBeFlippedToTrueError);
+    }
+  }
+}
+
+createErrorFromCodeLookup.set(0x1798, () => new PrimarySaleCanOnlyBeFlippedToTrueError());
+createErrorFromNameLookup.set(
+  'PrimarySaleCanOnlyBeFlippedToTrue',
+  () => new PrimarySaleCanOnlyBeFlippedToTrueError(),
+);
+
 /**
  * Attempts to resolve a custom program error from the provided error code.
  * @category Errors

clients/js-solita/src/generated/instructions/index.ts

@@ -13,5 +13,7 @@ export * from './setTreeDelegate';
 export * from './transfer';
 export * from './unverifyCollection';
 export * from './unverifyCreator';
+export * from './updateMetadata';
+export * from './updateMetadataCollectionNft';
 export * from './verifyCollection';
 export * from './verifyCreator';

clients/js-solita/src/generated/instructions/updateMetadata.ts

@@ -0,0 +1,171 @@
+/**
+ * This code was GENERATED using the solita package.
+ * Please DO NOT EDIT THIS FILE, instead rerun solita to update it or write a wrapper to add functionality.
+ *
+ * See: https://github.com/metaplex-foundation/solita
+ */
+
+import * as beet from '@metaplex-foundation/beet';
+import * as web3 from '@solana/web3.js';
+import { MetadataArgs, metadataArgsBeet } from '../types/MetadataArgs';
+import { UpdateArgs, updateArgsBeet } from '../types/UpdateArgs';
+
+/**
+ * @category Instructions
+ * @category UpdateMetadata
+ * @category generated
+ */
+export type UpdateMetadataInstructionArgs = {
+  root: number[] /* size: 32 */;
+  nonce: beet.bignum;
+  index: number;
+  currentMetadata: beet.COption<MetadataArgs>;
+  updateArgs: UpdateArgs;
+};
+/**
+ * @category Instructions
+ * @category UpdateMetadata
+ * @category generated
+ */
+export const updateMetadataStruct = new beet.FixableBeetArgsStruct<
+  UpdateMetadataInstructionArgs & {
+    instructionDiscriminator: number[] /* size: 8 */;
+  }
+>(
+  [
+    ['instructionDiscriminator', beet.uniformFixedSizeArray(beet.u8, 8)],
+    ['root', beet.uniformFixedSizeArray(beet.u8, 32)],
+    ['nonce', beet.u64],
+    ['index', beet.u32],
+    ['currentMetadata', beet.coption(metadataArgsBeet)],
+    ['updateArgs', updateArgsBeet],
+  ],
+  'UpdateMetadataInstructionArgs',
+);
+/**
+ * Accounts required by the _updateMetadata_ instruction
+ *
+ * @property [] metadataBuffer (optional)
+ * @property [] treeAuthority
+ * @property [**signer**] treeDelegate
+ * @property [] leafOwner
+ * @property [] leafDelegate
+ * @property [**signer**] payer
+ * @property [_writable_] merkleTree
+ * @property [] logWrapper
+ * @property [] compressionProgram
+ * @property [] tokenMetadataProgram
+ * @category Instructions
+ * @category UpdateMetadata
+ * @category generated
+ */
+export type UpdateMetadataInstructionAccounts = {
+  metadataBuffer?: web3.PublicKey;
+  treeAuthority: web3.PublicKey;
+  treeDelegate: web3.PublicKey;
+  leafOwner: web3.PublicKey;
+  leafDelegate: web3.PublicKey;
+  payer: web3.PublicKey;
+  merkleTree: web3.PublicKey;
+  logWrapper: web3.PublicKey;
+  compressionProgram: web3.PublicKey;
+  tokenMetadataProgram: web3.PublicKey;
+  systemProgram?: web3.PublicKey;
+  anchorRemainingAccounts?: web3.AccountMeta[];
+};
+
+export const updateMetadataInstructionDiscriminator = [170, 182, 43, 239, 97, 78, 225, 186];
+
+/**
+ * Creates a _UpdateMetadata_ instruction.
+ *
+ * Optional accounts that are not provided default to the program ID since
+ * this was indicated in the IDL from which this instruction was generated.
+ *
+ * @param accounts that will be accessed while the instruction is processed
+ * @param args to provide as instruction data to the program
+ *
+ * @category Instructions
+ * @category UpdateMetadata
+ * @category generated
+ */
+export function createUpdateMetadataInstruction(
+  accounts: UpdateMetadataInstructionAccounts,
+  args: UpdateMetadataInstructionArgs,
+  programId = new web3.PublicKey('BGUMAp9Gq7iTEuizy4pqaxsTyUCBK68MDfK752saRPUY'),
+) {
+  const [data] = updateMetadataStruct.serialize({
+    instructionDiscriminator: updateMetadataInstructionDiscriminator,
+    ...args,
+  });
+  const keys: web3.AccountMeta[] = [
+    {
+      pubkey: accounts.metadataBuffer ?? programId,
+      isWritable: false,
+      isSigner: false,
+    },
+    {
+      pubkey: accounts.treeAuthority,
+      isWritable: false,
+      isSigner: false,
+    },
+    {
+      pubkey: accounts.treeDelegate,
+      isWritable: false,
+      isSigner: true,
+    },
+    {
+      pubkey: accounts.leafOwner,
+      isWritable: false,
+      isSigner: false,
+    },
+    {
+      pubkey: accounts.leafDelegate,
+      isWritable: false,
+      isSigner: false,
+    },
+    {
+      pubkey: accounts.payer,
+      isWritable: false,
+      isSigner: true,
+    },
+    {
+      pubkey: accounts.merkleTree,
+      isWritable: true,
+      isSigner: false,
+    },
+    {
+      pubkey: accounts.logWrapper,
+      isWritable: false,
+      isSigner: false,
+    },
+    {
+      pubkey: accounts.compressionProgram,
+      isWritable: false,
+      isSigner: false,
+    },
+    {
+      pubkey: accounts.tokenMetadataProgram,
+      isWritable: false,
+      isSigner: false,
+    },
+    {
+      pubkey: accounts.systemProgram ?? web3.SystemProgram.programId,
+      isWritable: false,
+      isSigner: false,
+    },
+  ];
+
+  if (accounts.anchorRemainingAccounts != null) {
+    for (const acc of accounts.anchorRemainingAccounts) {
+      keys.push(acc);
+    }
+  }
+
+  const ix = new web3.TransactionInstruction({
+    programId,
+    keys,
+    data,
+  });
+  return ix;
+}