fix: remove &mut from program manager and fix some code

cli/commands/execute.rs

@@ -113,7 +113,7 @@ impl Execute {
 
         // Create the program manager and find the program
         println!("Attempting to find program: {}", program_string.bright_blue());
-        let mut program_manager = ProgramManager::<CurrentNetwork>::new(
+        let program_manager = ProgramManager::<CurrentNetwork>::new(
             self.private_key,
             self.ciphertext.clone(),
             Some(api_client.clone()),

rust/develop/src/routes.rs

@@ -104,19 +104,19 @@ impl<N: Network> Rest<N> {
         // Get API client and private key and create a program manager
         let api_client = Self::get_api_client(api_client, &request.peer_url)?;
         let private_key = Self::get_private_key(private_key_ciphertext, request.private_key, request.password.clone())?;
-        let mut program_manager = ProgramManager::new(Some(private_key), None, Some(api_client), None).or_reject()?;
+        let mut program_manager = ProgramManager::new(Some(private_key), None, Some(api_client), None, false).or_reject()?;
         program_manager.add_program(&request.program).or_reject()?;
 
         // Get the fee record if it is not provided in the request
         let fee_record = if request.fee_record.is_none() {
-            spawn_blocking!(record_finder.find_one_record(&private_key, request.fee))?
+            spawn_blocking!(record_finder.find_one_record(&private_key, request.fee, None))?
         } else {
             request.fee_record.unwrap()
         };
 
         // Deploy the program and return the resulting transaction id
         let transaction_id =
-            spawn_blocking!(program_manager.deploy_program(request.program.id(), request.fee, fee_record, None))?;
+            spawn_blocking!(program_manager.deploy_program(request.program.id(), request.fee, Some(fee_record), None))?;
 
         Ok(reply::json(&transaction_id))
     }
@@ -136,11 +136,11 @@ impl<N: Network> Rest<N> {
         // Get API client and private key and create a program manager
         let api_client = Self::get_api_client(api_client, &request.peer_url)?;
         let private_key = Self::get_private_key(private_key_ciphertext, request.private_key, request.password.clone())?;
-        let mut program_manager = ProgramManager::new(Some(private_key), None, Some(api_client), None).or_reject()?;
+        let program_manager = ProgramManager::new(Some(private_key), None, Some(api_client), None, false).or_reject()?;
 
         // Find a fee record if a fee is specified and a fee record is not provided
         let fee_record = if request.fee_record.is_none() {
-            spawn_blocking!(record_finder.find_one_record(&private_key, request.fee))?
+            spawn_blocking!(record_finder.find_one_record(&private_key, request.fee, None))?
         } else {
             request.fee_record.take().unwrap()
         };
@@ -151,7 +151,7 @@ impl<N: Network> Rest<N> {
             request.program_function,
             request.inputs.iter(),
             request.fee,
-            fee_record,
+            Some(fee_record),
             None,
             None,
         ))?;
@@ -174,7 +174,7 @@ impl<N: Network> Rest<N> {
         }
         let api_client = Self::get_api_client(api_client, &request.peer_url)?;
         let private_key = Self::get_private_key(private_key_ciphertext, request.private_key, request.password.clone())?;
-        let program_manager = ProgramManager::new(Some(private_key), None, Some(api_client), None).or_reject()?;
+        let program_manager = ProgramManager::new(Some(private_key), None, Some(api_client), None, false).or_reject()?;
 
         let specified_transfer_type = request.transfer_type.as_str();
         info!("Transfer type specified: {specified_transfer_type}");
@@ -192,14 +192,14 @@ impl<N: Network> Rest<N> {
                     if let Some(fee_record) = request.fee_record {
                         (None, fee_record)
                     } else {
-                        (None, spawn_blocking!(record_finder.find_one_record(&private_key, request.fee))?)
+                        (None, spawn_blocking!(record_finder.find_one_record(&private_key, request.fee, None))?)
                     }
                 }
                 TransferType::PublicToPrivate => {
                     if let Some(fee_record) = request.fee_record {
                         (None, fee_record)
                     } else {
-                        (None, spawn_blocking!(record_finder.find_one_record(&private_key, request.fee))?)
+                        (None, spawn_blocking!(record_finder.find_one_record(&private_key, request.fee, None))?)
                     }
                 }
                 _ => {
@@ -209,11 +209,11 @@ impl<N: Network> Rest<N> {
                             // Find a fee record if a fee is specified and a fee record is not provided
                             (
                                 Some(amount_record),
-                                spawn_blocking!(record_finder.find_one_record(&private_key, request.fee))?,
+                                spawn_blocking!(record_finder.find_one_record(&private_key, request.fee, None))?,
                             )
                         }
                         (None, Some(fee_record)) => (
-                            Some(spawn_blocking!(record_finder.find_one_record(&private_key, request.amount))?),
+                            Some(spawn_blocking!(record_finder.find_one_record(&private_key, request.amount, None))?),
                             fee_record,
                         ),
                         (None, None) => {
@@ -234,7 +234,7 @@ impl<N: Network> Rest<N> {
             transfer_type,
             None,
             amount_record,
-            fee_record
+            Some(fee_record)
         ))?;
         Ok(reply::json(&transaction_id))
     }

rust/src/program/execute.rs

@@ -91,7 +91,7 @@ impl<N: Network> ProgramManager<N> {
     ///
     /// To run this function successfully, the program must already be deployed on the Aleo Network
     pub fn execute_program(
-        &mut self,
+        &self,
         program_id: impl TryInto<ProgramID<N>>,
         function: impl TryInto<Identifier<N>>,
         inputs: impl ExactSizeIterator<Item = impl TryInto<Value<N>>>,
@@ -340,7 +340,7 @@ mod tests {
             crate::Encryptor::encrypt_private_key_with_secret(&private_key, "password").unwrap();
         let api_client = AleoAPIClient::<Testnet3>::local_testnet3("3033");
         let record_finder = RecordFinder::new(api_client.clone());
-        let mut program_manager =
+        let program_manager =
             ProgramManager::<Testnet3>::new(Some(private_key), None, Some(api_client.clone()), None, false).unwrap();
 
         let fee = 2_500_000;
@@ -369,7 +369,7 @@ mod tests {
         }
 
         // Test programs can be executed with an encrypted private key
-        let mut program_manager =
+        let program_manager =
             ProgramManager::<Testnet3>::new(None, Some(encrypted_private_key), Some(api_client), None, false).unwrap();
 
         for i in 0..5 {
@@ -442,7 +442,7 @@ mod tests {
             Record::<Testnet3, Plaintext<Testnet3>>::from_str(RECORD_2000000001_MICROCREDITS).unwrap();
 
         // Ensure that program manager creation fails if no key is provided
-        let mut program_manager =
+        let program_manager =
             ProgramManager::<Testnet3>::new(Some(recipient_private_key), None, Some(api_client), None, false).unwrap();
 
         // Assert that execution fails if record's available microcredits are below the fee