teach client to use v4

examples/cli/cli-client.rs

@@ -63,6 +63,8 @@ struct Cli {
     local: bool,
     #[clap(long, default_value_t = false)]
     json: bool,
+    #[clap(long, default_value_t = false)]
+    testnet: bool,
 }
 
 #[derive(ValueEnum, Debug, Copy, Clone)]
@@ -412,24 +414,45 @@ async fn create_client(cli: &Cli, account: IdentityStrategy) -> Result<Client, C
     let msg_store = get_encrypted_store(&cli.db).unwrap();
     let mut builder = ClientBuilder::new(account).store(msg_store);
 
-    if cli.local {
-        info!("Using local network");
-        builder = builder
-            .api_client(
-                ApiClient::create("http://localhost:5556".into(), false, false)
-                    .await
-                    .unwrap(),
-            )
-            .history_sync_url(MessageHistoryUrls::LOCAL_ADDRESS);
-    } else {
-        info!("Using dev network");
-        builder = builder
-            .api_client(
-                ApiClient::create("https://grpc.dev.xmtp.network:443".into(), true, false)
-                    .await
-                    .unwrap(),
-            )
-            .history_sync_url(MessageHistoryUrls::DEV_ADDRESS);
+    if cli.testnet {
+        if cli.local {
+            info!("Using local testnet network");
+            builder = builder
+                .api_client(
+                    ApiClient::create("http://localhost:5050".into(), false, true)
+                        .await
+                        .unwrap(),
+                );
+        } else {
+            info!("Using testnet network");
+            builder = builder
+                .api_client(
+                    ApiClient::create("https://grpc.testnet.xmtp.network:443".into(), true, true)
+                        .await
+                        .unwrap(),
+                );
+        }
+    }
+    else {
+        if cli.local {
+            info!("Using local network");
+            builder = builder
+                .api_client(
+                    ApiClient::create("http://localhost:5556".into(), false, false)
+                        .await
+                        .unwrap(),
+                )
+                .history_sync_url(MessageHistoryUrls::LOCAL_ADDRESS);
+        } else {
+            info!("Using dev network");
+            builder = builder
+                .api_client(
+                    ApiClient::create("https://grpc.dev.xmtp.network:443".into(), true, false)
+                        .await
+                        .unwrap(),
+                )
+                .history_sync_url(MessageHistoryUrls::DEV_ADDRESS);
+        }
     }
 
     let client = builder.build().await.map_err(CliError::ClientBuilder)?;

xmtp_api_grpc/src/conversions.rs

@@ -0,0 +1,14 @@
+use prost::Message;
+use xmtp_proto::xmtp::xmtpv4::{ClientEnvelope, PayerEnvelope, PublishEnvelopeRequest};
+
+pub fn wrap_client_envelope(req: ClientEnvelope) -> PublishEnvelopeRequest {
+    let mut buf = vec![];
+    req.encode(&mut buf).unwrap();
+
+    PublishEnvelopeRequest {
+        payer_envelope: Some(PayerEnvelope {
+            unsigned_client_envelope: buf,
+            payer_signature: None,
+        }),
+    }
+}

xmtp_api_grpc/src/grpc_api_helper.rs

@@ -32,6 +32,7 @@ use xmtp_proto::{
 use xmtp_proto::xmtp::xmtpv4::{BatchSubscribeEnvelopesRequest, BatchSubscribeEnvelopesResponse, ClientEnvelope, PayerEnvelope, PublishEnvelopeRequest, PublishEnvelopeResponse, QueryEnvelopesRequest, QueryEnvelopesResponse};
 use xmtp_proto::xmtp::xmtpv4::client_envelope::Payload;
 use xmtp_proto::xmtp::xmtpv4::replication_api_client::ReplicationApiClient;
+use crate::conversions::wrap_client_envelope;
 
 async fn create_tls_channel(address: String) -> Result<Channel, Error> {
     let channel = Channel::from_shared(address)
@@ -77,7 +78,7 @@ pub struct Client {
     pub(crate) app_version: MetadataValue<tonic::metadata::Ascii>,
     pub(crate) libxmtp_version: MetadataValue<tonic::metadata::Ascii>,
     pub(crate) replication_client: ReplicationApiClient<Channel>,
-    use_replication_v4: bool,
+    pub(crate) use_replication_v4: bool,
 }
 
 impl Client {
@@ -346,7 +347,7 @@ impl XmtpMlsClient for Client {
     async fn upload_key_package(&self, req: UploadKeyPackageRequest) -> Result<(), Error> {
         if self.use_replication_v4 {
             let client = &mut self.replication_client.clone();
-            let payload = wrap_client_envelope(req.to_client_envelope());
+            let payload = wrap_client_envelope(ClientEnvelope::from(req));
             let res = client.publish_envelope(payload).await;
             match res {
                 Ok(_) => Ok(()),
@@ -379,7 +380,7 @@ impl XmtpMlsClient for Client {
     async fn send_group_messages(&self, req: SendGroupMessagesRequest) -> Result<(), Error> {
         if self.use_replication_v4 {
             let client = &mut self.replication_client.clone();
-            let payload = wrap_client_envelope(req.to_client_envelope());
+            let payload = wrap_client_envelope(ClientEnvelope::from(req));
             let res = client.publish_envelope(payload).await;
             match res {
                 Ok(_) => Ok(()),
@@ -399,7 +400,7 @@ impl XmtpMlsClient for Client {
     async fn send_welcome_messages(&self, req: SendWelcomeMessagesRequest) -> Result<(), Error> {
         if self.use_replication_v4 {
             let client = &mut self.replication_client.clone();
-            let payload = wrap_client_envelope(req.to_client_envelope());
+            let payload = wrap_client_envelope(ClientEnvelope::from(req));
             let res = client.publish_envelope(payload).await;
             match res {
                 Ok(_) => Ok(()),
@@ -578,48 +579,4 @@ impl XmtpReplicationClient for Client {
 
         Ok(stream.into())
     }
-}
-
-
-trait ClientEnvelopeConversion {
-    fn to_client_envelope(self) -> ClientEnvelope;
-}
-
-impl ClientEnvelopeConversion for SendGroupMessagesRequest {
-    fn to_client_envelope(self) -> ClientEnvelope {
-        ClientEnvelope {
-            aad: None,
-            payload: Some(Payload::GroupMessage(self.messages.first().unwrap().clone()))
-        }
-    }
-}
-
-impl ClientEnvelopeConversion for SendWelcomeMessagesRequest {
-    fn to_client_envelope(self) -> ClientEnvelope {
-        ClientEnvelope {
-            aad: None,
-            payload: Some(Payload::WelcomeMessage(self.messages.first().unwrap().clone()))
-        }
-    }
-}
-
-impl ClientEnvelopeConversion for UploadKeyPackageRequest {
-    fn to_client_envelope(self) -> ClientEnvelope {
-        ClientEnvelope {
-            aad: None,
-            payload: Some(Payload::UploadKeyPackage(self))
-        }
-    }
-}
-
-fn wrap_client_envelope(req: ClientEnvelope) -> PublishEnvelopeRequest {
-    let mut buf = vec![];
-    req.encode(&mut buf).unwrap();
-
-    PublishEnvelopeRequest {
-        payer_envelope: Some(PayerEnvelope {
-            unsigned_client_envelope: buf,
-            payer_signature: None,
-        }),
-    }
 }

xmtp_api_grpc/src/identity.rs

@@ -6,23 +6,34 @@ use xmtp_proto::{
         GetInboxIdsResponse, PublishIdentityUpdateRequest, PublishIdentityUpdateResponse,
     },
 };
-
+use xmtp_proto::xmtp::xmtpv4::ClientEnvelope;
 use crate::Client;
+use crate::conversions::wrap_client_envelope;
 
 impl XmtpIdentityClient for Client {
     #[tracing::instrument(level = "trace", skip_all)]
     async fn publish_identity_update(
         &self,
         request: PublishIdentityUpdateRequest,
     ) -> Result<PublishIdentityUpdateResponse, Error> {
-        let client = &mut self.identity_client.clone();
+        if self.use_replication_v4 {
+            let client = &mut self.replication_client.clone();
+            let payload = wrap_client_envelope(ClientEnvelope::from(request));
+            let res = client.publish_envelope(payload).await;
+            match res {
+                Ok(_) => Ok(PublishIdentityUpdateResponse{}),
+                Err(e) => Err(Error::new(ErrorKind::MlsError).with(e)),
+            }
+        } else {
+            let client = &mut self.identity_client.clone();
 
-        let res = client
-            .publish_identity_update(self.build_request(request))
-            .await;
+            let res = client
+                .publish_identity_update(self.build_request(request))
+                .await;
 
-        res.map(|response| response.into_inner())
-            .map_err(|err| Error::new(ErrorKind::IdentityError).with(err))
+            res.map(|response| response.into_inner())
+                .map_err(|err| Error::new(ErrorKind::IdentityError).with(err))
+        }
     }
 
     #[tracing::instrument(level = "trace", skip_all)]

xmtp_api_grpc/src/lib.rs

@@ -1,10 +1,12 @@
 pub mod auth_token;
 pub mod grpc_api_helper;
 mod identity;
+mod conversions;
 
 pub const LOCALHOST_ADDRESS: &str = "http://localhost:5556";
 pub const DEV_ADDRESS: &str = "https://grpc.dev.xmtp.network:443";
 
+use prost::Message;
 pub use grpc_api_helper::{Client, GroupMessageStream, WelcomeMessageStream};
 
 #[cfg(test)]

xmtp_proto/src/convert.rs

@@ -1,3 +1,8 @@
+use crate::xmtp::identity::api::v1::PublishIdentityUpdateRequest;
+use crate::xmtp::mls::api::v1::{SendGroupMessagesRequest, SendWelcomeMessagesRequest, UploadKeyPackageRequest};
+use crate::xmtp::xmtpv4::client_envelope::Payload;
+use crate::xmtp::xmtpv4::ClientEnvelope;
+
 mod inbox_id {
 
     use crate::xmtp::identity::MlsCredential;
@@ -16,3 +21,39 @@ mod inbox_id {
         }
     }
 }
+
+impl From<SendWelcomeMessagesRequest> for ClientEnvelope {
+    fn from(req: SendWelcomeMessagesRequest) -> Self {
+        ClientEnvelope {
+            aad: None,
+            payload: Some(Payload::WelcomeMessage(req.messages.first().unwrap().clone()))
+        }
+    }
+}
+
+impl From<SendGroupMessagesRequest> for ClientEnvelope {
+    fn from(req: SendGroupMessagesRequest) -> Self {
+        ClientEnvelope {
+            aad: None,
+            payload: Some(Payload::GroupMessage(req.messages.first().unwrap().clone()))
+        }
+    }
+}
+
+impl From<UploadKeyPackageRequest> for ClientEnvelope {
+    fn from(req: UploadKeyPackageRequest) -> Self {
+        ClientEnvelope {
+            aad: None,
+            payload: Some(Payload::UploadKeyPackage(req))
+        }
+    }
+}
+
+impl From<PublishIdentityUpdateRequest> for ClientEnvelope {
+    fn from(req: PublishIdentityUpdateRequest) -> Self {
+        ClientEnvelope {
+            aad: None,
+            payload: Some(Payload::IdentityUpdate(req.identity_update.unwrap()))
+        }
+    }
+}