LSMTree

A Rust library that implements a Sparse Merkle tree for a key-value map. The tree implements the same optimisations specified in the [Libra whitepaper][libra whitepaper], to reduce the number of hash operations required per tree operation to O(k) where k is the number of non-empty elements in the tree. [

][Github-url] [

][CI-url] [

][codecov-url] [

][doc-url] [

][crates-url] [

][rustc-url] [

][license-apache-url] [

][license-mit-url] English | [简体中文][zh-cn-url]

Installation

toml [dependencies] lsmtree = "0.0.3"

Example

```rust use lsmtree::{SparseMerkleTree, KVStore, bytes::Bytes, BadProof}; use parking_lot::Mutex; use std::{collections::HashMap, sync::Arc}; use sha2::Sha256;

[derive(Debug)]

pub enum Error { NotFound, BadProof(BadProof), }

impl From for Error { fn from(e: BadProof) -> Self { Error::BadProof(e) } }

impl core::fmt::Display for Error { fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { write!(f, "Error") } }

impl std::error::Error for Error {}

[derive(Debug, Clone, Default)]

pub struct SimpleStore { data: Arc>>, }

impl SimpleStore { pub fn new() -> Self { Self { data: Arc::new(Mutex::new(HashMap::new())), } } }

impl KVStore for SimpleStore { type Error = Error; type Hasher = Sha256;

fn get(&self, key: &[u8]) -> Result<Option<Bytes>, Self::Error> {
    let data = self.data.lock();
    Ok(data.get(key).map(core::clone::Clone::clone))
}

fn set(&self, key: Bytes, value: Bytes) -> Result<(), Self::Error> {
    let mut data = self.data.lock();
    data.insert(key, value);
    Ok(())
}

fn remove(&self, key: &[u8]) -> Result<Bytes, Self::Error> {
    let mut data = self.data.lock();
    data.remove(key).ok_or(Error::NotFound)
}

fn contains(&self, key: &[u8]) -> Result<bool, Self::Error> {
    Ok(self.data.lock().contains_key(key))
}

}

fn main() { let mut smt = SparseMerkleTree::::new();

// insert
smt.update(b"key1", Bytes::from("val1")).unwrap();

// get
assert_eq!(smt.get(b"key1").unwrap(), Some(Bytes::from("val1")));

// prove 
let proof = smt.prove(b"key1").unwrap();
assert!(proof.verify(smt.root_ref(), b"key1", b"val1"));

} ```

Acknowledge

Thanks celestiaorg's developers for providing amazing Go version smt implementation.

License

lsmtree is under the terms of both the MIT license and the Apache License (Version 2.0).

See LICENSE-APACHE, LICENSE-MIT for details.