Updatable Metadata

clients/js-solita/package.json

@@ -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,180 @@
+/**
+ * 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 { Creator, creatorBeet } from '../types/Creator';
+
+/**
+ * @category Instructions
+ * @category UpdateMetadata
+ * @category generated
+ */
+export type UpdateMetadataInstructionArgs = {
+  root: number[] /* size: 32 */;
+  nonce: beet.bignum;
+  index: number;
+  oldMetadata: beet.COption<MetadataArgs>;
+  newName: beet.COption<string>;
+  newSymbol: beet.COption<string>;
+  newUri: beet.COption<string>;
+  newCreators: beet.COption<Creator[]>;
+  newSellerFeeBasisPoints: beet.COption<number>;
+  newPrimarySaleHappened: beet.COption<boolean>;
+  newIsMutable: beet.COption<boolean>;
+};
+/**
+ * @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],
+    ['oldMetadata', beet.coption(metadataArgsBeet)],
+    ['newName', beet.coption(beet.utf8String)],
+    ['newSymbol', beet.coption(beet.utf8String)],
+    ['newUri', beet.coption(beet.utf8String)],
+    ['newCreators', beet.coption(beet.array(creatorBeet))],
+    ['newSellerFeeBasisPoints', beet.coption(beet.u16)],
+    ['newPrimarySaleHappened', beet.coption(beet.bool)],
+    ['newIsMutable', beet.coption(beet.bool)],
+  ],
+  'UpdateMetadataInstructionArgs',
+);
+/**
+ * Accounts required by the _updateMetadata_ instruction
+ *
+ * @property [] oldMetadataAcct
+ * @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 = {
+  oldMetadataAcct: 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.
+ *
+ * @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.oldMetadataAcct,
+      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;
+}