feat(tap-core): changes eip712 and address components to alloy library

changes from using ethers-rs to using alloy which allows user defined domain separator.

BREAKING CHANGE: receipts, RAVs, and eip712-signed-message now use alloy primitive address

Signed-off-by: Bryan Cole <[email protected]>

Author: ColePBryan

tap_core/Cargo.toml

@@ -17,6 +17,8 @@ ethers-core = "2.0.0"
 ethers-contract = "2.0.0"
 ethers-contract-derive = "2.0.0"
 anyhow = "1"
+alloy-sol-types = { version = "0.3.1", features = ["eip712-serde"]}
+alloy-primitives = { version = "0.3.1", features = ["serde"]}
 
 strum = "0.24.1"
 strum_macros = "0.24.3"

tap_core/src/adapters/escrow_adapter.rs

@@ -1,8 +1,8 @@
 // Copyright 2023-, Semiotic AI, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
+use alloy_primitives::Address;
 use async_trait::async_trait;
-use ethereum_types::Address;
 
 /// `EscrowAdapter` defines a trait for adapters to handle escrow related operations.
 ///

tap_core/src/adapters/receipt_checks_adapter.rs

@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::{eip_712_signed_message::EIP712SignedMessage, tap_receipt::Receipt};
+use alloy_primitives::Address;
 use async_trait::async_trait;
-use ethereum_types::Address;
 
 /// `ReceiptChecksAdapter` defines a trait for adapters to handle checks related to TAP receipts.
 ///

tap_core/src/adapters/test/collateral_adapter_mock.rs

@@ -0,0 +1,86 @@
+// Copyright 2023-, Semiotic AI, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+use std::{collections::HashMap, sync::Arc};
+
+use alloy_primitives::Address;
+use async_trait::async_trait;
+use tokio::sync::RwLock;
+
+use crate::adapters::collateral_adapter::CollateralAdapter;
+
+pub struct CollateralAdapterMock {
+    gateway_collateral_storage: Arc<RwLock<HashMap<Address, u128>>>,
+}
+
+use thiserror::Error;
+#[derive(Debug, Error)]
+pub enum AdpaterErrorMock {
+    #[error("something went wrong: {error}")]
+    AdapterError { error: String },
+}
+
+impl CollateralAdapterMock {
+    pub fn new(gateway_collateral_storage: Arc<RwLock<HashMap<Address, u128>>>) -> Self {
+        CollateralAdapterMock {
+            gateway_collateral_storage,
+        }
+    }
+    pub async fn collateral(&self, gateway_id: Address) -> Result<u128, AdpaterErrorMock> {
+        let gateway_collateral_storage = self.gateway_collateral_storage.read().await;
+        if let Some(collateral) = gateway_collateral_storage.get(&gateway_id) {
+            return Ok(*collateral);
+        }
+        Err(AdpaterErrorMock::AdapterError {
+            error: "No collateral exists for provided gateway ID.".to_owned(),
+        })
+    }
+
+    pub async fn increase_collateral(&mut self, gateway_id: Address, value: u128) {
+        let mut gateway_collateral_storage = self.gateway_collateral_storage.write().await;
+
+        if let Some(current_value) = gateway_collateral_storage.get(&gateway_id) {
+            let mut gateway_collateral_storage = self.gateway_collateral_storage.write().await;
+            gateway_collateral_storage.insert(gateway_id, current_value + value);
+        } else {
+            gateway_collateral_storage.insert(gateway_id, value);
+        }
+    }
+
+    pub async fn reduce_collateral(
+        &self,
+        gateway_id: Address,
+        value: u128,
+    ) -> Result<(), AdpaterErrorMock> {
+        let mut gateway_collateral_storage = self.gateway_collateral_storage.write().await;
+
+        if let Some(current_value) = gateway_collateral_storage.get(&gateway_id) {
+            let checked_new_value = current_value.checked_sub(value);
+            if let Some(new_value) = checked_new_value {
+                gateway_collateral_storage.insert(gateway_id, new_value);
+                return Ok(());
+            }
+        }
+        Err(AdpaterErrorMock::AdapterError {
+            error: "Provided value is greater than existing collateral.".to_owned(),
+        })
+    }
+}
+
+#[async_trait]
+impl CollateralAdapter for CollateralAdapterMock {
+    type AdapterError = AdpaterErrorMock;
+    async fn get_available_collateral(
+        &self,
+        gateway_id: Address,
+    ) -> Result<u128, Self::AdapterError> {
+        self.collateral(gateway_id).await
+    }
+    async fn subtract_collateral(
+        &self,
+        gateway_id: Address,
+        value: u128,
+    ) -> Result<(), Self::AdapterError> {
+        self.reduce_collateral(gateway_id, value).await
+    }
+}

tap_core/src/adapters/test/escrow_adapter_mock.rs

@@ -3,8 +3,8 @@
 
 use std::{collections::HashMap, sync::Arc};
 
+use alloy_primitives::Address;
 use async_trait::async_trait;
-use ethereum_types::Address;
 use tokio::sync::RwLock;
 
 use crate::adapters::escrow_adapter::EscrowAdapter;

tap_core/src/adapters/test/escrow_adapter_test.rs

@@ -21,15 +21,17 @@ mod escrow_adapter_unit_test {
          .phrase("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about")
          .build()
          .unwrap();
-        let gateway_id = wallet.address();
+        let gateway_id: [u8; 20] = wallet.address().into();
+        let gateway_id = gateway_id.into();
 
         let invalid_wallet: LocalWallet = MnemonicBuilder::<English>::default()
             .phrase(
                 "wrong century settle satisfy market forest title connect ten push alley depend",
             )
             .build()
             .unwrap();
-        let invalid_gateway_id = invalid_wallet.address();
+        let invalid_gateway_id: [u8; 20] = invalid_wallet.address().into();
+        let invalid_gateway_id = invalid_gateway_id.into();
 
         let initial_value = 500u128;
 

tap_core/src/adapters/test/rav_storage_adapter_test.rs

@@ -5,7 +5,8 @@
 mod rav_storage_adapter_unit_test {
     use std::{str::FromStr, sync::Arc};
 
-    use ethereum_types::Address;
+    use alloy_primitives::Address;
+    use alloy_sol_types::{eip712_domain, Eip712Domain};
     use ethers::signers::coins_bip39::English;
     use ethers::signers::{LocalWallet, MnemonicBuilder};
     use rstest::*;
@@ -19,9 +20,19 @@ mod rav_storage_adapter_unit_test {
         receipt_aggregate_voucher::ReceiptAggregateVoucher, tap_receipt::Receipt,
     };
 
+    #[fixture]
+    fn domain_separator() -> Eip712Domain {
+        eip712_domain! {
+            name: "TAP",
+            version: "1",
+            chain_id: 1,
+            verifying_contract: Address::from([0x11u8; 20]),
+        }
+    }
+
     #[rstest]
     #[tokio::test]
-    async fn rav_storage_adapter_test() {
+    async fn rav_storage_adapter_test(domain_separator: Eip712Domain) {
         let rav_storage = Arc::new(RwLock::new(None));
         let rav_storage_adapter = RAVStorageAdapterMock::new(rav_storage);
 
@@ -30,20 +41,28 @@ mod rav_storage_adapter_unit_test {
          .build()
          .unwrap();
 
-        let allocation_id =
-            Address::from_str("0xabababababababababababababababababababab").unwrap();
+        let allocation_id: [u8; 20] =
+            Address::from_str("0xabababababababababababababababababababab")
+                .unwrap()
+                .into();
+        let allocation_id = allocation_id.into();
 
         // Create receipts
         let mut receipts = Vec::new();
         for value in 50..60 {
             receipts.push(
-                EIP712SignedMessage::new(Receipt::new(allocation_id, value).unwrap(), &wallet)
-                    .await
-                    .unwrap(),
+                EIP712SignedMessage::new(
+                    &domain_separator,
+                    Receipt::new(allocation_id, value).unwrap(),
+                    &wallet,
+                )
+                .await
+                .unwrap(),
             );
         }
 
         let signed_rav = EIP712SignedMessage::new(
+            &domain_separator,
             ReceiptAggregateVoucher::aggregate_receipts(allocation_id, &receipts, None).unwrap(),
             &wallet,
         )
@@ -65,13 +84,18 @@ mod rav_storage_adapter_unit_test {
         let mut receipts = Vec::new();
         for value in 60..70 {
             receipts.push(
-                EIP712SignedMessage::new(Receipt::new(allocation_id, value).unwrap(), &wallet)
-                    .await
-                    .unwrap(),
+                EIP712SignedMessage::new(
+                    &domain_separator,
+                    Receipt::new(allocation_id, value).unwrap(),
+                    &wallet,
+                )
+                .await
+                .unwrap(),
             );
         }
 
         let signed_rav = EIP712SignedMessage::new(
+            &domain_separator,
             ReceiptAggregateVoucher::aggregate_receipts(allocation_id, &receipts, None).unwrap(),
             &wallet,
         )

tap_core/src/adapters/test/receipt_checks_adapter_mock.rs

@@ -6,8 +6,8 @@ use std::{
     sync::Arc,
 };
 
+use alloy_primitives::Address;
 use async_trait::async_trait;
-use ethereum_types::Address;
 use thiserror::Error;
 use tokio::sync::RwLock;
 

tap_core/src/adapters/test/receipt_checks_adapter_test.rs

@@ -9,7 +9,8 @@ mod receipt_checks_adapter_unit_test {
         sync::Arc,
     };
 
-    use ethereum_types::Address;
+    use alloy_primitives::Address;
+    use alloy_sol_types::{eip712_domain, Eip712Domain};
     use ethers::signers::{coins_bip39::English, LocalWallet, MnemonicBuilder};
     use futures::{stream, StreamExt};
     use rstest::*;
@@ -24,9 +25,19 @@ mod receipt_checks_adapter_unit_test {
         tap_receipt::{get_full_list_of_checks, Receipt, ReceivedReceipt},
     };
 
+    #[fixture]
+    fn domain_separator() -> Eip712Domain {
+        eip712_domain! {
+            name: "TAP",
+            version: "1",
+            chain_id: 1,
+            verifying_contract: Address::from([0x11u8; 20]),
+        }
+    }
+
     #[rstest]
     #[tokio::test]
-    async fn receipt_checks_adapter_test() {
+    async fn receipt_checks_adapter_test(domain_separator: Eip712Domain) {
         let gateway_ids = [
             Address::from_str("0xfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfb").unwrap(),
             Address::from_str("0xfafafafafafafafafafafafafafafafafafafafa").unwrap(),
@@ -50,11 +61,13 @@ mod receipt_checks_adapter_unit_test {
         let receipts: HashMap<u64, ReceivedReceipt> = stream::iter(0..10)
             .then(|id| {
                 let wallet = wallet.clone();
+                let domain_separator = &domain_separator;
                 async move {
                     (
                         id,
                         ReceivedReceipt::new(
                             EIP712SignedMessage::new(
+                                domain_separator,
                                 Receipt::new(allocation_ids[0], value).unwrap(),
                                 &wallet,
                             )
@@ -84,9 +97,13 @@ mod receipt_checks_adapter_unit_test {
         let new_receipt = (
             10u64,
             ReceivedReceipt::new(
-                EIP712SignedMessage::new(Receipt::new(allocation_ids[0], value).unwrap(), &wallet)
-                    .await
-                    .unwrap(),
+                EIP712SignedMessage::new(
+                    &domain_separator,
+                    Receipt::new(allocation_ids[0], value).unwrap(),
+                    &wallet,
+                )
+                .await
+                .unwrap(),
                 10u64,
                 &get_full_list_of_checks(),
             ),

tap_core/src/adapters/test/receipt_storage_adapter_test.rs

@@ -7,7 +7,8 @@ mod receipt_storage_adapter_unit_test {
     use std::str::FromStr;
     use std::sync::Arc;
 
-    use ethereum_types::Address;
+    use alloy_primitives::Address;
+    use alloy_sol_types::{eip712_domain, Eip712Domain};
     use ethers::signers::coins_bip39::English;
     use ethers::signers::{LocalWallet, MnemonicBuilder};
     use rstest::*;
@@ -22,9 +23,19 @@ mod receipt_storage_adapter_unit_test {
         tap_receipt::Receipt, tap_receipt::ReceivedReceipt,
     };
 
+    #[fixture]
+    fn domain_separator() -> Eip712Domain {
+        eip712_domain! {
+            name: "TAP",
+            version: "1",
+            chain_id: 1,
+            verifying_contract: Address::from([0x11u8; 20]),
+        }
+    }
+
     #[rstest]
     #[tokio::test]
-    async fn receipt_adapter_test() {
+    async fn receipt_adapter_test(domain_separator: Eip712Domain) {
         let receipt_storage = Arc::new(RwLock::new(HashMap::new()));
         let mut receipt_adapter = ReceiptStorageAdapterMock::new(receipt_storage);
 
@@ -40,9 +51,13 @@ mod receipt_storage_adapter_unit_test {
         let query_id = 10u64;
         let value = 100u128;
         let received_receipt = ReceivedReceipt::new(
-            EIP712SignedMessage::new(Receipt::new(allocation_id, value).unwrap(), &wallet)
-                .await
-                .unwrap(),
+            EIP712SignedMessage::new(
+                &domain_separator,
+                Receipt::new(allocation_id, value).unwrap(),
+                &wallet,
+            )
+            .await
+            .unwrap(),
             query_id,
             &get_full_list_of_checks(),
         );
@@ -82,7 +97,7 @@ mod receipt_storage_adapter_unit_test {
 
     #[rstest]
     #[tokio::test]
-    async fn multi_receipt_adapter_test() {
+    async fn multi_receipt_adapter_test(domain_separator: Eip712Domain) {
         let receipt_storage = Arc::new(RwLock::new(HashMap::new()));
         let mut receipt_adapter = ReceiptStorageAdapterMock::new(receipt_storage);
 
@@ -98,9 +113,13 @@ mod receipt_storage_adapter_unit_test {
         let mut received_receipts = Vec::new();
         for (query_id, value) in (50..60).enumerate() {
             received_receipts.push(ReceivedReceipt::new(
-                EIP712SignedMessage::new(Receipt::new(allocation_id, value).unwrap(), &wallet)
-                    .await
-                    .unwrap(),
+                EIP712SignedMessage::new(
+                    &domain_separator,
+                    Receipt::new(allocation_id, value).unwrap(),
+                    &wallet,
+                )
+                .await
+                .unwrap(),
                 query_id as u64,
                 &get_full_list_of_checks(),
             ));