Struct clacc::Update

source ·

pub struct Update<T: BigInt> { /* private fields */ }

Expand description

A sum of updates to be applied to witnesses.

Implementations§

source §

impl<'u, T: 'u + BigInt> Update<T>

source

pub fn new(acc: &Accumulator<T>) -> Self

Create a new batched update.

source

pub fn from_products(acc: &Accumulator<T>, pi_a: &T, pi_d: &T) -> Self

Create a new batched update from products.

source

pub fn add(&mut self, x: &T)

Absorb an element that must be added to a witness.

source

pub fn del(&mut self, x: &T)

Absorb an element that must be deleted from a witness.

source

pub fn get_add(&self) -> T

Return the update’s product of additions.

source

pub fn get_del(&self) -> T

Return the update’s product of deletions.

source

pub fn update_witness(&self, x: &T, w: &T) -> T

Update a witness. The update will include all additions and deletions previously absorbed into this update struct.

use clacc::{
    Accumulator,
    Update,
};
use num_bigint::BigInt;
// In this example, the update will include a deletion, so the
// accumulator must be created with a private key.
let n = vec![0x0c, 0xa1];
let d = vec![0x0c, 0x30];
let mut acc = Accumulator::<BigInt>::with_private_key(
    &<BigInt as clacc::BigInt>::from_bytes_be(n.as_slice()),
    &<BigInt as clacc::BigInt>::from_bytes_be(d.as_slice()),
);
// Create the static elements.
let xs = <BigInt as clacc::BigInt>::from_i64(5);
// Create the deletion.
let xd = <BigInt as clacc::BigInt>::from_i64(7);
// Create the addition.
let xa = <BigInt as clacc::BigInt>::from_i64(11);
// Add the deletion element.
acc.add(&xd);
// Add the static element to the accumulator.
let mut wxs = acc.add(&xs);
// Delete the deletion element from the accumulator.
acc.prove(&xd).unwrap();
acc.del(&xd).unwrap();
// Add the addition element to the accumulator.
acc.add(&xa);
// Create an update object and absorb the addition and deletion.
let mut u = Update::new(&acc);
u.del(&xd);
u.add(&xa);
// Update the static element's witness.
wxs = u.update_witness(&xs, &wxs);
assert!(acc.verify(&xs, &wxs).is_ok());

source

pub fn update_witnesses<IA: Iterator<Item = &'u mut (T, T)> + Send, IS: Iterator<Item = &'u mut (T, T)> + Send>( &self, additions: Arc<Mutex<IA>>, staticels: Arc<Mutex<IS>> )

Thread-safe method that updates multiple witnesses.

It is assumed that the additional elements have been absorbed by the update and that their witnesses are the accumulator’s value before any of the additions or deletions absorbed by this update were applied. Updating the witnesses for each of these additional elements is thus achieved by simply removing its respective element from the update and applying the result to its witness.

This method operates on atomic references to iterators over collections of element-witness pairs. An invocation will run until the referenced iterators have reached the end of their collections. To update witnesses concurrently, simply invoke this method from multiple threads using references to the same iterators.

use clacc::{
    Accumulator,
    BigInt as BigIntTrait,
    Update,
};
use crossbeam::thread;
use num_cpus;
use num_bigint::{BigInt, ToBigInt};
use num_prime::nt_funcs::next_prime;
use rand::RngCore;
use std::sync::{Arc, Mutex};
// Create elements.
const BUCKET_SIZE: usize = 20;
const DELETIONS_COUNT: usize = 2;
const ADDITIONS_COUNT: usize = 10;
const STATICELS_COUNT: usize = BUCKET_SIZE - DELETIONS_COUNT;
let mut deletions: Vec<(BigInt, BigInt)> = vec![
    Default::default(); DELETIONS_COUNT
];
let mut additions: Vec<(BigInt, BigInt)> = vec![
    Default::default(); ADDITIONS_COUNT
];
let mut staticels: Vec<(BigInt, BigInt)> = vec![
    Default::default(); STATICELS_COUNT
];
let mut rng = rand::thread_rng();
let mut bytes = vec![0; 8];
for deletion in deletions.iter_mut() {
    rng.fill_bytes(&mut bytes);
    let x = <BigInt as clacc::BigInt>::from_bytes_be(bytes.as_slice());
    deletion.0 = next_prime(
        &x.to_biguint().unwrap(),
        None,
    ).unwrap().to_bigint().unwrap();
}
for addition in additions.iter_mut() {
    rng.fill_bytes(&mut bytes);
    let x = <BigInt as clacc::BigInt>::from_bytes_be(bytes.as_slice());
    addition.0 = next_prime(
        &x.to_biguint().unwrap(),
        None,
    ).unwrap().to_bigint().unwrap();
}
for staticel in staticels.iter_mut() {
    rng.fill_bytes(&mut bytes);
    let x = <BigInt as clacc::BigInt>::from_bytes_be(bytes.as_slice());
    staticel.0 = next_prime(
        &x.to_biguint().unwrap(),
        None,
    ).unwrap().to_bigint().unwrap();
}
// Create accumulator with private key.
let n = vec![0x0c, 0xa1];
let d = vec![0x0c, 0x30];
let mut acc = Accumulator::<BigInt>::with_private_key(
    &<BigInt as clacc::BigInt>::from_bytes_be(n.as_slice()),
    &<BigInt as clacc::BigInt>::from_bytes_be(d.as_slice()),
);
// Accumulate elements.
for (x, _) in deletions.iter() {
    acc.add(&x);
}
for (x, _) in staticels.iter() {
    acc.add(&x);
}
// Generate witnesses for static elements.
for (x, w) in staticels.iter_mut() {
    *w = acc.prove(&x).unwrap()
}
// Save accumulation at current state.
let prev = acc.clone();
// Accumulate deletions.
for (x, w) in deletions.iter_mut() {
    *w = acc.prove(&x).unwrap();
    acc.del(&x).unwrap();
}
// Accumulate additions.
for (x, w) in additions.iter_mut() {
    acc.add(&x);
    // Use the saved accumulation as the witness value.
    *w = prev.get_value();
}
// Batch updates.
let mut update = Update::new(&acc);
for (x, _) in deletions.iter() {
    update.del(&x);
}
for (x, _) in additions.iter() {
    update.add(&x);
}
// Update all witnesses concurrently.
let additions_iter = Arc::new(Mutex::new(additions.iter_mut()));
let staticels_iter = Arc::new(Mutex::new(staticels.iter_mut()));
thread::scope(|scope| {
    for _ in 0..num_cpus::get() {
        let u = update.clone();
        let add = additions_iter.clone();
        let sta = staticels_iter.clone();
        scope.spawn(move |_| u.update_witnesses(add, sta));
    }
}).unwrap();
// Verify all updated witnesses.
for (x, w) in additions.iter() {
    assert!(acc.verify(&x, &w).is_ok());
}
for (x, w) in staticels.iter() {
    assert!(acc.verify(&x, &w).is_ok());
}