pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-04-26 13:27:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

Compact proof utilities in sp_trie. (#8574)

Browse Source 
* validation extension in sp_io

* need paths

* arc impl

* missing host function in executor

* io to pkdot

* decode function.

* encode primitive.

* trailing tab

* multiple patch

* fix child trie logic

* restore master versionning

* bench compact proof size

* trie-db 22.3 is needed

* line width

* split line

* fixes for bench (additional root may not be needed as original issue was
with empty proof).

* revert compact from block size calculation.

* New error type for compression.

* Adding test (incomplete (failing)).
Also lacking real proof checking (no good primitives in sp-trie crate).

* There is currently no proof recording utility in sp_trie, removing
test.

* small test of child root in proof without a child proof.

* remove empty test.

* remove non compact proof size

* Missing revert.

* proof method to encode decode.
This commit is contained in:
cheme
2021-06-07 11:06:38 +02:00
committed by GitHub
parent f0c5699bc6
commit f01c396677
8 changed files with 407 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/primitives/state-machine/src/lib.rs
+55 -2
View File
@@ -1402,14 +1402,22 @@ mod tests {
}
}
fn test_compact(remote_proof: StorageProof, remote_root: &sp_core::H256) -> StorageProof {
let compact_remote_proof = remote_proof.into_compact_proof::<BlakeTwo256>(
remote_root.clone(),
).unwrap();
compact_remote_proof.to_storage_proof::<BlakeTwo256>(Some(remote_root)).unwrap().0
}
#[test]
fn prove_read_and_proof_check_works() {
let child_info = ChildInfo::new_default(b"sub1");
let child_info = &child_info;
// fetch read proof from 'remote' full node
let remote_backend = trie_backend::tests::test_trie();
let remote_root = remote_backend.storage_root(::std::iter::empty()).0;
let remote_root = remote_backend.storage_root(std::iter::empty()).0;
let remote_proof = prove_read(remote_backend, &[b"value2"]).unwrap();
let remote_proof = test_compact(remote_proof, &remote_root);
// check proof locally
let local_result1 = read_proof_check::<BlakeTwo256, _>(
remote_root,
@@ -1429,12 +1437,13 @@ mod tests {
assert_eq!(local_result2, false);
// on child trie
let remote_backend = trie_backend::tests::test_trie();
let remote_root = remote_backend.storage_root(::std::iter::empty()).0;
let remote_root = remote_backend.storage_root(std::iter::empty()).0;
let remote_proof = prove_child_read(
remote_backend,
child_info,
&[b"value3"],
).unwrap();
let remote_proof = test_compact(remote_proof, &remote_root);
let local_result1 = read_child_proof_check::<BlakeTwo256, _>(
remote_root,
remote_proof.clone(),
@@ -1457,6 +1466,50 @@ mod tests {
);
}
#[test]
fn compact_multiple_child_trie() {
// this root will be queried
let child_info1 = ChildInfo::new_default(b"sub1");
// this root will not be include in proof
let child_info2 = ChildInfo::new_default(b"sub2");
// this root will be include in proof
let child_info3 = ChildInfo::new_default(b"sub");
let mut remote_backend = trie_backend::tests::test_trie();
let (remote_root, transaction) = remote_backend.full_storage_root(
std::iter::empty(),
vec![
(&child_info1, vec![
(&b"key1"[..], Some(&b"val2"[..])),
(&b"key2"[..], Some(&b"val3"[..])),
].into_iter()),
(&child_info2, vec![
(&b"key3"[..], Some(&b"val4"[..])),
(&b"key4"[..], Some(&b"val5"[..])),
].into_iter()),
(&child_info3, vec![
(&b"key5"[..], Some(&b"val6"[..])),
(&b"key6"[..], Some(&b"val7"[..])),
].into_iter()),
].into_iter(),
);
remote_backend.backend_storage_mut().consolidate(transaction);
remote_backend.essence.set_root(remote_root.clone());
let remote_proof = prove_child_read(
remote_backend,
&child_info1,
&[b"key1"],
).unwrap();
let remote_proof = test_compact(remote_proof, &remote_root);
let local_result1 = read_child_proof_check::<BlakeTwo256, _>(
remote_root,
remote_proof.clone(),
&child_info1,
&[b"key1"],
).unwrap();
assert_eq!(local_result1.len(), 1);
assert_eq!(local_result1.get(&b"key1"[..]), Some(&Some(b"val2".to_vec())));
}
#[test]
fn child_storage_uuid() {