wip on solving commitment determinism issue

src/contract/id.rs

@@ -27,9 +27,10 @@ use std::str::FromStr;
 use amplify::hex::{FromHex, ToHex};
 use amplify::{hex, ByteArray, Bytes32, FromSliceError, Wrapper};
 use baid58::{Baid58ParseError, Chunking, FromBaid58, ToBaid58, CHUNKING_32CHECKSUM};
-use commit_verify::{mpc, CommitmentId, DigestExt, Sha256};
+use commit_verify::{mpc, CommitmentId, DigestExt, MerkleHash, Sha256};
+use strict_encoding::StrictEncode;
 
-use crate::LIB_NAME_RGB;
+use crate::{ExtensionType, Ffv, Transition, TransitionType, LIB_NAME_RGB};
 
 /// Unique contract identifier equivalent to the contract genesis commitment
 #[derive(Wrapper, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug, From)]
@@ -127,3 +128,57 @@ impl OpId {
         Bytes32::copy_from_slice(slice).map(Self)
     }
 }
+
+pub type ContractType = Bytes32;
+
+#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+#[derive(StrictType, StrictDumb, StrictEncode, StrictDecode)]
+#[strict_type(lib = LIB_NAME_RGB, tags = custom, dumb = Self::Transition(strict_dumb!()))]
+pub enum OpType {
+    #[strict_type(tag = 0)]
+    Genesis(Bytes32),
+
+    #[strict_type(tag = 1)]
+    Transition(TransitionType),
+
+    #[strict_type(tag = 2)]
+    Extension(ExtensionType),
+}
+
+#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+#[derive(StrictType, StrictDumb, StrictEncode, StrictDecode)]
+#[strict_type(lib = LIB_NAME_RGB)]
+#[derive(CommitEncode)]
+#[commit_encode(strategy = strict, id = OpId)]
+pub struct OpCommit {
+    pub ffv: Ffv,
+    pub contract_id: ContractId,
+    pub op_type: OpType,
+    pub metadata: Bytes32,
+    pub globals: MerkleHash,
+    pub inputs: MerkleHash,
+    pub assignments: MerkleHash,
+    pub redeemed: MerkleHash,
+    pub valencies: MerkleHash,
+}
+
+impl Transition {
+    pub fn commit(&self) -> OpCommit {
+        let mut meta_hasher = Sha256::default();
+        let _ = self
+            .metadata
+            .strict_write(u16::MAX as usize, &mut meta_hasher)
+            .ok();
+        OpCommit {
+            ffv: self.ffv,
+            contract_id: self.contract_id,
+            op_type: OpType::Transition(self.transition_type),
+            metadata: meta_hasher.finish().into(),
+            globals: MerkleHash::merklize(&self.globals),
+            inputs: MerkleHash::merklize(&self.inputs),
+            assignments: MerkleHash::merklize(&self.assignments),
+            redeemed: MerkleHash::void(0, 0),
+            valencies: MerkleHash::merklize(&self.valencies),
+        }
+    }
+}

src/contract/operations.rs

@@ -25,7 +25,7 @@ use std::iter;
 
 use amplify::confinement::{SmallBlob, TinyOrdMap, TinyOrdSet};
 use amplify::Wrapper;
-use commit_verify::{CommitId, Conceal};
+use commit_verify::{CommitId, Conceal, MerkleHash, MerkleLeaves};
 use strict_encoding::{StrictDeserialize, StrictEncode, StrictSerialize};
 
 use crate::schema::{self, ExtensionType, OpFullType, OpType, SchemaId, TransitionType};
@@ -53,6 +53,13 @@ impl<'a> IntoIterator for &'a Valencies {
     fn into_iter(self) -> Self::IntoIter { self.0.iter().copied() }
 }
 
+impl MerkleLeaves for Valencies {
+    type Leaf = schema::ValencyType;
+    type LeafIter<'tmp> = <TinyOrdSet<schema::ValencyType> as MerkleLeaves>::LeafIter<'tmp>;
+
+    fn merkle_leaves(&self) -> Self::LeafIter<'_> { self.0.merkle_leaves() }
+}
+
 #[derive(Wrapper, WrapperMut, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug, Default, From)]
 #[wrapper(Deref)]
 #[wrapper_mut(DerefMut)]
@@ -72,6 +79,13 @@ impl<'a> IntoIterator for &'a Redeemed {
     fn into_iter(self) -> Self::IntoIter { self.0.iter() }
 }
 
+impl MerkleLeaves for Redeemed {
+    type Leaf = schema::ValencyType;
+    type LeafIter<'tmp> = <TinyOrdSet<schema::ValencyType> as MerkleLeaves>::LeafIter<'tmp>;
+
+    fn merkle_leaves(&self) -> Self::LeafIter<'_> { self.0.merkle_leaves() }
+}
+
 #[derive(Wrapper, WrapperMut, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug, Default, From)]
 #[wrapper(Deref)]
 #[wrapper_mut(DerefMut)]
@@ -91,9 +105,18 @@ impl<'a> IntoIterator for &'a Inputs {
     fn into_iter(self) -> Self::IntoIter { self.0.iter().copied() }
 }
 
+impl MerkleLeaves for Inputs {
+    type Leaf = Input;
+    type LeafIter<'tmp> = <TinyOrdSet<Input> as MerkleLeaves>::LeafIter<'tmp>;
+
+    fn merkle_leaves(&self) -> Self::LeafIter<'_> { self.0.merkle_leaves() }
+}
+
 #[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug, Display)]
 #[derive(StrictType, StrictDumb, StrictEncode, StrictDecode)]
 #[strict_type(lib = LIB_NAME_RGB)]
+#[derive(CommitEncode)]
+#[commit_encode(strategy = strict, id = MerkleHash)]
 #[cfg_attr(
     feature = "serde",
     derive(Serialize, Deserialize),

src/schema/operations.rs

@@ -22,6 +22,7 @@
 
 use amplify::confinement::{TinyOrdMap, TinyOrdSet};
 use amplify::Wrapper;
+use commit_verify::MerkleHash;
 use strict_types::SemId;
 
 use super::{ExtensionType, GlobalStateType, Occurrences, TransitionType};
@@ -49,6 +50,8 @@ impl AssignmentType {
 #[display("0x{0:04X}")]
 #[derive(StrictType, StrictDumb, StrictEncode, StrictDecode)]
 #[strict_type(lib = LIB_NAME_RGB)]
+#[derive(CommitEncode)]
+#[commit_encode(strategy = strict, id = MerkleHash)]
 #[cfg_attr(
     feature = "serde",
     derive(Serialize, Deserialize),