From 0aa539f836bb2c0c90ac0518397be7f75501b3c2 Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Mon, 24 Jun 2024 13:30:39 +0000 Subject: [PATCH] hashes: remove engine/from_engine from embedded test This commit illustrates the transformation I intend to make everywhere we use newtyped hashes as "general hashes". *Within the module that the newtype is defined* I encapsulate engine calls, which I do by calling engine methods on the underlying general hash function. So within the module there is a slight reduction in type safety, in the sense that I need to make sure that I'm wrapping stuff properly. But outside of the module, there will be no difference except that I will no longer export engine/from_engine/hash/etc on newtyped hashes. Instead callers will need to compute the newtyped hash only in ways supported by the API. In theory we could have a macro to produce engine/from_engine/etc for newtypes that want to act as general hashes. But AFAICT there is no use case for this. Alternately, we could have a macro that produces *private* Engine types and private engine/from_engine/etc methods for the hashes, which could be used within the module and would provide stronger type safety within the module. But in practice, raw hashing is usually only used within a couple of methods, so all this infrastructure is way overkill and will just make maintenance harder for everybody. --- hashes/embedded/src/main.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/hashes/embedded/src/main.rs b/hashes/embedded/src/main.rs index e383696b7..738940ac6 100644 --- a/hashes/embedded/src/main.rs +++ b/hashes/embedded/src/main.rs @@ -33,11 +33,11 @@ fn main() -> ! { #[cfg(feature = "alloc")] unsafe { ALLOCATOR.init(cortex_m_rt::heap_start() as usize, HEAP_SIZE) } - let mut engine = TestType::engine(); + let mut engine = sha256::Hash::engine(); engine.write_all(b"abc").unwrap(); check_result(engine); - let mut engine = TestType::engine(); + let mut engine = sha256::Hash::engine(); engine.input(b"abc"); check_result(engine); @@ -46,7 +46,7 @@ fn main() -> ! { } fn check_result(engine: sha256::HashEngine) { - let hash = TestType::from_engine(engine); + let hash = TestType(sha256::Hash::from_engine(engine)); let hash_check = TestType::from_str("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad")