contract: solve operation commitment determinism

src/contract/id.rs

@@ -20,16 +20,24 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::fmt;
 use std::fmt::{Display, Formatter};
 use std::str::FromStr;
+use std::{fmt, vec};
 
 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, CommitEncode, CommitEngine, CommitId, CommitmentId, Conceal, DigestExt, MerkleHash,
+    MerkleLeaves, Sha256, StrictHash,
+};
+use strict_encoding::StrictEncode;
 
-use crate::LIB_NAME_RGB;
+use crate::{
+    Assign, AssignmentType, Assignments, ConcealedData, ConcealedState, ConfidentialState,
+    ExposedSeal, ExposedState, ExtensionType, Ffv, GlobalState, GlobalStateType, Redeemed,
+    SecretSeal, Transition, TransitionType, TypedAssigns, XChain, 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 +135,160 @@ impl OpId {
         Bytes32::copy_from_slice(slice).map(Self)
     }
 }
+
+pub type ContractType = StrictHash;
+
+#[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 TypeCommitment {
+    #[strict_type(tag = 0)]
+    Genesis(ContractType),
+
+    #[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 OpCommitment {
+    pub ffv: Ffv,
+    pub contract_id: ContractId,
+    pub op_type: TypeCommitment,
+    pub metadata: StrictHash,
+    pub globals: MerkleHash,
+    pub inputs: MerkleHash,
+    pub assignments: MerkleHash,
+    pub redeemed: StrictHash,
+    pub valencies: StrictHash,
+}
+
+impl Transition {
+    pub fn commit(&self) -> OpCommitment {
+        let mut meta_hasher = Sha256::default();
+        let _ = self
+            .metadata
+            .strict_write(u16::MAX as usize, &mut meta_hasher)
+            .ok();
+        OpCommitment {
+            ffv: self.ffv,
+            contract_id: self.contract_id,
+            op_type: TypeCommitment::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: Redeemed::default().commit_id(),
+            valencies: self.valencies.commit_id(),
+        }
+    }
+}
+
+impl ConcealedState {
+    fn commit_encode(&self, e: &mut CommitEngine) {
+        match self {
+            ConcealedState::Void => {}
+            ConcealedState::Fungible(val) => e.commit_to(&val.commitment),
+            ConcealedState::Structured(dat) => e.commit_to(dat),
+            ConcealedState::Attachment(att) => e.commit_to(att),
+        }
+    }
+}
+
+#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+pub struct AssignmentCommitment {
+    pub ty: AssignmentType,
+    pub state: ConcealedState,
+    pub seal: XChain<SecretSeal>,
+}
+
+impl CommitEncode for AssignmentCommitment {
+    type CommitmentId = MerkleHash;
+
+    fn commit_encode(&self, e: &mut CommitEngine) {
+        e.commit_to(&self.ty);
+        self.state.commit_encode(e);
+        e.commit_to(&self.seal);
+        e.set_finished();
+    }
+}
+
+impl<State: ExposedState, Seal: ExposedSeal> Assign<State, Seal> {
+    pub fn commitment(&self, ty: AssignmentType) -> AssignmentCommitment {
+        let Self::Confidential { seal, state } = self.conceal() else {
+            unreachable!();
+        };
+        AssignmentCommitment {
+            ty,
+            state: state.state_commitment(),
+            seal,
+        }
+    }
+}
+
+impl<Seal: ExposedSeal> MerkleLeaves for Assignments<Seal> {
+    type Leaf = AssignmentCommitment;
+    type LeafIter<'tmp> = vec::IntoIter<AssignmentCommitment> where Seal: 'tmp;
+
+    fn merkle_leaves(&self) -> Self::LeafIter<'_> {
+        self.iter()
+            .flat_map(|(ty, a)| {
+                match a {
+                    TypedAssigns::Declarative(list) => {
+                        list.iter().map(|a| a.commitment(*ty)).collect::<Vec<_>>()
+                    }
+                    TypedAssigns::Fungible(list) => {
+                        list.iter().map(|a| a.commitment(*ty)).collect()
+                    }
+                    TypedAssigns::Structured(list) => {
+                        list.iter().map(|a| a.commitment(*ty)).collect()
+                    }
+                    TypedAssigns::Attachment(list) => {
+                        list.iter().map(|a| a.commitment(*ty)).collect()
+                    }
+                }
+                .into_iter()
+            })
+            .collect::<Vec<_>>()
+            .into_iter()
+    }
+}
+
+#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+pub struct GlobalCommitment {
+    pub ty: GlobalStateType,
+    pub state: ConcealedData,
+}
+
+impl CommitEncode for GlobalCommitment {
+    type CommitmentId = MerkleHash;
+
+    fn commit_encode(&self, e: &mut CommitEngine) {
+        e.commit_to(&self.ty);
+        e.commit_to(&self.state);
+        e.set_finished();
+    }
+}
+
+impl MerkleLeaves for GlobalState {
+    type Leaf = GlobalCommitment;
+    type LeafIter<'tmp> = vec::IntoIter<GlobalCommitment>;
+
+    fn merkle_leaves(&self) -> Self::LeafIter<'_> {
+        self.iter()
+            .flat_map(|(ty, list)| {
+                list.iter().map(|val| GlobalCommitment {
+                    ty: *ty,
+                    state: val.conceal(),
+                })
+            })
+            .collect::<Vec<_>>()
+            .into_iter()
+    }
+}

src/contract/mod.rs

@@ -52,7 +52,10 @@ pub use fungible::{
     InvalidFieldElement, NoiseDumb, PedersenCommitment, RangeProof, RangeProofError, RevealedValue,
 };
 pub use global::{GlobalState, GlobalValues};
-pub use id::{ContractId, OpId};
+pub use id::{
+    AssignmentCommitment, ContractId, ContractType, GlobalCommitment, OpCommitment, OpId,
+    TypeCommitment,
+};
 pub use operations::{
     Extension, Genesis, Input, Inputs, OpRef, Operation, Redeemed, Transition, 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, StrictHash};
 use strict_encoding::{StrictDeserialize, StrictEncode, StrictSerialize};
 
 use crate::schema::{self, ExtensionType, OpFullType, OpType, SchemaId, TransitionType};
@@ -39,6 +39,8 @@ use crate::{
 #[wrapper_mut(DerefMut)]
 #[derive(StrictType, StrictEncode, StrictDecode)]
 #[strict_type(lib = LIB_NAME_RGB)]
+#[derive(CommitEncode)]
+#[commit_encode(strategy = strict, id = StrictHash)]
 #[cfg_attr(
     feature = "serde",
     derive(Serialize, Deserialize),
@@ -58,6 +60,8 @@ impl<'a> IntoIterator for &'a Valencies {
 #[wrapper_mut(DerefMut)]
 #[derive(StrictType, StrictEncode, StrictDecode)]
 #[strict_type(lib = LIB_NAME_RGB)]
+#[derive(CommitEncode)]
+#[commit_encode(strategy = strict, id = StrictHash)]
 #[cfg_attr(
     feature = "serde",
     derive(Serialize, Deserialize),
@@ -91,9 +95,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/stl.rs

@@ -28,11 +28,13 @@ use strict_types::stl::{std_stl, strict_types_stl};
 use strict_types::typelib::LibBuilder;
 use strict_types::{CompileError, TypeLib};
 
-use crate::{AnchoredBundle, ContractState, Extension, Genesis, SubSchema, LIB_NAME_RGB};
+use crate::{
+    AnchoredBundle, ContractState, Extension, Genesis, OpCommitment, SubSchema, LIB_NAME_RGB,
+};
 
 /// Strict types id for the library providing data types for RGB consensus.
 pub const LIB_ID_RGB: &str =
-    "urn:ubideco:stl:2YfZKdnGf9Gibvh15WcNSqe3xN7WH1143j1gCbDgecvG#axiom-detail-panther";
+    "urn:ubideco:stl:EM23PYNhUUBDQ3V6pSTFXiuVN9qMDJiKsNHDKpF1JvX5#albert-wizard-gemini";
 
 fn _rgb_core_stl() -> Result<TypeLib, CompileError> {
     LibBuilder::new(libname!(LIB_NAME_RGB), tiny_bset! {
@@ -48,6 +50,7 @@ fn _rgb_core_stl() -> Result<TypeLib, CompileError> {
     .transpile::<AnchoredBundle>()
     .transpile::<Extension>()
     .transpile::<ContractState>()
+    .transpile::<OpCommitment>()
     .compile()
 }