Rename to HashChallenge

Author: azarovh

mintscript/src/checker/hashlock.rs

@@ -15,7 +15,7 @@
 
 use crypto::hash::{self, hash};
 
-use crate::script::HashType;
+use crate::script::HashChallenge;
 
 #[derive(thiserror::Error, Debug, PartialEq, Eq, Clone)]
 pub enum HashlockError {
@@ -37,7 +37,7 @@ pub trait HashlockChecker {
 
     fn check_hashlock(
         &mut self,
-        hash_type: &HashType,
+        hash_challenge: &HashChallenge,
         preimage: &[u8; 32],
     ) -> Result<(), Self::Error>;
 }
@@ -49,7 +49,7 @@ impl HashlockChecker for NoOpHashlockChecker {
 
     fn check_hashlock(
         &mut self,
-        _hash_type: &HashType,
+        _hash_challenge: &HashChallenge,
         _preimage: &[u8; 32],
     ) -> Result<(), Self::Error> {
         Ok(())
@@ -63,19 +63,19 @@ impl HashlockChecker for StandardHashlockChecker {
 
     fn check_hashlock(
         &mut self,
-        hash_type: &HashType,
+        hash_challenge: &HashChallenge,
         preimage: &[u8; 32],
     ) -> Result<(), Self::Error> {
-        match hash_type {
-            HashType::HASH160(expected_hash) => {
+        match hash_challenge {
+            HashChallenge::HASH160(expected_hash) => {
                 let actual_hash = hash::<hash::Ripemd160, _>(hash::<hash::Sha256, _>(preimage));
 
                 ensure_hashes_equal(actual_hash.as_slice(), expected_hash)?;
             }
-            HashType::RIPEMD160(_)
-            | HashType::SHA1(_)
-            | HashType::SHA256(_)
-            | HashType::HASH256(_) => {
+            HashChallenge::RIPEMD160(_)
+            | HashChallenge::SHA1(_)
+            | HashChallenge::SHA256(_)
+            | HashChallenge::HASH256(_) => {
                 unimplemented!()
             }
         }

mintscript/src/checker/mod.rs

@@ -125,9 +125,9 @@ where
 
     fn visit_hashlock(
         &mut self,
-        hash_type: &crate::script::HashType,
+        hash_challenge: &crate::script::HashChallenge,
         preimage: &[u8; 32],
     ) -> Result<(), Self::HashlockError> {
-        self.hashlock_checker.check_hashlock(hash_type, preimage)
+        self.hashlock_checker.check_hashlock(hash_challenge, preimage)
     }
 }

mintscript/src/script/display.rs

@@ -18,7 +18,7 @@ use std::fmt;
 use common::chain::timelock::OutputTimeLock;
 use serialization::hex_encoded::HexEncoded;
 
-use crate::script::HashType;
+use crate::script::HashChallenge;
 
 use super::{DissatisfiedScript, ScriptCondition, Threshold, WitnessScript};
 
@@ -69,20 +69,20 @@ impl WitnessScript {
                 OutputTimeLock::ForSeconds(s) => write!(f, "after_seconds({s})"),
             },
             WitnessScript::HashLock {
-                hash_type,
+                hash_challenge,
                 preimage,
             } => {
                 let preimage = HexEncoded::new(preimage);
                 let mut write_fn = |algo: &str, hash: &[u8]| {
                     let hash = HexEncoded::new(hash);
                     write!(f, "{algo}(0x{hash}, 0x{preimage})")
                 };
-                match hash_type {
-                    HashType::RIPEMD160(hash) => write_fn("RIPEMD160", hash.as_slice()),
-                    HashType::SHA1(hash) => write_fn("SHA1", hash.as_slice()),
-                    HashType::SHA256(hash) => write_fn("SHA256", hash.as_slice()),
-                    HashType::HASH160(hash) => write_fn("HASH160", hash.as_slice()),
-                    HashType::HASH256(hash) => write_fn("HASH256", hash.as_slice()),
+                match hash_challenge {
+                    HashChallenge::RIPEMD160(hash) => write_fn("RIPEMD160", hash.as_slice()),
+                    HashChallenge::SHA1(hash) => write_fn("SHA1", hash.as_slice()),
+                    HashChallenge::SHA256(hash) => write_fn("SHA256", hash.as_slice()),
+                    HashChallenge::HASH160(hash) => write_fn("HASH160", hash.as_slice()),
+                    HashChallenge::HASH256(hash) => write_fn("HASH256", hash.as_slice()),
                 }
             }
         }

mintscript/src/script/mod.rs

@@ -123,7 +123,7 @@ impl Threshold {
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]
-pub enum HashType {
+pub enum HashChallenge {
     RIPEMD160([u8; 20]),
     SHA1([u8; 20]),
     SHA256([u8; 32]),
@@ -138,7 +138,7 @@ pub enum WitnessScript {
     Signature(Destination, InputWitness),
     Timelock(OutputTimeLock),
     HashLock {
-        hash_type: HashType,
+        hash_challenge: HashChallenge,
         preimage: [u8; 32],
     },
 }
@@ -158,9 +158,9 @@ impl WitnessScript {
     }
 
     /// Construct a hashlock condition
-    pub const fn hashlock(hash_type: HashType, preimage: [u8; 32]) -> Self {
+    pub const fn hashlock(hash_challenge: HashChallenge, preimage: [u8; 32]) -> Self {
         Self::HashLock {
-            hash_type,
+            hash_challenge,
             preimage,
         }
     }

mintscript/src/script/verify.rs

@@ -17,7 +17,7 @@
 
 use common::chain::{signature::inputsig::InputWitness, timelock::OutputTimeLock, Destination};
 
-use super::{HashType, WitnessScript};
+use super::{HashChallenge, WitnessScript};
 
 /// A script processing object
 ///
@@ -48,7 +48,7 @@ pub trait ScriptVisitor {
     ///Check hashlock
     fn visit_hashlock(
         &mut self,
-        hash_type: &HashType,
+        hash_challenge: &HashChallenge,
         preimage: &[u8; 32],
     ) -> Result<(), Self::HashlockError>;
 }
@@ -107,10 +107,10 @@ impl WitnessScript {
                     eval_stack.extend(thresh.collect_satisfied()?.into_iter().rev());
                 }
                 Self::HashLock {
-                    hash_type,
+                    hash_challenge,
                     preimage,
                 } => {
-                    v.visit_hashlock(hash_type, preimage).map_err(ScriptError::Hashlock)?;
+                    v.visit_hashlock(hash_challenge, preimage).map_err(ScriptError::Hashlock)?;
                 }
             }
         }

mintscript/src/tests/hashlock_checker.rs

@@ -76,7 +76,7 @@ fn check_hashlock_160_ok(#[case] preimage: &str, #[case] hash: &str) {
     let hash = hex::decode(hash).unwrap().try_into().unwrap();
     let preimage = hex::decode(preimage).unwrap().try_into().unwrap();
 
-    let script = WitnessScript::hashlock(HashType::HASH160(hash), preimage);
+    let script = WitnessScript::hashlock(HashChallenge::HASH160(hash), preimage);
 
     let context = EmptyContext;
     let mut checker = crate::ScriptChecker::full(context);
@@ -91,7 +91,7 @@ fn check_hashlock_160_random_values_mismatch(#[case] seed: Seed) {
     let preimage: [u8; 32] = std::array::from_fn(|_| rng.gen::<u8>());
     let hash: [u8; 20] = std::array::from_fn(|_| rng.gen::<u8>());
 
-    let script = WitnessScript::hashlock(HashType::HASH160(hash), preimage);
+    let script = WitnessScript::hashlock(HashChallenge::HASH160(hash), preimage);
 
     let context = EmptyContext;
     let mut checker = crate::ScriptChecker::full(context);

mintscript/src/tests/script.rs

@@ -139,7 +139,7 @@ fn visit_order(#[case] script: WS) {
 
         fn visit_hashlock(
             &mut self,
-            _hash_type: &crate::script::HashType,
+            _hash_challenge: &crate::script::HashChallenge,
             _preimage: &[u8; 32],
         ) -> Result<(), Self::HashlockError> {
             unreachable!("Not used in this test")