pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-09 20:11:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

Move Storage Parser from Bridge Pallet (#793)

Browse Source 
* Move storage proof checker to runtime primtives

* Add method for parsing storage proofs

* Use finality-verifier pallet in runtime-common

* Get bridge pallet compiling again

* Use storage prover from bp-runtime in a few more places

* Don't leak `std` items from proof helper into `no-std` builds

* Fix benchmarking compilation

* Remove unused import in fuzzer
This commit is contained in:
Hernando Castano
2021-03-08 17:13:25 -05:00
committed by Bastian Köcher
parent 80533af331
commit 51db99ea79
9 changed files with 128 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files
bridges/modules/substrate/src/lib.rs
+4 -7
View File
@@ -46,10 +46,7 @@ use sp_trie::StorageProof;
// Re-export since the node uses these when configuring genesis
pub use storage::{InitializationData, ScheduledChange};
pub use storage_proof::StorageProofChecker;
mod storage;
mod storage_proof;
mod verifier;
#[cfg(test)]
@@ -355,7 +352,7 @@ impl<T: Config> Module<T> {
pub fn parse_finalized_storage_proof<R>(
finalized_header_hash: BridgedBlockHash<T>,
storage_proof: StorageProof,
parse: impl FnOnce(StorageProofChecker<BridgedBlockHasher<T>>) -> R,
parse: impl FnOnce(bp_runtime::StorageProofChecker<BridgedBlockHasher<T>>) -> R,
) -> Result<R, sp_runtime::DispatchError> {
let storage = PalletStorage::<T>::new();
let header = storage
@@ -365,8 +362,8 @@ impl<T: Config> Module<T> {
return Err(Error::<T>::UnfinalizedHeader.into());
}
let storage_proof_checker =
StorageProofChecker::new(*header.state_root(), storage_proof).map_err(Error::<T>::from)?;
let storage_proof_checker = bp_runtime::StorageProofChecker::new(*header.state_root(), storage_proof)
.map_err(|_| Error::<T>::StorageRootMismatch)?;
Ok(parse(storage_proof_checker))
}
}
@@ -898,7 +895,7 @@ mod tests {
fn parse_finalized_storage_accepts_valid_proof() {
run_test(|| {
let mut storage = PalletStorage::<TestRuntime>::new();
let (state_root, storage_proof) = storage_proof::tests::craft_valid_storage_proof();
let (state_root, storage_proof) = bp_runtime::craft_valid_storage_proof();
let mut header = unfinalized_header(1);
header.is_finalized = true;
header.header.set_state_root(state_root);
bridges/modules/substrate/src/storage_proof.rs
-122
View File
@@ -1,122 +0,0 @@
// Copyright 2019-2020 Parity Technologies (UK) Ltd.
// This file is part of Parity Bridges Common.
// Parity Bridges Common 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.
// Parity Bridges Common 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 Parity Bridges Common. If not, see <http://www.gnu.org/licenses/>.
// TODO: remove on actual use
#![allow(dead_code)]
//! Logic for checking Substrate storage proofs.
use hash_db::{HashDB, Hasher, EMPTY_PREFIX};
use sp_runtime::RuntimeDebug;
use sp_std::vec::Vec;
use sp_trie::{read_trie_value, Layout, MemoryDB, StorageProof};
/// This struct is used to read storage values from a subset of a Merklized database. The "proof"
/// is a subset of the nodes in the Merkle structure of the database, so that it provides
/// authentication against a known Merkle root as well as the values in the database themselves.
pub struct StorageProofChecker<H>
where
H: Hasher,
{
root: H::Out,
db: MemoryDB<H>,
}
impl<H> StorageProofChecker<H>
where
H: Hasher,
{
/// Constructs a new storage proof checker.
///
/// This returns an error if the given proof is invalid with respect to the given root.
pub fn new(root: H::Out, proof: StorageProof) -> Result<Self, Error> {
let db = proof.into_memory_db();
if !db.contains(&root, EMPTY_PREFIX) {
return Err(Error::StorageRootMismatch);
}
let checker = StorageProofChecker { root, db };
Ok(checker)
}
/// Reads a value from the available subset of storage. If the value cannot be read due to an
/// incomplete or otherwise invalid proof, this returns an error.
pub fn read_value(&self, key: &[u8]) -> Result<Option<Vec<u8>>, Error> {
read_trie_value::<Layout<H>, _>(&self.db, &self.root, key).map_err(|_| Error::StorageValueUnavailable)
}
}
#[derive(RuntimeDebug, PartialEq)]
pub enum Error {
StorageRootMismatch,
StorageValueUnavailable,
}
impl<T: crate::Config> From<Error> for crate::Error<T> {
fn from(error: Error) -> Self {
match error {
Error::StorageRootMismatch => crate::Error::StorageRootMismatch,
Error::StorageValueUnavailable => crate::Error::StorageValueUnavailable,
}
}
}
#[cfg(test)]
pub mod tests {
use super::*;
use sp_core::{Blake2Hasher, H256};
use sp_state_machine::{backend::Backend, prove_read, InMemoryBackend};
/// Return valid storage proof and state root.
pub fn craft_valid_storage_proof() -> (H256, StorageProof) {
// construct storage proof
let backend = <InMemoryBackend<Blake2Hasher>>::from(vec![
(None, vec![(b"key1".to_vec(), Some(b"value1".to_vec()))]),
(None, vec![(b"key2".to_vec(), Some(b"value2".to_vec()))]),
(None, vec![(b"key3".to_vec(), Some(b"value3".to_vec()))]),
// Value is too big to fit in a branch node
(None, vec![(b"key11".to_vec(), Some(vec![0u8; 32]))]),
]);
let root = backend.storage_root(std::iter::empty()).0;
let proof = StorageProof::new(
prove_read(backend, &[&b"key1"[..], &b"key2"[..], &b"key22"[..]])
.unwrap()
.iter_nodes()
.collect(),
);
(root, proof)
}
#[test]
fn storage_proof_check() {
let (root, proof) = craft_valid_storage_proof();
// check proof in runtime
let checker = <StorageProofChecker<Blake2Hasher>>::new(root, proof.clone()).unwrap();
assert_eq!(checker.read_value(b"key1"), Ok(Some(b"value1".to_vec())));
assert_eq!(checker.read_value(b"key2"), Ok(Some(b"value2".to_vec())));
assert_eq!(checker.read_value(b"key11111"), Err(Error::StorageValueUnavailable));
assert_eq!(checker.read_value(b"key22"), Ok(None));
// checking proof against invalid commitment fails
assert_eq!(
<StorageProofChecker<Blake2Hasher>>::new(H256::random(), proof).err(),
Some(Error::StorageRootMismatch)
);
}
}