feat: implement state_getReadProof (#2136)

* feat: implement state_getReadProof

* cleanup code, remove unwraps

* expose merkle proofs on sync_service storage

* wire up get merkle proofs with rpc method

* merge proofs without decoding them

* Update light-base/src/sync_service.rs

Co-authored-by: Pierre Krieger <pierre.krieger1708@gmail.com>

* Update light-base/src/json_rpc_service/background.rs

Co-authored-by: Pierre Krieger <pierre.krieger1708@gmail.com>

* minimize proofs and merge them at the end

* fix build

* fix wasm build by using alloc::vec

* Fix the straight-forward concerns

* Add CHANGELOG entry

* Revert changes to proof_decode.rs

* Minor doc tweak

* Extract `build_proof_entry` from proof decoder

* Simplify `closest_ancestor_in_proof`

* Add `proof_entry`

* Update `minimize_proof`

* Finish the changes

* Fix sync service

* Fix `minimize_proof`

* Fix minimize_proof

---------

Co-authored-by: Pierre Krieger <pierre.krieger1708@gmail.com>

Author: voliva

lib/src/json_rpc/methods.rs

@@ -432,7 +432,7 @@ define_methods! {
     state_getKeysPaged(prefix: Option<HexString>, count: u32, start_key: Option<HexString>, hash: Option<HashHexString>) -> Vec<HexString> [state_getKeysPagedAt],
     state_getMetadata(hash: Option<HashHexString>) -> HexString,
     state_getPairs() -> (), // TODO:
-    state_getReadProof() -> (), // TODO:
+    state_getReadProof(keys: Vec<HexString>, at: Option<HashHexString>) -> ReadProof,
     state_getRuntimeVersion(at: Option<HashHexString>) -> RuntimeVersion<'a> [chain_getRuntimeVersion],
     state_getStorage(key: HexString, hash: Option<HashHexString>) -> HexString [state_getStorageAt],
     state_getStorageHash() -> () [state_getStorageHashAt], // TODO:
@@ -1049,6 +1049,12 @@ pub struct SystemHealth {
     pub should_have_peers: bool,
 }
 
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct ReadProof {
+    pub at: HashHexString,
+    pub proof: Vec<HexString>,
+}
+
 #[derive(Debug, Clone, serde::Serialize)]
 pub struct SystemPeer {
     #[serde(rename = "peerId")]

lib/src/trie.rs

@@ -109,6 +109,7 @@ mod nibble;
 
 pub mod branch_search;
 pub mod calculate_root;
+pub mod minimize_proof;
 pub mod prefix_proof;
 pub mod proof_decode;
 pub mod proof_encode;

lib/src/trie/minimize_proof.rs

@@ -0,0 +1,114 @@
+// Smoldot
+// Copyright (C) 2025  Pierre Krieger
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::trie::{
+    bytes_to_nibbles,
+    proof_decode::{self, DecodedTrieProof, StorageValue},
+    proof_encode::ProofBuilder,
+};
+use alloc::vec::Vec;
+use hashbrown::HashSet;
+
+pub use proof_decode::ParseError;
+
+/// Error potentially returned by [`minimize_proof`].
+#[derive(Debug, derive_more::Display, derive_more::Error)]
+pub enum MinimizeProofError {
+    /// Desired key can't be found in the proof.
+    KeyNotFound,
+    /// Proof doesn't contain enough information and isn't valid.
+    IncompleteProof,
+}
+
+/// Minimizes a single-key proof, removing all entries that are not related to the proof for
+/// that key.
+///
+/// Returns the resulting proof, encoded.
+pub fn minimize_proof<T: AsRef<[u8]>>(
+    decoded_proof: &DecodedTrieProof<T>,
+    trie_root_merkle_value: &[u8; 32],
+    key: &[u8],
+) -> Result<Vec<u8>, MinimizeProofError> {
+    let mut builder = ProofBuilder::new();
+
+    let mut key_nibbles_if_first_iter =
+        Some(bytes_to_nibbles(key.iter().copied()).collect::<Vec<_>>());
+
+    // Query a missing node and provide its value. Stop when the proof is complete.
+    loop {
+        let Some(missing) = builder
+            .missing_node_values()
+            .next()
+            .map(|v| Vec::from(v))
+            .or_else(|| key_nibbles_if_first_iter.take())
+        else {
+            break;
+        };
+
+        if let Some(ancestor_key) = decoded_proof
+            .closest_ancestor_in_proof(trie_root_merkle_value, missing.iter().copied())
+            .map_err(|_| MinimizeProofError::KeyNotFound)?
+        {
+            let ancestor = decoded_proof
+                .proof_entry(trie_root_merkle_value, ancestor_key)
+                .unwrap();
+            builder.set_node_value(
+                &missing,
+                ancestor.node_value,
+                match ancestor.trie_node_info.storage_value {
+                    StorageValue::Known { value, .. } => Some(value),
+                    _ => None,
+                },
+            );
+        } else {
+            // Add the root node in the output.
+            // This should only ever happen if the input key is completely outside of the trie.
+            debug_assert!(itertools::equal(
+                missing.iter().copied(),
+                bytes_to_nibbles(key.iter().copied())
+            ));
+            let root = decoded_proof
+                .trie_root_proof_entry(trie_root_merkle_value)
+                .ok_or(MinimizeProofError::KeyNotFound)?;
+            builder.set_node_value(&missing, root.node_value, None);
+        };
+    }
+
+    Ok(builder.build_to_vec())
+}
+
+/// Merges multiple proofs into a single one, removing common entries.
+pub fn merge_proofs<'a>(mut proofs: impl Iterator<Item = &'a [u8]>) -> Result<Vec<u8>, ParseError> {
+    // Decode each element of `proofs` and collect the entries in a `HashSet`.
+    let entries = proofs.try_fold(
+        HashSet::with_hasher(fnv::FnvBuildHasher::default()),
+        |mut acc, proof| {
+            let proof_entries = proof_decode::decode_proof(&proof)?;
+            acc.extend(proof_entries);
+            Ok(acc)
+        },
+    )?;
+
+    // Encode the output proof.
+    let mut ret = Vec::with_capacity(8 + entries.iter().map(|e| e.len() + 8).sum::<usize>());
+    ret.extend_from_slice(crate::util::encode_scale_compact_usize(entries.len()).as_ref());
+    for entry in entries {
+        ret.extend_from_slice(crate::util::encode_scale_compact_usize(entry.len()).as_ref());
+        ret.extend_from_slice(entry);
+    }
+    Ok(ret)
+}