vacp2p
/
pmtree
mirror of https://github.com/vacp2p/pmtree.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

rm testing files that fail

This commit is contained in:
tyshkor 2023-07-28 10:39:32 +02:00
parent 0c159f7c92
commit 3dd0655e2a
2 changed files with 0 additions and 603 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

389
tests/poseidon.rs
View File

@ -1,389 +0,0 @@
use pmtree::*;
use rln::circuit::Fr;
use rln::circuit::TEST_TREE_HEIGHT;
use rln::poseidon_hash::poseidon_hash;
use rln::protocol::hash_to_field;
use rln::utils::str_to_fr;
use std::collections::HashMap;
use std::fs;
use std::io::Cursor;
use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
struct MemoryDB(HashMap<DBKey, Value>);
struct MySled(sled::Db);
#[derive(Clone, Copy, PartialEq, Eq)]
struct PoseidonHash;
impl Hasher for PoseidonHash {
type Fr = Fr;
fn default_leaf() -> Self::Fr {
Fr::from(0)
}
fn serialize(value: Self::Fr) -> Value {
let mut buf = vec![];
Fr::serialize(&value, &mut buf).unwrap();
buf
}
fn deserialize(value: Value) -> Self::Fr {
let c = Cursor::new(value);
Fr::deserialize(c).unwrap()
}
fn hash(inputs: &[Self::Fr]) -> Self::Fr {
poseidon_hash(inputs)
}
}
#[derive(Default)]
struct MemoryDBConfig;
impl Database for MemoryDB {
type Config = MemoryDBConfig;
fn new(_db_config: MemoryDBConfig) -> PmtreeResult<Self> {
Ok(MemoryDB(HashMap::new()))
}
fn load(_db_config: MemoryDBConfig) -> PmtreeResult<Self> {
Err(PmtreeErrorKind::DatabaseError(
DatabaseErrorKind::CannotLoadDatabase,
))
}
fn get(&self, key: DBKey) -> PmtreeResult<Option<Value>> {
Ok(self.0.get(&key).cloned())
}
fn put(&mut self, key: DBKey, value: Value) -> PmtreeResult<()> {
self.0.insert(key, value);
Ok(())
}
fn put_batch(&mut self, subtree: HashMap<DBKey, Value>) -> PmtreeResult<()> {
self.0.extend(subtree.into_iter());
Ok(())
}
}
#[derive(Default)]
struct SledConfig {
path: String,
}
impl Database for MySled {
type Config = SledConfig;
fn new(db_config: SledConfig) -> PmtreeResult<Self> {
let db = sled::open(db_config.path).unwrap();
if db.was_recovered() {
return Err(PmtreeErrorKind::DatabaseError(
DatabaseErrorKind::DatabaseExists,
));
}
Ok(MySled(db))
}
fn load(db_config: SledConfig) -> PmtreeResult<Self> {
let db = sled::open(&db_config.path).unwrap();
if !db.was_recovered() {
fs::remove_dir_all(&db_config.path).expect("Error removing db");
return Err(PmtreeErrorKind::DatabaseError(
DatabaseErrorKind::CannotLoadDatabase,
));
}
Ok(MySled(db))
}
fn get(&self, key: DBKey) -> PmtreeResult<Option<Value>> {
Ok(self.0.get(key).unwrap().map(|val| val.to_vec()))
}
fn put(&mut self, key: DBKey, value: Value) -> PmtreeResult<()> {
self.0.insert(key, value).unwrap();
self.0.flush().unwrap();
Ok(())
}
fn put_batch(&mut self, subtree: HashMap<DBKey, Value>) -> PmtreeResult<()> {
let mut batch = sled::Batch::default();
for (key, value) in subtree {
batch.insert(&key, value);
}
self.0.apply_batch(batch).unwrap();
Ok(())
}
}
#[test]
fn poseidon_memory() -> PmtreeResult<()> {
let mut mt = MerkleTree::<MemoryDB, PoseidonHash>::new(TEST_TREE_HEIGHT, MemoryDBConfig)?;
let leaf_index = 3;
let identity_secret = hash_to_field(b"test-merkle-proof");
let id_commitment = poseidon_hash(&[identity_secret]);
// let default_leaf = Fr::from(0);
mt.set(leaf_index, id_commitment).unwrap();
// We check correct computation of the root
let root = mt.root();
assert_eq!(
root,
str_to_fr(
"0x21947ffd0bce0c385f876e7c97d6a42eec5b1fe935aab2f01c1f8a8cbcc356d2",
16
)
);
let merkle_proof = mt.proof(leaf_index).expect("proof should exist");
let path_elements = merkle_proof.get_path_elements();
let identity_path_index = merkle_proof.get_path_index();
// We check correct computation of the path and indexes
// These values refers to TEST_TREE_HEIGHT == 16
let expected_path_elements = vec![
str_to_fr(
"0x0000000000000000000000000000000000000000000000000000000000000000",
16,
),
str_to_fr(
"0x2098f5fb9e239eab3ceac3f27b81e481dc3124d55ffed523a839ee8446b64864",
16,
),
str_to_fr(
"0x1069673dcdb12263df301a6ff584a7ec261a44cb9dc68df067a4774460b1f1e1",
16,
),
str_to_fr(
"0x18f43331537ee2af2e3d758d50f72106467c6eea50371dd528d57eb2b856d238",
16,
),
str_to_fr(
"0x07f9d837cb17b0d36320ffe93ba52345f1b728571a568265caac97559dbc952a",
16,
),
str_to_fr(
"0x2b94cf5e8746b3f5c9631f4c5df32907a699c58c94b2ad4d7b5cec1639183f55",
16,
),
str_to_fr(
"0x2dee93c5a666459646ea7d22cca9e1bcfed71e6951b953611d11dda32ea09d78",
16,
),
str_to_fr(
"0x078295e5a22b84e982cf601eb639597b8b0515a88cb5ac7fa8a4aabe3c87349d",
16,
),
str_to_fr(
"0x2fa5e5f18f6027a6501bec864564472a616b2e274a41211a444cbe3a99f3cc61",
16,
),
str_to_fr(
"0x0e884376d0d8fd21ecb780389e941f66e45e7acce3e228ab3e2156a614fcd747",
16,
),
str_to_fr(
"0x1b7201da72494f1e28717ad1a52eb469f95892f957713533de6175e5da190af2",
16,
),
str_to_fr(
"0x1f8d8822725e36385200c0b201249819a6e6e1e4650808b5bebc6bface7d7636",
16,
),
str_to_fr(
"0x2c5d82f66c914bafb9701589ba8cfcfb6162b0a12acf88a8d0879a0471b5f85a",
16,
),
str_to_fr(
"0x14c54148a0940bb820957f5adf3fa1134ef5c4aaa113f4646458f270e0bfbfd0",
16,
),
str_to_fr(
"0x190d33b12f986f961e10c0ee44d8b9af11be25588cad89d416118e4bf4ebe80c",
16,
),
str_to_fr(
"0x22f98aa9ce704152ac17354914ad73ed1167ae6596af510aa5b3649325e06c92",
16,
),
str_to_fr(
"0x2a7c7c9b6ce5880b9f6f228d72bf6a575a526f29c66ecceef8b753d38bba7323",
16,
),
str_to_fr(
"0x2e8186e558698ec1c67af9c14d463ffc470043c9c2988b954d75dd643f36b992",
16,
),
str_to_fr(
"0x0f57c5571e9a4eab49e2c8cf050dae948aef6ead647392273546249d1c1ff10f",
16,
),
str_to_fr(
"0x1830ee67b5fb554ad5f63d4388800e1cfe78e310697d46e43c9ce36134f72cca",
16,
),
];
let expected_identity_path_index: Vec<u8> =
vec![1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
assert_eq!(path_elements, expected_path_elements);
assert_eq!(identity_path_index, expected_identity_path_index);
// We check correct verification of the proof
assert!(mt.verify(&id_commitment, &merkle_proof));
Ok(())
}
#[test]
fn poseidon_sled() -> PmtreeResult<()> {
let mut mt = MerkleTree::<MySled, PoseidonHash>::new(
TEST_TREE_HEIGHT,
SledConfig {
path: String::from("abacaba"),
},
)?;
let leaf_index = 3;
let identity_secret = hash_to_field(b"test-merkle-proof");
let id_commitment = poseidon_hash(&[identity_secret]);
// let default_leaf = Fr::from(0);
mt.set(leaf_index, id_commitment).unwrap();
// We check correct computation of the root
let root = mt.root();
assert_eq!(
root,
str_to_fr(
"0x21947ffd0bce0c385f876e7c97d6a42eec5b1fe935aab2f01c1f8a8cbcc356d2",
16
)
);
let merkle_proof = mt.proof(leaf_index).expect("proof should exist");
let path_elements = merkle_proof.get_path_elements();
let identity_path_index = merkle_proof.get_path_index();
// We check correct computation of the path and indexes
// These values refers to TEST_TREE_HEIGHT == 16
let expected_path_elements = vec![
str_to_fr(
"0x0000000000000000000000000000000000000000000000000000000000000000",
16,
),
str_to_fr(
"0x2098f5fb9e239eab3ceac3f27b81e481dc3124d55ffed523a839ee8446b64864",
16,
),
str_to_fr(
"0x1069673dcdb12263df301a6ff584a7ec261a44cb9dc68df067a4774460b1f1e1",
16,
),
str_to_fr(
"0x18f43331537ee2af2e3d758d50f72106467c6eea50371dd528d57eb2b856d238",
16,
),
str_to_fr(
"0x07f9d837cb17b0d36320ffe93ba52345f1b728571a568265caac97559dbc952a",
16,
),
str_to_fr(
"0x2b94cf5e8746b3f5c9631f4c5df32907a699c58c94b2ad4d7b5cec1639183f55",
16,
),
str_to_fr(
"0x2dee93c5a666459646ea7d22cca9e1bcfed71e6951b953611d11dda32ea09d78",
16,
),
str_to_fr(
"0x078295e5a22b84e982cf601eb639597b8b0515a88cb5ac7fa8a4aabe3c87349d",
16,
),
str_to_fr(
"0x2fa5e5f18f6027a6501bec864564472a616b2e274a41211a444cbe3a99f3cc61",
16,
),
str_to_fr(
"0x0e884376d0d8fd21ecb780389e941f66e45e7acce3e228ab3e2156a614fcd747",
16,
),
str_to_fr(
"0x1b7201da72494f1e28717ad1a52eb469f95892f957713533de6175e5da190af2",
16,
),
str_to_fr(
"0x1f8d8822725e36385200c0b201249819a6e6e1e4650808b5bebc6bface7d7636",
16,
),
str_to_fr(
"0x2c5d82f66c914bafb9701589ba8cfcfb6162b0a12acf88a8d0879a0471b5f85a",
16,
),
str_to_fr(
"0x14c54148a0940bb820957f5adf3fa1134ef5c4aaa113f4646458f270e0bfbfd0",
16,
),
str_to_fr(
"0x190d33b12f986f961e10c0ee44d8b9af11be25588cad89d416118e4bf4ebe80c",
16,
),
str_to_fr(
"0x22f98aa9ce704152ac17354914ad73ed1167ae6596af510aa5b3649325e06c92",
16,
),
str_to_fr(
"0x2a7c7c9b6ce5880b9f6f228d72bf6a575a526f29c66ecceef8b753d38bba7323",
16,
),
str_to_fr(
"0x2e8186e558698ec1c67af9c14d463ffc470043c9c2988b954d75dd643f36b992",
16,
),
str_to_fr(
"0x0f57c5571e9a4eab49e2c8cf050dae948aef6ead647392273546249d1c1ff10f",
16,
),
str_to_fr(
"0x1830ee67b5fb554ad5f63d4388800e1cfe78e310697d46e43c9ce36134f72cca",
16,
),
];
let expected_identity_path_index: Vec<u8> =
vec![1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
assert_eq!(path_elements, expected_path_elements);
assert_eq!(identity_path_index, expected_identity_path_index);
// We check correct verification of the proof
assert!(mt.verify(&id_commitment, &merkle_proof));
fs::remove_dir_all("abacaba").expect("Error removing db");
Ok(())
}

214
tests/sled_keccak.rs
View File

@ -1,214 +0,0 @@
use hex_literal::hex;
use pmtree::*;
use std::collections::HashMap;
use std::fs;
use tiny_keccak::{Hasher as _, Keccak};
struct MyKeccak(Keccak);
struct MySled(sled::Db);
#[derive(Default)]
struct SledConfig {
path: String,
}
impl Database for MySled {
type Config = SledConfig;
fn new(db_config: SledConfig) -> PmtreeResult<Self> {
let db = sled::open(db_config.path).unwrap();
if db.was_recovered() {
return Err(PmtreeErrorKind::DatabaseError(
DatabaseErrorKind::DatabaseExists,
));
}
Ok(MySled(db))
}
fn load(db_config: SledConfig) -> PmtreeResult<Self> {
let db = sled::open(&db_config.path).unwrap();
if !db.was_recovered() {
fs::remove_dir_all(&db_config.path).expect("Error removing db");
return Err(PmtreeErrorKind::DatabaseError(
DatabaseErrorKind::CannotLoadDatabase,
));
}
Ok(MySled(db))
}
fn get(&self, key: DBKey) -> PmtreeResult<Option<Value>> {
Ok(self.0.get(key).unwrap().map(|val| val.to_vec()))
}
fn put(&mut self, key: DBKey, value: Value) -> PmtreeResult<()> {
self.0.insert(key, value).unwrap();
self.0.flush().unwrap();
Ok(())
}
fn put_batch(&mut self, subtree: HashMap<DBKey, Value>) -> PmtreeResult<()> {
let mut batch = sled::Batch::default();
for (key, value) in subtree {
batch.insert(&key, value);
}
self.0.apply_batch(batch).unwrap();
Ok(())
}
fn close(&mut self) -> PmtreeResult<()> {
self.0.close().map_err(|_| {
PmtreeErrorKind::DatabaseError(DatabaseErrorKind::CustomError(
String::from("Error closing database"),
))
})
}
fn flush(&mut self) -> PmtreeResult<()> {
self.0.flush().map_err(|_| {
PmtreeErrorKind::DatabaseError(DatabaseErrorKind::CustomError(
String::from("Error flushing database"),
))
})
}
}
impl Hasher for MyKeccak {
type Fr = [u8; 32];
fn default_leaf() -> Self::Fr {
[0; 32]
}
fn serialize(value: Self::Fr) -> Value {
value.to_vec()
}
fn deserialize(value: Value) -> Self::Fr {
value.to_vec().try_into().unwrap()
}
fn hash(input: &[Self::Fr]) -> Self::Fr {
let mut output = [0; 32];
let mut hasher = Keccak::v256();
for element in input {
hasher.update(element);
}
hasher.finalize(&mut output);
output
}
}
#[test]
fn insert_delete() -> PmtreeResult<()> {
let mut mt = MerkleTree::<MySled, MyKeccak>::new(
2,
SledConfig {
path: String::from("abacabas"),
},
)?;
assert_eq!(mt.capacity(), 4);
assert_eq!(mt.depth(), 2);
let leaves = [
hex!("0000000000000000000000000000000000000000000000000000000000000001"),
hex!("0000000000000000000000000000000000000000000000000000000000000002"),
hex!("0000000000000000000000000000000000000000000000000000000000000003"),
hex!("0000000000000000000000000000000000000000000000000000000000000004"),
];
let default_tree_root =
hex!("b4c11951957c6f8f642c4af61cd6b24640fec6dc7fc607ee8206a99e92410d30");
assert_eq!(mt.root(), default_tree_root);
let roots = [
hex!("c1ba1812ff680ce84c1d5b4f1087eeb08147a4d510f3496b2849df3a73f5af95"),
hex!("893760ec5b5bee236f29e85aef64f17139c3c1b7ff24ce64eb6315fca0f2485b"),
hex!("222ff5e0b5877792c2bc1670e2ccd0c2c97cd7bb1672a57d598db05092d3d72c"),
hex!("a9bb8c3f1f12e9aa903a50c47f314b57610a3ab32f2d463293f58836def38d36"),
];
for i in 0..leaves.len() {
mt.update_next(leaves[i])?;
assert_eq!(mt.root(), roots[i]);
}
for (i, &leaf) in leaves.iter().enumerate() {
assert!(mt.verify(&leaf, &mt.proof(i)?));
}
for i in (0..leaves.len()).rev() {
mt.delete(i)?;
}
assert_eq!(mt.root(), default_tree_root);
assert!(mt.update_next(leaves[0]).is_err());
fs::remove_dir_all("abacabas").expect("Error removing db");
Ok(())
}
#[test]
fn batch_insertions() -> PmtreeResult<()> {
let mut mt = MerkleTree::<MySled, MyKeccak>::new(
2,
SledConfig {
path: String::from("abacabasa"),
},
)?;
let leaves = [
hex!("0000000000000000000000000000000000000000000000000000000000000001"),
hex!("0000000000000000000000000000000000000000000000000000000000000002"),
hex!("0000000000000000000000000000000000000000000000000000000000000003"),
hex!("0000000000000000000000000000000000000000000000000000000000000004"),
];
mt.batch_insert(None, &leaves)?;
assert_eq!(
mt.root(),
hex!("a9bb8c3f1f12e9aa903a50c47f314b57610a3ab32f2d463293f58836def38d36")
);
fs::remove_dir_all("abacabasa").expect("Error removing db");
Ok(())
}
#[test]
fn set_range() -> PmtreeResult<()> {
let mut mt = MerkleTree::<MySled, MyKeccak>::new(
2,
SledConfig {
path: String::from("abacabasab"),
},
)?;
let leaves = [
hex!("0000000000000000000000000000000000000000000000000000000000000001"),
hex!("0000000000000000000000000000000000000000000000000000000000000002"),
];
mt.set_range(2, leaves)?;
assert_eq!(
mt.root(),
hex!("1e9f6c8d3fd5b7ae3a29792adb094c6d4cc6149d0c81c8c8e57cf06c161a92b8")
);
fs::remove_dir_all("abacabasab").expect("Error removing db");
Ok(())
}