github/darkfi
1
1
Fork 0
mirror of https://github.com/darkrenaissance/darkfi.git synced 2026-01-10 07:08:05 -05:00
Code Issues Packages Projects Releases Wiki Activity

serial: Replace incrementalmerkletree with bridgetree crate.

Browse Source
This commit is contained in:
parazyd
2023-04-19 19:18:21 +02:00
parent aec4ed8a53
commit 24b26fa6f1
4 changed files with 95 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/serial/Cargo.toml
View File

@@ -14,7 +14,7 @@ futures-lite = {version = "1.13.0", optional = true}
# Supported types for encoding
blake3 = {version = "1.3.3", optional = true}
incrementalmerkletree = {version = "0.3.1", optional = true}
bridgetree = {version = "0.2.0", optional = true}
pasta_curves = {version = "0.5.1", optional = true}
url = {version = "2.4.0", optional = true}
@@ -24,5 +24,5 @@ derive = ["darkfi-derive"]
async = ["futures-lite"]
collections = []
crypto = ["collections", "hash", "incrementalmerkletree", "pasta_curves"]
crypto = ["collections", "hash", "bridgetree", "pasta_curves"]
hash = ["blake3"]

29
src/serial/src/lib.rs
View File

@@ -16,7 +16,10 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
use std::io::{Cursor, Error, ErrorKind, Read, Write};
use std::{
collections::VecDeque,
io::{Cursor, Error, ErrorKind, Read, Write},
};
#[cfg(feature = "derive")]
pub use darkfi_derive::{SerialDecodable, SerialEncodable};
@@ -467,6 +470,30 @@ impl<T: Decodable> Decodable for Vec<T> {
}
}
impl<T: Encodable> Encodable for VecDeque<T> {
#[inline]
fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
let mut len = 0;
len += VarInt(self.len() as u64).encode(&mut s)?;
for val in self {
len += val.encode(&mut s)?;
}
Ok(len)
}
}
impl<T: Decodable> Decodable for VecDeque<T> {
#[inline]
fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
let len = VarInt::decode(&mut d)?.0;
let mut ret = VecDeque::with_capacity(len as usize);
for _ in 0..len {
ret.push_back(Decodable::decode(&mut d)?);
}
Ok(ret)
}
}
impl<T: Encodable> Encodable for Option<T> {
fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
let mut len = 0;

4
src/serial/src/types.rs
View File

@@ -24,8 +24,8 @@ mod collections;
#[cfg(feature = "hash")]
mod hash;
#[cfg(feature = "incrementalmerkletree")]
mod incrementalmerkletree;
#[cfg(feature = "bridgetree")]
mod bridgetree;
#[cfg(feature = "pasta_curves")]
mod pasta;

167
src/serial/src/types/incrementalmerkletree.rs → src/serial/src/types/bridgetree.rs
View File

@@ -16,88 +16,42 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
use core::fmt::Debug;
use std::io::{Error, ErrorKind, Read, Write};
use incrementalmerkletree::Hashable;
use crate::{Decodable, Encodable};
impl Encodable for incrementalmerkletree::Position {
impl Encodable for bridgetree::Position {
fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
u64::from(*self).encode(&mut s)
}
}
impl Decodable for incrementalmerkletree::Position {
impl Decodable for bridgetree::Position {
fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
let dec: u64 = Decodable::decode(&mut d)?;
Ok(Self::try_from(dec).unwrap())
}
}
impl<T: Encodable + Ord> Encodable for incrementalmerkletree::bridgetree::Leaf<T> {
impl Encodable for bridgetree::Address {
fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
let mut len = 0;
match self {
incrementalmerkletree::bridgetree::Leaf::Left(a) => {
len += false.encode(&mut s)?;
len += a.encode(&mut s)?;
}
incrementalmerkletree::bridgetree::Leaf::Right(a, b) => {
len += true.encode(&mut s)?;
len += a.encode(&mut s)?;
len += b.encode(&mut s)?;
}
}
len += u8::from(self.level()).encode(&mut s)?;
len += self.index().encode(&mut s)?;
Ok(len)
}
}
impl<T: Decodable + Ord> Decodable for incrementalmerkletree::bridgetree::Leaf<T> {
impl Decodable for bridgetree::Address {
fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
let side: bool = Decodable::decode(&mut d)?;
match side {
false => {
let a: T = Decodable::decode(&mut d)?;
Ok(Self::Left(a))
}
true => {
let a: T = Decodable::decode(&mut d)?;
let b: T = Decodable::decode(&mut d)?;
Ok(Self::Right(a, b))
}
}
let level: u8 = Decodable::decode(&mut d)?;
let index = Decodable::decode(&mut d)?;
Ok(Self::from_parts(level.into(), index))
}
}
impl Encodable for incrementalmerkletree::bridgetree::Checkpoint {
fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
let mut len = 0;
len += self.bridges_len().encode(&mut s)?;
len += self.is_witnessed().encode(&mut s)?;
len += self.witnessed().encode(&mut s)?;
len += self.forgotten().encode(&mut s)?;
Ok(len)
}
}
impl Decodable for incrementalmerkletree::bridgetree::Checkpoint {
fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
let bridges_len = Decodable::decode(&mut d)?;
let is_witnessed = Decodable::decode(&mut d)?;
let witnessed = Decodable::decode(&mut d)?;
let forgotten = Decodable::decode(&mut d)?;
Ok(Self::from_parts(bridges_len, is_witnessed, witnessed, forgotten))
}
}
impl<T: Encodable + Ord + Clone> Encodable
for incrementalmerkletree::bridgetree::NonEmptyFrontier<T>
{
impl<H: Encodable + Ord + Clone> Encodable for bridgetree::NonEmptyFrontier<H> {
fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
let mut len = 0;
len += self.position().encode(&mut s)?;
@@ -107,9 +61,7 @@ impl<T: Encodable + Ord + Clone> Encodable
}
}
impl<T: Decodable + Ord + Clone> Decodable
for incrementalmerkletree::bridgetree::NonEmptyFrontier<T>
{
impl<H: Decodable + Ord + Clone> Decodable for bridgetree::NonEmptyFrontier<H> {
fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
let position = Decodable::decode(&mut d)?;
let leaf = Decodable::decode(&mut d)?;
@@ -122,60 +74,67 @@ impl<T: Decodable + Ord + Clone> Decodable
}
}
impl<T: Encodable + Ord + Clone> Encodable for incrementalmerkletree::bridgetree::AuthFragment<T> {
fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
let mut len = 0;
len += self.position().encode(&mut s)?;
len += self.altitudes_observed().encode(&mut s)?;
len += self.values().to_vec().encode(&mut s)?;
Ok(len)
}
}
impl<T: Decodable + Ord + Clone> Decodable for incrementalmerkletree::bridgetree::AuthFragment<T> {
fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
let position = Decodable::decode(&mut d)?;
let altitudes_observed = Decodable::decode(&mut d)?;
let values = Decodable::decode(&mut d)?;
Ok(Self::from_parts(position, altitudes_observed, values))
}
}
impl<T: Encodable + Ord + Clone> Encodable for incrementalmerkletree::bridgetree::MerkleBridge<T> {
impl<H: Encodable + Ord + Clone> Encodable for bridgetree::MerkleBridge<H> {
fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
let mut len = 0;
len += self.prior_position().encode(&mut s)?;
len += self.auth_fragments().encode(&mut s)?;
len += self.tracking().encode(&mut s)?;
len += self.ommers().encode(&mut s)?;
len += self.frontier().encode(&mut s)?;
Ok(len)
}
}
impl<T: Decodable + Ord + Clone> Decodable for incrementalmerkletree::bridgetree::MerkleBridge<T> {
impl<H: Decodable + Ord + Clone> Decodable for bridgetree::MerkleBridge<H> {
fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
let prior_position = Decodable::decode(&mut d)?;
let auth_fragments = Decodable::decode(&mut d)?;
let tracking = Decodable::decode(&mut d)?;
let ommers = Decodable::decode(&mut d)?;
let frontier = Decodable::decode(&mut d)?;
Ok(Self::from_parts(prior_position, auth_fragments, frontier))
Ok(Self::from_parts(prior_position, tracking, ommers, frontier))
}
}
impl<T: Encodable + Ord + Clone, const V: u8> Encodable
for incrementalmerkletree::bridgetree::BridgeTree<T, V>
impl<C: Encodable> Encodable for bridgetree::Checkpoint<C> {
fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
let mut len = 0;
len += self.id().encode(&mut s)?;
len += self.bridges_len().encode(&mut s)?;
len += self.marked().encode(&mut s)?;
len += self.forgotten().encode(&mut s)?;
Ok(len)
}
}
impl<C: Decodable> Decodable for bridgetree::Checkpoint<C> {
fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
let id = Decodable::decode(&mut d)?;
let bridges_len = Decodable::decode(&mut d)?;
let marked = Decodable::decode(&mut d)?;
let forgotten = Decodable::decode(&mut d)?;
Ok(Self::from_parts(id, bridges_len, marked, forgotten))
}
}
impl<H: Encodable + Ord + Clone, C: Encodable + Debug, const DEPTH: u8> Encodable
for bridgetree::BridgeTree<H, C, DEPTH>
{
fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
let mut len = 0;
len += self.prior_bridges().to_vec().encode(&mut s)?;
len += self.current_bridge().encode(&mut s)?;
len += self.witnessed_indices().encode(&mut s)?;
len += self.checkpoints().to_vec().encode(&mut s)?;
len += self.marked_indices().encode(&mut s)?;
len += self.checkpoints().encode(&mut s)?;
len += self.max_checkpoints().encode(&mut s)?;
Ok(len)
}
}
impl<T: Decodable + Ord + Clone + Hashable, const V: u8> Decodable
for incrementalmerkletree::bridgetree::BridgeTree<T, V>
impl<
H: Decodable + Clone + Ord + bridgetree::Hashable,
C: Decodable + Clone + Ord + Eq + Debug,
const DEPTH: u8,
> Decodable for bridgetree::BridgeTree<H, C, DEPTH>
{
fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
let prior_bridges = Decodable::decode(&mut d)?;
@@ -193,7 +152,7 @@ impl<T: Decodable + Ord + Clone + Hashable, const V: u8> Decodable
#[cfg(test)]
mod tests {
use crate::{deserialize, serialize, SerialDecodable, SerialEncodable};
use incrementalmerkletree::{bridgetree::BridgeTree, Altitude, Hashable, Tree};
use bridgetree::{BridgeTree, Hashable, Level};
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, SerialEncodable, SerialDecodable)]
struct Node(String);
@@ -203,7 +162,7 @@ mod tests {
Self("_".to_string())
}
fn combine(_: Altitude, a: &Self, b: &Self) -> Self {
fn combine(_: Level, a: &Self, b: &Self) -> Self {
Self(a.0.to_string() + &b.0)
}
}
@@ -213,29 +172,29 @@ mod tests {
const DEPTH: u8 = 8;
// Fill the tree with 100 leaves
let mut tree: BridgeTree<Node, DEPTH> = BridgeTree::new(100);
let mut tree: BridgeTree<Node, usize, DEPTH> = BridgeTree::new(100);
for i in 0..100 {
tree.append(&Node(format!("test{}", i)));
tree.witness();
tree.checkpoint();
tree.append(Node(format!("test{}", i)));
tree.mark();
tree.checkpoint(i);
}
let serial_tree = serialize(&tree);
let deserial_tree: BridgeTree<Node, DEPTH> = deserialize(&serial_tree).unwrap();
let deserial_tree: BridgeTree<Node, usize, DEPTH> = deserialize(&serial_tree).unwrap();
// Empty tree
let tree2: BridgeTree<Node, DEPTH> = BridgeTree::new(100);
let tree2: BridgeTree<Node, usize, DEPTH> = BridgeTree::new(100);
let serial_tree2 = serialize(&tree2);
let deserial_tree2: BridgeTree<Node, DEPTH> = deserialize(&serial_tree2).unwrap();
let deserial_tree2: BridgeTree<Node, usize, DEPTH> = deserialize(&serial_tree2).unwrap();
// Max leaves
let mut tree3: BridgeTree<Node, DEPTH> = BridgeTree::new(100);
let mut tree3: BridgeTree<Node, usize, DEPTH> = BridgeTree::new(100);
for i in 0..2_i32.pow(DEPTH as u32) {
tree3.append(&Node(format!("test{}", i)));
tree3.witness();
tree3.checkpoint();
tree3.append(Node(format!("test{}", i)));
tree3.mark();
tree3.checkpoint(i.try_into().unwrap());
}
let serial_tree3 = serialize(&tree3);
let deserial_tree3: BridgeTree<Node, DEPTH> = deserialize(&serial_tree3).unwrap();
let deserial_tree3: BridgeTree<Node, usize, DEPTH> = deserialize(&serial_tree3).unwrap();
assert!(tree == deserial_tree);
assert!(tree2 == deserial_tree2);