more

crates/chia-datalayer/src/merkle.rs

@@ -310,6 +310,46 @@ pub struct ProofOfInclusion {
     pub layers: Vec<ProofOfInclusionLayer>,
 }
 
+impl ProofOfInclusion {
+    pub fn root_hash(&self) -> Hash {
+        if let Some(last) = self.layers.last() {
+            last.combined_hash
+        } else {
+            self.node_hash
+        }
+    }
+
+    pub fn valid(&self) -> bool {
+        let mut existing_hash = self.node_hash;
+
+        for layer in &self.layers {
+            let calculated_hash =
+                calculate_internal_hash(&existing_hash, layer.other_hash_side, &layer.other_hash);
+
+            if calculated_hash != layer.combined_hash {
+                return false;
+            }
+
+            existing_hash = calculated_hash;
+        }
+
+        existing_hash == self.root_hash()
+    }
+}
+
+#[cfg(feature = "py-bindings")]
+#[pymethods]
+impl ProofOfInclusion {
+    #[pyo3(name = "root_hash")]
+    pub fn py_root_hash(&self) -> Hash {
+        self.root_hash()
+    }
+    #[pyo3(name = "valid")]
+    pub fn py_valid(&self) -> bool {
+        self.valid()
+    }
+}
+
 #[allow(clippy::needless_pass_by_value)]
 fn sha256_num<T: ToBytes>(input: T) -> Hash {
     let mut hasher = Sha256::new();
@@ -334,6 +374,13 @@ fn internal_hash(left_hash: &Hash, right_hash: &Hash) -> Hash {
     Hash(Bytes32::new(hasher.finalize()))
 }
 
+pub fn calculate_internal_hash(hash: &Hash, other_hash_side: Side, other_hash: &Hash) -> Hash {
+    match other_hash_side {
+        Side::Left => internal_hash(other_hash, hash),
+        Side::Right => internal_hash(hash, other_hash),
+    }
+}
+
 #[cfg_attr(feature = "py-bindings", pyclass(eq, eq_int))]
 #[repr(u8)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, Streamable)]
@@ -1631,6 +1678,11 @@ impl MerkleBlob {
     pub fn py_get_key_index(&self, key: KeyId) -> PyResult<TreeIndex> {
         Ok(self.get_key_index(key)?)
     }
+
+    #[pyo3(name = "get_proof_of_inclusion")]
+    pub fn py_get_proof_of_inclusion(&self, key: KeyId) -> PyResult<ProofOfInclusion> {
+        Ok(self.get_proof_of_inclusion(key)?)
+    }
 }
 
 fn try_get_block(blob: &[u8], index: TreeIndex) -> Result<Block, Error> {

wheel/python/chia_rs/datalayer.pyi

@@ -74,6 +74,9 @@ class ProofOfInclusion:
     # children before parents
     layers: list[ProofOfInclusionLayer]
 
+    def root_hash(self) -> bytes32: ...
+    def valid(self) -> bool: ...
+
 @final
 class MerkleBlob:
     @property
@@ -103,6 +106,7 @@ class MerkleBlob:
     def get_hash_at_index(self, index: uint32): ...
     def get_keys_values(self) -> dict[int64, int64]: ...
     def get_key_index(self, key: int64) -> uint32: ...
+    def get_proof_of_inclusion(self, key: int64) -> ProofOfInclusion: ...
 
     def __len__(self) -> int: ...