feat!: implement command inclusion proof for eviction (#6724)

Description
---

Add and verify command inclusion proof

Motivation and Context
---
Adds a JMT implementation to tari_jellyfish crate. Useful for state tree
inclusion proofs. Currently used to validate eviction command commit
proofs

How Has This Been Tested?
---
Cucumber test on tari-dan repo

What process can a PR reviewer use to test or verify this change?
---

<!-- Checklist -->
<!-- 1. Is the title of your PR in the form that would make nice release
notes? The title, excluding the conventional commit
tag, will be included exactly as is in the CHANGELOG, so please think
about it carefully. -->


Breaking Changes
---

- [ ] None
- [x] Requires data directory on base node to be deleted
- [ ] Requires hard fork
- [ ] Other - Please specify
BREAKING CHANGE: eviction proof changed

Cargo.toml

@@ -27,6 +27,7 @@ members = [
     "common_sqlite",
     "infrastructure/libtor",
     "infrastructure/metrics",
+    "infrastructure/jellyfish",
     "infrastructure/shutdown",
     "infrastructure/storage",
     "infrastructure/tari_script",
@@ -44,6 +45,7 @@ members = [
 ]
 
 [workspace.dependencies]
+tari_jellyfish = { path = "infrastructure/jellyfish" }
 tari_comms = { path = "comms/core" }
 tari_comms_dht = { path = "comms/dht", default-features = false }
 tari_common = { path = "common" }

applications/minotari_app_grpc/proto/sidechain_types.proto

@@ -97,6 +97,7 @@ message CommitProof {
 message CommitProofV1 {
   bytes command = 1;
   SidechainBlockCommitProof commit_proof = 2;
+  bytes encoded_inclusion_proof = 3;
 }
 
 message SidechainBlockCommitProof {

applications/minotari_app_grpc/src/conversions/sidechain_feature.rs

@@ -361,6 +361,9 @@ impl TryFrom<grpc::CommitProofV1> for CommandCommitProofV1<EvictNodeAtom> {
         Ok(CommandCommitProofV1 {
             command: command.try_into()?,
             commit_proof: value.commit_proof.ok_or("commit_proof not provided")?.try_into()?,
+
+            inclusion_proof: borsh::from_slice(&value.encoded_inclusion_proof)
+                .map_err(|e| format!("Failed to decode SparseMerkleProofExt: {e}"))?,
         })
     }
 }
@@ -370,6 +373,10 @@ impl From<&CommandCommitProofV1<EvictNodeAtom>> for grpc::CommitProofV1 {
         Self {
             command: grpc::EvictAtom::from(value.command()).encode_to_vec(),
             commit_proof: Some(value.commit_proof().into()),
+            // Encode since the type is complex
+            // TODO: making this fallible is a pain - we may need to implement the proto for this
+            encoded_inclusion_proof: borsh::to_vec(value.inclusion_proof())
+                .expect("Failed to encode SparseMerkleProofExt"),
         }
     }
 }

base_layer/core/src/proto/sidechain_feature.proto

@@ -80,6 +80,7 @@ message CommitProof {
 message CommitProofV1 {
   bytes command = 1;
   SidechainBlockCommitProof commit_proof = 2;
+  bytes encoded_inclusion_proof = 3;
 }
 
 message SidechainBlockCommitProof {

base_layer/core/src/proto/sidechain_feature.rs

@@ -355,15 +355,22 @@ impl TryFrom<proto::types::CommitProofV1> for CommandCommitProofV1<EvictNodeAtom
         Ok(CommandCommitProofV1 {
             command: command.try_into()?,
             commit_proof: value.commit_proof.ok_or("commit_proof not provided")?.try_into()?,
+            inclusion_proof: borsh::from_slice(&value.encoded_inclusion_proof)
+                .map_err(|e| format!("Failed to decode SparseMerkleProofExt: {e}"))?,
         })
     }
 }
 
 impl From<&CommandCommitProofV1<EvictNodeAtom>> for proto::types::CommitProofV1 {
     fn from(value: &CommandCommitProofV1<EvictNodeAtom>) -> Self {
         Self {
+            // Encode since command is generic
             command: proto::types::EvictAtom::from(value.command()).encode_to_vec(),
             commit_proof: Some(value.commit_proof().into()),
+            // Encode since the type is complex
+            // TODO: making this fallible is a pain - we may need to implement the proto for this
+            encoded_inclusion_proof: borsh::to_vec(value.inclusion_proof())
+                .expect("Failed to encode SparseMerkleProofExt"),
         }
     }
 }

base_layer/sidechain/Cargo.toml

@@ -9,6 +9,7 @@ tari_hashing = { workspace = true }
 tari_crypto = { version = "0.21.0", features = ["borsh"] }
 tari_utilities = "0.8"
 tari_common_types = { workspace = true }
+tari_jellyfish = { workspace = true }
 
 log = "0.4.22"
 thiserror = "2.0"

base_layer/sidechain/src/commit_proof.rs

@@ -12,6 +12,7 @@ use tari_hashing::{
     layer2::{block_hasher, vote_signature_hasher},
     ValidatorNodeHashDomain,
 };
+use tari_jellyfish::{LeafKey, SparseMerkleProofExt, TreeHash};
 
 use super::error::SidechainProofValidationError;
 use crate::{
@@ -29,8 +30,12 @@ pub enum CommandCommitProof<C> {
 }
 
 impl<C: ToCommand> CommandCommitProof<C> {
-    pub fn new(command: C, commit_proof: SidechainBlockCommitProof) -> Self {
-        Self::V1(CommandCommitProofV1 { command, commit_proof })
+    pub fn new(command: C, commit_proof: SidechainBlockCommitProof, inclusion_proof: SparseMerkleProofExt) -> Self {
+        Self::V1(CommandCommitProofV1 {
+            command,
+            commit_proof,
+            inclusion_proof,
+        })
     }
 
     pub fn command(&self) -> &C {
@@ -71,10 +76,9 @@ impl<C: ToCommand> CommandCommitProof<C> {
 
 #[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, BorshSerialize, BorshDeserialize)]
 pub struct CommandCommitProofV1<C> {
-    // TODO: Implement MerkleProof
-    // command_merkle_proof: MerkleProof,
     pub command: C,
     pub commit_proof: SidechainBlockCommitProof,
+    pub inclusion_proof: SparseMerkleProofExt,
 }
 
 impl<C: ToCommand> CommandCommitProofV1<C> {
@@ -86,12 +90,26 @@ impl<C: ToCommand> CommandCommitProofV1<C> {
         &self.commit_proof
     }
 
+    pub fn inclusion_proof(&self) -> &SparseMerkleProofExt {
+        &self.inclusion_proof
+    }
+
+    fn validate_inclusion_proof(&self, command: &Command) -> Result<(), SidechainProofValidationError> {
+        let command_hash = TreeHash::new(command.hash().into_array());
+        // Command JMT uses an identity mapping between hashes and keys.
+        let key = LeafKey::new(command_hash);
+        let root_hash = TreeHash::new(self.commit_proof.header.command_merkle_root.into_array());
+        self.inclusion_proof.verify_inclusion(&root_hash, &key, &command_hash)?;
+        Ok(())
+    }
+
     pub fn validate_committed(
         &self,
         quorum_threshold: usize,
         check_vn: &CheckVnFunc<'_>,
     ) -> Result<(), SidechainProofValidationError> {
         let command = self.command.to_command();
+        self.validate_inclusion_proof(&command)?;
         self.commit_proof
             .validate_committed(&command, quorum_threshold, check_vn)
     }

base_layer/sidechain/src/error.rs

@@ -9,6 +9,8 @@ pub enum SidechainProofValidationError {
     InvalidProof { details: String },
     #[error("Internal error: {details}")]
     InternalError { details: String },
+    #[error("Jellyfish proof verification error: {0}")]
+    JmtProofVerifyError(#[from] tari_jellyfish::JmtProofVerifyError),
 }
 
 impl SidechainProofValidationError {

base_layer/sidechain/tests/eviction_proof.rs

@@ -10,12 +10,12 @@ mod validate {
     #[test]
     fn it_validates_a_valid_proof() {
         let proof = support::load_fixture::<EvictionProof>("eviction_proof1.json");
-        proof.validate(5, &|_| Ok(true)).unwrap();
+        proof.validate(4, &|_| Ok(true)).unwrap();
     }
 
     #[test]
     fn it_rejects_if_qc_signs_for_unknown_validator() {
         let proof = support::load_fixture::<EvictionProof>("eviction_proof1.json");
-        proof.validate(5, &|_| Ok(false)).unwrap_err();
+        proof.validate(4, &|_| Ok(false)).unwrap_err();
     }
 }