cleanup

Author: sergeytimoshin

forester/src/processor/v2/processor.rs

@@ -132,7 +132,7 @@ where
         }
 
         if self.worker_pool.is_none() {
-            let job_tx = spawn_proof_workers(&self.context.prover_config)?;
+            let job_tx = spawn_proof_workers(&self.context.prover_config);
             self.worker_pool = Some(WorkerPool { job_tx });
         }
 
@@ -532,7 +532,7 @@ where
             ((queue_size / self.zkp_batch_size) as usize).min(self.context.max_batches_per_tree);
 
         if self.worker_pool.is_none() {
-            let job_tx = spawn_proof_workers(&self.context.prover_config)?;
+            let job_tx = spawn_proof_workers(&self.context.prover_config);
             self.worker_pool = Some(WorkerPool { job_tx });
         }
 
@@ -561,7 +561,7 @@ where
         let max_batches = max_batches.min(self.context.max_batches_per_tree);
 
         if self.worker_pool.is_none() {
-            let job_tx = spawn_proof_workers(&self.context.prover_config)?;
+            let job_tx = spawn_proof_workers(&self.context.prover_config);
             self.worker_pool = Some(WorkerPool { job_tx });
         }
 

forester/src/processor/v2/proof_worker.rs

@@ -132,27 +132,27 @@ struct ProofClients {
 }
 
 impl ProofClients {
-    fn new(config: &ProverConfig) -> crate::Result<Self> {
-        Ok(Self {
+    fn new(config: &ProverConfig) -> Self {
+        Self {
             append_client: ProofClient::with_config(
                 config.append_url.clone(),
                 config.polling_interval,
                 config.max_wait_time,
                 config.api_key.clone(),
-            )?,
+            ),
             nullify_client: ProofClient::with_config(
                 config.update_url.clone(),
                 config.polling_interval,
                 config.max_wait_time,
                 config.api_key.clone(),
-            )?,
+            ),
             address_append_client: ProofClient::with_config(
                 config.address_append_url.clone(),
                 config.polling_interval,
                 config.max_wait_time,
                 config.api_key.clone(),
-            )?,
-        })
+            ),
+        }
     }
 
     fn get_client(&self, input: &ProofInput) -> &ProofClient {
@@ -164,13 +164,11 @@ impl ProofClients {
     }
 }
 
-pub fn spawn_proof_workers(
-    config: &ProverConfig,
-) -> crate::Result<async_channel::Sender<ProofJob>> {
+pub fn spawn_proof_workers(config: &ProverConfig) -> async_channel::Sender<ProofJob> {
     let (job_tx, job_rx) = async_channel::bounded::<ProofJob>(256);
-    let clients = Arc::new(ProofClients::new(config)?);
+    let clients = Arc::new(ProofClients::new(config));
     tokio::spawn(async move { run_proof_pipeline(job_rx, clients).await });
-    Ok(job_tx)
+    job_tx
 }
 
 async fn run_proof_pipeline(

js/compressed-token/CHANGELOG.md

@@ -5,7 +5,7 @@
 - **Delegate approval and revocation** for SPL Token, Token-2022, and light-token, aligned with existing interface helpers:
     - **Actions:** `approveInterface`, `revokeInterface`.
     - **Instruction builders:** `createApproveInterfaceInstructions`, `createRevokeInterfaceInstructions` — each inner array is one transaction’s instructions (same batching style as other interface instruction builders).
-    - **Program-level helpers:** `createLightTokenApproveInstruction`, `createLightTokenRevokeInstruction` 
+    - **Program-level helpers:** `createLightTokenApproveInstruction`, `createLightTokenRevokeInstruction`
 - **Shared options:** approve/revoke accept optional `InterfaceOptions` (same type as `transferInterface`), including `splInterfaceInfos` when you need to supply SPL interface pool accounts explicitly.
 
 ### Changed

js/stateless.js/src/utils/instruction.ts

@@ -2,8 +2,7 @@ import { AccountMeta, PublicKey, SystemProgram } from '@solana/web3.js';
 import { defaultStaticAccountsStruct, featureFlags } from '../constants';
 import { LightSystemProgram } from '../programs';
 
-const toStrictBool = (value: unknown): boolean =>
-    value === true || value === 1;
+const toStrictBool = (value: unknown): boolean => value === true || value === 1;
 
 export class PackedAccounts {
     private preAccounts: AccountMeta[] = [];

program-tests/utils/src/mock_batched_forester.rs

@@ -132,7 +132,7 @@ impl<const HEIGHT: usize> MockBatchedForester<HEIGHT> {
 
         assert_eq!(computed_new_root, self.merkle_tree.root());
 
-        let proof_client = ProofClient::local()?;
+        let proof_client = ProofClient::local();
         let proof_result = match proof_client
             .generate_batch_append_proof(circuit_inputs)
             .await
@@ -208,7 +208,7 @@ impl<const HEIGHT: usize> MockBatchedForester<HEIGHT> {
             batch_size,
             &[],
         )?;
-        let proof_client = ProofClient::local()?;
+        let proof_client = ProofClient::local();
         let proof_result = proof_client.generate_batch_update_proof(inputs).await?;
         let new_root = self.merkle_tree.root();
         let proof = CompressedProof {
@@ -318,7 +318,7 @@ impl<const HEIGHT: usize> MockBatchedAddressForester<HEIGHT> {
                 )));
             }
         };
-        let proof_client = ProofClient::local()?;
+        let proof_client = ProofClient::local();
         let proof_result = match proof_client
             .generate_batch_address_append_proof(inputs)
             .await

program-tests/utils/src/test_batch_forester.rs

@@ -164,7 +164,7 @@ pub async fn create_append_batch_ix_data<R: Rpc>(
             bigint_to_be_bytes_array::<32>(&circuit_inputs.new_root.to_biguint().unwrap()).unwrap(),
             bundle.merkle_tree.root()
         );
-        let proof_client = ProofClient::local().unwrap();
+        let proof_client = ProofClient::local();
         let inputs_json = BatchAppendInputsJson::from_inputs(&circuit_inputs).to_string();
 
         match proof_client.generate_proof(inputs_json).await {
@@ -293,7 +293,7 @@ pub async fn get_batched_nullify_ix_data<R: Rpc>(
         &[],
     )
     .unwrap();
-    let proof_client = ProofClient::local().unwrap();
+    let proof_client = ProofClient::local();
     let circuit_inputs_new_root =
         bigint_to_be_bytes_array::<32>(&inputs.new_root.to_biguint().unwrap()).unwrap();
     let inputs_json = update_inputs_string(&inputs);
@@ -715,7 +715,7 @@ pub async fn create_batch_update_address_tree_instruction_data_with_proof<R: Rpc
         )
         .unwrap();
 
-    let proof_client = ProofClient::local().unwrap();
+    let proof_client = ProofClient::local();
     let circuit_inputs_new_root = bigint_to_be_bytes_array::<32>(&inputs.new_root).unwrap();
     let inputs_json = to_json(&inputs);
 

prover/client/src/proof_client.rs

@@ -67,15 +67,15 @@ pub struct ProofClient {
 }
 
 impl ProofClient {
-    pub fn local() -> Result<Self, ProverClientError> {
-        Ok(Self {
-            client: build_http_client()?,
+    pub fn local() -> Self {
+        Self {
+            client: build_http_client(),
             server_address: SERVER_ADDRESS.to_string(),
             polling_interval: Duration::from_millis(DEFAULT_POLLING_INTERVAL_MS),
             max_wait_time: Duration::from_secs(DEFAULT_MAX_WAIT_TIME_SECS),
             api_key: None,
             initial_poll_delay: Duration::from_millis(INITIAL_POLL_DELAY_SMALL_CIRCUIT_MS),
-        })
+        }
     }
 
     #[allow(unused)]
@@ -84,21 +84,21 @@ impl ProofClient {
         polling_interval: Duration,
         max_wait_time: Duration,
         api_key: Option<String>,
-    ) -> Result<Self, ProverClientError> {
+    ) -> Self {
         let initial_poll_delay = if api_key.is_some() {
             Duration::from_millis(INITIAL_POLL_DELAY_LARGE_CIRCUIT_MS)
         } else {
             Duration::from_millis(INITIAL_POLL_DELAY_SMALL_CIRCUIT_MS)
         };
 
-        Ok(Self {
-            client: build_http_client()?,
+        Self {
+            client: build_http_client(),
             server_address,
             polling_interval,
             max_wait_time,
             api_key,
             initial_poll_delay,
-        })
+        }
     }
 
     #[allow(unused)]
@@ -108,15 +108,15 @@ impl ProofClient {
         max_wait_time: Duration,
         api_key: Option<String>,
         initial_poll_delay: Duration,
-    ) -> Result<Self, ProverClientError> {
-        Ok(Self {
-            client: build_http_client()?,
+    ) -> Self {
+        Self {
+            client: build_http_client(),
             server_address,
             polling_interval,
             max_wait_time,
             api_key,
             initial_poll_delay,
-        })
+        }
     }
 
     pub async fn submit_proof_async(

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

@@ -221,12 +221,12 @@ pub fn get_batch_address_append_circuit_inputs<const HEIGHT: usize>(
     }
     let new_element_values = &new_element_values[..zkp_batch_size];
     let mut new_root = [0u8; 32];
-    let mut low_element_circuit_merkle_proofs = Vec::with_capacity(batch_len);
-    let mut new_element_circuit_merkle_proofs = Vec::with_capacity(batch_len);
-    let mut patched_low_element_next_values = Vec::with_capacity(batch_len);
-    let mut patched_low_element_next_indices = Vec::with_capacity(batch_len);
-    let mut patched_low_element_values = Vec::with_capacity(batch_len);
-    let mut patched_low_element_indices = Vec::with_capacity(batch_len);
+    let mut low_element_circuit_merkle_proofs = Vec::with_capacity(zkp_batch_size);
+    let mut new_element_circuit_merkle_proofs = Vec::with_capacity(zkp_batch_size);
+    let mut patched_low_element_next_values = Vec::with_capacity(zkp_batch_size);
+    let mut patched_low_element_next_indices = Vec::with_capacity(zkp_batch_size);
+    let mut patched_low_element_values = Vec::with_capacity(zkp_batch_size);
+    let mut patched_low_element_indices = Vec::with_capacity(zkp_batch_size);
 
     let computed_hashchain = create_hash_chain_from_slice(new_element_values).map_err(|e| {
         ProverClientError::GenericError(format!("Failed to compute hashchain: {}", e))
@@ -261,7 +261,7 @@ pub fn get_batch_address_append_circuit_inputs<const HEIGHT: usize>(
     let is_first_batch = indexed_changelog.is_empty();
     let mut expected_root_for_low = current_root;
 
-    for i in 0..batch_len {
+    for i in 0..zkp_batch_size {
         let mut changelog_index = 0;
         let low_element_index = low_element_indices[i].try_into().map_err(|_| {
             ProverClientError::IntegerConversion(format!(