interface for determining scw or eoa

Cargo.toml

@@ -48,6 +48,7 @@ tracing = "0.1"
 anyhow = "1.0"
 jsonrpsee = { version = "0.22", features = ["macros", "server", "client-core"] }
 tracing-subscriber = { version = "0.3.18", features = ["fmt", "env-filter"] }
+ctor = "0.2"
 
 # Internal Crate Dependencies
 xmtp_cryptography = { path = "xmtp_cryptography" }

examples/cli/cli-client.rs

@@ -12,7 +12,7 @@ extern crate xmtp_mls;
 use std::{fs, path::PathBuf, time::Duration};
 
 use clap::{Parser, Subcommand, ValueEnum};
-use ethers::signers::{coins_bip39::English, MnemonicBuilder};
+use ethers::signers::{coins_bip39::English, LocalWallet, MnemonicBuilder};
 use kv_log_macro::{error, info};
 use prost::Message;
 
@@ -25,7 +25,7 @@ use thiserror::Error;
 use xmtp_api_grpc::grpc_api_helper::Client as ApiClient;
 use xmtp_cryptography::{
     signature::{RecoverableSignature, SignatureError},
-    utils::{rng, LocalWallet},
+    utils::rng,
 };
 use xmtp_mls::{
     builder::{ClientBuilderError, IdentityStrategy, LegacyIdentity},

xmtp_cryptography/src/signature.rs

@@ -19,8 +19,8 @@ pub enum SignatureError {
     },
     #[error("Error creating signature")]
     SigningError(#[from] ecdsa::Error),
-    #[error("Error thrown from thirdParty")]
-    ThirdPartyError(String),
+    #[error("Error creating signature with ethers wallet")]
+    EthersWalletError(#[from] ethers::signers::WalletError),
     #[error("unknown data store error")]
     Unknown,
 }
@@ -74,6 +74,12 @@ impl RecoverableSignature {
     }
 }
 
+impl From<Vec<u8>> for RecoverableSignature {
+    fn from(value: Vec<u8>) -> Self {
+        RecoverableSignature::Eip191Signature(value)
+    }
+}
+
 impl From<RecoverableSignature> for Vec<u8> {
     fn from(value: RecoverableSignature) -> Self {
         match value {

xmtp_id/Cargo.toml

@@ -17,25 +17,15 @@ openmls.workspace = true
 openmls_basic_credential.workspace = true
 openmls_rust_crypto.workspace = true
 prost.workspace = true
-chrono.workspace = true
 serde.workspace = true
 async-trait.workspace = true
 futures.workspace = true
 sha2 = "0.10.8"
 rand.workspace = true
 hex.workspace = true
 ethers.workspace = true
-anyhow.workspace = true
 
 [dev-dependencies]
 tracing-subscriber.workspace = true 
-serde_json.workspace = true
-anyhow.workspace = true
 tokio = { workspace = true, features = ["time"] }
-jsonrpsee = { workspace = true, features = ["macros", "ws-client"] }
 ethers = { workspace = true, features = ["ws"] }
-tokio-test = "0.4"
-futures = "0.3"
-ctor = "0.2.5"
-surf = "2.3"
-regex = "1.10"

xmtp_id/src/erc1271_verifier.rs

@@ -1,9 +1,14 @@
-use anyhow::Error;
 use ethers::contract::abigen;
 use ethers::providers::{Http, Provider};
 use ethers::types::{Address, BlockNumber, Bytes};
-use std::convert::TryFrom;
 use std::sync::Arc;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum VerifierError {
+    #[error("calling smart contract {0}")]
+    Contract(#[from] ethers::contract::ContractError<Provider<Http>>),
+}
 
 const EIP1271_MAGIC_VALUE: [u8; 4] = [0x16, 0x26, 0xba, 0x7e];
 
@@ -15,6 +20,7 @@ abigen!(
     derives(serde::Serialize, serde::Deserialize)
 );
 
+#[derive(Debug)]
 pub struct ERC1271Verifier {
     pub provider: Arc<Provider<Http>>,
 }
@@ -38,7 +44,7 @@ impl ERC1271Verifier {
         block_number: Option<BlockNumber>,
         hash: [u8; 32],
         signature: Bytes,
-    ) -> Result<bool, Error> {
+    ) -> Result<bool, VerifierError> {
         let erc1271 = ERC1271::new(contract_address, self.provider.clone());
 
         let res: [u8; 4] = erc1271
@@ -56,16 +62,15 @@ mod tests {
     use super::*;
     use ethers::{
         abi::{self, Token},
-        providers::{Http, Middleware, Provider},
-        types::{Bytes, H256, U256},
+        providers::Middleware,
+        types::{H256, U256},
     };
 
     use ethers::{
         core::utils::Anvil,
         middleware::SignerMiddleware,
         signers::{LocalWallet, Signer as _},
     };
-    use std::{convert::TryFrom, sync::Arc};
 
     abigen!(
         CoinbaseSmartWallet,

xmtp_id/src/lib.rs

@@ -10,8 +10,7 @@ use openmls_traits::types::CryptoError;
 use thiserror::Error;
 use xmtp_mls::{
     configuration::CIPHERSUITE,
-    credential::Credential,
-    credential::{AssociationError, UnsignedGrantMessagingAccessData},
+    credential::{AssociationError, Credential, UnsignedGrantMessagingAccessData},
     types::Address,
     utils::time::now_ns,
 };
@@ -32,6 +31,11 @@ pub enum IdentityError {
     VerificationError(#[from] VerificationError),
 }
 
+#[async_trait::async_trait]
+pub trait WalletIdentity {
+    async fn is_smart_wallet(&self, block: Option<u64>) -> Result<bool, IdentityError>;
+}
+
 pub struct Identity {
     #[allow(dead_code)]
     pub(crate) account_address: Address,
@@ -89,3 +93,47 @@ impl Identity {
         Ok(credential.account_address().to_string())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ethers::{
+        middleware::Middleware,
+        providers::{Http, Provider},
+        types::Address,
+    };
+    use std::str::FromStr;
+    use xmtp_cryptography::utils::generate_local_wallet;
+    use xmtp_mls::InboxOwner;
+
+    struct EthereumWallet {
+        provider: Provider<Http>,
+        address: String,
+    }
+
+    impl EthereumWallet {
+        pub fn new(address: String) -> Self {
+            let provider = Provider::<Http>::try_from("https://eth.llamarpc.com").unwrap();
+            Self { provider, address }
+        }
+    }
+
+    #[async_trait::async_trait]
+    impl WalletIdentity for EthereumWallet {
+        async fn is_smart_wallet(&self, block: Option<u64>) -> Result<bool, IdentityError> {
+            let address = Address::from_str(&self.address).unwrap();
+            let res = self.provider.get_code(address, block.map(Into::into)).await;
+            Ok(!res.unwrap().to_vec().is_empty())
+        }
+    }
+
+    #[tokio::test]
+    async fn test_is_smart_wallet() {
+        let wallet = generate_local_wallet();
+        let eth = EthereumWallet::new(wallet.get_address());
+        let scw = EthereumWallet::new("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48".into());
+
+        assert!(!eth.is_smart_wallet(None).await.unwrap());
+        assert!(scw.is_smart_wallet(None).await.unwrap());
+    }
+}

xmtp_mls/Cargo.toml

@@ -47,7 +47,7 @@ xmtp_cryptography = { workspace = true }
 xmtp_v2 = { path = "../xmtp_v2" }
 
 [dev-dependencies]
-ctor = "0.2"
+ctor.workspace = true
 flume = "0.11"
 mockall = "0.11.4"
 tempfile = "3.5.0"

xmtp_mls/src/lib.rs

@@ -21,20 +21,24 @@ use storage::StorageError;
 use xmtp_cryptography::signature::{RecoverableSignature, SignatureError};
 
 pub trait InboxOwner {
+    /// Get address of the wallet.
     fn get_address(&self) -> String;
+    /// Sign text with the wallet.
     fn sign(&self, text: &str) -> Result<RecoverableSignature, SignatureError>;
 }
 
-// Inserts a model to the underlying data store
+/// Inserts a model to the underlying data store
 pub trait Store<StorageConnection> {
     fn store(&self, into: &StorageConnection) -> Result<(), StorageError>;
 }
 
+/// Fetches a model from the underlying data store
 pub trait Fetch<Model> {
     type Key;
     fn fetch(&self, key: &Self::Key) -> Result<Option<Model>, StorageError>;
 }
 
+/// Deletes a model from the underlying data store
 pub trait Delete<Model> {
     type Key;
     fn delete(&self, key: Self::Key) -> Result<usize, StorageError>;

xmtp_mls/src/owner/evm_owner.rs

@@ -11,9 +11,6 @@ impl InboxOwner for LocalWallet {
     }
 
     fn sign(&self, text: &str) -> Result<RecoverableSignature, SignatureError> {
-        let signature = executor::block_on(self.sign_message(text))
-            .map_err(|e| SignatureError::ThirdPartyError(e.to_string()))?;
-
-        Ok(RecoverableSignature::Eip191Signature(signature.to_vec()))
+        Ok(executor::block_on(self.sign_message(text))?.to_vec().into())
     }
 }

xmtp_mls/src/owner/mod.rs

@@ -1,2 +1 @@
-// #[cfg(feature = "ethers")]
 mod evm_owner;

xmtp_mls/src/storage/encrypted_store/mod.rs

@@ -256,7 +256,7 @@ where
 
 #[cfg(test)]
 mod tests {
-    use std::{boxed::Box, fs};
+    use std::fs;
 
     use super::{
         db_connection::DbConnection, identity::StoredIdentity, EncryptedMessageStore, StorageError,

xmtp_mls/src/storage/encrypted_store/refresh_state.rs

@@ -115,7 +115,7 @@ impl DbConnection<'_> {
 #[cfg(test)]
 pub(crate) mod tests {
     use super::*;
-    use crate::{storage::encrypted_store::tests::with_connection, Store};
+    use crate::storage::encrypted_store::tests::with_connection;
 
     #[test]
     fn get_cursor_with_no_existing_state() {