refactor: rename append-with-proofs to append (#1829)s

* refactor: rename append-with-proofs to append

* fix circuit type handling

* batch append rename

Author: sergeytimoshin

cli/src/commands/start-prover/index.ts

@@ -34,10 +34,10 @@ class StartProver extends Command {
         "inclusion",
         "non-inclusion",
         "combined",
-        "append-with-proofs",
+        "append",
         "update",
         "address-append",
-        "append-with-proofs-test",
+        "append-test",
         "update-test",
         "address-append-test",
       ],

forester-utils/src/instructions/state_batch_append.rs

@@ -10,9 +10,7 @@ use light_hasher::bigint::bigint_to_be_bytes_array;
 use light_merkle_tree_metadata::QueueType;
 use light_prover_client::{
     proof_client::ProofClient,
-    proof_types::batch_append::{
-        get_batch_append_with_proofs_inputs, BatchAppendWithProofsCircuitInputs,
-    },
+    proof_types::batch_append::{get_batch_append_inputs, BatchAppendsCircuitInputs},
 };
 use light_sparse_merkle_tree::changelog::ChangelogEntry;
 use tracing::{error, trace};
@@ -117,7 +115,7 @@ pub async fn create_append_batch_ix_data<R: Rpc, I: Indexer>(
         let adjusted_start_index =
             merkle_tree_next_index as u32 + (batch_idx * zkp_batch_size as usize) as u32;
 
-        let (circuit_inputs, batch_changelogs) = get_batch_append_with_proofs_inputs::<32>(
+        let (circuit_inputs, batch_changelogs) = get_batch_append_inputs::<32>(
             current_root,
             adjusted_start_index,
             leaves,
@@ -163,7 +161,7 @@ pub async fn create_append_batch_ix_data<R: Rpc, I: Indexer>(
     Ok(instruction_data_vec)
 }
 async fn generate_zkp_proof(
-    circuit_inputs: BatchAppendWithProofsCircuitInputs,
+    circuit_inputs: BatchAppendsCircuitInputs,
 ) -> Result<(CompressedProof, [u8; 32]), ForesterUtilsError> {
     let proof_client = ProofClient::local();
     let (proof, new_root) = proof_client

program-tests/utils/src/mock_batched_forester.rs

@@ -8,7 +8,7 @@ use light_prover_client::{
     proof_client::ProofClient,
     proof_types::{
         batch_address_append::get_batch_address_append_circuit_inputs,
-        batch_append::get_batch_append_with_proofs_inputs, batch_update::get_batch_update_inputs,
+        batch_append::get_batch_append_inputs, batch_update::get_batch_update_inputs,
     },
 };
 use light_sparse_merkle_tree::{
@@ -101,7 +101,7 @@ impl<const HEIGHT: usize> MockBatchedForester<HEIGHT> {
                 self.merkle_tree.update(leaf, index).unwrap();
             }
         }
-        let (circuit_inputs, _) = match get_batch_append_with_proofs_inputs::<HEIGHT>(
+        let (circuit_inputs, _) = match get_batch_append_inputs::<HEIGHT>(
             old_root,
             account_next_index as u32,
             leaves,
@@ -114,7 +114,7 @@ impl<const HEIGHT: usize> MockBatchedForester<HEIGHT> {
             Ok(val) => val,
             Err(e) => {
                 return Err(ProverClientError::GenericError(format!(
-                    "get_batch_append_with_proofs_inputs error: {:?}",
+                    "get_batch_append_inputs error: {:?}",
                     e
                 )));
             }

program-tests/utils/src/test_batch_forester.rs

@@ -30,7 +30,7 @@ use light_prover_client::{
     proof_client::ProofClient,
     proof_types::{
         batch_address_append::{get_batch_address_append_circuit_inputs, to_json},
-        batch_append::{get_batch_append_with_proofs_inputs, BatchAppendWithProofsInputsJson},
+        batch_append::{get_batch_append_inputs, BatchAppendInputsJson},
         batch_update::{get_batch_update_inputs, update_inputs_string},
     },
 };
@@ -149,7 +149,7 @@ pub async fn create_append_batch_ix_data<R: Rpc>(
 
         // TODO: remove unwraps
         let (circuit_inputs, _) =
-            get_batch_append_with_proofs_inputs::<{ DEFAULT_BATCH_STATE_TREE_HEIGHT as usize }>(
+            get_batch_append_inputs::<{ DEFAULT_BATCH_STATE_TREE_HEIGHT as usize }>(
                 old_root,
                 merkle_tree_next_index as u32,
                 batch_update_leaves,
@@ -165,12 +165,9 @@ pub async fn create_append_batch_ix_data<R: Rpc>(
             bundle.merkle_tree.root()
         );
         let proof_client = ProofClient::local();
-        let inputs_json = BatchAppendWithProofsInputsJson::from_inputs(&circuit_inputs).to_string();
+        let inputs_json = BatchAppendInputsJson::from_inputs(&circuit_inputs).to_string();
 
-        match proof_client
-            .generate_proof(inputs_json, "append-with-proofs")
-            .await
-        {
+        match proof_client.generate_proof(inputs_json, "append").await {
             Ok(compressed_proof) => (
                 compressed_proof,
                 bigint_to_be_bytes_array::<32>(&circuit_inputs.new_root.to_biguint().unwrap())

prover/client/src/proof_client.rs

@@ -13,7 +13,7 @@ use crate::{
     },
     proof_types::{
         batch_address_append::{to_json, BatchAddressAppendInputs},
-        batch_append::{BatchAppendWithProofsCircuitInputs, BatchAppendWithProofsInputsJson},
+        batch_append::{BatchAppendInputsJson, BatchAppendsCircuitInputs},
         batch_update::{update_inputs_string, BatchUpdateCircuitInputs},
     },
 };
@@ -517,15 +517,13 @@ impl ProofClient {
 
     pub async fn generate_batch_append_proof(
         &self,
-        circuit_inputs: BatchAppendWithProofsCircuitInputs,
+        circuit_inputs: BatchAppendsCircuitInputs,
     ) -> Result<(ProofCompressed, [u8; 32]), ProverClientError> {
         let new_root = light_hasher::bigint::bigint_to_be_bytes_array::<32>(
             &circuit_inputs.new_root.to_biguint().unwrap(),
         )?;
-        let inputs_json = BatchAppendWithProofsInputsJson::from_inputs(&circuit_inputs).to_string();
-        let proof = self
-            .generate_proof(inputs_json, "append-with-proofs")
-            .await?;
+        let inputs_json = BatchAppendInputsJson::from_inputs(&circuit_inputs).to_string();
+        let proof = self.generate_proof(inputs_json, "append").await?;
         Ok((proof, new_root))
     }
 

prover/client/src/proof_type.rs

@@ -5,11 +5,11 @@ pub enum ProofType {
     Inclusion,
     NonInclusion,
     Combined,
-    BatchAppendWithProofs,
+    BatchAppend,
     BatchUpdate,
     BatchAddressAppend,
     BatchUpdateTest,
-    BatchAppendWithProofsTest,
+    BatchAppendTest,
     BatchAddressAppendTest,
 }
 
@@ -22,11 +22,11 @@ impl Display for ProofType {
                 ProofType::Inclusion => "inclusion",
                 ProofType::NonInclusion => "non-inclusion",
                 ProofType::Combined => "combined",
-                ProofType::BatchAppendWithProofs => "append-with-proofs",
+                ProofType::BatchAppend => "append",
                 ProofType::BatchUpdate => "update",
                 ProofType::BatchUpdateTest => "update-test",
-                ProofType::BatchAppendWithProofsTest => "append-with-proofs-test",
-                ProofType::BatchAddressAppend => "addressAppend",
+                ProofType::BatchAppendTest => "append-test",
+                ProofType::BatchAddressAppend => "address-append",
                 ProofType::BatchAddressAppendTest => "address-append-test",
             }
         )

prover/client/src/proof_types/batch_append/json.rs

@@ -2,11 +2,11 @@ use serde::Serialize;
 
 use crate::{
     helpers::{big_int_to_string, create_json_from_struct},
-    proof_types::{batch_append::BatchAppendWithProofsCircuitInputs, circuit_type::CircuitType},
+    proof_types::{batch_append::BatchAppendsCircuitInputs, circuit_type::CircuitType},
 };
 
 #[derive(Debug, Clone, Serialize)]
-pub struct BatchAppendWithProofsInputsJson {
+pub struct BatchAppendInputsJson {
     #[serde(rename = "circuitType")]
     circuit_type: String,
     #[serde(rename = "publicInputHash")]
@@ -31,10 +31,10 @@ pub struct BatchAppendWithProofsInputsJson {
     batch_size: u32,
 }
 
-impl BatchAppendWithProofsInputsJson {
-    pub fn from_inputs(inputs: &BatchAppendWithProofsCircuitInputs) -> Self {
+impl BatchAppendInputsJson {
+    pub fn from_inputs(inputs: &BatchAppendsCircuitInputs) -> Self {
         Self {
-            circuit_type: CircuitType::BatchAppendWithProofs.to_string(),
+            circuit_type: CircuitType::BatchAppend.to_string(),
             public_input_hash: big_int_to_string(&inputs.public_input_hash),
             old_root: big_int_to_string(&inputs.old_root),
             new_root: big_int_to_string(&inputs.new_root),

prover/client/src/proof_types/batch_append/proof_inputs.rs

@@ -10,7 +10,7 @@ use crate::{
 };
 
 #[derive(Debug, Clone, Serialize)]
-pub struct BatchAppendWithProofsCircuitInputs {
+pub struct BatchAppendsCircuitInputs {
     pub public_input_hash: BigInt,
     pub old_root: BigInt,
     pub new_root: BigInt,
@@ -23,14 +23,14 @@ pub struct BatchAppendWithProofsCircuitInputs {
     pub batch_size: u32,
 }
 
-impl BatchAppendWithProofsCircuitInputs {
+impl BatchAppendsCircuitInputs {
     pub fn public_inputs_arr(&self) -> [u8; 32] {
         bigint_to_u8_32(&self.public_input_hash).unwrap()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-pub fn get_batch_append_with_proofs_inputs<const HEIGHT: usize>(
+pub fn get_batch_append_inputs<const HEIGHT: usize>(
     // get this from Merkle tree account
     current_root: [u8; 32],
     // get this from Merkle tree account
@@ -45,13 +45,7 @@ pub fn get_batch_append_with_proofs_inputs<const HEIGHT: usize>(
     merkle_proofs: Vec<Vec<[u8; 32]>>,
     batch_size: u32,
     previous_changelogs: &[ChangelogEntry<HEIGHT>],
-) -> Result<
-    (
-        BatchAppendWithProofsCircuitInputs,
-        Vec<ChangelogEntry<HEIGHT>>,
-    ),
-    ProverClientError,
-> {
+) -> Result<(BatchAppendsCircuitInputs, Vec<ChangelogEntry<HEIGHT>>), ProverClientError> {
     let mut new_root = [0u8; 32];
     let mut changelog: Vec<ChangelogEntry<HEIGHT>> = Vec::new();
     let mut circuit_merkle_proofs = Vec::with_capacity(batch_size as usize);
@@ -127,7 +121,7 @@ pub fn get_batch_append_with_proofs_inputs<const HEIGHT: usize>(
         start_index_bytes,
     ])?;
     Ok((
-        BatchAppendWithProofsCircuitInputs {
+        BatchAppendsCircuitInputs {
             public_input_hash: BigInt::from_bytes_be(Sign::Plus, &public_input_hash),
             old_root: BigInt::from_bytes_be(Sign::Plus, &current_root),
             new_root: BigInt::from_bytes_be(Sign::Plus, &new_root),

prover/client/src/proof_types/circuit_type.rs

@@ -3,7 +3,7 @@ pub enum CircuitType {
     Combined,
     Inclusion,
     NonInclusion,
-    BatchAppendWithProofs,
+    BatchAppend,
     BatchUpdate,
     BatchAddressAppend,
 }
@@ -15,7 +15,7 @@ impl CircuitType {
             Self::Combined => "combined".to_string(),
             Self::Inclusion => "inclusion".to_string(),
             Self::NonInclusion => "non-inclusion".to_string(),
-            Self::BatchAppendWithProofs => "append-with-proofs".to_string(),
+            Self::BatchAppend => "append".to_string(),
             Self::BatchUpdate => "update".to_string(),
             Self::BatchAddressAppend => "address-append".to_string(),
         }

prover/client/tests/batch_append.rs

@@ -2,9 +2,7 @@ use light_hasher::{hash_chain::create_hash_chain_from_slice, Hasher, Poseidon};
 use light_merkle_tree_reference::MerkleTree;
 use light_prover_client::{
     constants::{DEFAULT_BATCH_STATE_TREE_HEIGHT, PROVE_PATH, SERVER_ADDRESS},
-    proof_types::batch_append::{
-        get_batch_append_with_proofs_inputs, BatchAppendWithProofsInputsJson,
-    },
+    proof_types::batch_append::{get_batch_append_inputs, BatchAppendInputsJson},
     prover::{spawn_prover, ProverConfig},
 };
 use reqwest::Client;
@@ -55,8 +53,8 @@ async fn prove_batch_append_with_proofs() {
         let root = merkle_tree.root();
         let leaves_hashchain = create_hash_chain_from_slice(&leaves).unwrap();
 
-        // Generate inputs for BatchAppendWithProofsCircuit
-        let (inputs, _) = get_batch_append_with_proofs_inputs::<HEIGHT>(
+        // Generate inputs for BatchAppendCircuit
+        let (inputs, _) = get_batch_append_inputs::<HEIGHT>(
             root,
             (i * num_insertions) as u32,
             leaves.clone(),
@@ -70,7 +68,7 @@ async fn prove_batch_append_with_proofs() {
 
         // Serialize inputs to JSON
         let client = Client::new();
-        let inputs_json = BatchAppendWithProofsInputsJson::from_inputs(&inputs).to_string();
+        let inputs_json = BatchAppendInputsJson::from_inputs(&inputs).to_string();
         // Send proof request to server
         let response_result = client
             .post(format!("{}{}", SERVER_ADDRESS, PROVE_PATH))