Change all instances of Accumulator to Aggragate

Author: rustaceanrob

README.md

@@ -10,5 +10,5 @@ See the `node/README.md` to run an initial block download using _SwiftSync_.
 
 ## Crates
 
-- `accumulator`: A hash-based SwiftSync accumulator used to add and subtrack elements from a set.
+- `aggregate`: A hash-based data structure used to add and subtrack elements from a set.
 - `node`: Perform fast IBD using a SwiftSync hints file.

aggregate/src/lib.rs

@@ -11,7 +11,7 @@ sha256t_tag! {
 /// added and removed the equivalent amount of times, the accumulator is zero. In the context of
 /// bitcoin, this is used to add and remove hashes of [`OutPoint`] data.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, std::hash::Hash)]
-pub struct Accumulator {
+pub struct Aggregate {
     high: u128,
     low: u128,
 }
@@ -36,14 +36,14 @@ fn split_in_half(a: [u8; 32]) -> ([u8; 16], [u8; 16]) {
 
 /// Update an accumulator by adding or spending a pre-hashed outpoint
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum AccumulatorUpdate {
+pub enum AggregateUpdate {
     Add([u8; 32]),
     Spent([u8; 32]),
 }
 
-impl Accumulator {
+impl Aggregate {
     /// The zero accumulator
-    pub const ZERO: Accumulator = Accumulator { high: 0, low: 0 };
+    pub const ZERO: Aggregate = Aggregate { high: 0, low: 0 };
 
     /// Build a new accumulator.
     pub const fn new() -> Self {
@@ -66,10 +66,10 @@ impl Accumulator {
     }
 
     /// Update the accumulator
-    pub fn update(&mut self, update: AccumulatorUpdate) {
+    pub fn update(&mut self, update: AggregateUpdate) {
         match update {
-            AccumulatorUpdate::Add(added) => self.add_hashed_outpoint(added),
-            AccumulatorUpdate::Spent(spent) => self.spend_hashed_outpoint(spent),
+            AggregateUpdate::Add(added) => self.add_hashed_outpoint(added),
+            AggregateUpdate::Spent(spent) => self.spend_hashed_outpoint(spent),
         }
     }
 
@@ -101,7 +101,7 @@ impl Accumulator {
     }
 }
 
-impl Default for Accumulator {
+impl Default for Aggregate {
     fn default() -> Self {
         Self::ZERO
     }
@@ -218,7 +218,7 @@ mod tests {
 
     #[test]
     fn test_accumulator_is_zero() {
-        let mut acc = Accumulator::default();
+        let mut acc = Aggregate::default();
         let [outpoint_one, outpoint_two, outpoint_three, outpoint_four, outpoint_five] =
             make_five_outpoint();
         // Add the members
@@ -241,10 +241,10 @@ mod tests {
     fn test_same_state() {
         let [outpoint_one, outpoint_two, outpoint_three, outpoint_four, outpoint_five] =
             make_five_outpoint();
-        let mut acc_ref = Accumulator::default();
+        let mut acc_ref = Aggregate::default();
         acc_ref.add(outpoint_two);
         acc_ref.add(outpoint_four);
-        let mut acc_cmp = Accumulator::default();
+        let mut acc_cmp = Aggregate::default();
         acc_cmp.add(outpoint_one);
         acc_cmp.add(outpoint_two);
         acc_cmp.add(outpoint_three);
@@ -266,7 +266,7 @@ mod tests {
         let hash_three = hash_outpoint(outpoint_three);
         let hash_four = hash_outpoint(outpoint_four);
         let hash_five = hash_outpoint(outpoint_five);
-        let mut acc = Accumulator::default();
+        let mut acc = Aggregate::default();
         acc.add_hashed_outpoint(hash_five);
         acc.add_hashed_outpoint(hash_four);
         acc.add_hashed_outpoint(hash_one);
@@ -288,17 +288,17 @@ mod tests {
         let hash_three = hash_outpoint(outpoint_three);
         let hash_four = hash_outpoint(outpoint_four);
         let hash_five = hash_outpoint(outpoint_five);
-        let mut acc = Accumulator::default();
-        acc.update(AccumulatorUpdate::Add(hash_one));
-        acc.update(AccumulatorUpdate::Add(hash_two));
-        acc.update(AccumulatorUpdate::Add(hash_three));
-        acc.update(AccumulatorUpdate::Add(hash_four));
-        acc.update(AccumulatorUpdate::Add(hash_five));
-        acc.update(AccumulatorUpdate::Spent(hash_five));
-        acc.update(AccumulatorUpdate::Spent(hash_four));
-        acc.update(AccumulatorUpdate::Spent(hash_three));
-        acc.update(AccumulatorUpdate::Spent(hash_two));
-        acc.update(AccumulatorUpdate::Spent(hash_one));
+        let mut acc = Aggregate::default();
+        acc.update(AggregateUpdate::Add(hash_one));
+        acc.update(AggregateUpdate::Add(hash_two));
+        acc.update(AggregateUpdate::Add(hash_three));
+        acc.update(AggregateUpdate::Add(hash_four));
+        acc.update(AggregateUpdate::Add(hash_five));
+        acc.update(AggregateUpdate::Spent(hash_five));
+        acc.update(AggregateUpdate::Spent(hash_four));
+        acc.update(AggregateUpdate::Spent(hash_three));
+        acc.update(AggregateUpdate::Spent(hash_two));
+        acc.update(AggregateUpdate::Spent(hash_one));
         assert!(acc.is_zero());
     }
 

aggregate/tests/test.rs

@@ -1,12 +1,12 @@
-use aggregate::{Accumulator, MultAggregate};
+use aggregate::{Aggregate, MultAggregate};
 use bitcoin::{OutPoint, Txid};
 use rusqlite::Connection;
 
 const SELECT_STMT: &str = "SELECT txid, vout FROM utxos";
 
 #[test]
 fn test_static_utxo_set() {
-    let mut acc = Accumulator::new();
+    let mut acc = Aggregate::new();
     let conn = Connection::open("../contrib/data/signet_outpoints.sqlite").unwrap();
     let mut stmt = conn.prepare(SELECT_STMT).unwrap();
     let mut rows = stmt.query([]).unwrap();

node/src/bin/ibd.rs

@@ -11,7 +11,7 @@ use kernel::{ChainstateManager, ChainstateManagerOptions, ContextBuilder};
 
 use node::{
     bootstrap_dns, elapsed_time, get_blocks_for_range, hashes_from_chain, sync_block_headers,
-    AccumulatorState, ChainExt,
+    AggregateState, ChainExt,
 };
 use p2p::net::TimeoutParams;
 
@@ -77,7 +77,7 @@ fn main() {
     tracing::info!("Assume valid height: {}", chain.best_header().height());
     let (tx, rx) = channel();
     let main_routine_time = Instant::now();
-    let mut accumulator_state = AccumulatorState::new(rx);
+    let mut accumulator_state = AggregateState::new(rx);
     let acc_task = std::thread::spawn(move || accumulator_state.verify());
     let peers = Arc::new(Mutex::new(peers));
     let mut tasks = Vec::new();

node/src/lib.rs

@@ -11,7 +11,7 @@ use std::{
     time::{Duration, Instant},
 };
 
-use aggregate::{Accumulator, AccumulatorUpdate};
+use aggregate::{Aggregate, AggregateUpdate};
 use bitcoin::{
     consensus,
     key::rand::{seq::SliceRandom, thread_rng},
@@ -43,15 +43,15 @@ pub fn elapsed_time(then: Instant) {
 }
 
 #[derive(Debug)]
-pub struct AccumulatorState {
-    acc: Accumulator,
-    update_rx: Receiver<AccumulatorUpdate>,
+pub struct AggregateState {
+    acc: Aggregate,
+    update_rx: Receiver<AggregateUpdate>,
 }
 
-impl AccumulatorState {
-    pub fn new(rx: Receiver<AccumulatorUpdate>) -> Self {
+impl AggregateState {
+    pub fn new(rx: Receiver<AggregateUpdate>) -> Self {
         Self {
-            acc: Accumulator::new(),
+            acc: Aggregate::new(),
             update_rx: rx,
         }
     }
@@ -179,7 +179,7 @@ pub fn get_blocks_for_range(
     chain: Arc<ChainstateManager>,
     hints: Arc<Mutex<Hintsfile>>,
     peers: Arc<Mutex<Vec<SocketAddr>>>,
-    updater: Sender<AccumulatorUpdate>,
+    updater: Sender<AggregateUpdate>,
     hashes: Arc<Mutex<Vec<Vec<BlockHash>>>>,
 ) {
     let mut batch = Vec::new();
@@ -265,7 +265,7 @@ pub fn get_blocks_for_range(
                         if !transaction.is_coinbase() {
                             for input in transaction.inputs {
                                 let input_hash = aggregate::hash_outpoint(input.previous_output);
-                                let update = AccumulatorUpdate::Spent(input_hash);
+                                let update = AggregateUpdate::Spent(input_hash);
                                 updater
                                     .send(update)
                                     .expect("accumulator task must not panic");
@@ -283,7 +283,7 @@ pub fn get_blocks_for_range(
                                     vout: vout as u32,
                                 };
                                 let input_hash = aggregate::hash_outpoint(outpoint);
-                                let update = AccumulatorUpdate::Add(input_hash);
+                                let update = AggregateUpdate::Add(input_hash);
                                 updater
                                     .send(update)
                                     .expect("accumulator task must not panic");