Update metadata into main

.github/workflows/main.yml

@@ -4,7 +4,6 @@ on:
   push:
     branches: [main]
   pull_request:
-    branches: [main]
 
 env:
   CACHE: true

CONTRIBUTING.md

@@ -16,8 +16,8 @@ You will then have access to the following commands.
 - `pnpm programs:test` - Runs BPF tests for all programs (logs disabled).
 - `pnpm programs:debug` - Runs BPF tests for all programs.
 - `pnpm programs:clean` - Deletes all generated program binaries.
-- `clients:rust:test` - Runs BPF tests for the Rust client SDK.
-- `clients:js:test` - Runs the JavaScript tests (you must first start the local validator `pnpm validator`).
+- `pnpm clients:rust:test` - Runs BPF tests for the Rust client SDK.
+- `pnpm clients:js:test` - Runs the JavaScript tests (you must first start the local validator `pnpm validator`).
 - `pnpm generate` - Shortcut for `pnpm generate:idls && pnpm generate:clients`.
 - `pnpm generate:idls` - Generate IDLs for all programs, as configured in the `configs/shank.cjs` file.
 - `pnpm generate:clients` - Generate clients using Kinobi, as configured in the `configs/kinobi.cjs` file.

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",

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

@@ -718,6 +718,135 @@ export class DecompressionDisabledError extends Error {
 createErrorFromCodeLookup.set(0x1791, () => new DecompressionDisabledError());
 createErrorFromNameLookup.set('DecompressionDisabled', () => new DecompressionDisabledError());
 
+/**
+ * MissingCollectionMintAccount: 'Missing collection mint account'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class MissingCollectionMintAccountError extends Error {
+  readonly code: number = 0x1792;
+  readonly name: string = 'MissingCollectionMintAccount';
+  constructor() {
+    super('Missing collection mint account');
+    if (typeof Error.captureStackTrace === 'function') {
+      Error.captureStackTrace(this, MissingCollectionMintAccountError);
+    }
+  }
+}
+
+createErrorFromCodeLookup.set(0x1792, () => new MissingCollectionMintAccountError());
+createErrorFromNameLookup.set(
+  'MissingCollectionMintAccount',
+  () => new MissingCollectionMintAccountError(),
+);
+
+/**
+ * MissingCollectionMetadataAccount: 'Missing collection metadata account'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class MissingCollectionMetadataAccountError extends Error {
+  readonly code: number = 0x1793;
+  readonly name: string = 'MissingCollectionMetadataAccount';
+  constructor() {
+    super('Missing collection metadata account');
+    if (typeof Error.captureStackTrace === 'function') {
+      Error.captureStackTrace(this, MissingCollectionMetadataAccountError);
+    }
+  }
+}
+
+createErrorFromCodeLookup.set(0x1793, () => new MissingCollectionMetadataAccountError());
+createErrorFromNameLookup.set(
+  'MissingCollectionMetadataAccount',
+  () => new MissingCollectionMetadataAccountError(),
+);
+
+/**
+ * CollectionMismatch: 'Collection mismatch'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class CollectionMismatchError extends Error {
+  readonly code: number = 0x1794;
+  readonly name: string = 'CollectionMismatch';
+  constructor() {
+    super('Collection mismatch');
+    if (typeof Error.captureStackTrace === 'function') {
+      Error.captureStackTrace(this, CollectionMismatchError);
+    }
+  }
+}
+
+createErrorFromCodeLookup.set(0x1794, () => new CollectionMismatchError());
+createErrorFromNameLookup.set('CollectionMismatch', () => new CollectionMismatchError());
+
+/**
+ * MetadataImmutable: 'Metadata not mutable'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class MetadataImmutableError extends Error {
+  readonly code: number = 0x1795;
+  readonly name: string = 'MetadataImmutable';
+  constructor() {
+    super('Metadata not mutable');
+    if (typeof Error.captureStackTrace === 'function') {
+      Error.captureStackTrace(this, MetadataImmutableError);
+    }
+  }
+}
+
+createErrorFromCodeLookup.set(0x1795, () => new MetadataImmutableError());
+createErrorFromNameLookup.set('MetadataImmutable', () => new MetadataImmutableError());
+
+/**
+ * PrimarySaleCanOnlyBeFlippedToTrue: 'Can only update primary sale to true'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class PrimarySaleCanOnlyBeFlippedToTrueError extends Error {
+  readonly code: number = 0x1796;
+  readonly name: string = 'PrimarySaleCanOnlyBeFlippedToTrue';
+  constructor() {
+    super('Can only update primary sale to true');
+    if (typeof Error.captureStackTrace === 'function') {
+      Error.captureStackTrace(this, PrimarySaleCanOnlyBeFlippedToTrueError);
+    }
+  }
+}
+
+createErrorFromCodeLookup.set(0x1796, () => new PrimarySaleCanOnlyBeFlippedToTrueError());
+createErrorFromNameLookup.set(
+  'PrimarySaleCanOnlyBeFlippedToTrue',
+  () => new PrimarySaleCanOnlyBeFlippedToTrueError(),
+);
+
+/**
+ * CreatorDidNotUnverify: 'Creator did not unverify the metadata'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class CreatorDidNotUnverifyError extends Error {
+  readonly code: number = 0x1797;
+  readonly name: string = 'CreatorDidNotUnverify';
+  constructor() {
+    super('Creator did not unverify the metadata');
+    if (typeof Error.captureStackTrace === 'function') {
+      Error.captureStackTrace(this, CreatorDidNotUnverifyError);
+    }
+  }
+}
+
+createErrorFromCodeLookup.set(0x1797, () => new CreatorDidNotUnverifyError());
+createErrorFromNameLookup.set('CreatorDidNotUnverify', () => new CreatorDidNotUnverifyError());
+
 /**
  * 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,6 @@ export * from './setTreeDelegate';
 export * from './transfer';
 export * from './unverifyCollection';
 export * from './unverifyCreator';
+export * from './updateMetadata';
 export * from './verifyCollection';
 export * from './verifyCreator';

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

@@ -0,0 +1,185 @@
+/**
+ * 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: 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', metadataArgsBeet],
+    ['updateArgs', updateArgsBeet],
+  ],
+  'UpdateMetadataInstructionArgs',
+);
+/**
+ * Accounts required by the _updateMetadata_ instruction
+ *
+ * @property [] treeAuthority
+ * @property [**signer**] authority
+ * @property [] collectionMint (optional)
+ * @property [] collectionMetadata (optional)
+ * @property [] collectionAuthorityRecordPda (optional)
+ * @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 = {
+  treeAuthority: web3.PublicKey;
+  authority: web3.PublicKey;
+  collectionMint?: web3.PublicKey;
+  collectionMetadata?: web3.PublicKey;
+  collectionAuthorityRecordPda?: 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.treeAuthority,
+      isWritable: false,
+      isSigner: false,
+    },
+    {
+      pubkey: accounts.authority,
+      isWritable: false,
+      isSigner: true,
+    },
+    {
+      pubkey: accounts.collectionMint ?? programId,
+      isWritable: false,
+      isSigner: false,
+    },
+    {
+      pubkey: accounts.collectionMetadata ?? programId,
+      isWritable: false,
+      isSigner: false,
+    },
+    {
+      pubkey: accounts.collectionAuthorityRecordPda ?? programId,
+      isWritable: false,
+      isSigner: false,
+    },
+    {
+      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;
+}