citahub / cita_trie Goto Github PK

use cita_trie::codec::RLPNodeCodec;
use cita_trie::db::MemoryDB;
use cita_trie::trie::{PatriciaTrie, Trie};
use hex::FromHex;

use ethereum_types::*;
use keccak_hasher::KeccakHasher;
use kvdb::DBValue;
use memorydb;
use patricia_trie::{TrieFactory, TrieSpec};
use patricia_trie_ethereum::RlpCodec;

fn cita_empty_trie_root() {
    let mut memdb = MemoryDB::new();
    let mut trie = PatriciaTrie::new(&mut memdb, RLPNodeCodec::default());
    println!("{:?}", hex::encode(trie.root().unwrap()));
}

fn parity_empty_trie_root() {
    let factory = TrieFactory::<_, RlpCodec>::new(TrieSpec::Generic);
    let mut memdb = memorydb::MemoryDB::<KeccakHasher, DBValue>::new();
    let mut root = H256::default();
    let mut t = factory.create(&mut memdb, &mut root);
    println!("{:?}", t.root());
}

fn main() {
    cita_empty_trie_root();
    parity_empty_trie_root();
}

fn main() {
    let root1 = {
        let mut db = cita_trie::db::MemoryDB::new();
        let mut trie = cita_trie::trie::PatriciaTrie::new(&mut db, cita_trie::codec::RLPNodeCodec::default());
        trie.insert(b"a", b"a").unwrap();
        trie.root().unwrap()
    };

    let root2 = {
        let mut db = cita_trie::db::MemoryDB::new();
        let mut trie = cita_trie::trie::PatriciaTrie::new(&mut db, cita_trie::codec::RLPNodeCodec::default());
        trie.insert(b"a", b"a").unwrap();
        trie.insert(b"b", b"b").unwrap();
        trie.root().unwrap();
        trie.remove(b"b").unwrap();
        trie.root().unwrap()
    };

    let root3 = {
        let mut db = cita_trie::db::MemoryDB::new();
        let mut t1 = cita_trie::trie::PatriciaTrie::new(&mut db, cita_trie::codec::RLPNodeCodec::default());
        t1.insert(b"a", b"a").unwrap();
        t1.insert(b"b", b"b").unwrap();
        let root = t1.root().unwrap();
        let mut t2 = cita_trie::trie::PatriciaTrie::from(&mut db, cita_trie::codec::RLPNodeCodec::default(), &root).unwrap();
        t2.remove(b"b").unwrap();
        t2.root().unwrap()
    };

    println!("{:?}", hex::encode(root1)); // "668aee9307d4b41714f33b61fd7e0704d31b95e42169292ba56af48929079580"
    println!("{:?}", hex::encode(root2)); // "668aee9307d4b41714f33b61fd7e0704d31b95e42169292ba56af48929079580"
    println!("{:?}", hex::encode(root3)); // "f3313809b6501771b8a698b8c70979f3f8340b4f7e90dc5db96caf81cf5a25e0"
}

    #[test]
    fn test_insert_and_revert() {
        // Arrange
        let db = Arc::new(MemoryDB::new(true));
        let mut trie = PatriciaTrie::new(db.clone(), Arc::new(HasherKeccak::new()));
        let root_0 = trie.commit().unwrap();

        // Insert "do"
        let root_1 = {
            trie.insert(b"do".to_vec(), b"verb".to_vec()).unwrap();
            trie.root().unwrap()
        };

        // Insert "doge"
        let root_2 = {
            trie.insert(b"doge".to_vec(), b"coin".to_vec()).unwrap();
            trie.root().unwrap()
        };

        // Insert "dog"
        {
            trie.insert(b"dog".to_vec(), b"puppy".to_vec()).unwrap();
            trie.root().unwrap()
        };

        // Remove "dog"
        {
            trie.remove(b"dog").unwrap();
            // It fails here, the root hash does not match the expected one
            assert_eq!(root_2, trie.root().unwrap());
        }

        // Remove "doge"
        {
            trie.remove(b"doge").unwrap();
            assert_eq!(root_1, trie.root().unwrap());
        }

        // Remove "do"
        {
            trie.remove(b"do").unwrap();
            // Now the trie is empty but the hash is not the one of an empty trie
            assert_eq!(root_0, trie.root().unwrap());
        }

    }

pub fn from(db: &'db mut D, codec: C, root: &C::Hash) -> TrieResult<Self, C, D> {
        Ok(PatriciaTrie {
            root: Node::Hash(HashNode::new(root.as_ref())),
            db,
            codec,

            cache: HashMap::new(),
            deleted_keys: vec![],
        })
    }

        let mut memdb = MemoryDB::new();
        let mut trie = PatriciaTrie::new(&mut memdb, RLPNodeCodec::default());
        for i in 0..10 {
            trie.insert(format!("test{}", i).as_bytes(), b"testvalue");
            trie.commit();
        }
        for i in 0..10 {
            trie.remove(format!("test{}", i).as_bytes());
            trie.commit();
        }
        println!("clear all:trie.root={:?}", trie.root);
        println!("clear all:{:?}", trie.db);