commit: add strict encoding

Author: dr-orlovsky

Cargo.lock

@@ -36,7 +36,7 @@ pub use convolve::{ConvolveCommit, ConvolveCommitProof};
 pub use embed::{EmbedCommitProof, EmbedCommitVerify, VerifyEq};
 pub use encode::CommitEncode;
 
-pub const STY_LIB_NAME: &str = "CommitVerify";
+pub const LIB_NAME_COMMIT_VERIFY: &str = "CommitVerify";
 
 /// Marker trait for specific commitment protocols.
 ///

commit_verify/src/lib.rs

@@ -19,10 +19,9 @@ use amplify::confinement::Confined;
 use amplify::num::u4;
 use amplify::{Bytes32, Wrapper};
 use bitcoin_hashes::{sha256, Hash};
-use strict_encoding::{DecodeError, ReadTuple, StrictDecode, StrictEncode, TypedRead, TypedWrite};
 
 use crate::encode::{strategies, CommitStrategy};
-use crate::{CommitEncode, STY_LIB_NAME};
+use crate::{CommitEncode, LIB_NAME_COMMIT_VERIFY};
 
 /// Type of a merkle node branching.
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
@@ -56,8 +55,8 @@ impl CommitStrategy for NodeBranching {
 /// [LNPBP-4]: https://github.com/LNP-BP/LNPBPs/blob/master/lnpbp-0004.md
 #[derive(Wrapper, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug, From)]
 #[wrapper(Deref, BorrowSlice, Display, FromStr, Hex, RangeOps)]
-#[derive(StrictDumb, StrictType)]
-#[strict_type(lib = STY_LIB_NAME, dumb = MerkleNode(default!()))]
+#[derive(StrictDumb, StrictType, StrictEncode, StrictDecode)]
+#[strict_type(lib = LIB_NAME_COMMIT_VERIFY, dumb = MerkleNode(default!()))]
 #[cfg_attr(
     feature = "serde",
     derive(Serialize, Deserialize),
@@ -69,22 +68,6 @@ pub struct MerkleNode(
     Bytes32,
 );
 
-impl StrictEncode for MerkleNode {
-    fn strict_encode<W: TypedWrite>(&self, writer: W) -> io::Result<W> {
-        writer.write_newtype::<Self>(self.0.as_inner())
-    }
-}
-
-impl StrictDecode for MerkleNode {
-    fn strict_decode(reader: &mut impl TypedRead) -> Result<Self, DecodeError> {
-        reader.read_tuple(|r| {
-            r.read_field::<[u8; 32]>()
-                .map(Bytes32::from_inner)
-                .map(MerkleNode)
-        })
-    }
-}
-
 const VIRTUAL_LEAF: MerkleNode = MerkleNode(Bytes32::from_array([0xFF; 32]));
 
 impl MerkleNode {

commit_verify/src/merkle.rs

@@ -29,8 +29,10 @@ pub type MessageMap = SmallOrdMap<ProtocolId, Message>;
 /// procedure.
 ///
 /// [LNPBP-4]: https://github.com/LNP-BP/LNPBPs/blob/master/lnpbp-0004.md
-#[derive(Wrapper, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug, From)]
+#[derive(Wrapper, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug, From, Default)]
 #[wrapper(Deref, BorrowSlice, Display, FromStr, Hex, RangeOps)]
+#[derive(StrictType, StrictEncode, StrictDecode)]
+#[strict_type(lib = crate::LIB_NAME_COMMIT_VERIFY)]
 #[cfg_attr(
     feature = "serde",
     derive(Serialize, Deserialize),
@@ -49,8 +51,10 @@ impl CommitEncode for ProtocolId {
 /// Original message participating in multi-message commitment.
 ///
 /// The message must be represented by a 32-byte hash.
-#[derive(Wrapper, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug, From)]
+#[derive(Wrapper, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug, From, Default)]
 #[wrapper(Deref, BorrowSlice, Display, FromStr, Hex, RangeOps)]
+#[derive(StrictType, StrictEncode, StrictDecode)]
+#[strict_type(lib = crate::LIB_NAME_COMMIT_VERIFY)]
 #[cfg_attr(
     feature = "serde",
     derive(Serialize, Deserialize),

commit_verify/src/mpc/atoms.rs

@@ -12,6 +12,8 @@
 // You should have received a copy of the Apache 2.0 License along with this
 // software. If not, see <https://opensource.org/licenses/Apache-2.0>.
 
+#![allow(unused_braces)]
+
 use std::cmp::Ordering;
 use std::collections::{BTreeMap, BTreeSet};
 use std::io::Write;
@@ -24,8 +26,8 @@ use crate::id::CommitmentId;
 use crate::merkle::MerkleNode;
 use crate::mpc::atoms::Leaf;
 use crate::mpc::tree::protocol_id_pos;
-use crate::mpc::{Commitment, MerkleTree, Message, ProtocolId, LNPBP4_TAG};
-use crate::{CommitEncode, Conceal};
+use crate::mpc::{Commitment, MerkleTree, Message, Proof, ProtocolId, LNPBP4_TAG};
+use crate::{CommitEncode, Conceal, LIB_NAME_COMMIT_VERIFY};
 
 /// commitment under protocol id {_0} is absent from the known part of a given
 /// LNPBP-4 Merkle block.
@@ -40,6 +42,12 @@ pub struct UnrelatedProof;
 
 /// LNPBP-4 Merkle tree node.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
+#[derive(StrictType, StrictDumb, StrictEncode, StrictDecode)]
+#[strict_type(
+    lib = LIB_NAME_COMMIT_VERIFY,
+    tags = order,
+    dumb = { TreeNode::ConcealedNode { depth: u4::ZERO, hash: [0u8; 32].into() } }
+)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "serde_crate"))]
 enum TreeNode {
     /// A node of the tree with concealed leaf or tree branch information.
@@ -90,6 +98,8 @@ impl TreeNode {
 
 /// Partially-concealed merkle tree data.
 #[derive(Getters, Clone, PartialEq, Eq, Hash, Debug, Default)]
+#[derive(StrictType, StrictEncode, StrictDecode)]
+#[strict_type(lib = LIB_NAME_COMMIT_VERIFY)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "serde_crate"))]
 pub struct MerkleBlock {
     /// Tree depth (up to 16).
@@ -106,6 +116,8 @@ pub struct MerkleBlock {
     entropy: Option<u64>,
 }
 
+impl Proof for MerkleBlock {}
+
 impl From<&MerkleTree> for MerkleBlock {
     fn from(tree: &MerkleTree) -> Self {
         let map = &tree.map;
@@ -454,6 +466,8 @@ impl CommitmentId for MerkleBlock {
 
 /// A proof of the merkle commitment.
 #[derive(Getters, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)]
+#[derive(StrictType, StrictEncode, StrictDecode)]
+#[strict_type(lib = LIB_NAME_COMMIT_VERIFY)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "serde_crate"))]
 pub struct MerkleProof {
     /// Position of the leaf in the tree.
@@ -468,6 +482,8 @@ pub struct MerkleProof {
     path: SmallVec<MerkleNode>,
 }
 
+impl Proof for MerkleProof {}
+
 impl MerkleProof {
     /// Computes the depth of the merkle tree.
     pub fn depth(&self) -> u8 { self.path.len() as u8 }

commit_verify/src/mpc/block.rs

@@ -27,3 +27,10 @@ pub use tree::Error;
 pub use tree::{IntoIter, MerkleTree};
 
 const LNPBP4_TAG: [u8; 16] = *b"urn:lnpbp:lnpbp4";
+
+/// Marker trait for variates of LNPBP-4 commitment proofs, which differ by the
+/// amount of concealed information.
+pub trait Proof:
+    strict_encoding::StrictEncode + strict_encoding::StrictDecode + Clone + Eq + std::fmt::Debug
+{
+}

commit_verify/src/mpc/mod.rs

@@ -14,20 +14,23 @@
 
 use std::collections::BTreeMap;
 
+use amplify::confinement::SmallOrdMap;
 use amplify::num::{u256, u4};
 use amplify::Wrapper;
 
 #[cfg(feature = "rand")]
 pub use self::commit::Error;
 use crate::merkle::{MerkleLeaves, MerkleNode};
 use crate::mpc::atoms::Leaf;
-use crate::mpc::{Message, MessageMap, ProtocolId, LNPBP4_TAG};
-use crate::Conceal;
+use crate::mpc::{Message, MessageMap, Proof, ProtocolId, LNPBP4_TAG};
+use crate::{Conceal, LIB_NAME_COMMIT_VERIFY};
 
-type OrderedMap = BTreeMap<u16, (ProtocolId, Message)>;
+type OrderedMap = SmallOrdMap<u16, (ProtocolId, Message)>;
 
 /// Complete information about LNPBP-4 merkle tree.
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
+#[derive(StrictDumb, StrictType, StrictEncode, StrictDecode)]
+#[strict_type(lib = LIB_NAME_COMMIT_VERIFY)]
 pub struct MerkleTree {
     /// Tree depth (up to 16).
     pub(super) depth: u4,
@@ -41,6 +44,8 @@ pub struct MerkleTree {
     pub(super) map: OrderedMap,
 }
 
+impl Proof for MerkleTree {}
+
 pub struct IntoIter {
     width: u16,
     pos: u16,
@@ -100,6 +105,7 @@ impl Conceal for MerkleTree {
 
 #[cfg(feature = "rand")]
 mod commit {
+    use amplify::confinement::Confined;
     use rand::{thread_rng, RngCore};
 
     use super::*;
@@ -157,7 +163,7 @@ mod commit {
                 depth,
                 messages: source.messages.clone(),
                 entropy,
-                map,
+                map: Confined::try_from(map).expect("MultiSource type guarantees"),
             })
         }
     }