remove the empty fields

neptune-core/src/protocol/consensus/transaction/lock_script.rs

@@ -1,19 +1,16 @@
-use std::collections::HashMap;
 use std::sync::Arc;
 
 #[cfg(any(test, feature = "arbitrary-impls"))]
 use arbitrary::Arbitrary;
 use get_size2::GetSize;
 use itertools::Itertools;
-use rand::Rng;
 use serde::Deserialize;
 use serde::Serialize;
 use tasm_lib::triton_vm::prelude::*;
 use tasm_lib::twenty_first::math::b_field_element::BFieldElement;
 use tasm_lib::twenty_first::math::bfield_codec::BFieldCodec;
 use tasm_lib::twenty_first::tip5::digest::Digest;
 
-use super::utxo::Utxo;
 use crate::api::tx_initiation::builder::proof_builder::ProofBuilder;
 use crate::api::tx_initiation::error::CreateProofError;
 use crate::application::triton_vm_job_queue::TritonVmJobQueue;
@@ -108,18 +105,14 @@ impl<'a> Arbitrary<'a> for LockScript {
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, GetSize, BFieldCodec)]
 pub struct LockScriptAndWitness {
     pub program: Program,
-    nd_memory: Vec<(BFieldElement, BFieldElement)>,
     nd_tokens: Vec<BFieldElement>,
-    nd_digests: Vec<Digest>,
 }
 
 impl LockScriptAndWitness {
     pub fn new_with_nondeterminism(program: Program, witness: NonDeterminism) -> Self {
         Self {
             program,
-            nd_memory: witness.ram.into_iter().collect(),
             nd_tokens: witness.individual_tokens,
-            nd_digests: witness.digests,
         }
     }
 
@@ -142,34 +135,29 @@ impl LockScriptAndWitness {
     pub fn new(program: Program) -> Self {
         Self {
             program,
-            nd_memory: vec![],
             nd_tokens: vec![],
-            nd_digests: vec![],
         }
     }
 
     pub fn new_with_tokens(program: Program, tokens: Vec<BFieldElement>) -> Self {
         Self {
             program,
-            nd_memory: vec![],
             nd_tokens: tokens,
-            nd_digests: vec![],
         }
     }
 
     pub fn nondeterminism(&self) -> NonDeterminism {
         NonDeterminism::new(self.nd_tokens.clone())
-            .with_digests(self.nd_digests.clone())
-            .with_ram(self.nd_memory.iter().copied().collect::<HashMap<_, _>>())
     }
 
     /// Determine if the given UTXO can be unlocked with this
     /// lock-script-and-witness pair.
-    pub fn can_unlock(&self, utxo: &Utxo) -> bool {
+    #[cfg(test)]
+    pub fn can_unlock(&self, utxo: &super::utxo::Utxo) -> bool {
         if self.program.hash() != utxo.lock_script_hash() {
             return false;
         }
-        let any_digest = rand::rng().random::<Digest>();
+        let any_digest = rand::Rng::random::<Digest>(&mut rand::rng());
         self.halts_gracefully(any_digest.values().into())
     }
 
@@ -184,10 +172,9 @@ impl LockScriptAndWitness {
         triton_vm_job_queue: Arc<TritonVmJobQueue>,
         proof_job_options: TritonVmProofJobOptions,
     ) -> Result<Proof, CreateProofError> {
-        let claim = Claim::new(self.program.hash()).with_input(public_input.individual_tokens);
         ProofBuilder::new()
             .program(self.program.clone())
-            .claim(claim)
+            .claim(Claim::new(self.program.hash()).with_input(public_input.individual_tokens))
             .nondeterminism(|| self.nondeterminism())
             .job_queue(triton_vm_job_queue)
             .proof_job_options(proof_job_options)