Renaming AutoConceal trait and removing CommitEncode for Assignments

Author: dr-orlovsky

src/contract/assignments.rs

@@ -27,7 +27,7 @@ use lnpbp::seals::OutpointReveal;
 use strict_encoding::{StrictDecode, StrictEncode};
 
 use super::{
-    data, seal, value, AtomicValue, AutoConceal, NoDataError, NodeId,
+    data, seal, value, AtomicValue, ConcealState, NoDataError, NodeId,
     SealDefinition, SealEndpoint, SECP256K1_ZKP,
 };
 use crate::schema;
@@ -615,16 +615,19 @@ impl Assignments {
     }
 }
 
-impl AutoConceal for Assignments {
-    fn conceal_except(&mut self, seals: &Vec<seal::Confidential>) -> usize {
+impl ConcealState for Assignments {
+    fn conceal_state_except(
+        &mut self,
+        seals: &Vec<seal::Confidential>,
+    ) -> usize {
         match self {
-            Assignments::Declarative(data) => data as &mut dyn AutoConceal,
+            Assignments::Declarative(data) => data as &mut dyn ConcealState,
             Assignments::DiscreteFiniteField(data) => {
-                data as &mut dyn AutoConceal
+                data as &mut dyn ConcealState
             }
-            Assignments::CustomData(data) => data as &mut dyn AutoConceal,
+            Assignments::CustomData(data) => data as &mut dyn ConcealState,
         }
-        .conceal_except(seals)
+        .conceal_state_except(seals)
     }
 }
 
@@ -981,15 +984,18 @@ where
     }
 }
 
-impl<STATE> AutoConceal for OwnedState<STATE>
+impl<STATE> ConcealState for OwnedState<STATE>
 where
     STATE: StateTypes,
     STATE::Revealed: CommitConceal,
     STATE::Confidential: PartialEq + Eq,
     <STATE as StateTypes>::Confidential:
         From<<STATE::Revealed as CommitConceal>::ConcealedCommitment>,
 {
-    fn conceal_except(&mut self, seals: &Vec<seal::Confidential>) -> usize {
+    fn conceal_state_except(
+        &mut self,
+        seals: &Vec<seal::Confidential>,
+    ) -> usize {
         match self {
             OwnedState::Confidential { .. }
             | OwnedState::ConfidentialAmount { .. } => 0,
@@ -2116,7 +2122,7 @@ mod test {
         // CommitConceal all without any exception
         // This will create 2 Confidential and 2 ConfidentialState type
         // Assignments
-        assert_eq!(2, hash_type.conceal_all());
+        assert_eq!(2, hash_type.conceal_state());
 
         // Precomputed values of revealed seals in 2 ConfidentialState type
         // Assignments

src/contract/conceal.rs

@@ -16,73 +16,91 @@ use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 
 use super::seal;
 
-pub trait AutoConceal {
-    fn conceal_all(&mut self) -> usize {
-        self.conceal_except(&vec![])
+pub trait ConcealState {
+    fn conceal_state(&mut self) -> usize {
+        self.conceal_state_except(&vec![])
     }
-    fn conceal_except(&mut self, seals: &Vec<seal::Confidential>) -> usize;
+    fn conceal_state_except(
+        &mut self,
+        seals: &Vec<seal::Confidential>,
+    ) -> usize;
 }
 
-impl<T> AutoConceal for Vec<T>
+impl<T> ConcealState for Vec<T>
 where
-    T: AutoConceal,
+    T: ConcealState,
 {
-    fn conceal_except(&mut self, seals: &Vec<seal::Confidential>) -> usize {
+    fn conceal_state_except(
+        &mut self,
+        seals: &Vec<seal::Confidential>,
+    ) -> usize {
         self.iter_mut()
-            .fold(0usize, |sum, item| sum + item.conceal_except(seals))
+            .fold(0usize, |sum, item| sum + item.conceal_state_except(seals))
     }
 }
 
-impl<T> AutoConceal for BTreeSet<T>
+impl<T> ConcealState for BTreeSet<T>
 where
-    T: AutoConceal + Ord + Clone,
+    T: ConcealState + Ord + Clone,
 {
-    fn conceal_except(&mut self, seals: &Vec<seal::Confidential>) -> usize {
+    fn conceal_state_except(
+        &mut self,
+        seals: &Vec<seal::Confidential>,
+    ) -> usize {
         let mut count = 0;
         let mut new_self = BTreeSet::<T>::new();
         for item in self.iter() {
             let mut new_item = item.clone();
-            count += new_item.conceal_except(seals);
+            count += new_item.conceal_state_except(seals);
             new_self.insert(new_item);
         }
         *self = new_self;
         count
     }
 }
 
-impl<K, V> AutoConceal for BTreeMap<K, V>
+impl<K, V> ConcealState for BTreeMap<K, V>
 where
-    V: AutoConceal,
+    V: ConcealState,
 {
-    fn conceal_except(&mut self, seals: &Vec<seal::Confidential>) -> usize {
+    fn conceal_state_except(
+        &mut self,
+        seals: &Vec<seal::Confidential>,
+    ) -> usize {
         self.iter_mut()
-            .fold(0usize, |sum, item| sum + item.1.conceal_except(seals))
+            .fold(0usize, |sum, item| sum + item.1.conceal_state_except(seals))
     }
 }
 
-impl<T> AutoConceal for HashSet<T>
+impl<T> ConcealState for HashSet<T>
 where
-    T: AutoConceal + Ord + Clone + std::hash::Hash,
+    T: ConcealState + Ord + Clone + std::hash::Hash,
 {
-    fn conceal_except(&mut self, seals: &Vec<seal::Confidential>) -> usize {
+    fn conceal_state_except(
+        &mut self,
+        seals: &Vec<seal::Confidential>,
+    ) -> usize {
         let mut count = 0;
         let mut new_self = HashSet::<T>::new();
         for item in self.iter() {
             let mut new_item = item.clone();
-            count += new_item.conceal_except(seals);
+            count += new_item.conceal_state_except(seals);
             new_self.insert(new_item);
         }
         *self = new_self;
         count
     }
 }
 
-impl<K, V> AutoConceal for HashMap<K, V>
+impl<K, V> ConcealState for HashMap<K, V>
 where
-    V: AutoConceal,
+    V: ConcealState,
 {
-    fn conceal_except(&mut self, seals: &Vec<seal::Confidential>) -> usize {
+    fn conceal_state_except(
+        &mut self,
+        seals: &Vec<seal::Confidential>,
+    ) -> usize {
         self.iter_mut()
-            .fold(0usize, |sum, item| sum + item.1.conceal_except(seals))
+            .fold(0usize, |sum, item| sum + item.1.conceal_state_except(seals))
     }
 }

src/contract/mod.rs

@@ -29,7 +29,7 @@ pub(self) use assignments::{
     OwnedRightsInner, ParentOwnedRightsInner, ParentPublicRightsInner,
     PublicRightsInner,
 };
-pub use conceal::AutoConceal;
+pub use conceal::ConcealState;
 pub use metadata::Metadata;
 pub use nodes::{ContractId, Extension, Genesis, Node, NodeId, Transition};
 pub use seal::{SealDefinition, SealEndpoint};

src/contract/nodes.rs

@@ -25,7 +25,7 @@ use lnpbp::commit_verify::CommitVerify;
 use lnpbp::{Chain, TaggedHash};
 
 use super::{
-    Assignments, AutoConceal, OwnedRights, ParentOwnedRights,
+    Assignments, ConcealState, OwnedRights, ParentOwnedRights,
     ParentPublicRights, PublicRights,
 };
 use super::{
@@ -328,31 +328,40 @@ impl CommitEncode for Transition {
     }
 }
 
-impl AutoConceal for Genesis {
-    fn conceal_except(&mut self, seals: &Vec<seal::Confidential>) -> usize {
+impl ConcealState for Genesis {
+    fn conceal_state_except(
+        &mut self,
+        seals: &Vec<seal::Confidential>,
+    ) -> usize {
         let mut count = 0;
         for (_, assignment) in self.owned_rights_mut() {
-            count += assignment.conceal_except(seals);
+            count += assignment.conceal_state_except(seals);
         }
         count
     }
 }
 
-impl AutoConceal for Extension {
-    fn conceal_except(&mut self, seals: &Vec<seal::Confidential>) -> usize {
+impl ConcealState for Extension {
+    fn conceal_state_except(
+        &mut self,
+        seals: &Vec<seal::Confidential>,
+    ) -> usize {
         let mut count = 0;
         for (_, assignment) in self.owned_rights_mut() {
-            count += assignment.conceal_except(seals);
+            count += assignment.conceal_state_except(seals);
         }
         count
     }
 }
 
-impl AutoConceal for Transition {
-    fn conceal_except(&mut self, seals: &Vec<seal::Confidential>) -> usize {
+impl ConcealState for Transition {
+    fn conceal_state_except(
+        &mut self,
+        seals: &Vec<seal::Confidential>,
+    ) -> usize {
         let mut count = 0;
         for (_, assignment) in self.owned_rights_mut() {
-            count += assignment.conceal_except(seals);
+            count += assignment.conceal_state_except(seals);
         }
         count
     }
@@ -765,12 +774,12 @@ mod test {
 
     use super::*;
     use lnpbp::chain::{Chain, GENESIS_HASH_MAINNET};
+    use lnpbp::client_side_validation::CommitConceal;
     use lnpbp::commit_verify::CommitVerify;
     use lnpbp::strict_encoding::{
         strict_serialize, StrictDecode, StrictEncode,
     };
     use lnpbp::tagged_hash;
-    use lnpbp::client_side_validation::CommitConceal;
 
     static TRANSITION: [u8; 2356] = include!("../../test/transition.in");
     static GENESIS: [u8; 2454] = include!("../../test/genesis.in");
@@ -887,17 +896,17 @@ mod test {
                         for assignment in set {
                             *assignment = assignment.commit_conceal();
                         }
-                    },
+                    }
                     Assignments::DiscreteFiniteField(set) => {
                         for assignment in set {
                             *assignment = assignment.commit_conceal();
                         }
-                    },
+                    }
                     Assignments::CustomData(set) => {
                         for assignment in set {
                             *assignment = assignment.commit_conceal();
                         }
-                    },
+                    }
                 }
             }
         }
@@ -1141,8 +1150,8 @@ mod test {
                 .unwrap()
         );
 
-        genesis.conceal_all();
-        transition.conceal_all();
+        genesis.conceal_state();
+        transition.conceal_state();
 
         assert_eq!(
             genesis.clone().consensus_commit(),

src/lib.rs

@@ -59,7 +59,7 @@ pub mod prelude {
 
     pub use super::bech32::{Bech32, FromBech32, ToBech32};
     pub use contract::{
-        data, seal, value, Assignments, AtomicValue, AutoConceal,
+        data, seal, value, Assignments, AtomicValue, ConcealState,
         ConfidentialState, ContractId, DeclarativeStrategy, Extension, Genesis,
         HashStrategy, Metadata, NoDataError, Node, NodeId, OwnedRights,
         OwnedState, ParentOwnedRights, ParentPublicRights, PedersenStrategy,