naming changes

Author: StanChe

account-compression/programs/account-compression/src/concurrent_tree_wrapper.rs

@@ -92,7 +92,7 @@ pub fn merkle_tree_append_leaf(
 /// lifting with macros. An empty account is a zero'd account. The tree is considered empty if the
 /// tree_bytes are all 0. A regular non-batch initialized tree is initialized early on when the
 /// init_empty_merkle_tree is called. A batch initialized tree stays uninitialized until the
-/// finalize_merkle_tree_with_root is called.
+/// init_prepared_tree_with_root is called.
 pub fn tree_bytes_uninitialized(tree_bytes: &[u8]) -> bool {
     tree_bytes.iter().all(|&x| x == 0)
 }

account-compression/programs/account-compression/src/lib.rs

@@ -195,12 +195,12 @@ pub mod spl_account_compression {
     /// expected flow is `init_empty_merkle_tree`. For the latter case, the canopy should be
     /// filled with the necessary nodes to render the tree usable. Thus we need to prefill the
     /// canopy with the necessary nodes. The expected flow for a tree without canopy is
-    /// `prepare_tree` -> `finalize_merkle_tree_with_root`. The expected flow for a tree with canopy
-    /// is `prepare_tree` -> `append_canopy_nodes` (multiple times until all of the canopy is
-    /// filled) -> `finalize_merkle_tree_with_root`. This instruction initializes the tree header
-    /// while leaving the tree itself uninitialized. This allows distinguishing between an empty
-    /// tree and a tree prepare to be initialized with a root.
-    pub fn prepare_tree(
+    /// `prepare_batch_merkle_tree` -> `init_prepared_tree_with_root`. The expected flow for a tree
+    /// with canopy is `prepare_batch_merkle_tree` -> `append_canopy_nodes` (multiple times
+    /// until all of the canopy is filled) -> `init_prepared_tree_with_root`. This instruction
+    /// initializes the tree header while leaving the tree itself uninitialized. This allows
+    /// distinguishing between an empty tree and a tree prepare to be initialized with a root.
+    pub fn prepare_batch_merkle_tree(
         ctx: Context<Initialize>,
         max_depth: u32,
         max_buffer_size: u32,
@@ -229,19 +229,19 @@ pub mod spl_account_compression {
     }
 
     /// This instruction pre-initializes the canopy with the specified leaf nodes of the canopy.
-    /// This is intended to be used after `prepare_tree` and in conjunction with the
-    /// `finalize_merkle_tree_with_root` instruction that'll finalize the tree initialization.
+    /// This is intended to be used after `prepare_batch_merkle_tree` and in conjunction with the
+    /// `init_prepared_tree_with_root` instruction that'll finalize the tree initialization.
     /// The canopy is used to cache the uppermost nodes of the tree, which allows for a smaller
     /// proof size when updating the tree. The canopy should be filled with the necessary nodes
-    /// before calling `finalize_merkle_tree_with_root`. You may call this instruction multiple
+    /// before calling `init_prepared_tree_with_root`. You may call this instruction multiple
     /// times to fill the canopy with the necessary nodes. The canopy may be filled with the
     /// nodes in any order. The already filled nodes may be replaced with new nodes before calling
-    /// `finalize_merkle_tree_with_root` if the step was done in error.
+    /// `init_prepared_tree_with_root` if the step was done in error.
     /// The canopy should be filled with all the nodes that are to the left of the rightmost
-    /// leaf of the tree before calling `finalize_merkle_tree_with_root`. The canopy should not
+    /// leaf of the tree before calling `init_prepared_tree_with_root`. The canopy should not
     /// contain any nodes to the right of the rightmost leaf of the tree.
     /// This instruction calculates and filles in all the canopy nodes "above" the provided ones.
-    /// The validation of the canopy is done in the `finalize_merkle_tree_with_root` instruction.
+    /// The validation of the canopy is done in the `init_prepared_tree_with_root` instruction.
     pub fn append_canopy_nodes(
         ctx: Context<Modify>,
         start_index: u32,
@@ -279,14 +279,14 @@ pub mod spl_account_compression {
 
     /// Initializes a prepared tree with a root and a rightmost leaf. The rightmost leaf is used to
     /// verify the canopy if the tree has it. Before calling this instruction, the tree should be
-    /// prepared with `prepare_tree` and the canopy should be filled with the necessary nodes with
-    /// `append_canopy_nodes` (if the canopy is used). This method should be used for rolluped
-    /// creation of trees. The indexing of such rollups should be done off-chain. The programs
-    /// calling this instruction should take care of ensuring the indexing is possible. For example,
-    /// staking may be required to ensure the tree creator has some responsibility for what is being
-    /// indexed. If indexing is not possible, there should be a mechanism to penalize the tree
-    /// creator.
-    pub fn finalize_merkle_tree_with_root(
+    /// prepared with `prepare_batch_merkle_tree` and the canopy should be filled with the necessary
+    /// nodes with `append_canopy_nodes` (if the canopy is used). This method should be used for
+    /// rolluped creation of trees. The indexing of such rollups should be done off-chain. The
+    /// programs calling this instruction should take care of ensuring the indexing is possible.
+    /// For example, staking may be required to ensure the tree creator has some responsibility
+    /// for what is being indexed. If indexing is not possible, there should be a mechanism to
+    /// penalize the tree creator.
+    pub fn init_prepared_tree_with_root(
         ctx: Context<Modify>,
         root: [u8; 32],
         rightmost_leaf: [u8; 32],
@@ -301,7 +301,7 @@ pub mod spl_account_compression {
 
         let (header_bytes, rest) =
             merkle_tree_bytes.split_at_mut(CONCURRENT_MERKLE_TREE_HEADER_SIZE_V1);
-        // the header should already be initialized with prepare_tree
+        // the header should already be initialized with prepare_batch_merkle_tree
         let header = ConcurrentMerkleTreeHeader::try_from_slice(header_bytes)?;
         header.assert_valid_authority(&ctx.accounts.authority.key())?;
         header.assert_is_batch_initialized()?;

account-compression/sdk/idl/spl_account_compression.json

@@ -52,7 +52,7 @@
       ]
     },
     {
-      "name": "prepareTree",
+      "name": "prepareBatchMerkleTree",
       "docs": [
         "In order to initialize a tree with a root, we need to create the tree on-chain first with",
         "the proper authority. The tree might contain a canopy, which is a cache of the uppermost",
@@ -65,11 +65,11 @@
         "expected flow is `init_empty_merkle_tree`. For the latter case, the canopy should be",
         "filled with the necessary nodes to render the tree usable. Thus we need to prefill the",
         "canopy with the necessary nodes. The expected flow for a tree without canopy is",
-        "`prepare_tree` -> `finalize_merkle_tree_with_root`. The expected flow for a tree with canopy",
-        "is `prepare_tree` -> `append_canopy_nodes` (multiple times until all of the canopy is",
-        "filled) -> `finalize_merkle_tree_with_root`. This instruction initializes the tree header",
-        "while leaving the tree itself uninitialized. This allows distinguishing between an empty",
-        "tree and a tree prepare to be initialized with a root."
+        "`prepare_batch_merkle_tree` -> `init_prepared_tree_with_root`. The expected flow for a tree",
+        "with canopy is `prepare_batch_merkle_tree` -> `append_canopy_nodes` (multiple times",
+        "until all of the canopy is filled) -> `init_prepared_tree_with_root`. This instruction",
+        "initializes the tree header while leaving the tree itself uninitialized. This allows",
+        "distinguishing between an empty tree and a tree prepare to be initialized with a root."
       ],
       "accounts": [
         {
@@ -108,19 +108,19 @@
       "name": "appendCanopyNodes",
       "docs": [
         "This instruction pre-initializes the canopy with the specified leaf nodes of the canopy.",
-        "This is intended to be used after `prepare_tree` and in conjunction with the",
-        "`finalize_merkle_tree_with_root` instruction that'll finalize the tree initialization.",
+        "This is intended to be used after `prepare_batch_merkle_tree` and in conjunction with the",
+        "`init_prepared_tree_with_root` instruction that'll finalize the tree initialization.",
         "The canopy is used to cache the uppermost nodes of the tree, which allows for a smaller",
         "proof size when updating the tree. The canopy should be filled with the necessary nodes",
-        "before calling `finalize_merkle_tree_with_root`. You may call this instruction multiple",
+        "before calling `init_prepared_tree_with_root`. You may call this instruction multiple",
         "times to fill the canopy with the necessary nodes. The canopy may be filled with the",
         "nodes in any order. The already filled nodes may be replaced with new nodes before calling",
-        "`finalize_merkle_tree_with_root` if the step was done in error.",
+        "`init_prepared_tree_with_root` if the step was done in error.",
         "The canopy should be filled with all the nodes that are to the left of the rightmost",
-        "leaf of the tree before calling `finalize_merkle_tree_with_root`. The canopy should not",
+        "leaf of the tree before calling `init_prepared_tree_with_root`. The canopy should not",
         "contain any nodes to the right of the rightmost leaf of the tree.",
         "This instruction calculates and filles in all the canopy nodes \"above\" the provided ones.",
-        "The validation of the canopy is done in the `finalize_merkle_tree_with_root` instruction."
+        "The validation of the canopy is done in the `init_prepared_tree_with_root` instruction."
       ],
       "accounts": [
         {
@@ -160,17 +160,17 @@
       ]
     },
     {
-      "name": "finalizeMerkleTreeWithRoot",
+      "name": "initPreparedTreeWithRoot",
       "docs": [
         "Initializes a prepared tree with a root and a rightmost leaf. The rightmost leaf is used to",
         "verify the canopy if the tree has it. Before calling this instruction, the tree should be",
-        "prepared with `prepare_tree` and the canopy should be filled with the necessary nodes with",
-        "`append_canopy_nodes` (if the canopy is used). This method should be used for rolluped",
-        "creation of trees. The indexing of such rollups should be done off-chain. The programs",
-        "calling this instruction should take care of ensuring the indexing is possible. For example,",
-        "staking may be required to ensure the tree creator has some responsibility for what is being",
-        "indexed. If indexing is not possible, there should be a mechanism to penalize the tree",
-        "creator."
+        "prepared with `prepare_batch_merkle_tree` and the canopy should be filled with the necessary",
+        "nodes with `append_canopy_nodes` (if the canopy is used). This method should be used for",
+        "rolluped creation of trees. The indexing of such rollups should be done off-chain. The",
+        "programs calling this instruction should take care of ensuring the indexing is possible.",
+        "For example, staking may be required to ensure the tree creator has some responsibility",
+        "for what is being indexed. If indexing is not possible, there should be a mechanism to",
+        "penalize the tree creator."
       ],
       "accounts": [
         {

account-compression/sdk/src/generated/instructions/index.ts

@@ -1,10 +1,10 @@
 export * from './append';
 export * from './appendCanopyNodes';
 export * from './closeEmptyTree';
-export * from './finalizeMerkleTreeWithRoot';
 export * from './initEmptyMerkleTree';
+export * from './initPreparedTreeWithRoot';
 export * from './insertOrAppend';
-export * from './prepareTree';
+export * from './prepareBatchMerkleTree';
 export * from './replaceLeaf';
 export * from './transferAuthority';
 export * from './verifyLeaf';

account-compression/sdk/src/generated/instructions/finalizeMerkleTreeWithRoot.ts renamed to account-compression/sdk/src/generated/instructions/initPreparedTreeWithRoot.ts

@@ -10,21 +10,21 @@ import * as web3 from '@solana/web3.js';
 
 /**
  * @category Instructions
- * @category FinalizeMerkleTreeWithRoot
+ * @category InitPreparedTreeWithRoot
  * @category generated
  */
-export type FinalizeMerkleTreeWithRootInstructionArgs = {
+export type InitPreparedTreeWithRootInstructionArgs = {
     rightmostIndex: number;
     rightmostLeaf: number[] /* size: 32 */;
     root: number[] /* size: 32 */;
 };
 /**
  * @category Instructions
- * @category FinalizeMerkleTreeWithRoot
+ * @category InitPreparedTreeWithRoot
  * @category generated
  */
-export const finalizeMerkleTreeWithRootStruct = new beet.BeetArgsStruct<
-    FinalizeMerkleTreeWithRootInstructionArgs & {
+export const initPreparedTreeWithRootStruct = new beet.BeetArgsStruct<
+    InitPreparedTreeWithRootInstructionArgs & {
         instructionDiscriminator: number[] /* size: 8 */;
     }
 >(
@@ -34,44 +34,44 @@ export const finalizeMerkleTreeWithRootStruct = new beet.BeetArgsStruct<
         ['rightmostLeaf', beet.uniformFixedSizeArray(beet.u8, 32)],
         ['rightmostIndex', beet.u32],
     ],
-    'FinalizeMerkleTreeWithRootInstructionArgs',
+    'InitPreparedTreeWithRootInstructionArgs',
 );
 /**
- * Accounts required by the _finalizeMerkleTreeWithRoot_ instruction
+ * Accounts required by the _initPreparedTreeWithRoot_ instruction
  *
  * @property [_writable_] merkleTree
  * @property [**signer**] authority
  * @property [] noop
  * @category Instructions
- * @category FinalizeMerkleTreeWithRoot
+ * @category InitPreparedTreeWithRoot
  * @category generated
  */
-export type FinalizeMerkleTreeWithRootInstructionAccounts = {
+export type InitPreparedTreeWithRootInstructionAccounts = {
     anchorRemainingAccounts?: web3.AccountMeta[];
     authority: web3.PublicKey;
     merkleTree: web3.PublicKey;
     noop: web3.PublicKey;
 };
 
-export const finalizeMerkleTreeWithRootInstructionDiscriminator = [112, 137, 139, 87, 67, 99, 164, 82];
+export const initPreparedTreeWithRootInstructionDiscriminator = [218, 248, 192, 55, 91, 205, 122, 10];
 
 /**
- * Creates a _FinalizeMerkleTreeWithRoot_ instruction.
+ * Creates a _InitPreparedTreeWithRoot_ 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 FinalizeMerkleTreeWithRoot
+ * @category InitPreparedTreeWithRoot
  * @category generated
  */
-export function createFinalizeMerkleTreeWithRootInstruction(
-    accounts: FinalizeMerkleTreeWithRootInstructionAccounts,
-    args: FinalizeMerkleTreeWithRootInstructionArgs,
+export function createInitPreparedTreeWithRootInstruction(
+    accounts: InitPreparedTreeWithRootInstructionAccounts,
+    args: InitPreparedTreeWithRootInstructionArgs,
     programId = new web3.PublicKey('cmtDvXumGCrqC1Age74AVPhSRVXJMd8PJS91L8KbNCK'),
 ) {
-    const [data] = finalizeMerkleTreeWithRootStruct.serialize({
-        instructionDiscriminator: finalizeMerkleTreeWithRootInstructionDiscriminator,
+    const [data] = initPreparedTreeWithRootStruct.serialize({
+        instructionDiscriminator: initPreparedTreeWithRootInstructionDiscriminator,
         ...args,
     });
     const keys: web3.AccountMeta[] = [

account-compression/sdk/src/generated/instructions/prepareTree.ts renamed to account-compression/sdk/src/generated/instructions/prepareBatchMerkleTree.ts

@@ -10,20 +10,20 @@ import * as web3 from '@solana/web3.js';
 
 /**
  * @category Instructions
- * @category PrepareTree
+ * @category PrepareBatchMerkleTree
  * @category generated
  */
-export type PrepareTreeInstructionArgs = {
+export type PrepareBatchMerkleTreeInstructionArgs = {
     maxBufferSize: number;
     maxDepth: number;
 };
 /**
  * @category Instructions
- * @category PrepareTree
+ * @category PrepareBatchMerkleTree
  * @category generated
  */
-export const prepareTreeStruct = new beet.BeetArgsStruct<
-    PrepareTreeInstructionArgs & {
+export const prepareBatchMerkleTreeStruct = new beet.BeetArgsStruct<
+    PrepareBatchMerkleTreeInstructionArgs & {
         instructionDiscriminator: number[] /* size: 8 */;
     }
 >(
@@ -32,44 +32,44 @@ export const prepareTreeStruct = new beet.BeetArgsStruct<
         ['maxDepth', beet.u32],
         ['maxBufferSize', beet.u32],
     ],
-    'PrepareTreeInstructionArgs',
+    'PrepareBatchMerkleTreeInstructionArgs',
 );
 /**
- * Accounts required by the _prepareTree_ instruction
+ * Accounts required by the _prepareBatchMerkleTree_ instruction
  *
  * @property [_writable_] merkleTree
  * @property [**signer**] authority
  * @property [] noop
  * @category Instructions
- * @category PrepareTree
+ * @category PrepareBatchMerkleTree
  * @category generated
  */
-export type PrepareTreeInstructionAccounts = {
+export type PrepareBatchMerkleTreeInstructionAccounts = {
     anchorRemainingAccounts?: web3.AccountMeta[];
     authority: web3.PublicKey;
     merkleTree: web3.PublicKey;
     noop: web3.PublicKey;
 };
 
-export const prepareTreeInstructionDiscriminator = [41, 56, 189, 77, 58, 12, 142, 71];
+export const prepareBatchMerkleTreeInstructionDiscriminator = [230, 124, 120, 196, 249, 134, 199, 128];
 
 /**
- * Creates a _PrepareTree_ instruction.
+ * Creates a _PrepareBatchMerkleTree_ 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 PrepareTree
+ * @category PrepareBatchMerkleTree
  * @category generated
  */
-export function createPrepareTreeInstruction(
-    accounts: PrepareTreeInstructionAccounts,
-    args: PrepareTreeInstructionArgs,
+export function createPrepareBatchMerkleTreeInstruction(
+    accounts: PrepareBatchMerkleTreeInstructionAccounts,
+    args: PrepareBatchMerkleTreeInstructionArgs,
     programId = new web3.PublicKey('cmtDvXumGCrqC1Age74AVPhSRVXJMd8PJS91L8KbNCK'),
 ) {
-    const [data] = prepareTreeStruct.serialize({
-        instructionDiscriminator: prepareTreeInstructionDiscriminator,
+    const [data] = prepareBatchMerkleTreeStruct.serialize({
+        instructionDiscriminator: prepareBatchMerkleTreeInstructionDiscriminator,
         ...args,
     });
     const keys: web3.AccountMeta[] = [