diff --git a/tap_core/src/error.rs b/tap_core/src/error.rs
index 9a4a31f8..052fd06b 100644
--- a/tap_core/src/error.rs
+++ b/tap_core/src/error.rs
@@ -9,7 +9,7 @@ use std::result::Result as StdResult;
 use alloy::primitives::{Address, SignatureError};
 use thiserror::Error as ThisError;
 
-use crate::{rav::ReceiptAggregateVoucher, receipt::ReceiptError};
+use crate::receipt::ReceiptError;
 
 /// Error type for the TAP protocol
 #[derive(ThisError, Debug)]
@@ -38,8 +38,8 @@ pub enum Error {
     /// Error when the received RAV does not match the expected RAV
     #[error("Received RAV does not match expexted RAV")]
     InvalidReceivedRAV {
-        received_rav: ReceiptAggregateVoucher,
-        expected_rav: ReceiptAggregateVoucher,
+        received_rav: String,
+        expected_rav: String,
     },
     /// Generic error from the adapter
     #[error("Error from adapter.\n Caused by: {source_error}")]
diff --git a/tap_core/src/manager/adapters/escrow.rs b/tap_core/src/manager/adapters/escrow.rs
index 6570c513..c4a0250c 100644
--- a/tap_core/src/manager/adapters/escrow.rs
+++ b/tap_core/src/manager/adapters/escrow.rs
@@ -1,12 +1,13 @@
 // Copyright 2023-, Semiotic AI, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-use alloy::{dyn_abi::Eip712Domain, primitives::Address};
+use alloy::{dyn_abi::Eip712Domain, primitives::Address, sol_types::SolStruct};
 use async_trait::async_trait;
 
 use crate::{
-    rav::SignedRAV,
+    manager::WithValueAndTimestamp,
     receipt::{state::AwaitingReserve, ReceiptError, ReceiptResult, ReceiptWithState},
+    signed_message::EIP712SignedMessage,
     Error,
 };
 
@@ -41,9 +42,9 @@ pub trait EscrowHandler: Send + Sync {
     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(
+    async fn check_and_reserve_escrow<T: SolStruct + WithValueAndTimestamp + Sync>(
         &self,
-        received_receipt: &ReceiptWithState<AwaitingReserve>,
+        received_receipt: &ReceiptWithState<AwaitingReserve, T>,
         domain_separator: &Eip712Domain,
     ) -> ReceiptResult<()> {
         let signed_receipt = &received_receipt.signed_receipt;
@@ -55,7 +56,7 @@ pub trait EscrowHandler: Send + Sync {
                 })?;
 
         if self
-            .subtract_escrow(receipt_signer_address, signed_receipt.message.value)
+            .subtract_escrow(receipt_signer_address, signed_receipt.message.value())
             .await
             .is_err()
         {
@@ -66,9 +67,9 @@ pub trait EscrowHandler: Send + Sync {
     }
 
     /// Checks the signature of the RAV
-    async fn check_rav_signature(
+    async fn check_rav_signature<R: SolStruct + Sync>(
         &self,
-        signed_rav: &SignedRAV,
+        signed_rav: &EIP712SignedMessage<R>,
         domain_separator: &Eip712Domain,
     ) -> Result<(), Error> {
         let recovered_address = signed_rav.recover_signer(domain_separator)?;
diff --git a/tap_core/src/manager/adapters/rav.rs b/tap_core/src/manager/adapters/rav.rs
index 3e719b98..96b48f5f 100644
--- a/tap_core/src/manager/adapters/rav.rs
+++ b/tap_core/src/manager/adapters/rav.rs
@@ -1,9 +1,10 @@
 // Copyright 2023-, Semiotic AI, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
+use alloy::sol_types::SolStruct;
 use async_trait::async_trait;
 
-use crate::rav::SignedRAV;
+use crate::signed_message::EIP712SignedMessage;
 
 /// Stores the latest RAV in the storage.
 ///
@@ -12,7 +13,10 @@ use crate::rav::SignedRAV;
 /// For example code see [crate::manager::context::memory::RAVStorage]
 
 #[async_trait]
-pub trait RAVStore {
+pub trait RAVStore<T>
+where
+    T: SolStruct,
+{
     /// Defines the user-specified error type.
     ///
     /// This error type should implement the `Error` and `Debug` traits from
@@ -25,7 +29,7 @@ pub trait RAVStore {
     /// This method should be implemented to store the most recent validated
     /// `SignedRAV` into your chosen storage system. Any errors that occur
     /// during this process should be captured and returned as an `AdapterError`.
-    async fn update_last_rav(&self, rav: SignedRAV) -> Result<(), Self::AdapterError>;
+    async fn update_last_rav(&self, rav: EIP712SignedMessage<T>) -> Result<(), Self::AdapterError>;
 }
 
 /// Reads the RAV from storage
@@ -35,7 +39,10 @@ pub trait RAVStore {
 /// For example code see [crate::manager::context::memory::RAVStorage]
 
 #[async_trait]
-pub trait RAVRead {
+pub trait RAVRead<T>
+where
+    T: SolStruct,
+{
     /// Defines the user-specified error type.
     ///
     /// This error type should implement the `Error` and `Debug` traits from
@@ -46,5 +53,5 @@ pub trait RAVRead {
     /// Retrieves the latest `SignedRAV` from the storage.
     ///
     /// If no `SignedRAV` is available, this method should return `None`.
-    async fn last_rav(&self) -> Result<Option<SignedRAV>, Self::AdapterError>;
+    async fn last_rav(&self) -> Result<Option<EIP712SignedMessage<T>>, Self::AdapterError>;
 }
diff --git a/tap_core/src/manager/adapters/receipt.rs b/tap_core/src/manager/adapters/receipt.rs
index 92fe2972..74d2792a 100644
--- a/tap_core/src/manager/adapters/receipt.rs
+++ b/tap_core/src/manager/adapters/receipt.rs
@@ -3,11 +3,15 @@
 
 use std::ops::RangeBounds;
 
+use alloy::sol_types::SolStruct;
 use async_trait::async_trait;
 
-use crate::receipt::{
-    state::{Checking, ReceiptState},
-    ReceiptWithState,
+use crate::{
+    manager::WithValueAndTimestamp,
+    receipt::{
+        state::{Checking, ReceiptState},
+        ReceiptWithState,
+    },
 };
 
 /// Stores receipts in the storage.
@@ -16,7 +20,10 @@ use crate::receipt::{
 ///
 /// For example code see [crate::manager::context::memory::ReceiptStorage]
 #[async_trait]
-pub trait ReceiptStore {
+pub trait ReceiptStore<T>
+where
+    T: SolStruct,
+{
     /// Defines the user-specified error type.
     ///
     /// This error type should implement the `Error` and `Debug` traits from the standard library.
@@ -29,7 +36,7 @@ pub trait ReceiptStore {
     /// this process should be captured and returned as an `AdapterError`.
     async fn store_receipt(
         &self,
-        receipt: ReceiptWithState<Checking>,
+        receipt: ReceiptWithState<Checking, T>,
     ) -> Result<u64, Self::AdapterError>;
 }
 
@@ -62,7 +69,10 @@ pub trait ReceiptDelete {
 ///
 /// For example code see [crate::manager::context::memory::ReceiptStorage]
 #[async_trait]
-pub trait ReceiptRead {
+pub trait ReceiptRead<T>
+where
+    T: SolStruct,
+{
     /// Defines the user-specified error type.
     ///
     /// This error type should implement the `Error` and `Debug` traits from
@@ -92,15 +102,15 @@ pub trait ReceiptRead {
         &self,
         timestamp_range_ns: R,
         limit: Option<u64>,
-    ) -> Result<Vec<ReceiptWithState<Checking>>, Self::AdapterError>;
+    ) -> Result<Vec<ReceiptWithState<Checking, T>>, Self::AdapterError>;
 }
 
 /// See [`ReceiptRead::retrieve_receipts_in_timestamp_range()`] for details.
 ///
 /// 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>(
-    receipts: &mut Vec<ReceiptWithState<T>>,
+pub fn safe_truncate_receipts<T: ReceiptState, R: SolStruct + WithValueAndTimestamp>(
+    receipts: &mut Vec<ReceiptWithState<T, R>>,
     limit: u64,
 ) {
     if receipts.len() <= limit as usize {
@@ -110,18 +120,18 @@ pub fn safe_truncate_receipts<T: ReceiptState>(
         return;
     }
 
-    receipts.sort_unstable_by_key(|rx_receipt| rx_receipt.signed_receipt().message.timestamp_ns);
+    receipts.sort_unstable_by_key(|rx_receipt| rx_receipt.signed_receipt().message.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_ns;
+        .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_ns;
+        .timestamp();
 
     receipts.truncate(limit as usize);
 
@@ -129,8 +139,7 @@ pub fn safe_truncate_receipts<T: ReceiptState>(
         // 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_ns != last_timestamp
-        });
+        receipts
+            .retain(|rx_receipt| rx_receipt.signed_receipt().message.timestamp() != last_timestamp);
     }
 }
diff --git a/tap_core/src/manager/context/memory.rs b/tap_core/src/manager/context/memory.rs
index 455b123d..757a43e8 100644
--- a/tap_core/src/manager/context/memory.rs
+++ b/tap_core/src/manager/context/memory.rs
@@ -17,14 +17,14 @@ use async_trait::async_trait;
 
 use crate::{
     manager::adapters::*,
-    rav::SignedRAV,
-    receipt::{checks::StatefulTimestampCheck, state::Checking, ReceiptWithState},
+    rav::{ReceiptAggregateVoucher, SignedRAV},
+    receipt::{checks::StatefulTimestampCheck, state::Checking, Receipt, ReceiptWithState},
     signed_message::MessageId,
 };
 
 pub type EscrowStorage = Arc<RwLock<HashMap<Address, u128>>>;
 pub type QueryAppraisals = Arc<RwLock<HashMap<MessageId, u128>>>;
-pub type ReceiptStorage = Arc<RwLock<HashMap<u64, ReceiptWithState<Checking>>>>;
+pub type ReceiptStorage = Arc<RwLock<HashMap<u64, ReceiptWithState<Checking, Receipt>>>>;
 pub type RAVStorage = Arc<RwLock<Option<SignedRAV>>>;
 
 use thiserror::Error;
@@ -71,7 +71,7 @@ impl InMemoryContext {
     pub async fn retrieve_receipt_by_id(
         &self,
         receipt_id: u64,
-    ) -> Result<ReceiptWithState<Checking>, InMemoryError> {
+    ) -> Result<ReceiptWithState<Checking, Receipt>, InMemoryError> {
         let receipt_storage = self.receipt_storage.read().unwrap();
 
         receipt_storage
@@ -85,7 +85,7 @@ impl InMemoryContext {
     pub async fn retrieve_receipts_by_timestamp(
         &self,
         timestamp_ns: u64,
-    ) -> Result<Vec<(u64, ReceiptWithState<Checking>)>, InMemoryError> {
+    ) -> Result<Vec<(u64, ReceiptWithState<Checking, Receipt>)>, InMemoryError> {
         let receipt_storage = self.receipt_storage.read().unwrap();
         Ok(receipt_storage
             .iter()
@@ -99,7 +99,7 @@ impl InMemoryContext {
     pub async fn retrieve_receipts_upto_timestamp(
         &self,
         timestamp_ns: u64,
-    ) -> Result<Vec<ReceiptWithState<Checking>>, InMemoryError> {
+    ) -> Result<Vec<ReceiptWithState<Checking, Receipt>>, InMemoryError> {
         self.retrieve_receipts_in_timestamp_range(..=timestamp_ns, None)
             .await
     }
@@ -125,7 +125,7 @@ impl InMemoryContext {
 }
 
 #[async_trait]
-impl RAVStore for InMemoryContext {
+impl RAVStore<ReceiptAggregateVoucher> for InMemoryContext {
     type AdapterError = InMemoryError;
 
     async fn update_last_rav(&self, rav: SignedRAV) -> Result<(), Self::AdapterError> {
@@ -138,7 +138,7 @@ impl RAVStore for InMemoryContext {
 }
 
 #[async_trait]
-impl RAVRead for InMemoryContext {
+impl RAVRead<ReceiptAggregateVoucher> for InMemoryContext {
     type AdapterError = InMemoryError;
 
     async fn last_rav(&self) -> Result<Option<SignedRAV>, Self::AdapterError> {
@@ -147,12 +147,12 @@ impl RAVRead for InMemoryContext {
 }
 
 #[async_trait]
-impl ReceiptStore for InMemoryContext {
+impl ReceiptStore<Receipt> for InMemoryContext {
     type AdapterError = InMemoryError;
 
     async fn store_receipt(
         &self,
-        receipt: ReceiptWithState<Checking>,
+        receipt: ReceiptWithState<Checking, Receipt>,
     ) -> Result<u64, Self::AdapterError> {
         let mut id_pointer = self.unique_id.write().unwrap();
         let id_previous = *id_pointer;
@@ -179,15 +179,15 @@ impl ReceiptDelete for InMemoryContext {
     }
 }
 #[async_trait]
-impl ReceiptRead for InMemoryContext {
+impl ReceiptRead<Receipt> for InMemoryContext {
     type AdapterError = InMemoryError;
     async fn retrieve_receipts_in_timestamp_range<R: RangeBounds<u64> + std::marker::Send>(
         &self,
         timestamp_range_ns: R,
         limit: Option<u64>,
-    ) -> Result<Vec<ReceiptWithState<Checking>>, Self::AdapterError> {
+    ) -> Result<Vec<ReceiptWithState<Checking, Receipt>>, Self::AdapterError> {
         let receipt_storage = self.receipt_storage.read().unwrap();
-        let mut receipts_in_range: Vec<ReceiptWithState<Checking>> = receipt_storage
+        let mut receipts_in_range: Vec<ReceiptWithState<Checking, Receipt>> = receipt_storage
             .iter()
             .filter(|(_, rx_receipt)| {
                 timestamp_range_ns.contains(&rx_receipt.signed_receipt().message.timestamp_ns)
@@ -274,7 +274,7 @@ pub mod checks {
         receipt::{
             checks::{Check, CheckError, CheckResult, ReceiptCheck},
             state::Checking,
-            Context, ReceiptError, ReceiptWithState,
+            Context, Receipt, ReceiptError, ReceiptWithState,
         },
         signed_message::MessageId,
     };
@@ -284,7 +284,7 @@ pub mod checks {
         valid_signers: HashSet<Address>,
         allocation_ids: Arc<RwLock<HashSet<Address>>>,
         _query_appraisals: Arc<RwLock<HashMap<MessageId, u128>>>,
-    ) -> Vec<ReceiptCheck> {
+    ) -> Vec<ReceiptCheck<Receipt>> {
         vec![
             // Arc::new(UniqueCheck ),
             // Arc::new(ValueCheck { query_appraisals }),
@@ -301,8 +301,12 @@ pub mod checks {
     }
 
     #[async_trait::async_trait]
-    impl Check for AllocationIdCheck {
-        async fn check(&self, _: &Context, receipt: &ReceiptWithState<Checking>) -> CheckResult {
+    impl Check<Receipt> for AllocationIdCheck {
+        async fn check(
+            &self,
+            _: &Context,
+            receipt: &ReceiptWithState<Checking, Receipt>,
+        ) -> CheckResult {
             let received_allocation_id = receipt.signed_receipt().message.allocation_id;
             if self
                 .allocation_ids
@@ -328,8 +332,12 @@ pub mod checks {
     }
 
     #[async_trait::async_trait]
-    impl Check for SignatureCheck {
-        async fn check(&self, _: &Context, receipt: &ReceiptWithState<Checking>) -> CheckResult {
+    impl Check<Receipt> for SignatureCheck {
+        async fn check(
+            &self,
+            _: &Context,
+            receipt: &ReceiptWithState<Checking, Receipt>,
+        ) -> CheckResult {
             let recovered_address = receipt
                 .signed_receipt()
                 .recover_signer(&self.domain_separator)
diff --git a/tap_core/src/manager/mod.rs b/tap_core/src/manager/mod.rs
index 7696796e..55fbab3d 100644
--- a/tap_core/src/manager/mod.rs
+++ b/tap_core/src/manager/mod.rs
@@ -34,6 +34,7 @@
 //!
 //! ```rust
 //! use async_trait::async_trait;
+//! use alloy::sol_types::SolStruct;
 //! use tap_core::{
 //!     receipt::{
 //!         ReceiptWithState,
@@ -42,6 +43,7 @@
 //!         ReceiptError,
 //!         Context
 //!     },
+//!#     rav::ReceiptAggregateVoucher,
 //!     manager::{
 //!         Manager,
 //!         adapters::ReceiptStore
@@ -51,14 +53,19 @@
 //! struct MyContext;
 //!
 //! #[async_trait]
-//! impl ReceiptStore for MyContext {
+//! impl<T> ReceiptStore<T> for MyContext
+//! where 
+//!     T: SolStruct + Send + 'static
+//! {
 //!     type AdapterError = ReceiptError;
 //!
-//!     async fn store_receipt(&self, receipt: ReceiptWithState<Checking>) -> Result<u64, Self::AdapterError> {
+//!     async fn store_receipt(&self, receipt: ReceiptWithState<Checking, T>) -> Result<u64, Self::AdapterError> {
 //!         // ...
 //!         # Ok(0)
 //!     }
 //! }
+//!
+//! # type Rav = ReceiptAggregateVoucher;
 //! # #[tokio::main]
 //! # async fn main() {
 //! # use alloy::{dyn_abi::Eip712Domain, primitives::Address, signers::local::PrivateKeySigner};
@@ -70,7 +77,7 @@
 //!
 //! let receipt = EIP712SignedMessage::new(&domain_separator, message, &wallet).unwrap();
 //!
-//! let manager = Manager::new(domain_separator, MyContext, CheckList::empty());
+//! let manager = Manager::<_, _, Rav>::new(domain_separator, MyContext, CheckList::empty());
 //! manager.verify_and_store_receipt(&Context::new(), receipt).await.unwrap()
 //! # }
 //! ```
@@ -82,3 +89,8 @@ pub mod context;
 mod tap_manager;
 
 pub use tap_manager::Manager;
+
+pub trait WithValueAndTimestamp {
+    fn value(&self) -> u128;
+    fn timestamp(&self) -> u64;
+}
diff --git a/tap_core/src/manager/tap_manager.rs b/tap_core/src/manager/tap_manager.rs
index 304e4d17..0e114871 100644
--- a/tap_core/src/manager/tap_manager.rs
+++ b/tap_core/src/manager/tap_manager.rs
@@ -1,48 +1,62 @@
 // Copyright 2023-, Semiotic AI, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-use alloy::dyn_abi::Eip712Domain;
+use std::marker::PhantomData;
 
-use super::adapters::{EscrowHandler, RAVRead, RAVStore, ReceiptDelete, ReceiptRead, ReceiptStore};
+use alloy::{dyn_abi::Eip712Domain, sol_types::SolStruct};
+
+use super::{
+    adapters::{EscrowHandler, RAVRead, RAVStore, ReceiptDelete, ReceiptRead, ReceiptStore},
+    WithValueAndTimestamp,
+};
 use crate::{
-    rav::{RAVRequest, ReceiptAggregateVoucher, SignedRAV},
+    rav::RAVRequest,
     receipt::{
         checks::{CheckBatch, CheckList, TimestampCheck, UniqueCheck},
         state::{Failed, Reserved},
-        Context, ReceiptError, ReceiptWithState, SignedReceipt,
+        Context, ReceiptError, ReceiptWithState,
     },
+    signed_message::EIP712SignedMessage,
     Error,
 };
 
-pub struct Manager<E> {
+pub struct Manager<E, T, R> {
     /// Context that implements adapters
     context: E,
 
     /// Checks that must be completed for each receipt before being confirmed or denied for rav request
-    checks: CheckList,
+    checks: CheckList<T>,
 
     /// Struct responsible for doing checks for receipt. Ownership stays with manager allowing manager
     /// to update configuration ( like minimum timestamp ).
     domain_separator: Eip712Domain,
+
+    _receipt: PhantomData<(T, R)>,
 }
 
-impl<E> Manager<E> {
+impl<E, T, R> Manager<E, T, R> {
     /// Creates new manager with provided `adapters`, any receipts received by this manager
     /// will complete all `required_checks` before being accepted or declined from RAV.
     /// `starting_min_timestamp` will be used as min timestamp until the first RAV request is created.
     ///
-    pub fn new(domain_separator: Eip712Domain, context: E, checks: impl Into<CheckList>) -> Self {
+    pub fn new(
+        domain_separator: Eip712Domain,
+        context: E,
+        checks: impl Into<CheckList<T>>,
+    ) -> Self {
         Self {
             context,
             domain_separator,
             checks: checks.into(),
+            _receipt: PhantomData,
         }
     }
 }
 
-impl<E> Manager<E>
+impl<E, T, R> Manager<E, T, R>
 where
-    E: RAVStore + EscrowHandler,
+    E: RAVStore<R> + EscrowHandler,
+    R: SolStruct + PartialEq + Sync + std::fmt::Debug,
 {
     /// Verify `signed_rav` matches all values on `expected_rav`, and that `signed_rav` has a valid signer.
     ///
@@ -52,8 +66,8 @@ where
     ///
     pub async fn verify_and_store_rav(
         &self,
-        expected_rav: ReceiptAggregateVoucher,
-        signed_rav: SignedRAV,
+        expected_rav: R,
+        signed_rav: EIP712SignedMessage<R>,
     ) -> std::result::Result<(), Error> {
         self.context
             .check_rav_signature(&signed_rav, &self.domain_separator)
@@ -61,8 +75,8 @@ where
 
         if signed_rav.message != expected_rav {
             return Err(Error::InvalidReceivedRAV {
-                received_rav: signed_rav.message,
-                expected_rav,
+                received_rav: format!("{:?}", signed_rav.message),
+                expected_rav: format!("{:?}", expected_rav),
             });
         }
 
@@ -77,11 +91,12 @@ where
     }
 }
 
-impl<E> Manager<E>
+impl<E, T, R> Manager<E, T, R>
 where
-    E: RAVRead,
+    E: RAVRead<R>,
+    R: SolStruct,
 {
-    async fn get_previous_rav(&self) -> Result<Option<SignedRAV>, Error> {
+    async fn get_previous_rav(&self) -> Result<Option<EIP712SignedMessage<R>>, Error> {
         let previous_rav = self
             .context
             .last_rav()
@@ -93,9 +108,10 @@ where
     }
 }
 
-impl<E> Manager<E>
+impl<E, T, R> Manager<E, T, R>
 where
-    E: ReceiptRead + EscrowHandler,
+    E: ReceiptRead<T> + EscrowHandler,
+    T: SolStruct + WithValueAndTimestamp + Sync,
 {
     async fn collect_receipts(
         &self,
@@ -105,8 +121,8 @@ where
         limit: Option<u64>,
     ) -> Result<
         (
-            Vec<ReceiptWithState<Reserved>>,
-            Vec<ReceiptWithState<Failed>>,
+            Vec<ReceiptWithState<Reserved, T>>,
+            Vec<ReceiptWithState<Failed, T>>,
         ),
         Error,
     > {
@@ -164,9 +180,11 @@ where
     }
 }
 
-impl<E> Manager<E>
+impl<E, T, R> Manager<E, T, R>
 where
-    E: ReceiptRead + RAVRead + EscrowHandler,
+    E: ReceiptRead<T> + RAVRead<R> + EscrowHandler,
+    T: SolStruct + WithValueAndTimestamp + Sync,
+    R: SolStruct + WithValueAndTimestamp + Clone,
 {
     /// Completes remaining checks on all receipts up to
     /// (current time - `timestamp_buffer_ns`). Returns them in two lists
@@ -188,18 +206,22 @@ where
         ctx: &Context,
         timestamp_buffer_ns: u64,
         receipts_limit: Option<u64>,
-    ) -> Result<RAVRequest, Error> {
+        generate_rav: impl FnOnce(
+            &[ReceiptWithState<Reserved, T>],
+            Option<EIP712SignedMessage<R>>,
+        ) -> Result<R, Error>,
+    ) -> Result<RAVRequest<T, R>, Error> {
         let previous_rav = self.get_previous_rav().await?;
         let min_timestamp_ns = previous_rav
             .as_ref()
-            .map(|rav| rav.message.timestampNs + 1)
+            .map(|rav| rav.message.timestamp() + 1)
             .unwrap_or(0);
 
         let (valid_receipts, invalid_receipts) = self
             .collect_receipts(ctx, timestamp_buffer_ns, min_timestamp_ns, receipts_limit)
             .await?;
 
-        let expected_rav = Self::generate_expected_rav(&valid_receipts, previous_rav.clone());
+        let expected_rav = generate_rav(&valid_receipts, previous_rav.clone());
 
         Ok(RAVRequest {
             valid_receipts,
@@ -208,30 +230,12 @@ where
             expected_rav,
         })
     }
-
-    fn generate_expected_rav(
-        receipts: &[ReceiptWithState<Reserved>],
-        previous_rav: Option<SignedRAV>,
-    ) -> Result<ReceiptAggregateVoucher, Error> {
-        if receipts.is_empty() {
-            return Err(Error::NoValidReceiptsForRAVRequest);
-        }
-        let allocation_id = receipts[0].signed_receipt().message.allocation_id;
-        let receipts = receipts
-            .iter()
-            .map(|rx_receipt| rx_receipt.signed_receipt().clone())
-            .collect::<Vec<_>>();
-        ReceiptAggregateVoucher::aggregate_receipts(
-            allocation_id,
-            receipts.as_slice(),
-            previous_rav,
-        )
-    }
 }
 
-impl<E> Manager<E>
+impl<E, T, R> Manager<E, T, R>
 where
-    E: ReceiptDelete + RAVRead,
+    E: ReceiptDelete + RAVRead<R>,
+    R: SolStruct + WithValueAndTimestamp,
 {
     /// Removes obsolete receipts from storage. Obsolete receipts are receipts
     /// that are older than the last RAV, and therefore already aggregated into the RAV.
@@ -247,7 +251,7 @@ where
         match self.get_previous_rav().await? {
             Some(last_rav) => {
                 self.context
-                    .remove_receipts_in_timestamp_range(..=last_rav.message.timestampNs)
+                    .remove_receipts_in_timestamp_range(..=last_rav.message.timestamp())
                     .await
                     .map_err(|err| Error::AdapterError {
                         source_error: anyhow::Error::new(err),
@@ -259,9 +263,10 @@ where
     }
 }
 
-impl<E> Manager<E>
+impl<E, T, R> Manager<E, T, R>
 where
-    E: ReceiptStore,
+    E: ReceiptStore<T>,
+    T: SolStruct,
 {
     /// Runs `initial_checks` on `signed_receipt` for initial verification,
     /// then stores received receipt.
@@ -274,7 +279,7 @@ where
     pub async fn verify_and_store_receipt(
         &self,
         ctx: &Context,
-        signed_receipt: SignedReceipt,
+        signed_receipt: EIP712SignedMessage<T>,
     ) -> std::result::Result<(), Error> {
         let mut received_receipt = ReceiptWithState::new(signed_receipt);
 
diff --git a/tap_core/src/rav.rs b/tap_core/src/rav.rs
index bf55f862..bd72c95c 100644
--- a/tap_core/src/rav.rs
+++ b/tap_core/src/rav.rs
@@ -44,7 +44,12 @@ use std::cmp;
 use alloy::{primitives::Address, sol};
 use serde::{Deserialize, Serialize};
 
-use crate::{receipt::Receipt, signed_message::EIP712SignedMessage, Error};
+use crate::{
+    manager::WithValueAndTimestamp,
+    receipt::{state::Reserved, Receipt, ReceiptWithState},
+    signed_message::EIP712SignedMessage,
+    Error,
+};
 
 /// EIP712 signed message for ReceiptAggregateVoucher
 pub type SignedRAV = EIP712SignedMessage<ReceiptAggregateVoucher>;
@@ -67,6 +72,16 @@ sol! {
     }
 }
 
+impl WithValueAndTimestamp for ReceiptAggregateVoucher {
+    fn value(&self) -> u128 {
+        self.valueAggregate
+    }
+
+    fn timestamp(&self) -> u64 {
+        self.timestampNs
+    }
+}
+
 impl ReceiptAggregateVoucher {
     /// Aggregates a batch of validated receipts with optional validated previous RAV,
     /// returning a new RAV if all provided items are valid or an error if not.
@@ -106,3 +121,18 @@ impl ReceiptAggregateVoucher {
         })
     }
 }
+
+pub fn generate_expected_rav(
+    receipts: &[ReceiptWithState<Reserved, Receipt>],
+    previous_rav: Option<SignedRAV>,
+) -> Result<ReceiptAggregateVoucher, Error> {
+    if receipts.is_empty() {
+        return Err(Error::NoValidReceiptsForRAVRequest);
+    }
+    let allocation_id = receipts[0].signed_receipt().message.allocation_id;
+    let receipts = receipts
+        .iter()
+        .map(|rx_receipt| rx_receipt.signed_receipt().clone())
+        .collect::<Vec<_>>();
+    ReceiptAggregateVoucher::aggregate_receipts(allocation_id, receipts.as_slice(), previous_rav)
+}
diff --git a/tap_core/src/rav/request.rs b/tap_core/src/rav/request.rs
index 3854d7f2..a22b65d2 100644
--- a/tap_core/src/rav/request.rs
+++ b/tap_core/src/rav/request.rs
@@ -1,24 +1,30 @@
 // Copyright 2023-, Semiotic AI, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
+use alloy::sol_types::SolStruct;
+
 use crate::{
-    rav::{ReceiptAggregateVoucher, SignedRAV},
     receipt::{
         state::{Failed, Reserved},
         ReceiptWithState,
     },
+    signed_message::EIP712SignedMessage,
     Error,
 };
 
 /// Request to `tap_aggregator` to aggregate receipts into a Signed RAV.
 #[derive(Debug)]
-pub struct RAVRequest {
+pub struct RAVRequest<T, Rav>
+where
+    T: SolStruct,
+    Rav: SolStruct,
+{
     /// List of checked and reserved receipts to aggregate
-    pub valid_receipts: Vec<ReceiptWithState<Reserved>>,
+    pub valid_receipts: Vec<ReceiptWithState<Reserved, T>>,
     /// Optional previous RAV to aggregate with
-    pub previous_rav: Option<SignedRAV>,
+    pub previous_rav: Option<EIP712SignedMessage<Rav>>,
     /// List of failed receipt used to log invalid receipts
-    pub invalid_receipts: Vec<ReceiptWithState<Failed>>,
+    pub invalid_receipts: Vec<ReceiptWithState<Failed, T>>,
     /// Expected RAV to be created
-    pub expected_rav: Result<ReceiptAggregateVoucher, Error>,
+    pub expected_rav: Result<Rav, Error>,
 }
diff --git a/tap_core/src/receipt/checks.rs b/tap_core/src/receipt/checks.rs
index 86889f0d..2d5a28d3 100644
--- a/tap_core/src/receipt/checks.rs
+++ b/tap_core/src/receipt/checks.rs
@@ -12,21 +12,25 @@
 //! # use std::sync::Arc;
 //! use tap_core::{
 //!     receipt::checks::{Check, CheckResult, ReceiptCheck},
-//!     receipt::{Context, ReceiptWithState, state::Checking}
+//!     receipt::{Context, ReceiptWithState, state::Checking, Receipt}
 //! };
+//! use alloy::sol_types::SolStruct;
 //! # use async_trait::async_trait;
 //!
 //! struct MyCheck;
 //!
 //! #[async_trait]
-//! impl Check for MyCheck {
-//!    async fn check(&self, ctx: &Context, receipt: &ReceiptWithState<Checking>) -> CheckResult {
+//! impl<T> Check<T> for MyCheck
+//! where
+//!     T: SolStruct
+//! {
+//!    async fn check(&self, ctx: &Context, receipt: &ReceiptWithState<Checking, T>) -> CheckResult {
 //!       // Implement your check here
 //!      Ok(())
 //!   }
 //! }
 //!
-//! let my_check: ReceiptCheck = Arc::new(MyCheck);
+//! let my_check: ReceiptCheck<Receipt> = Arc::new(MyCheck);
 //! ```
 
 use std::{
@@ -35,14 +39,19 @@ use std::{
     sync::{Arc, RwLock},
 };
 
+use alloy::sol_types::SolStruct;
+
 use super::{
     state::{Checking, Failed},
-    Context, ReceiptError, ReceiptWithState,
+    Context, Receipt, ReceiptError, ReceiptWithState,
+};
+use crate::{
+    manager::WithValueAndTimestamp,
+    signed_message::{SignatureBytes, SignatureBytesExt},
 };
-use crate::signed_message::{SignatureBytes, SignatureBytesExt};
 
 /// ReceiptCheck is a type alias for an Arc of a struct that implements the `Check` trait.
-pub type ReceiptCheck = Arc<dyn Check + Sync + Send>;
+pub type ReceiptCheck<R> = Arc<dyn Check<R> + Sync + Send>;
 
 /// Result of a check operation. It uses the `anyhow` crate to handle errors.
 pub type CheckResult = Result<(), CheckError>;
@@ -57,10 +66,10 @@ pub enum CheckError {
 
 /// CheckList is a NewType pattern to store a list of checks.
 /// It is a wrapper around an Arc of ReceiptCheck[].
-pub struct CheckList(Arc<[ReceiptCheck]>);
+pub struct CheckList<R>(Arc<[ReceiptCheck<R>]>);
 
-impl CheckList {
-    pub fn new(checks: Vec<ReceiptCheck>) -> Self {
+impl<R> CheckList<R> {
+    pub fn new(checks: Vec<ReceiptCheck<R>>) -> Self {
         Self(checks.into())
     }
 
@@ -69,8 +78,8 @@ impl CheckList {
     }
 }
 
-impl Deref for CheckList {
-    type Target = [ReceiptCheck];
+impl<R> Deref for CheckList<R> {
+    type Target = [ReceiptCheck<R>];
 
     fn deref(&self) -> &Self::Target {
         self.0.as_ref()
@@ -79,20 +88,25 @@ impl Deref for CheckList {
 
 /// Check trait is implemented by the lib user to validate receipts before they are stored.
 #[async_trait::async_trait]
-pub trait Check {
-    async fn check(&self, ctx: &Context, receipt: &ReceiptWithState<Checking>) -> CheckResult;
+pub trait Check<T>
+where
+    T: SolStruct,
+{
+    async fn check(&self, ctx: &Context, receipt: &ReceiptWithState<Checking, T>) -> CheckResult;
 }
 
+type CheckBatchResponse<R> = (
+    Vec<ReceiptWithState<Checking, R>>,
+    Vec<ReceiptWithState<Failed, R>>,
+);
+
 /// CheckBatch is mostly used by the lib to implement checks
 /// that transition from one state to another.
-pub trait CheckBatch {
-    fn check_batch(
-        &self,
-        receipts: Vec<ReceiptWithState<Checking>>,
-    ) -> (
-        Vec<ReceiptWithState<Checking>>,
-        Vec<ReceiptWithState<Failed>>,
-    );
+pub trait CheckBatch<R>
+where
+    R: SolStruct,
+{
+    fn check_batch(&self, receipts: Vec<ReceiptWithState<Checking, R>>) -> CheckBatchResponse<R>;
 }
 
 /// Provides a built-in check to verify that the timestamp of a receipt
@@ -118,8 +132,12 @@ impl StatefulTimestampCheck {
 }
 
 #[async_trait::async_trait]
-impl Check for StatefulTimestampCheck {
-    async fn check(&self, _: &Context, receipt: &ReceiptWithState<Checking>) -> CheckResult {
+impl Check<Receipt> for StatefulTimestampCheck {
+    async fn check(
+        &self,
+        _: &Context,
+        receipt: &ReceiptWithState<Checking, Receipt>,
+    ) -> CheckResult {
         let min_timestamp_ns = *self.min_timestamp_ns.read().unwrap();
         let signed_receipt = receipt.signed_receipt();
         if signed_receipt.message.timestamp_ns <= min_timestamp_ns {
@@ -141,17 +159,20 @@ impl Check for StatefulTimestampCheck {
 /// Used by the [`crate::manager::Manager`].
 pub struct TimestampCheck(pub u64);
 
-impl CheckBatch for TimestampCheck {
+impl<T> CheckBatch<T> for TimestampCheck
+where
+    T: SolStruct + WithValueAndTimestamp,
+{
     fn check_batch(
         &self,
-        receipts: Vec<ReceiptWithState<Checking>>,
+        receipts: Vec<ReceiptWithState<Checking, T>>,
     ) -> (
-        Vec<ReceiptWithState<Checking>>,
-        Vec<ReceiptWithState<Failed>>,
+        Vec<ReceiptWithState<Checking, T>>,
+        Vec<ReceiptWithState<Failed, T>>,
     ) {
         let (mut checking, mut failed) = (vec![], vec![]);
         for receipt in receipts.into_iter() {
-            let receipt_timestamp_ns = receipt.signed_receipt().message.timestamp_ns;
+            let receipt_timestamp_ns = receipt.signed_receipt().message.timestamp();
             let min_timestamp_ns = self.0;
             if receipt_timestamp_ns >= min_timestamp_ns {
                 checking.push(receipt);
@@ -172,13 +193,16 @@ impl CheckBatch for TimestampCheck {
 /// Used by the [`crate::manager::Manager`].
 pub struct UniqueCheck;
 
-impl CheckBatch for UniqueCheck {
+impl<T> CheckBatch<T> for UniqueCheck
+where
+    T: SolStruct,
+{
     fn check_batch(
         &self,
-        receipts: Vec<ReceiptWithState<Checking>>,
+        receipts: Vec<ReceiptWithState<Checking, T>>,
     ) -> (
-        Vec<ReceiptWithState<Checking>>,
-        Vec<ReceiptWithState<Failed>>,
+        Vec<ReceiptWithState<Checking, T>>,
+        Vec<ReceiptWithState<Failed, T>>,
     ) {
         let mut signatures: HashSet<SignatureBytes> = HashSet::new();
         let (mut checking, mut failed) = (vec![], vec![]);
@@ -213,7 +237,7 @@ mod tests {
     use super::*;
     use crate::{receipt::Receipt, signed_message::EIP712SignedMessage};
 
-    fn create_signed_receipt_with_custom_value(value: u128) -> ReceiptWithState<Checking> {
+    fn create_signed_receipt_with_custom_value(value: u128) -> ReceiptWithState<Checking, Receipt> {
         let wallet: PrivateKeySigner = PrivateKeySigner::random();
         let eip712_domain_separator: Eip712Domain = eip712_domain! {
             name: "TAP",
@@ -243,7 +267,7 @@ mod tests {
             &wallet,
         )
         .unwrap();
-        ReceiptWithState::<Checking>::new(receipt)
+        ReceiptWithState::<Checking, Receipt>::new(receipt)
     }
 
     #[tokio::test]
diff --git a/tap_core/src/receipt/receipt_sol.rs b/tap_core/src/receipt/receipt_sol.rs
index f855fb2b..3e770515 100644
--- a/tap_core/src/receipt/receipt_sol.rs
+++ b/tap_core/src/receipt/receipt_sol.rs
@@ -12,6 +12,8 @@ use alloy::{primitives::Address, sol};
 use rand::{thread_rng, Rng};
 use serde::{Deserialize, Serialize};
 
+use crate::manager::WithValueAndTimestamp;
+
 sol! {
     /// Holds information needed for promise of payment signed with ECDSA
     #[derive(Debug, Serialize, Deserialize, Eq, PartialEq)]
@@ -27,6 +29,16 @@ sol! {
     }
 }
 
+impl WithValueAndTimestamp for Receipt {
+    fn value(&self) -> u128 {
+        self.value
+    }
+
+    fn timestamp(&self) -> u64 {
+        self.timestamp_ns
+    }
+}
+
 impl Receipt {
     /// Returns a receipt with provided values
     pub fn new(allocation_id: Address, value: u128) -> crate::Result<Self> {
diff --git a/tap_core/src/receipt/received_receipt.rs b/tap_core/src/receipt/received_receipt.rs
index 708d6dab..b1bc7d6e 100644
--- a/tap_core/src/receipt/received_receipt.rs
+++ b/tap_core/src/receipt/received_receipt.rs
@@ -13,11 +13,11 @@
 //! This module is useful for managing and tracking the state of received receipts, as well as
 //! their progress through various checks and stages of inclusion in RAV requests and received RAVs.
 
-use alloy::dyn_abi::Eip712Domain;
+use alloy::{dyn_abi::Eip712Domain, sol_types::SolStruct};
 
-use super::{checks::CheckError, Context, Receipt, ReceiptError, ReceiptResult, SignedReceipt};
+use super::{checks::CheckError, Context, ReceiptError, ReceiptResult};
 use crate::{
-    manager::adapters::EscrowHandler,
+    manager::{adapters::EscrowHandler, WithValueAndTimestamp},
     receipt::{
         checks::ReceiptCheck,
         state::{AwaitingReserve, Checking, Failed, ReceiptState, Reserved},
@@ -25,7 +25,8 @@ use crate::{
     signed_message::EIP712SignedMessage,
 };
 
-pub type ResultReceipt<S> = std::result::Result<ReceiptWithState<S>, ReceiptWithState<Failed>>;
+pub type ResultReceipt<S, R> =
+    std::result::Result<ReceiptWithState<S, R>, ReceiptWithState<Failed, R>>;
 
 /// Typestate pattern for tracking the state of a receipt
 ///
@@ -40,17 +41,21 @@ pub type ResultReceipt<S> = std::result::Result<ReceiptWithState<S>, ReceiptWith
 /// - The [ `Reserved` ] state is used to represent a receipt that has
 ///   successfully reserved escrow.
 #[derive(Debug, Clone)]
-pub struct ReceiptWithState<S>
+pub struct ReceiptWithState<S, R>
 where
     S: ReceiptState,
+    R: SolStruct,
 {
     /// An EIP712 signed receipt message
-    pub(crate) signed_receipt: EIP712SignedMessage<Receipt>,
+    pub(crate) signed_receipt: EIP712SignedMessage<R>,
     /// The current state of the receipt (e.g., received, checking, failed, accepted, etc.)
     pub(crate) _state: S,
 }
 
-impl ReceiptWithState<AwaitingReserve> {
+impl<R> ReceiptWithState<AwaitingReserve, R>
+where
+    R: SolStruct + Sync + WithValueAndTimestamp,
+{
     /// Perform the checks implemented by the context and reserve escrow if
     /// all checks pass
     ///
@@ -60,7 +65,7 @@ impl ReceiptWithState<AwaitingReserve> {
         self,
         context: &E,
         domain_separator: &Eip712Domain,
-    ) -> ResultReceipt<Reserved>
+    ) -> ResultReceipt<Reserved, R>
     where
         E: EscrowHandler,
     {
@@ -74,9 +79,12 @@ impl ReceiptWithState<AwaitingReserve> {
     }
 }
 
-impl ReceiptWithState<Checking> {
+impl<R> ReceiptWithState<Checking, R>
+where
+    R: SolStruct,
+{
     /// Creates a new `ReceiptWithState` in the `Checking` state
-    pub fn new(signed_receipt: SignedReceipt) -> ReceiptWithState<Checking> {
+    pub fn new(signed_receipt: EIP712SignedMessage<R>) -> ReceiptWithState<Checking, R> {
         ReceiptWithState {
             signed_receipt,
             _state: Checking,
@@ -94,7 +102,7 @@ impl ReceiptWithState<Checking> {
     pub async fn perform_checks(
         &mut self,
         ctx: &Context,
-        checks: &[ReceiptCheck],
+        checks: &[ReceiptCheck<R>],
     ) -> ReceiptResult<()> {
         for check in checks {
             // return early on an error
@@ -114,8 +122,8 @@ impl ReceiptWithState<Checking> {
     pub async fn finalize_receipt_checks(
         mut self,
         ctx: &Context,
-        checks: &[ReceiptCheck],
-    ) -> Result<ResultReceipt<AwaitingReserve>, String> {
+        checks: &[ReceiptCheck<R>],
+    ) -> Result<ResultReceipt<AwaitingReserve, R>, String> {
         let all_checks_passed = self.perform_checks(ctx, checks).await;
         if let Err(ReceiptError::RetryableCheck(e)) = all_checks_passed {
             Err(e.to_string())
@@ -128,24 +136,28 @@ impl ReceiptWithState<Checking> {
     }
 }
 
-impl ReceiptWithState<Failed> {
+impl<R> ReceiptWithState<Failed, R>
+where
+    R: SolStruct,
+{
     pub fn error(self) -> ReceiptError {
         self._state.error
     }
 }
 
-impl<S> ReceiptWithState<S>
+impl<S, R> ReceiptWithState<S, R>
 where
     S: ReceiptState,
+    R: SolStruct,
 {
-    pub(super) fn perform_state_error(self, error: ReceiptError) -> ReceiptWithState<Failed> {
+    pub(super) fn perform_state_error(self, error: ReceiptError) -> ReceiptWithState<Failed, R> {
         ReceiptWithState {
             signed_receipt: self.signed_receipt,
             _state: Failed { error },
         }
     }
 
-    fn perform_state_changes<T>(self, new_state: T) -> ReceiptWithState<T>
+    fn perform_state_changes<T>(self, new_state: T) -> ReceiptWithState<T, R>
     where
         T: ReceiptState,
     {
@@ -156,7 +168,7 @@ where
     }
 
     /// Returns the signed receipt
-    pub fn signed_receipt(&self) -> &EIP712SignedMessage<Receipt> {
+    pub fn signed_receipt(&self) -> &EIP712SignedMessage<R> {
         &self.signed_receipt
     }
 }
diff --git a/tap_core/tests/manager_test.rs b/tap_core/tests/manager_test.rs
index e8a05082..f801a840 100644
--- a/tap_core/tests/manager_test.rs
+++ b/tap_core/tests/manager_test.rs
@@ -23,7 +23,7 @@ use tap_core::{
         },
         Manager,
     },
-    rav::ReceiptAggregateVoucher,
+    rav::{self, ReceiptAggregateVoucher},
     receipt::{
         checks::{Check, CheckError, CheckList, StatefulTimestampCheck},
         state::Checking,
@@ -71,7 +71,7 @@ struct ContextFixture {
     context: InMemoryContext,
     escrow_storage: EscrowStorage,
     query_appraisals: QueryAppraisals,
-    checks: CheckList,
+    checks: CheckList<Receipt>,
     signer: PrivateKeySigner,
 }
 
@@ -128,7 +128,8 @@ async fn manager_verify_and_store_varying_initial_checks(
         signer,
         ..
     } = context;
-    let manager = Manager::new(domain_separator.clone(), context, checks);
+    let manager =
+        Manager::<_, _, ReceiptAggregateVoucher>::new(domain_separator.clone(), context, checks);
 
     let value = 20u128;
     let signed_receipt = EIP712SignedMessage::new(
@@ -188,7 +189,9 @@ async fn manager_create_rav_request_all_valid_receipts(
             .await
             .is_ok());
     }
-    let rav_request_result = manager.create_rav_request(&Context::new(), 0, None).await;
+    let rav_request_result = manager
+        .create_rav_request(&Context::new(), 0, None, rav::generate_expected_rav)
+        .await;
     assert!(rav_request_result.is_ok());
 
     let rav_request = rav_request_result.unwrap();
@@ -284,7 +287,9 @@ async fn manager_create_multiple_rav_requests_all_valid_receipts(
             .is_ok());
         expected_accumulated_value += value;
     }
-    let rav_request_result = manager.create_rav_request(&Context::new(), 0, None).await;
+    let rav_request_result = manager
+        .create_rav_request(&Context::new(), 0, None, rav::generate_expected_rav)
+        .await;
     assert!(rav_request_result.is_ok());
 
     let rav_request = rav_request_result.unwrap();
@@ -328,7 +333,9 @@ async fn manager_create_multiple_rav_requests_all_valid_receipts(
             .is_ok());
         expected_accumulated_value += value;
     }
-    let rav_request_result = manager.create_rav_request(&Context::new(), 0, None).await;
+    let rav_request_result = manager
+        .create_rav_request(&Context::new(), 0, None, rav::generate_expected_rav)
+        .await;
     assert!(rav_request_result.is_ok());
 
     let rav_request = rav_request_result.unwrap();
@@ -403,7 +410,9 @@ async fn manager_create_multiple_rav_requests_all_valid_receipts_consecutive_tim
         manager.remove_obsolete_receipts().await.unwrap();
     }
 
-    let rav_request_1_result = manager.create_rav_request(&Context::new(), 0, None).await;
+    let rav_request_1_result = manager
+        .create_rav_request(&Context::new(), 0, None, rav::generate_expected_rav)
+        .await;
     assert!(rav_request_1_result.is_ok());
 
     let rav_request_1 = rav_request_1_result.unwrap();
@@ -458,7 +467,9 @@ async fn manager_create_multiple_rav_requests_all_valid_receipts_consecutive_tim
         );
     }
 
-    let rav_request_2_result = manager.create_rav_request(&Context::new(), 0, None).await;
+    let rav_request_2_result = manager
+        .create_rav_request(&Context::new(), 0, None, rav::generate_expected_rav)
+        .await;
     assert!(rav_request_2_result.is_ok());
 
     let rav_request_2 = rav_request_2_result.unwrap();
@@ -524,7 +535,7 @@ async fn manager_create_rav_and_ignore_invalid_receipts(
     }
 
     let rav_request = manager
-        .create_rav_request(&Context::new(), 0, None)
+        .create_rav_request(&Context::new(), 0, None, rav::generate_expected_rav)
         .await
         .unwrap();
     let expected_rav = rav_request.expected_rav.unwrap();
@@ -546,11 +557,11 @@ async fn test_retryable_checks(
     struct RetryableCheck(Arc<AtomicBool>);
 
     #[async_trait::async_trait]
-    impl Check for RetryableCheck {
+    impl Check<Receipt> for RetryableCheck {
         async fn check(
             &self,
             _: &Context,
-            receipt: &ReceiptWithState<Checking>,
+            receipt: &ReceiptWithState<Checking, Receipt>,
         ) -> Result<(), CheckError> {
             // we want to fail only if nonce is 5 and if is create rav step
             if self.0.load(std::sync::atomic::Ordering::SeqCst)
@@ -573,7 +584,7 @@ async fn test_retryable_checks(
 
     let is_create_rav = Arc::new(AtomicBool::new(false));
 
-    let mut checks: Vec<Arc<dyn Check + Send + Sync>> = checks.iter().cloned().collect();
+    let mut checks: Vec<Arc<dyn Check<Receipt> + Send + Sync>> = checks.iter().cloned().collect();
     checks.push(Arc::new(RetryableCheck(is_create_rav.clone())));
 
     let manager = Manager::new(
@@ -605,7 +616,9 @@ async fn test_retryable_checks(
 
     is_create_rav.store(true, std::sync::atomic::Ordering::SeqCst);
 
-    let rav_request = manager.create_rav_request(&Context::new(), 0, None).await;
+    let rav_request = manager
+        .create_rav_request(&Context::new(), 0, None, rav::generate_expected_rav)
+        .await;
 
     assert_eq!(
         rav_request.expect_err("Didn't fail").to_string(),
diff --git a/tap_core/tests/receipt_test.rs b/tap_core/tests/receipt_test.rs
index 6416d0d8..1a58f34a 100644
--- a/tap_core/tests/receipt_test.rs
+++ b/tap_core/tests/receipt_test.rs
@@ -159,7 +159,7 @@ fn safe_truncate_receipts_test(
     let wallet = PrivateKeySigner::random();
 
     // Vec of (id, receipt)
-    let mut receipts_orig: Vec<ReceiptWithState<Checking>> = Vec::new();
+    let mut receipts_orig: Vec<ReceiptWithState<Checking, Receipt>> = Vec::new();
 
     for timestamp in input.iter() {
         // The contents of the receipt only need to be unique for this test (so we can check)
diff --git a/tap_core/tests/received_receipt_test.rs b/tap_core/tests/received_receipt_test.rs
index 2b6c6e0b..38248bc5 100644
--- a/tap_core/tests/received_receipt_test.rs
+++ b/tap_core/tests/received_receipt_test.rs
@@ -59,7 +59,7 @@ struct ContextFixture {
     context: InMemoryContext,
     escrow_storage: EscrowStorage,
     query_appraisals: QueryAppraisals,
-    checks: Vec<ReceiptCheck>,
+    checks: Vec<ReceiptCheck<Receipt>>,
     signer: PrivateKeySigner,
 }
 
diff --git a/tap_integration_tests/tests/indexer_mock.rs b/tap_integration_tests/tests/indexer_mock.rs
index 7877ffba..78d14425 100644
--- a/tap_integration_tests/tests/indexer_mock.rs
+++ b/tap_integration_tests/tests/indexer_mock.rs
@@ -20,8 +20,8 @@ use tap_core::{
         adapters::{EscrowHandler, RAVRead, RAVStore, ReceiptRead, ReceiptStore},
         Manager,
     },
-    rav::SignedRAV,
-    receipt::{checks::CheckList, Context, SignedReceipt},
+    rav::{self, ReceiptAggregateVoucher, SignedRAV},
+    receipt::{checks::CheckList, Context, Receipt, SignedReceipt},
 };
 /// Rpc trait represents a JSON-RPC server that has a single async method `request`.
 /// This method is designed to handle incoming JSON-RPC requests.
@@ -43,9 +43,9 @@ pub trait Rpc {
 /// threshold is a limit to which receipt_count can increment, after reaching which RAV request is triggered.
 /// aggregator_client is an HTTP client used for making JSON-RPC requests to another server.
 pub struct RpcManager<E> {
-    manager: Arc<Manager<E>>, // Manager object reference counted with an Arc
+    manager: Arc<Manager<E, Receipt, ReceiptAggregateVoucher>>, // Manager object reference counted with an Arc
     receipt_count: Arc<AtomicU64>, // Thread-safe atomic counter for receipts
-    threshold: u64,           // The count at which a RAV request will be triggered
+    threshold: u64,                // The count at which a RAV request will be triggered
     aggregator_client: (HttpClient, String), // HTTP client for sending requests to the aggregator server
 }
 
@@ -59,17 +59,13 @@ where
     pub fn new(
         domain_separator: Eip712Domain,
         context: E,
-        required_checks: CheckList,
+        required_checks: CheckList<Receipt>,
         threshold: u64,
         aggregate_server_address: String,
         aggregate_server_api_version: String,
     ) -> Result<Self> {
         Ok(Self {
-            manager: Arc::new(Manager::<E>::new(
-                domain_separator,
-                context,
-                required_checks,
-            )),
+            manager: Arc::new(Manager::new(domain_separator, context, required_checks)),
             receipt_count: Arc::new(AtomicU64::new(0)),
             threshold,
             aggregator_client: (
@@ -83,7 +79,14 @@ where
 #[async_trait]
 impl<E> RpcServer for RpcManager<E>
 where
-    E: ReceiptStore + ReceiptRead + RAVStore + RAVRead + EscrowHandler + Send + Sync + 'static,
+    E: ReceiptStore<Receipt>
+        + ReceiptRead<Receipt>
+        + RAVStore<ReceiptAggregateVoucher>
+        + RAVRead<ReceiptAggregateVoucher>
+        + EscrowHandler
+        + Send
+        + Sync
+        + 'static,
 {
     async fn request(
         &self,
@@ -137,16 +140,16 @@ pub async fn run_server<E>(
     port: u16,                            // Port on which the server will listen
     domain_separator: Eip712Domain,       // EIP712 domain separator
     context: E,                           // context instance
-    required_checks: CheckList, // Vector of required checks to be performed on each request
-    threshold: u64,             // The count at which a RAV request will be triggered
-    aggregate_server_address: String, // Address of the aggregator server
+    required_checks: CheckList<Receipt>, // Vector of required checks to be performed on each request
+    threshold: u64,                      // The count at which a RAV request will be triggered
+    aggregate_server_address: String,    // Address of the aggregator server
     aggregate_server_api_version: String, // API version of the aggregator server
 ) -> Result<(ServerHandle, std::net::SocketAddr)>
 where
-    E: ReceiptStore
-        + ReceiptRead
-        + RAVStore
-        + RAVRead
+    E: ReceiptStore<Receipt>
+        + ReceiptRead<Receipt>
+        + RAVStore<ReceiptAggregateVoucher>
+        + RAVRead<ReceiptAggregateVoucher>
         + EscrowHandler
         + Clone
         + Send
@@ -176,17 +179,25 @@ where
 
 // request_rav function creates a request for aggregate receipts (RAV), sends it to another server and verifies the result.
 async fn request_rav<E>(
-    manager: &Arc<Manager<E>>,
+    manager: &Arc<Manager<E, Receipt, ReceiptAggregateVoucher>>,
     time_stamp_buffer: u64, // Buffer for timestamping, see tap_core for details
     aggregator_client: &(HttpClient, String), // HttpClient for making requests to the tap_aggregator server
     threshold: usize,
 ) -> Result<()>
 where
-    E: ReceiptRead + RAVRead + RAVStore + EscrowHandler,
+    E: ReceiptRead<Receipt>
+        + RAVRead<ReceiptAggregateVoucher>
+        + RAVStore<ReceiptAggregateVoucher>
+        + EscrowHandler,
 {
     // Create the aggregate_receipts request params
     let rav_request = manager
-        .create_rav_request(&Context::new(), time_stamp_buffer, None)
+        .create_rav_request(
+            &Context::new(),
+            time_stamp_buffer,
+            None,
+            rav::generate_expected_rav,
+        )
         .await?;
 
     // To-do: Need to add previous RAV, when tap_manager supports replacing receipts
diff --git a/tap_integration_tests/tests/showcase.rs b/tap_integration_tests/tests/showcase.rs
index 794b2e9d..f73d34ee 100644
--- a/tap_integration_tests/tests/showcase.rs
+++ b/tap_integration_tests/tests/showcase.rs
@@ -161,7 +161,7 @@ fn query_appraisals(query_price: &[u128]) -> QueryAppraisals {
 
 struct ContextFixture {
     context: InMemoryContext,
-    checks: CheckList,
+    checks: CheckList<Receipt>,
 }
 
 #[fixture]
@@ -800,7 +800,7 @@ async fn start_indexer_server(
     mut context: InMemoryContext,
     sender_id: Address,
     available_escrow: u128,
-    required_checks: CheckList,
+    required_checks: CheckList<Receipt>,
     receipt_threshold: u64,
     agg_server_addr: SocketAddr,
 ) -> Result<(ServerHandle, SocketAddr)> {