refactor: use SignedReceipt in generic over Receipt

refactor: remove unused escrow handler
Signed-off-by: Gustavo Inacio <[email protected]>

Author: gusinacio

tap_aggregator/Cargo.toml

@@ -12,7 +12,7 @@ name = "tap_aggregator"
 path = "src/main.rs"
 
 [dependencies]
-tap_core = { path = "../tap_core", version = "2.0.0" }
+tap_core = { path = "../tap_core", version = "2.0.0", features = ["test"] }
 serde.workspace = true
 alloy.workspace = true
 anyhow.workspace = true

tap_aggregator/src/aggregator.rs

@@ -10,19 +10,19 @@ use alloy::{
 use anyhow::{bail, Ok, Result};
 use rayon::prelude::*;
 use tap_core::{
-    rav::ReceiptAggregateVoucher,
+    rav::{Aggregate, ReceiptAggregateVoucher},
     receipt::Receipt,
     signed_message::{EIP712SignedMessage, SignatureBytes, SignatureBytesExt},
 };
 
 pub fn check_and_aggregate_receipts(
     domain_separator: &Eip712Domain,
-    receipts: &[EIP712SignedMessage<Receipt>],
+    receipts: Vec<EIP712SignedMessage<Receipt>>,
     previous_rav: Option<EIP712SignedMessage<ReceiptAggregateVoucher>>,
     wallet: &PrivateKeySigner,
     accepted_addresses: &HashSet<Address>,
 ) -> Result<EIP712SignedMessage<ReceiptAggregateVoucher>> {
-    check_signatures_unique(receipts)?;
+    check_signatures_unique(&receipts)?;
 
     // Check that the receipts are signed by an accepted signer address
     receipts.par_iter().try_for_each(|receipt| {
@@ -39,7 +39,7 @@ pub fn check_and_aggregate_receipts(
     }
 
     // Check that the receipts timestamp is greater than the previous rav
-    check_receipt_timestamps(receipts, previous_rav.as_ref())?;
+    check_receipt_timestamps(&receipts, previous_rav.as_ref())?;
 
     // Get the allocation id from the first receipt, return error if there are no receipts
     let allocation_id = match receipts.first() {
@@ -48,7 +48,7 @@ pub fn check_and_aggregate_receipts(
     };
 
     // Check that the receipts all have the same allocation id
-    check_allocation_id(receipts, allocation_id)?;
+    check_allocation_id(&receipts, allocation_id)?;
 
     // Check that the rav has the correct allocation id
     if let Some(previous_rav) = &previous_rav {
@@ -62,8 +62,10 @@ pub fn check_and_aggregate_receipts(
         }
     }
 
+    let receipts = receipts.into_iter().map(Into::into).collect::<Vec<_>>();
+
     // Aggregate the receipts
-    let rav = ReceiptAggregateVoucher::aggregate_receipts(allocation_id, receipts, previous_rav)?;
+    let rav = ReceiptAggregateVoucher::aggregate_receipts(&receipts, previous_rav)?;
 
     // Sign the rav and return
     Ok(EIP712SignedMessage::new(domain_separator, rav, wallet)?)

tap_aggregator/src/server.rs

@@ -159,7 +159,7 @@ fn aggregate_receipts_(
     let res = match api_version {
         TapRpcApiVersion::V0_0 => check_and_aggregate_receipts(
             domain_separator,
-            &receipts,
+            receipts,
             previous_rav,
             wallet,
             accepted_addresses,
@@ -202,7 +202,7 @@ impl TapAggregator for RpcImpl {
 
         match check_and_aggregate_receipts(
             &self.domain_separator,
-            receipts.as_slice(),
+            receipts,
             previous_rav,
             &self.wallet,
             &self.accepted_addresses,
@@ -494,6 +494,8 @@ mod tests {
         #[values(0, 1, 2)] random_seed: u64,
     ) {
         // The keys that will be used to sign the new RAVs
+
+        use tap_core::rav::Aggregate;
         let keys_main = keys();
         // Extra keys to test the server's ability to accept multiple signers as input
         let keys_0 = keys();
@@ -546,9 +548,11 @@ mod tests {
 
         let remote_rav = res.data;
 
-        let local_rav =
-            ReceiptAggregateVoucher::aggregate_receipts(allocation_ids[0], &receipts, None)
-                .unwrap();
+        let local_rav = ReceiptAggregateVoucher::aggregate_receipts(
+            &receipts.into_iter().map(Into::into).collect::<Vec<_>>(),
+            None,
+        )
+        .unwrap();
 
         assert!(remote_rav.message.allocationId == local_rav.allocationId);
         assert!(remote_rav.message.timestampNs == local_rav.timestampNs);
@@ -574,6 +578,8 @@ mod tests {
         #[values(0, 1, 2, 3, 4)] random_seed: u64,
     ) {
         // The keys that will be used to sign the new RAVs
+
+        use tap_core::rav::Aggregate;
         let keys_main = keys();
         // Extra keys to test the server's ability to accept multiple signers as input
         let keys_0 = keys();
@@ -614,10 +620,10 @@ mod tests {
             );
         }
 
+        let checked_receipt = receipts.iter().cloned().map(Into::into).collect::<Vec<_>>();
         // Create previous RAV from first half of receipts locally
         let prev_rav = ReceiptAggregateVoucher::aggregate_receipts(
-            allocation_ids[0],
-            &receipts[0..receipts.len() / 2],
+            &checked_receipt[0..checked_receipt.len() / 2],
             None,
         )
         .unwrap();

tap_core/Cargo.toml

@@ -22,10 +22,12 @@ criterion = { version = "0.5", features = ["async_std"] }
 rstest.workspace = true
 insta.workspace = true
 serde_json.workspace = true
+tap_core = { path = ".", features = ["test"] }
 
 
 [features]
 default = ["in_memory"]
+test = []
 in_memory = []
 
 [[bench]]

tap_core/benches/timeline_aggretion_protocol_benchmark.rs

@@ -13,7 +13,9 @@ use std::str::FromStr;
 use alloy::{dyn_abi::Eip712Domain, primitives::Address, signers::local::PrivateKeySigner};
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use tap_core::{
-    rav::ReceiptAggregateVoucher, receipt::Receipt, signed_message::EIP712SignedMessage,
+    rav::{Aggregate, ReceiptAggregateVoucher},
+    receipt::Receipt,
+    signed_message::EIP712SignedMessage,
     tap_eip712_domain,
 };
 
@@ -66,15 +68,16 @@ pub fn criterion_benchmark(c: &mut Criterion) {
 
     for log_number_of_receipts in 10..30 {
         let receipts = (0..2 ^ log_number_of_receipts)
-            .map(|_| create_and_sign_receipt(&domain_seperator, allocation_id, value, &wallet))
+            .map(|_| {
+                create_and_sign_receipt(&domain_seperator, allocation_id, value, &wallet).into()
+            })
             .collect::<Vec<_>>();
 
         rav_group.bench_function(
             format!("Create RAV w/ 2^{} receipt's", log_number_of_receipts),
             |b| {
                 b.iter(|| {
                     ReceiptAggregateVoucher::aggregate_receipts(
-                        black_box(allocation_id),
                         black_box(&receipts),
                         black_box(None),
                     )
@@ -84,7 +87,7 @@ pub fn criterion_benchmark(c: &mut Criterion) {
 
         let signed_rav = EIP712SignedMessage::new(
             &domain_seperator,
-            ReceiptAggregateVoucher::aggregate_receipts(allocation_id, &receipts, None).unwrap(),
+            ReceiptAggregateVoucher::aggregate_receipts(&receipts, None).unwrap(),
             &wallet,
         )
         .unwrap();

tap_core/src/lib.rs

@@ -64,7 +64,9 @@ mod tap_tests {
     use rstest::*;
 
     use crate::{
-        rav::ReceiptAggregateVoucher, receipt::Receipt, signed_message::EIP712SignedMessage,
+        rav::{Aggregate, ReceiptAggregateVoucher},
+        receipt::Receipt,
+        signed_message::EIP712SignedMessage,
         tap_eip712_domain,
     };
 
@@ -102,6 +104,7 @@ mod tap_tests {
         #[case] values: Vec<u128>,
     ) {
         // Create receipts
+
         let mut receipts = Vec::new();
         for value in values {
             receipts.push(
@@ -110,14 +113,14 @@ mod tap_tests {
                     Receipt::new(allocation_ids[0], value).unwrap(),
                     &keys.0,
                 )
-                .unwrap(),
+                .unwrap()
+                .into(),
             );
         }
 
         // Skipping receipts validation in this test, aggregate_receipts assumes receipts are valid.
 
-        let rav = ReceiptAggregateVoucher::aggregate_receipts(allocation_ids[0], &receipts, None)
-            .unwrap();
+        let rav = ReceiptAggregateVoucher::aggregate_receipts(&receipts, None).unwrap();
         let signed_rav = EIP712SignedMessage::new(&domain_separator, rav, &keys.0).unwrap();
         assert!(signed_rav.recover_signer(&domain_separator).unwrap() == keys.1);
     }
@@ -141,23 +144,20 @@ mod tap_tests {
                     Receipt::new(allocation_ids[0], value).unwrap(),
                     &keys.0,
                 )
-                .unwrap(),
+                .unwrap()
+                .into(),
             );
         }
 
         // Create previous RAV from first half of receipts
-        let prev_rav = ReceiptAggregateVoucher::aggregate_receipts(
-            allocation_ids[0],
-            &receipts[0..receipts.len() / 2],
-            None,
-        )
-        .unwrap();
+        let prev_rav =
+            ReceiptAggregateVoucher::aggregate_receipts(&receipts[0..receipts.len() / 2], None)
+                .unwrap();
         let signed_prev_rav =
             EIP712SignedMessage::new(&domain_separator, prev_rav, &keys.0).unwrap();
 
         // Create new RAV from last half of receipts and prev_rav
         let rav = ReceiptAggregateVoucher::aggregate_receipts(
-            allocation_ids[0],
             &receipts[receipts.len() / 2..receipts.len()],
             Some(signed_prev_rav),
         )

tap_core/src/manager/adapters/escrow.rs

@@ -4,12 +4,7 @@
 use alloy::{dyn_abi::Eip712Domain, primitives::Address, sol_types::SolStruct};
 use async_trait::async_trait;
 
-use crate::{
-    manager::WithValueAndTimestamp,
-    receipt::{state::AwaitingReserve, ReceiptError, ReceiptResult, ReceiptWithState},
-    signed_message::EIP712SignedMessage,
-    Error,
-};
+use crate::{signed_message::EIP712SignedMessage, Error};
 
 /// Manages the escrow operations
 ///
@@ -26,46 +21,21 @@ pub trait EscrowHandler: Send + Sync {
     /// Errors of this type are returned to the user when an operation fails.
     type AdapterError: std::error::Error + std::fmt::Debug + Send + Sync + 'static;
 
-    /// Retrieves the local accounting amount of available escrow for a specified sender.
-    async fn get_available_escrow(&self, sender_id: Address) -> Result<u128, Self::AdapterError>;
-
-    /// Deducts a specified value from the local accounting of available escrow for a specified sender.
-    async fn subtract_escrow(
-        &self,
-        sender_id: Address,
-        value: u128,
-    ) -> Result<(), Self::AdapterError>;
+    ///// Retrieves the local accounting amount of available escrow for a specified sender.
+    //async fn get_available_escrow(&self, sender_id: Address) -> Result<u128, Self::AdapterError>;
+    //
+    ///// Deducts a specified value from the local accounting of available escrow for a specified sender.
+    //async fn subtract_escrow(
+    //    &self,
+    //    sender_id: Address,
+    //    value: u128,
+    //) -> Result<(), Self::AdapterError>;
 
     /// Verifies the signer of the receipt
     ///
     /// Used by [`Self::check_rav_signature`] to verify the signer of the receipt
     async fn verify_signer(&self, signer_address: Address) -> Result<bool, Self::AdapterError>;
 
-    /// Checks and reserves escrow for the received receipt
-    async fn check_and_reserve_escrow<T: SolStruct + WithValueAndTimestamp + Sync>(
-        &self,
-        received_receipt: &ReceiptWithState<AwaitingReserve, T>,
-        domain_separator: &Eip712Domain,
-    ) -> ReceiptResult<()> {
-        let signed_receipt = &received_receipt.signed_receipt;
-        let receipt_signer_address =
-            signed_receipt
-                .recover_signer(domain_separator)
-                .map_err(|err| ReceiptError::InvalidSignature {
-                    source_error_message: err.to_string(),
-                })?;
-
-        if self
-            .subtract_escrow(receipt_signer_address, signed_receipt.message.value())
-            .await
-            .is_err()
-        {
-            return Err(ReceiptError::SubtractEscrowFailed);
-        }
-
-        Ok(())
-    }
-
     /// Checks the signature of the RAV
     async fn check_rav_signature<R: SolStruct + Sync>(
         &self,

tap_core/src/manager/adapters/receipt.rs

@@ -3,7 +3,6 @@
 
 use std::ops::RangeBounds;
 
-use alloy::sol_types::SolStruct;
 use async_trait::async_trait;
 
 use crate::{
@@ -20,10 +19,7 @@ use crate::{
 ///
 /// For example code see [crate::manager::context::memory::ReceiptStorage]
 #[async_trait]
-pub trait ReceiptStore<T>
-where
-    T: SolStruct,
-{
+pub trait ReceiptStore<T> {
     /// Defines the user-specified error type.
     ///
     /// This error type should implement the `Error` and `Debug` traits from the standard library.
@@ -69,10 +65,7 @@ pub trait ReceiptDelete {
 ///
 /// For example code see [crate::manager::context::memory::ReceiptStorage]
 #[async_trait]
-pub trait ReceiptRead<T>
-where
-    T: SolStruct,
-{
+pub trait ReceiptRead<T> {
     /// Defines the user-specified error type.
     ///
     /// This error type should implement the `Error` and `Debug` traits from
@@ -109,7 +102,7 @@ where
 ///
 /// WARNING: Will sort the receipts by timestamp using
 /// [vec::sort_unstable](https://doc.rust-lang.org/std/vec/struct.Vec.html#method.sort_unstable).
-pub fn safe_truncate_receipts<T: ReceiptState, R: SolStruct + WithValueAndTimestamp>(
+pub fn safe_truncate_receipts<T: ReceiptState, R: WithValueAndTimestamp>(
     receipts: &mut Vec<ReceiptWithState<T, R>>,
     limit: u64,
 ) {
@@ -120,26 +113,19 @@ pub fn safe_truncate_receipts<T: ReceiptState, R: SolStruct + WithValueAndTimest
         return;
     }
 
-    receipts.sort_unstable_by_key(|rx_receipt| rx_receipt.signed_receipt().message.timestamp());
+    receipts.sort_unstable_by_key(|rx_receipt| rx_receipt.signed_receipt().timestamp());
 
     // This one will be the last timestamp in `receipts` after naive truncation
-    let last_timestamp = receipts[limit as usize - 1]
-        .signed_receipt()
-        .message
-        .timestamp();
+    let last_timestamp = receipts[limit as usize - 1].signed_receipt().timestamp();
     // This one is the timestamp that comes just after the one above
-    let after_last_timestamp = receipts[limit as usize]
-        .signed_receipt()
-        .message
-        .timestamp();
+    let after_last_timestamp = receipts[limit as usize].signed_receipt().timestamp();
 
     receipts.truncate(limit as usize);
 
     if last_timestamp == after_last_timestamp {
         // If the last timestamp is the same as the one that came after it, we need to
         // remove all the receipts with the same timestamp as the last one, because
         // otherwise we would leave behind part of the receipts for that timestamp.
-        receipts
-            .retain(|rx_receipt| rx_receipt.signed_receipt().message.timestamp() != last_timestamp);
+        receipts.retain(|rx_receipt| rx_receipt.signed_receipt().timestamp() != last_timestamp);
     }
 }