Migrate Identity

.gitignore

@@ -166,3 +166,6 @@ ecies_bindings_wasm/
 **/tracing-flamegraph.svg
 
 chain_urls.json
+
+# Mise Configs
+.mise.toml

bindings_ffi/Cargo.toml

@@ -9,6 +9,7 @@ crate-type = ["lib", "cdylib", "staticlib"]
 
 [dependencies]
 futures.workspace = true
+hex.workspace = true
 parking_lot.workspace = true
 prost.workspace = true
 thiserror.workspace = true

bindings_ffi/benches/create_client.rs

@@ -10,9 +10,9 @@ use xmtp_common::{
     bench::{bench_async_setup, BENCH_ROOT_SPAN},
     tmp_path,
 };
-use xmtp_id::InboxOwner;
+use xmtp_id::associations::test_utils::WalletTestExt;
 use xmtp_mls::utils::test::HISTORY_SYNC_URL;
-use xmtpv3::generate_inbox_id;
+use xmtpv3::identity::FfiPublicIdentifier;
 
 #[macro_use]
 extern crate tracing;
@@ -52,8 +52,9 @@ fn create_ffi_client(c: &mut Criterion) {
             || {
                 bench_async_setup(|| async {
                     let wallet = xmtp_cryptography::utils::generate_local_wallet();
+                    let ident = wallet.public_identifier();
                     let nonce = 1;
-                    let inbox_id = generate_inbox_id(wallet.get_address(), nonce).unwrap();
+                    let inbox_id = ident.inbox_id(nonce).unwrap();
                     let path = tmp_path();
                     let (url, is_secure) = network_url();
                     let api = xmtpv3::mls::connect_to_backend(url, is_secure)
@@ -62,20 +63,21 @@ fn create_ffi_client(c: &mut Criterion) {
                     (
                         api,
                         inbox_id,
-                        wallet.get_address(),
+                        wallet.public_identifier(),
                         nonce,
                         path,
                         span.clone(),
                     )
                 })
             },
-            |(api, inbox_id, address, nonce, path, span)| async move {
+            |(api, inbox_id, ident, nonce, path, span)| async move {
+                let ffi_ident: FfiPublicIdentifier = ident.into();
                 xmtpv3::mls::create_client(
                     api,
                     Some(path),
                     Some(vec![0u8; 32]),
                     &inbox_id,
-                    address,
+                    ffi_ident,
                     nonce,
                     None,
                     Some(HISTORY_SYNC_URL.to_string()),
@@ -99,9 +101,11 @@ fn cached_create_ffi_client(c: &mut Criterion) {
     let _ = fdlimit::raise_fd_limit();
     let mut benchmark_group = c.benchmark_group("create_client_from_cached");
     let wallet = xmtp_cryptography::utils::generate_local_wallet();
+    let ident = wallet.public_identifier();
     let nonce = 1;
-    let inbox_id = generate_inbox_id(wallet.get_address(), nonce).unwrap();
-    let address = wallet.get_address();
+    let inbox_id = ident.inbox_id(nonce).unwrap();
+    let ffi_ident: FfiPublicIdentifier = ident.into();
+    let address = wallet.public_identifier();
     let path = tmp_path();
     let (url, is_secure) = network_url();
     let api = runtime.block_on(async {
@@ -113,7 +117,7 @@ fn cached_create_ffi_client(c: &mut Criterion) {
             Some(path.clone()),
             Some(vec![0u8; 32]),
             &inbox_id.clone(),
-            address.clone(),
+            ffi_ident,
             nonce,
             None,
             Some(HISTORY_SYNC_URL.to_string()),
@@ -138,13 +142,14 @@ fn cached_create_ffi_client(c: &mut Criterion) {
                     span.clone(),
                 )
             },
-            |(api, inbox_id, address, nonce, path, history_sync, span)| async move {
+            |(api, inbox_id, ident, nonce, path, history_sync, span)| async move {
+                let ffi_ident: FfiPublicIdentifier = ident.into();
                 xmtpv3::mls::create_client(
                     api,
                     Some(path),
                     Some(vec![0u8; 32]),
                     &inbox_id,
-                    address,
+                    ffi_ident,
                     nonce,
                     None,
                     Some(history_sync),

bindings_ffi/build.rs

@@ -1,7 +1,6 @@
 use std::process::Command;
 
 fn main() {
-    uniffi::generate_scaffolding("./src/xmtpv3.udl").expect("Building the UDL file failed");
     Command::new("make")
         .args(["libxmtp-version"])
         .status()

bindings_ffi/gen_kotlin.sh

@@ -71,4 +71,3 @@ unzip -o LibXMTPKotlinFFI.zip
 cd ../../..
 
 cp -r $BINDINGS_PATH/src/uniffi/$PROJECT_NAME/jniLibs/* ~/XMTP/xmtp-android/library/src/main/jniLibs
-

bindings_ffi/src/identity.rs

@@ -0,0 +1,105 @@
+use std::fmt::Display;
+use xmtp_cryptography::signature::IdentifierValidationError;
+use xmtp_id::associations::{ident, PublicIdentifier};
+
+use crate::GenericError;
+
+#[derive(uniffi::Record, Hash, PartialEq, Eq, Clone)]
+pub struct FfiPublicIdentifier {
+    pub identifier: String,
+    pub identifier_kind: FfiPublicIdentifierKind,
+    pub relying_partner: Option<String>,
+}
+
+#[derive(uniffi::Enum, Hash, PartialEq, Eq, Clone)]
+pub enum FfiPublicIdentifierKind {
+    Ethereum,
+    Passkey,
+}
+
+impl FfiPublicIdentifier {
+    pub fn inbox_id(&self, nonce: u64) -> Result<String, GenericError> {
+        let ident: PublicIdentifier = self.clone().try_into().map_err(GenericError::from_error)?;
+        Ok(ident.inbox_id(nonce)?)
+    }
+}
+
+impl Display for FfiPublicIdentifier {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self.identifier_kind {
+            FfiPublicIdentifierKind::Ethereum => write!(f, "{}", self.identifier),
+            FfiPublicIdentifierKind::Passkey => write!(f, "{}", hex::encode(&self.identifier)),
+        }
+    }
+}
+
+#[allow(unused)]
+#[uniffi::export]
+pub fn generate_inbox_id(
+    account_identifier: FfiPublicIdentifier,
+    nonce: u64,
+) -> Result<String, GenericError> {
+    account_identifier.inbox_id(nonce)
+}
+
+impl From<PublicIdentifier> for FfiPublicIdentifier {
+    fn from(ident: PublicIdentifier) -> Self {
+        match ident {
+            PublicIdentifier::Ethereum(ident::Ethereum(addr)) => Self {
+                identifier: addr,
+                identifier_kind: FfiPublicIdentifierKind::Ethereum,
+                relying_partner: None,
+            },
+            PublicIdentifier::Passkey(ident::Passkey {
+                key,
+                relying_partner,
+            }) => Self {
+                identifier: hex::encode(key),
+                identifier_kind: FfiPublicIdentifierKind::Passkey,
+                relying_partner,
+            },
+        }
+    }
+}
+
+impl TryFrom<FfiPublicIdentifier> for PublicIdentifier {
+    type Error = IdentifierValidationError;
+    fn try_from(ident: FfiPublicIdentifier) -> Result<Self, Self::Error> {
+        let ident = match ident.identifier_kind {
+            FfiPublicIdentifierKind::Ethereum => Self::eth(ident.identifier)?,
+            FfiPublicIdentifierKind::Passkey => {
+                Self::passkey_str(&ident.identifier, ident.relying_partner)?
+            }
+        };
+        Ok(ident)
+    }
+}
+
+pub trait IdentityExt<T, U> {
+    fn to_internal(self) -> Result<Vec<U>, IdentifierValidationError>;
+}
+
+impl IdentityExt<FfiPublicIdentifier, PublicIdentifier> for Vec<FfiPublicIdentifier> {
+    fn to_internal(self) -> Result<Vec<PublicIdentifier>, IdentifierValidationError> {
+        let ident: Result<Vec<_>, IdentifierValidationError> =
+            self.into_iter().map(|ident| ident.try_into()).collect();
+        ident
+    }
+}
+
+pub trait FfiCollectionExt<T> {
+    fn to_ffi(self) -> Vec<T>;
+}
+impl FfiCollectionExt<FfiPublicIdentifier> for Vec<PublicIdentifier> {
+    fn to_ffi(self) -> Vec<FfiPublicIdentifier> {
+        self.into_iter().map(Into::into).collect()
+    }
+}
+pub trait FfiCollectionTryExt<T> {
+    fn to_internal(self) -> Result<Vec<T>, IdentifierValidationError>;
+}
+impl FfiCollectionTryExt<PublicIdentifier> for Vec<FfiPublicIdentifier> {
+    fn to_internal(self) -> Result<Vec<PublicIdentifier>, IdentifierValidationError> {
+        self.into_iter().map(|ident| ident.try_into()).collect()
+    }
+}

bindings_ffi/src/inbox_owner.rs

@@ -1,21 +1,32 @@
-use xmtp_cryptography::signature::{RecoverableSignature, SignatureError};
+use crate::identity::FfiPublicIdentifier;
+use xmtp_cryptography::signature::{
+    IdentifierValidationError, RecoverableSignature, SignatureError,
+};
+use xmtp_id::associations::PublicIdentifier;
 
 // TODO proper error handling
-#[derive(Debug, thiserror::Error)]
+#[derive(uniffi::Error, Debug, thiserror::Error)]
 pub enum SigningError {
     #[error("This is a generic error")]
     Generic,
 }
 
+#[derive(uniffi::Error, Debug, thiserror::Error)]
+pub enum IdentityValidationError {
+    #[error("Error: {0:?}")]
+    Generic(String),
+}
+
 impl From<uniffi::UnexpectedUniFFICallbackError> for SigningError {
     fn from(_: uniffi::UnexpectedUniFFICallbackError) -> Self {
         Self::Generic
     }
 }
 
 // A simplified InboxOwner passed to Rust across the FFI boundary
+#[uniffi::export(with_foreign)]
 pub trait FfiInboxOwner: Send + Sync {
-    fn get_address(&self) -> String;
+    fn get_identifier(&self) -> Result<FfiPublicIdentifier, IdentityValidationError>;
     fn sign(&self, text: String) -> Result<Vec<u8>, SigningError>;
 }
 
@@ -30,8 +41,12 @@ impl RustInboxOwner {
 }
 
 impl xmtp_mls::InboxOwner for RustInboxOwner {
-    fn get_address(&self) -> String {
-        self.ffi_inbox_owner.get_address().to_lowercase()
+    fn get_identifier(&self) -> Result<PublicIdentifier, IdentifierValidationError> {
+        let ident = self
+            .ffi_inbox_owner
+            .get_identifier()
+            .map_err(|err| IdentifierValidationError::Generic(err.to_string()))?;
+        ident.try_into()
     }
 
     fn sign(&self, text: &str) -> Result<RecoverableSignature, SignatureError> {

bindings_ffi/src/lib.rs

@@ -1,22 +1,18 @@
 #![recursion_limit = "256"]
 #![warn(clippy::unwrap_used)]
+pub mod identity;
 pub mod inbox_owner;
 pub mod logger;
 pub mod mls;
 
 pub use crate::inbox_owner::SigningError;
-use inbox_owner::FfiInboxOwner;
 pub use mls::*;
 use std::error::Error;
+use xmtp_cryptography::signature::IdentifierValidationError;
 
 extern crate tracing as log;
 
-pub use ffi::*;
-#[allow(clippy::all)]
-mod ffi {
-    use super::*;
-    uniffi::include_scaffolding!("xmtpv3");
-}
+uniffi::setup_scaffolding!("xmtpv3");
 
 #[derive(uniffi::Error, thiserror::Error, Debug)]
 #[uniffi(flat_error)]
@@ -63,6 +59,8 @@ pub enum GenericError {
     ApiClientBuild(#[from] xmtp_api_grpc::GrpcBuilderError),
     #[error(transparent)]
     Grpc(#[from] xmtp_api_grpc::GrpcError),
+    #[error(transparent)]
+    AddressValidation(#[from] IdentifierValidationError),
 }
 
 #[derive(uniffi::Error, thiserror::Error, Debug)]