feat: add client

Signed-off-by: Gustavo Inacio <[email protected]>

Author: gusinacio

tap_aggregator/Cargo.toml

@@ -21,7 +21,7 @@ alloy.workspace = true
 anyhow.workspace = true
 tokio.workspace = true
 serde_json.workspace = true
-jsonrpsee = { workspace = true, features = ["server", "macros"] }
+jsonrpsee = { workspace = true, features = ["server", "macros", "client"] }
 clap = { version = "4.5.15", features = ["derive", "env"] }
 strum = { version = "0.26.3", features = ["derive"] }
 tracing-subscriber = "0.3.17"

tap_aggregator/src/bin/client.rs

@@ -1,4 +1,79 @@
+use std::str::FromStr;
 
-fn main() {
+use alloy::{
+    primitives::{Address, B256},
+    signers::local::PrivateKeySigner,
+};
+
+use jsonrpsee::{core::client::ClientT, http_client::HttpClientBuilder, rpc_params};
+use tap_aggregator::{
+    jsonrpsee_helpers::JsonRpcResponse,
+    tap_aggregator::{tap_aggregator_client::TapAggregatorClient, RavRequest},
+};
+use tap_core::{
+    rav::ReceiptAggregateVoucher, receipt::Receipt, signed_message::EIP712SignedMessage,
+    tap_eip712_domain,
+};
+
+#[tokio::main]
+async fn main() {
     println!("Hello world");
+
+    let domain_separator = tap_eip712_domain(1, Address::ZERO);
+
+    let mut client = TapAggregatorClient::connect("http://localhost:8080")
+        .await
+        .unwrap();
+
+    let wallet = PrivateKeySigner::from_bytes(
+        &B256::from_str("8990ccae49d8fff982bfcd2b3f83d6b14cb272fcd29e49f7a335accd906005dc")
+            .unwrap(),
+    )
+    .unwrap();
+
+    let allocation_id = Address::from_str("0xabababababababababababababababababababab").unwrap();
+
+    // Create receipts
+    let mut receipts = Vec::new();
+    for value in 50..60 {
+        receipts.push(
+            EIP712SignedMessage::new(
+                &domain_separator,
+                Receipt::new(allocation_id, value).unwrap(),
+                &wallet,
+            )
+            .unwrap(),
+        );
+    }
+
+    let rav_request = RavRequest {
+        receipts: receipts.clone().into_iter().map(Into::into).collect(),
+        previous_rav: None,
+    };
+    let res = client.aggregate_receipts(rav_request).await.unwrap();
+    let signed_rav: tap_core::rav::SignedRAV =
+        res.into_inner().rav.take().unwrap().try_into().unwrap();
+    println!("Response:  {signed_rav:?}");
+
+    let sender_aggregator = HttpClientBuilder::default()
+        .build("http://localhost:8080")
+        .unwrap();
+
+    let previous_rav: Option<tap_core::rav::SignedRAV> = None;
+
+    let response: JsonRpcResponse<EIP712SignedMessage<ReceiptAggregateVoucher>> = sender_aggregator
+        .request(
+            "aggregate_receipts",
+            rpc_params!(
+                "0.0", // TODO: Set the version in a smarter place.
+                receipts,
+                previous_rav
+            ),
+        )
+        .await
+        .unwrap();
+    let response = response.data;
+    assert_eq!(signed_rav, response);
+
+    println!("Response:  {response:?}");
 }

tap_aggregator/src/main.rs

@@ -3,13 +3,11 @@
 
 #![doc = include_str!("../README.md")]
 
-use std::borrow::Cow;
 use std::collections::HashSet;
 use std::str::FromStr;
 
 use alloy::dyn_abi::Eip712Domain;
 use alloy::primitives::Address;
-use alloy::primitives::FixedBytes;
 use alloy::signers::local::PrivateKeySigner;
 use anyhow::Result;
 use axum::error_handling::HandleError;
@@ -18,7 +16,7 @@ use axum::BoxError;
 use axum::Router;
 use clap::Parser;
 use hyper::StatusCode;
-use ruint::aliases::U256;
+use tap_core::tap_eip712_domain;
 use tokio::net::TcpListener;
 
 use log::{debug, info};
@@ -181,7 +179,7 @@ async fn main() -> Result<()> {
     info!("Shutting down...");
 
     // Stop the server and wait for it to finish gracefully.
-    handle.stop()?;
+    let _ = handle.stop();
     handle.stopped().await;
 
     debug!("Goodbye!");
@@ -215,14 +213,11 @@ fn create_eip712_domain(args: &Args) -> Result<Eip712Domain> {
     // Transfrom the args into the types expected by Eip712Domain::new().
 
     // Transform optional strings into optional Cow<str>.
-    let name = args.domain_name.clone().map(Cow::Owned);
-    let version = args.domain_version.clone().map(Cow::Owned);
-
     // Transform optional strings into optional U256.
     if args.domain_chain_id.is_some() {
         debug!("Parsing domain chain ID...");
     }
-    let chain_id: Option<U256> = args
+    let chain_id: Option<u64> = args
         .domain_chain_id
         .as_ref()
         .map(|s| s.parse())
@@ -231,17 +226,14 @@ fn create_eip712_domain(args: &Args) -> Result<Eip712Domain> {
     if args.domain_salt.is_some() {
         debug!("Parsing domain salt...");
     }
-    let salt: Option<FixedBytes<32>> = args.domain_salt.as_ref().map(|s| s.parse()).transpose()?;
 
     // Transform optional strings into optional Address.
     let verifying_contract: Option<Address> = args.domain_verifying_contract;
 
     // Create the EIP-712 domain separator.
-    Ok(Eip712Domain::new(
-        name,
-        version,
-        chain_id,
-        verifying_contract,
-        salt,
+    //
+    Ok(tap_eip712_domain(
+        chain_id.unwrap_or(1),
+        verifying_contract.unwrap_or_default(),
     ))
 }

tap_aggregator/src/tap_aggregator.rs

@@ -28,6 +28,26 @@ impl TryFrom<SignedReceipt> for tap_core::receipt::SignedReceipt {
     }
 }
 
+impl From<tap_core::receipt::Receipt> for Receipt {
+    fn from(value: tap_core::receipt::Receipt) -> Self {
+        Self {
+            allocation_id: value.allocation_id.as_slice().to_vec(),
+            timestamp_ns: value.timestamp_ns,
+            nonce: value.nonce,
+            value: Some(value.value.into()),
+        }
+    }
+}
+
+impl From<tap_core::receipt::SignedReceipt> for SignedReceipt {
+    fn from(value: tap_core::receipt::SignedReceipt) -> Self {
+        Self {
+            message: Some(value.message.into()),
+            signature: value.signature.as_bytes().to_vec(),
+        }
+    }
+}
+
 impl TryFrom<SignedRav> for EIP712SignedMessage<tap_core::rav::ReceiptAggregateVoucher> {
     type Error = anyhow::Error;
     fn try_from(voucher: SignedRav) -> Result<Self, Self::Error> {