diff --git a/services/identity/src/grpc_services/authenticated.rs b/services/identity/src/grpc_services/authenticated.rs
index 56852a248..33eef0d4b 100644
--- a/services/identity/src/grpc_services/authenticated.rs
+++ b/services/identity/src/grpc_services/authenticated.rs
@@ -1,623 +1,625 @@
 use std::collections::HashMap;
 
 use crate::config::CONFIG;
 use crate::database::{DeviceListRow, DeviceListUpdate};
 use crate::{
   client_service::{handle_db_error, UpdateState, WorkflowInProgress},
   constants::request_metadata,
   database::DatabaseClient,
   ddb_utils::DateTimeExt,
   grpc_services::shared::get_value,
 };
 use chrono::{DateTime, Utc};
 use comm_opaque2::grpc::protocol_error_to_grpc_status;
 use tonic::{Request, Response, Status};
 use tracing::{debug, error, warn};
 
 use super::protos::auth::{
   identity, identity_client_service_server::IdentityClientService,
   GetDeviceListRequest, GetDeviceListResponse, Identity, InboundKeyInfo,
   InboundKeysForUserRequest, InboundKeysForUserResponse, KeyserverKeysResponse,
   LinkFarcasterAccountRequest, OutboundKeyInfo, OutboundKeysForUserRequest,
   OutboundKeysForUserResponse, RefreshUserPrekeysRequest,
   UpdateDeviceListRequest, UpdateUserPasswordFinishRequest,
   UpdateUserPasswordStartRequest, UpdateUserPasswordStartResponse,
   UploadOneTimeKeysRequest,
 };
 use super::protos::auth::{UserIdentityRequest, UserIdentityResponse};
 use super::protos::unauth::Empty;
 
 #[derive(derive_more::Constructor)]
 pub struct AuthenticatedService {
   db_client: DatabaseClient,
 }
 
 fn get_auth_info(req: &Request<()>) -> Option<(String, String, String)> {
   debug!("Retrieving auth info for request: {:?}", req);
 
   let user_id = get_value(req, request_metadata::USER_ID)?;
   let device_id = get_value(req, request_metadata::DEVICE_ID)?;
   let access_token = get_value(req, request_metadata::ACCESS_TOKEN)?;
 
   Some((user_id, device_id, access_token))
 }
 
 pub fn auth_interceptor(
   req: Request<()>,
   db_client: &DatabaseClient,
 ) -> Result<Request<()>, Status> {
   debug!("Intercepting request to check auth info: {:?}", req);
 
   let (user_id, device_id, access_token) = get_auth_info(&req)
     .ok_or_else(|| Status::unauthenticated("Missing credentials"))?;
 
   let handle = tokio::runtime::Handle::current();
   let new_db_client = db_client.clone();
 
   // This function cannot be `async`, yet must call the async db call
   // Force tokio to resolve future in current thread without an explicit .await
   let valid_token = tokio::task::block_in_place(move || {
     handle
       .block_on(new_db_client.verify_access_token(
         user_id,
         device_id,
         access_token,
       ))
       .map_err(handle_db_error)
   })?;
 
   if !valid_token {
     return Err(Status::aborted("Bad Credentials"));
   }
 
   Ok(req)
 }
 
 pub fn get_user_and_device_id<T>(
   request: &Request<T>,
 ) -> Result<(String, String), Status> {
   let user_id = get_value(request, request_metadata::USER_ID)
     .ok_or_else(|| Status::unauthenticated("Missing user_id field"))?;
   let device_id = get_value(request, request_metadata::DEVICE_ID)
     .ok_or_else(|| Status::unauthenticated("Missing device_id field"))?;
 
   Ok((user_id, device_id))
 }
 
 #[tonic::async_trait]
 impl IdentityClientService for AuthenticatedService {
   async fn refresh_user_prekeys(
     &self,
     request: Request<RefreshUserPrekeysRequest>,
   ) -> Result<Response<Empty>, Status> {
     let (user_id, device_id) = get_user_and_device_id(&request)?;
     let message = request.into_inner();
 
     debug!("Refreshing prekeys for user: {}", user_id);
 
     let content_keys = message
       .new_content_prekeys
       .ok_or_else(|| Status::invalid_argument("Missing content keys"))?;
     let notif_keys = message
       .new_notif_prekeys
       .ok_or_else(|| Status::invalid_argument("Missing notification keys"))?;
 
     self
       .db_client
       .update_device_prekeys(
         user_id,
         device_id,
         content_keys.into(),
         notif_keys.into(),
       )
       .await
       .map_err(handle_db_error)?;
 
     let response = Response::new(Empty {});
     Ok(response)
   }
 
   async fn get_outbound_keys_for_user(
     &self,
     request: tonic::Request<OutboundKeysForUserRequest>,
   ) -> Result<tonic::Response<OutboundKeysForUserResponse>, tonic::Status> {
     let message = request.into_inner();
     let user_id = &message.user_id;
 
     let devices_map = self
       .db_client
       .get_keys_for_user(user_id, true)
       .await
       .map_err(handle_db_error)?
       .ok_or_else(|| tonic::Status::not_found("user not found"))?;
 
     let transformed_devices = devices_map
       .into_iter()
       .map(|(key, device_info)| (key, OutboundKeyInfo::from(device_info)))
       .collect::<HashMap<_, _>>();
 
     Ok(tonic::Response::new(OutboundKeysForUserResponse {
       devices: transformed_devices,
     }))
   }
 
   async fn get_inbound_keys_for_user(
     &self,
     request: tonic::Request<InboundKeysForUserRequest>,
   ) -> Result<tonic::Response<InboundKeysForUserResponse>, tonic::Status> {
     use identity::IdentityInfo;
 
     let message = request.into_inner();
     let user_id = &message.user_id;
 
     let devices_map = self
       .db_client
       .get_keys_for_user(user_id, false)
       .await
       .map_err(handle_db_error)?
       .ok_or_else(|| tonic::Status::not_found("user not found"))?;
 
     let transformed_devices = devices_map
       .into_iter()
       .map(|(key, device_info)| (key, InboundKeyInfo::from(device_info)))
       .collect::<HashMap<_, _>>();
 
     let identifier = self
       .db_client
       .get_user_identifier(user_id)
       .await
       .map_err(handle_db_error)?
       .ok_or_else(|| tonic::Status::not_found("user not found"))?;
 
     let identity_info = IdentityInfo::try_from(identifier)?;
 
     Ok(tonic::Response::new(InboundKeysForUserResponse {
       devices: transformed_devices,
       identity: Some(Identity {
         identity_info: Some(identity_info),
       }),
     }))
   }
 
   async fn get_keyserver_keys(
     &self,
     request: Request<OutboundKeysForUserRequest>,
   ) -> Result<Response<KeyserverKeysResponse>, Status> {
     use identity::IdentityInfo;
 
     let message = request.into_inner();
 
     let identifier = self
       .db_client
       .get_user_identifier(&message.user_id)
       .await
       .map_err(handle_db_error)?
       .ok_or_else(|| tonic::Status::not_found("user not found"))?;
     let identity_info = IdentityInfo::try_from(identifier)?;
     let identity = Some(Identity {
       identity_info: Some(identity_info),
     });
 
-    let keyserver_info = self
+    let Some(keyserver_info) = self
       .db_client
       .get_keyserver_keys_for_user(&message.user_id)
       .await
       .map_err(handle_db_error)?
-      .map(OutboundKeyInfo::from);
+    else {
+      return Err(Status::not_found("keyserver not found"));
+    };
 
     let primary_device_data = self
       .db_client
       .get_primary_device_data(&message.user_id)
       .await
       .map_err(handle_db_error)?;
     let primary_device_keys = primary_device_data.device_key_info;
 
     let response = Response::new(KeyserverKeysResponse {
-      keyserver_info,
+      keyserver_info: Some(keyserver_info.into()),
       identity,
       primary_device_identity_info: Some(primary_device_keys.into()),
     });
 
     return Ok(response);
   }
 
   async fn upload_one_time_keys(
     &self,
     request: tonic::Request<UploadOneTimeKeysRequest>,
   ) -> Result<tonic::Response<Empty>, tonic::Status> {
     let (user_id, device_id) = get_user_and_device_id(&request)?;
     let message = request.into_inner();
 
     debug!("Attempting to update one time keys for user: {}", user_id);
     self
       .db_client
       .append_one_time_prekeys(
         device_id,
         message.content_one_time_prekeys,
         message.notif_one_time_prekeys,
       )
       .await
       .map_err(handle_db_error)?;
 
     Ok(tonic::Response::new(Empty {}))
   }
 
   async fn update_user_password_start(
     &self,
     request: tonic::Request<UpdateUserPasswordStartRequest>,
   ) -> Result<tonic::Response<UpdateUserPasswordStartResponse>, tonic::Status>
   {
     let (user_id, _) = get_user_and_device_id(&request)?;
     let message = request.into_inner();
 
     let server_registration = comm_opaque2::server::Registration::new();
     let server_message = server_registration
       .start(
         &CONFIG.server_setup,
         &message.opaque_registration_request,
         user_id.as_bytes(),
       )
       .map_err(protocol_error_to_grpc_status)?;
 
     let update_state = UpdateState { user_id };
     let session_id = self
       .db_client
       .insert_workflow(WorkflowInProgress::Update(update_state))
       .await
       .map_err(handle_db_error)?;
 
     let response = UpdateUserPasswordStartResponse {
       session_id,
       opaque_registration_response: server_message,
     };
     Ok(Response::new(response))
   }
 
   async fn update_user_password_finish(
     &self,
     request: tonic::Request<UpdateUserPasswordFinishRequest>,
   ) -> Result<tonic::Response<Empty>, tonic::Status> {
     let message = request.into_inner();
 
     let Some(WorkflowInProgress::Update(state)) = self
       .db_client
       .get_workflow(message.session_id)
       .await
       .map_err(handle_db_error)?
     else {
       return Err(tonic::Status::not_found("session not found"));
     };
 
     let server_registration = comm_opaque2::server::Registration::new();
     let password_file = server_registration
       .finish(&message.opaque_registration_upload)
       .map_err(protocol_error_to_grpc_status)?;
 
     self
       .db_client
       .update_user_password(state.user_id, password_file)
       .await
       .map_err(handle_db_error)?;
 
     let response = Empty {};
     Ok(Response::new(response))
   }
 
   async fn log_out_user(
     &self,
     request: tonic::Request<Empty>,
   ) -> Result<tonic::Response<Empty>, tonic::Status> {
     let (user_id, device_id) = get_user_and_device_id(&request)?;
 
     self
       .db_client
       .remove_device(&user_id, &device_id)
       .await
       .map_err(handle_db_error)?;
 
     self
       .db_client
       .delete_access_token_data(user_id, device_id)
       .await
       .map_err(handle_db_error)?;
 
     let response = Empty {};
     Ok(Response::new(response))
   }
 
   async fn delete_user(
     &self,
     request: tonic::Request<Empty>,
   ) -> Result<tonic::Response<Empty>, tonic::Status> {
     let (user_id, _) = get_user_and_device_id(&request)?;
 
     self
       .db_client
       .delete_user(user_id)
       .await
       .map_err(handle_db_error)?;
 
     let response = Empty {};
     Ok(Response::new(response))
   }
 
   async fn get_device_list_for_user(
     &self,
     request: tonic::Request<GetDeviceListRequest>,
   ) -> Result<tonic::Response<GetDeviceListResponse>, tonic::Status> {
     let GetDeviceListRequest {
       user_id,
       since_timestamp,
     } = request.into_inner();
 
     let since = since_timestamp
       .map(|timestamp| {
         DateTime::<Utc>::from_utc_timestamp_millis(timestamp)
           .ok_or_else(|| tonic::Status::invalid_argument("Invalid timestamp"))
       })
       .transpose()?;
 
     let mut db_result = self
       .db_client
       .get_device_list_history(user_id, since)
       .await
       .map_err(handle_db_error)?;
 
     // these should be sorted already, but just in case
     db_result.sort_by_key(|list| list.timestamp);
 
     let device_list_updates: Vec<SignedDeviceList> = db_result
       .into_iter()
       .map(RawDeviceList::from)
       .map(SignedDeviceList::try_from_raw)
       .collect::<Result<Vec<_>, _>>()?;
 
     let stringified_updates = device_list_updates
       .iter()
       .map(serde_json::to_string)
       .collect::<Result<Vec<_>, _>>()
       .map_err(|err| {
         error!("Failed to serialize device list updates: {}", err);
         tonic::Status::failed_precondition("unexpected error")
       })?;
 
     Ok(Response::new(GetDeviceListResponse {
       device_list_updates: stringified_updates,
     }))
   }
 
   async fn update_device_list(
     &self,
     request: tonic::Request<UpdateDeviceListRequest>,
   ) -> Result<Response<Empty>, tonic::Status> {
     let (user_id, _device_id) = get_user_and_device_id(&request)?;
     // TODO: when we stop doing "primary device rotation" (migration procedure)
     // we should verify if this RPC is called by primary device only
 
     let new_list = SignedDeviceList::try_from(request.into_inner())?;
     let update = DeviceListUpdate::try_from(new_list)?;
     self
       .db_client
       .apply_devicelist_update(&user_id, update)
       .await
       .map_err(handle_db_error)?;
 
     Ok(Response::new(Empty {}))
   }
 
   async fn link_farcaster_account(
     &self,
     request: tonic::Request<LinkFarcasterAccountRequest>,
   ) -> Result<Response<Empty>, tonic::Status> {
     let (user_id, _) = get_user_and_device_id(&request)?;
     let message = request.into_inner();
 
     let mut get_farcaster_users_response = self
       .db_client
       .get_farcaster_users(vec![message.farcaster_id.clone()])
       .await
       .map_err(handle_db_error)?;
 
     if get_farcaster_users_response.len() > 1 {
       error!("multiple users associated with the same Farcaster ID");
       return Err(Status::failed_precondition("cannot link Farcaster ID"));
     }
 
     if let Some(u) = get_farcaster_users_response.pop() {
       if u.0.user_id == user_id {
         return Ok(Response::new(Empty {}));
       } else {
         return Err(Status::already_exists(
           "farcaster ID already associated with different user",
         ));
       }
     }
 
     self
       .db_client
       .add_farcaster_id(user_id, message.farcaster_id)
       .await
       .map_err(handle_db_error)?;
 
     let response = Empty {};
     Ok(Response::new(response))
   }
 
   async fn unlink_farcaster_account(
     &self,
     request: tonic::Request<Empty>,
   ) -> Result<Response<Empty>, tonic::Status> {
     let (user_id, _) = get_user_and_device_id(&request)?;
 
     self
       .db_client
       .remove_farcaster_id(user_id)
       .await
       .map_err(handle_db_error)?;
 
     let response = Empty {};
     Ok(Response::new(response))
   }
 
   async fn find_user_identity(
     &self,
     request: tonic::Request<UserIdentityRequest>,
   ) -> Result<Response<UserIdentityResponse>, tonic::Status> {
     use identity::IdentityInfo;
 
     let message = request.into_inner();
     let identifier = self
       .db_client
       .get_user_identifier(&message.user_id)
       .await
       .map_err(handle_db_error)?
       .ok_or_else(|| tonic::Status::not_found("user not found"))?;
 
     let identity_info = IdentityInfo::try_from(identifier)?;
     let identity = Some(Identity {
       identity_info: Some(identity_info),
     });
 
     let response = Response::new(UserIdentityResponse { identity });
     return Ok(response);
   }
 }
 
 // raw device list that can be serialized to JSON (and then signed in the future)
 #[derive(serde::Serialize, serde::Deserialize)]
 struct RawDeviceList {
   devices: Vec<String>,
   timestamp: i64,
 }
 
 impl From<DeviceListRow> for RawDeviceList {
   fn from(row: DeviceListRow) -> Self {
     Self {
       devices: row.device_ids,
       timestamp: row.timestamp.timestamp_millis(),
     }
   }
 }
 
 #[derive(serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct SignedDeviceList {
   /// JSON-stringified [`RawDeviceList`]
   raw_device_list: String,
 }
 
 impl SignedDeviceList {
   /// Serialize (and sign in the future) a [`RawDeviceList`]
   fn try_from_raw(raw: RawDeviceList) -> Result<Self, tonic::Status> {
     let stringified_list = serde_json::to_string(&raw).map_err(|err| {
       error!("Failed to serialize raw device list: {}", err);
       tonic::Status::failed_precondition("unexpected error")
     })?;
 
     Ok(Self {
       raw_device_list: stringified_list,
     })
   }
 
   fn as_raw(&self) -> Result<RawDeviceList, tonic::Status> {
     // The device list payload is sent as an escaped JSON payload.
     // Escaped double quotes need to be trimmed before attempting to deserialize
     serde_json::from_str(&self.raw_device_list.replace(r#"\""#, r#"""#))
       .map_err(|err| {
         warn!("Failed to deserialize raw device list: {}", err);
         tonic::Status::invalid_argument("invalid device list payload")
       })
   }
 }
 
 impl TryFrom<UpdateDeviceListRequest> for SignedDeviceList {
   type Error = tonic::Status;
   fn try_from(request: UpdateDeviceListRequest) -> Result<Self, Self::Error> {
     serde_json::from_str(&request.new_device_list).map_err(|err| {
       warn!("Failed to deserialize device list update: {}", err);
       tonic::Status::invalid_argument("invalid device list payload")
     })
   }
 }
 
 impl TryFrom<SignedDeviceList> for DeviceListUpdate {
   type Error = tonic::Status;
   fn try_from(signed_list: SignedDeviceList) -> Result<Self, Self::Error> {
     let RawDeviceList {
       devices,
       timestamp: raw_timestamp,
     } = signed_list.as_raw()?;
     let timestamp = DateTime::<Utc>::from_utc_timestamp_millis(raw_timestamp)
       .ok_or_else(|| {
       error!("Failed to parse RawDeviceList timestamp!");
       tonic::Status::invalid_argument("invalid timestamp")
     })?;
     Ok(DeviceListUpdate::new(devices, timestamp))
   }
 }
 
 #[cfg(test)]
 mod tests {
   use super::*;
 
   #[test]
   fn serialize_device_list_updates() {
     let raw_updates = vec![
       RawDeviceList {
         devices: vec!["device1".into()],
         timestamp: 111111111,
       },
       RawDeviceList {
         devices: vec!["device1".into(), "device2".into()],
         timestamp: 222222222,
       },
     ];
 
     let expected_raw_list1 = r#"{"devices":["device1"],"timestamp":111111111}"#;
     let expected_raw_list2 =
       r#"{"devices":["device1","device2"],"timestamp":222222222}"#;
 
     let signed_updates = raw_updates
       .into_iter()
       .map(SignedDeviceList::try_from_raw)
       .collect::<Result<Vec<_>, _>>()
       .expect("signing device list updates failed");
 
     assert_eq!(signed_updates[0].raw_device_list, expected_raw_list1);
     assert_eq!(signed_updates[1].raw_device_list, expected_raw_list2);
 
     let stringified_updates = signed_updates
       .iter()
       .map(serde_json::to_string)
       .collect::<Result<Vec<_>, _>>()
       .expect("serialize signed device lists failed");
 
     let expected_stringified_list1 = r#"{"rawDeviceList":"{\"devices\":[\"device1\"],\"timestamp\":111111111}"}"#;
     let expected_stringified_list2 = r#"{"rawDeviceList":"{\"devices\":[\"device1\",\"device2\"],\"timestamp\":222222222}"}"#;
 
     assert_eq!(stringified_updates[0], expected_stringified_list1);
     assert_eq!(stringified_updates[1], expected_stringified_list2);
   }
 
   #[test]
   fn deserialize_device_list_update() {
     let raw_payload = r#"{"rawDeviceList":"{\"devices\":[\"device1\",\"device2\"],\"timestamp\":123456789}"}"#;
     let request = UpdateDeviceListRequest {
       new_device_list: raw_payload.to_string(),
     };
 
     let signed_list = SignedDeviceList::try_from(request)
       .expect("Failed to parse SignedDeviceList");
     let update = DeviceListUpdate::try_from(signed_list)
       .expect("Failed to parse DeviceListUpdate from signed list");
 
     let expected_timestamp =
       DateTime::<Utc>::from_utc_timestamp_millis(123456789).unwrap();
 
     assert_eq!(update.timestamp, expected_timestamp);
     assert_eq!(
       update.devices,
       vec!["device1".to_string(), "device2".to_string()]
     );
   }
 }
diff --git a/shared/protos/identity_auth.proto b/shared/protos/identity_auth.proto
index 25ea2674c..2ae00e689 100644
--- a/shared/protos/identity_auth.proto
+++ b/shared/protos/identity_auth.proto
@@ -1,229 +1,229 @@
 syntax = "proto3";
 
 import "identity_unauth.proto";
 
 package identity.auth;
 
 // RPCs from a client (iOS, Android, or web) to identity service
 //
 // This service will assert authenticity of a device by verifying the access
 // token through an interceptor, thus avoiding the need to explicitly pass
 // the credentials on every request
 service IdentityClientService {
 
   /* X3DH actions */
 
   // Replenish one-time preKeys
   rpc UploadOneTimeKeys(UploadOneTimeKeysRequest)
     returns (identity.unauth.Empty) {}
   // Rotate a device's prekey and prekey signature
   // Rotated for deniability of older messages
   rpc RefreshUserPrekeys(RefreshUserPrekeysRequest)
     returns (identity.unauth.Empty) {}
 
   // Called by clients to get all device keys associated with a user in order
   // to open a new channel of communication on any of their devices.
   // Specially, this will return the following per device:
   //   - Identity keys (both Content and Notif Keys)
   //   - Prekey (including prekey signature)
   //   - One-time Prekey
   rpc GetOutboundKeysForUser(OutboundKeysForUserRequest) returns
     (OutboundKeysForUserResponse) {}
   // Called by receivers of a communication request. The reponse will return
   // identity keys (both content and notif keys) and related prekeys per device,
   // but will not contain one-time keys. Additionally, the response will contain
   // the other user's username.
   rpc GetInboundKeysForUser(InboundKeysForUserRequest) returns
     (InboundKeysForUserResponse) {}
   // Called by clients to get required keys for opening a connection
   // to a user's keyserver
   rpc GetKeyserverKeys(OutboundKeysForUserRequest) returns
     (KeyserverKeysResponse) {}
 
   /* Account actions */
 
   // Called by user to update password and receive new access token
   rpc UpdateUserPasswordStart(UpdateUserPasswordStartRequest) returns
     (UpdateUserPasswordStartResponse) {}
   rpc UpdateUserPasswordFinish(UpdateUserPasswordFinishRequest) returns
     (identity.unauth.Empty) {}
 
   // Called by user to log out (clears device's keys and access token)
   rpc LogOutUser(identity.unauth.Empty) returns (identity.unauth.Empty) {}
   // Called by a user to delete their own account
   rpc DeleteUser(identity.unauth.Empty) returns (identity.unauth.Empty) {}
 
   /* Device list actions */
 
   // Returns device list history
   rpc GetDeviceListForUser(GetDeviceListRequest) returns
     (GetDeviceListResponse) {}
 
   rpc UpdateDeviceList(UpdateDeviceListRequest) returns
     (identity.unauth.Empty) {}
 
   /* Farcaster actions */
 
   // Called by an existing user to link their Farcaster account
   rpc LinkFarcasterAccount(LinkFarcasterAccountRequest) returns
     (identity.unauth.Empty) {}
   // Called by an existing user to unlink their Farcaster account
   rpc UnlinkFarcasterAccount(identity.unauth.Empty) returns
     (identity.unauth.Empty) {}
 
   /* Miscellaneous actions */
 
   rpc FindUserIdentity(UserIdentityRequest) returns (UserIdentityResponse) {}
 }
 
 // Helper types
 
 message EthereumIdentity {
   string wallet_address = 1;
   string social_proof = 2;
 }
 
 message Identity {
   oneof identity_info {
     string username = 1;
     EthereumIdentity eth_identity = 2;
   }
 }
 
 // UploadOneTimeKeys
 
 // As OPKs get exhausted, they need to be refreshed
 message UploadOneTimeKeysRequest {
   repeated string content_one_time_prekeys = 1;
   repeated string notif_one_time_prekeys = 2;
 }
 
 
 // RefreshUserPreKeys
 
 message RefreshUserPrekeysRequest {
   identity.unauth.Prekey new_content_prekeys = 1;
   identity.unauth.Prekey new_notif_prekeys = 2;
 }
 
 // Information needed when establishing communication to someone else's device
 message OutboundKeyInfo {
   identity.unauth.IdentityKeyInfo identity_info = 1;
   identity.unauth.Prekey content_prekey = 2;
   identity.unauth.Prekey notif_prekey = 3;
   optional string one_time_content_prekey = 4;
   optional string one_time_notif_prekey = 5;
 }
 
 message KeyserverKeysResponse {
-  optional OutboundKeyInfo keyserver_info = 1;
+  OutboundKeyInfo keyserver_info = 1;
   Identity identity = 2;
   identity.unauth.IdentityKeyInfo primary_device_identity_info = 3;
 }
 
 // GetOutboundKeysForUser
 
 message OutboundKeysForUserResponse {
   // Map is keyed on devices' public ed25519 key used for signing
   map<string, OutboundKeyInfo> devices = 1;
 }
 
 // Information needed by a device to establish communcation when responding
 // to a request.
 // The device receiving a request only needs the content key and prekey.
 message OutboundKeysForUserRequest {
   string user_id = 1;
 }
 
 // GetInboundKeysForUser
 
 message InboundKeyInfo {
   identity.unauth.IdentityKeyInfo identity_info = 1;
   identity.unauth.Prekey content_prekey = 2;
   identity.unauth.Prekey notif_prekey = 3;
 }
 
 message InboundKeysForUserResponse {
   // Map is keyed on devices' public ed25519 key used for signing
   map<string, InboundKeyInfo> devices = 1;
   Identity identity = 2;
 }
 
 message InboundKeysForUserRequest {
   string user_id = 1;
 }
 
 // UpdateUserPassword
 
 // Request for updating a user, similar to registration but need a
 // access token to validate user before updating password
 message UpdateUserPasswordStartRequest {
   // Message sent to initiate PAKE registration (step 1)
   bytes opaque_registration_request = 1;
 }
 
 // Do a user registration, but overwrite the existing credentials
 // after validation of user
 message UpdateUserPasswordFinishRequest {
   // Identifier used to correlate start and finish request
   string session_id = 1;
   // Opaque client registration upload (step 3)
   bytes opaque_registration_upload = 2;
 }
 
 message UpdateUserPasswordStartResponse {
   // Identifier used to correlate start request with finish request
   string session_id = 1;
   bytes opaque_registration_response = 2;
 }
 
 // GetDeviceListForUser
 
 message GetDeviceListRequest {
   // User whose device lists we want to retrieve
   string user_id = 1;
   // UTC timestamp in milliseconds
   // If none, whole device list history will be retrieved
   optional int64 since_timestamp = 2;
 }
 
 message GetDeviceListResponse {
   // A list of stringified JSON objects of the following format:
   // {
   //   "rawDeviceList": JSON.stringify({
   //     "devices": [<device_id: string>, ...]
   //     "timestamp": <UTC timestamp in milliseconds: int>,
   //   })
   // }
   repeated string device_list_updates = 1;
 }
 
 // UpdateDeviceListForUser
 
 message UpdateDeviceListRequest {
   // A stringified JSON object of the following format:
   // {
   //   "rawDeviceList": JSON.stringify({
   //     "devices": [<device_id: string>, ...]
   //     "timestamp": <UTC timestamp in milliseconds: int>,
   //   })
   // }
   string new_device_list = 1;
 }
 
 // LinkFarcasterAccount
 
 message LinkFarcasterAccountRequest {
   string farcaster_id = 1;
 }
 
 // FindUserIdentity
 
 message UserIdentityRequest {
   // user ID for which we want to get the identity
   string user_id = 1;
 }
 
 message UserIdentityResponse {
   Identity identity = 1;
 }
diff --git a/web/protobufs/identity-auth-structs.cjs.flow b/web/protobufs/identity-auth-structs.cjs.flow
index a6b739af7..6bdb98a44 100644
--- a/web/protobufs/identity-auth-structs.cjs.flow
+++ b/web/protobufs/identity-auth-structs.cjs.flow
@@ -1,446 +1,446 @@
 // @flow
 
 import {
   Message,
   BinaryWriter,
   BinaryReader,
   Map as ProtoMap,
 } from 'google-protobuf';
 
 import * as identityStructs from './identity-unauth-structs.cjs';
 
 declare export class EthereumIdentity extends Message {
   getWalletAddress(): string;
   setWalletAddress(value: string): EthereumIdentity;
 
   getSocialProof(): string;
   setSocialProof(value: string): EthereumIdentity;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): EthereumIdentityObject;
   static toObject(includeInstance: boolean, msg: EthereumIdentity): EthereumIdentityObject;
   static serializeBinaryToWriter(message: EthereumIdentity, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): EthereumIdentity;
   static deserializeBinaryFromReader(message: EthereumIdentity, reader: BinaryReader): EthereumIdentity;
 }
 
 export type EthereumIdentityObject = {
   walletAddress: string,
   socialProof: string,
 }
 
 export type IdentityInfoCase = 0 | 1 | 2;
 
 declare export class Identity extends Message {
   getUsername(): string;
   setUsername(value: string): Identity;
 
   getEthIdentity(): EthereumIdentity | void;
   setEthIdentity(value?: EthereumIdentity): Identity;
   hasEthIdentity(): boolean;
   clearEthIdentity(): Identity;
 
   getIdentityInfoCase(): IdentityInfoCase;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): IdentityObject;
   static toObject(includeInstance: boolean, msg: Identity): IdentityObject;
   static serializeBinaryToWriter(message: Identity, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): Identity;
   static deserializeBinaryFromReader(message: Identity, reader: BinaryReader): Identity;
 }
 
 export type IdentityObject = {
   username: string,
   ethIdentity: ?EthereumIdentityObject,
 }
 
 declare export class UploadOneTimeKeysRequest extends Message {
   getContentOneTimePrekeysList(): Array<string>;
   setContentOneTimePrekeysList(value: Array<string>): UploadOneTimeKeysRequest;
   clearContentOneTimePrekeysList(): UploadOneTimeKeysRequest;
   addContentOneTimePrekeys(value: string, index?: number): UploadOneTimeKeysRequest;
 
   getNotifOneTimePrekeysList(): Array<string>;
   setNotifOneTimePrekeysList(value: Array<string>): UploadOneTimeKeysRequest;
   clearNotifOneTimePrekeysList(): UploadOneTimeKeysRequest;
   addNotifOneTimePrekeys(value: string, index?: number): UploadOneTimeKeysRequest;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): UploadOneTimeKeysRequestObject;
   static toObject(includeInstance: boolean, msg: UploadOneTimeKeysRequest): UploadOneTimeKeysRequestObject;
   static serializeBinaryToWriter(message: UploadOneTimeKeysRequest, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): UploadOneTimeKeysRequest;
   static deserializeBinaryFromReader(message: UploadOneTimeKeysRequest, reader: BinaryReader): UploadOneTimeKeysRequest;
 }
 
 export type UploadOneTimeKeysRequestObject = {
   contentOneTimePrekeysList: Array<string>,
   notifOneTimePrekeysList: Array<string>,
 };
 
 declare export class RefreshUserPrekeysRequest extends Message {
   getNewContentPrekeys(): identityStructs.Prekey | void;
   setNewContentPrekeys(value?: identityStructs.Prekey): RefreshUserPrekeysRequest;
   hasNewContentPrekeys(): boolean;
   clearNewContentPrekeys(): RefreshUserPrekeysRequest;
 
   getNewNotifPrekeys(): identityStructs.Prekey | void;
   setNewNotifPrekeys(value?: identityStructs.Prekey): RefreshUserPrekeysRequest;
   hasNewNotifPrekeys(): boolean;
   clearNewNotifPrekeys(): RefreshUserPrekeysRequest;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): RefreshUserPrekeysRequestObject;
   static toObject(includeInstance: boolean, msg: RefreshUserPrekeysRequest): RefreshUserPrekeysRequestObject;
   static serializeBinaryToWriter(message: RefreshUserPrekeysRequest, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): RefreshUserPrekeysRequest;
   static deserializeBinaryFromReader(message: RefreshUserPrekeysRequest, reader: BinaryReader): RefreshUserPrekeysRequest;
 }
 
 export type RefreshUserPrekeysRequestObject = {
   newContentPrekeys?: identityStructs.PrekeyObject,
   newNotifPrekeys?: identityStructs.PrekeyObject,
 }
 
 declare export class OutboundKeyInfo extends Message {
   getIdentityInfo(): identityStructs.IdentityKeyInfo | void;
   setIdentityInfo(value?: identityStructs.IdentityKeyInfo): OutboundKeyInfo;
   hasIdentityInfo(): boolean;
   clearIdentityInfo(): OutboundKeyInfo;
 
   getContentPrekey(): identityStructs.Prekey | void;
   setContentPrekey(value?: identityStructs.Prekey): OutboundKeyInfo;
   hasContentPrekey(): boolean;
   clearContentPrekey(): OutboundKeyInfo;
 
   getNotifPrekey(): identityStructs.Prekey | void;
   setNotifPrekey(value?: identityStructs.Prekey): OutboundKeyInfo;
   hasNotifPrekey(): boolean;
   clearNotifPrekey(): OutboundKeyInfo;
 
   getOneTimeContentPrekey(): string;
   setOneTimeContentPrekey(value: string): OutboundKeyInfo;
   hasOneTimeContentPrekey(): boolean;
   clearOneTimeContentPrekey(): OutboundKeyInfo;
 
   getOneTimeNotifPrekey(): string;
   setOneTimeNotifPrekey(value: string): OutboundKeyInfo;
   hasOneTimeNotifPrekey(): boolean;
   clearOneTimeNotifPrekey(): OutboundKeyInfo;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): OutboundKeyInfoObject;
   static toObject(includeInstance: boolean, msg: OutboundKeyInfo): OutboundKeyInfoObject;
   static serializeBinaryToWriter(message: OutboundKeyInfo, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): OutboundKeyInfo;
   static deserializeBinaryFromReader(message: OutboundKeyInfo, reader: BinaryReader): OutboundKeyInfo;
 }
 
 export type OutboundKeyInfoObject = {
   identityInfo?: identityStructs.IdentityKeyInfoObject,
   contentPrekey?: identityStructs.PrekeyObject,
   notifPrekey?: identityStructs.PrekeyObject,
   oneTimeContentPrekey?: string,
   oneTimeNotifPrekey?: string,
 };
 
 declare export class KeyserverKeysResponse extends Message {
   getKeyserverInfo(): OutboundKeyInfo | void;
   setKeyserverInfo(value?: OutboundKeyInfo): KeyserverKeysResponse;
   hasKeyserverInfo(): boolean;
   clearKeyserverInfo(): KeyserverKeysResponse;
 
   getIdentity(): Identity | void;
   setIdentity(value?: Identity): KeyserverKeysResponse;
   hasIdentity(): boolean;
   clearIdentity(): KeyserverKeysResponse;
 
   getPrimaryDeviceIdentityInfo(): identityStructs.IdentityKeyInfo | void;
   setPrimaryDeviceIdentityInfo(value?: identityStructs.IdentityKeyInfo): KeyserverKeysResponse;
   hasPrimaryDeviceIdentityInfo(): boolean;
   clearPrimaryDeviceIdentityInfo(): KeyserverKeysResponse;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): KeyserverKeysResponseObject;
   static toObject(includeInstance: boolean, msg: KeyserverKeysResponse): KeyserverKeysResponseObject;
   static serializeBinaryToWriter(message: KeyserverKeysResponse, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): KeyserverKeysResponse;
   static deserializeBinaryFromReader(message: KeyserverKeysResponse, reader: BinaryReader): KeyserverKeysResponse;
 }
 
 export type KeyserverKeysResponseObject = {
-  keyserverInfo?: OutboundKeyInfoObject,
+  keyserverInfo: ?OutboundKeyInfoObject,
   identity: ?IdentityObject,
   primaryDeviceIdentityInfo: ?identityStructs.IdentityKeyInfoObject,
 };
 
 declare export class OutboundKeysForUserResponse extends Message {
   getDevicesMap(): ProtoMap<string, OutboundKeyInfo>;
   clearDevicesMap(): OutboundKeysForUserResponse;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): OutboundKeysForUserResponseObject;
   static toObject(includeInstance: boolean, msg: OutboundKeysForUserResponse): OutboundKeysForUserResponseObject;
   static serializeBinaryToWriter(message: OutboundKeysForUserResponse, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): OutboundKeysForUserResponse;
   static deserializeBinaryFromReader(message: OutboundKeysForUserResponse, reader: BinaryReader): OutboundKeysForUserResponse;
 }
 
 export type OutboundKeysForUserResponseObject = {
   devicesMap: Array<[string, OutboundKeyInfoObject]>,
 };
 
 declare export class OutboundKeysForUserRequest extends Message {
   getUserId(): string;
   setUserId(value: string): OutboundKeysForUserRequest;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): OutboundKeysForUserRequestObject;
   static toObject(includeInstance: boolean, msg: OutboundKeysForUserRequest): OutboundKeysForUserRequestObject;
   static serializeBinaryToWriter(message: OutboundKeysForUserRequest, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): OutboundKeysForUserRequest;
   static deserializeBinaryFromReader(message: OutboundKeysForUserRequest, reader: BinaryReader): OutboundKeysForUserRequest;
 }
 
 export type OutboundKeysForUserRequestObject = {
   userId: string,
 };
 
 declare export class InboundKeyInfo extends Message {
   getIdentityInfo(): identityStructs.IdentityKeyInfo | void;
   setIdentityInfo(value?: identityStructs.IdentityKeyInfo): InboundKeyInfo;
   hasIdentityInfo(): boolean;
   clearIdentityInfo(): InboundKeyInfo;
 
   getContentPrekey(): identityStructs.Prekey | void;
   setContentPrekey(value?: identityStructs.Prekey): InboundKeyInfo;
   hasContentPrekey(): boolean;
   clearContentPrekey(): InboundKeyInfo;
 
   getNotifPrekey(): identityStructs.Prekey | void;
   setNotifPrekey(value?: identityStructs.Prekey): InboundKeyInfo;
   hasNotifPrekey(): boolean;
   clearNotifPrekey(): InboundKeyInfo;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): InboundKeyInfoObject;
   static toObject(includeInstance: boolean, msg: InboundKeyInfo): InboundKeyInfoObject;
   static serializeBinaryToWriter(message: InboundKeyInfo, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): InboundKeyInfo;
   static deserializeBinaryFromReader(message: InboundKeyInfo, reader: BinaryReader): InboundKeyInfo;
 }
 
 export type InboundKeyInfoObject = {
   identityInfo?: identityStructs.IdentityKeyInfoObject,
   contentPrekey?: identityStructs.PrekeyObject,
   notifPrekey?: identityStructs.PrekeyObject,
 };
 
 declare export class InboundKeysForUserResponse extends Message {
   getDevicesMap(): ProtoMap<string, InboundKeyInfo>;
   clearDevicesMap(): InboundKeysForUserResponse;
 
   getIdentity(): Identity | void;
   setIdentity(value?: Identity): InboundKeysForUserResponse;
   hasIdentity(): boolean;
   clearIdentity(): InboundKeysForUserResponse;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): InboundKeysForUserResponseObject;
   static toObject(includeInstance: boolean, msg: InboundKeysForUserResponse): InboundKeysForUserResponseObject;
   static serializeBinaryToWriter(message: InboundKeysForUserResponse, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): InboundKeysForUserResponse;
   static deserializeBinaryFromReader(message: InboundKeysForUserResponse, reader: BinaryReader): InboundKeysForUserResponse;
 }
 
 export type InboundKeysForUserResponseObject = {
   devicesMap: Array<[string, InboundKeyInfoObject]>,
   identity: ?IdentityObject,
 }
 
 declare export class InboundKeysForUserRequest extends Message {
   getUserId(): string;
   setUserId(value: string): InboundKeysForUserRequest;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): InboundKeysForUserRequestObject;
   static toObject(includeInstance: boolean, msg: InboundKeysForUserRequest): InboundKeysForUserRequestObject;
   static serializeBinaryToWriter(message: InboundKeysForUserRequest, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): InboundKeysForUserRequest;
   static deserializeBinaryFromReader(message: InboundKeysForUserRequest, reader: BinaryReader): InboundKeysForUserRequest;
 }
 
 export type InboundKeysForUserRequestObject = {
   userId: string,
 };
 
 declare export class UpdateUserPasswordStartRequest extends Message {
   getOpaqueRegistrationRequest(): Uint8Array | string;
   getOpaqueRegistrationRequest_asU8(): Uint8Array;
   getOpaqueRegistrationRequest_asB64(): string;
   setOpaqueRegistrationRequest(value: Uint8Array | string): UpdateUserPasswordStartRequest;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): UpdateUserPasswordStartRequestObject;
   static toObject(includeInstance: boolean, msg: UpdateUserPasswordStartRequest): UpdateUserPasswordStartRequestObject;
   static serializeBinaryToWriter(message: UpdateUserPasswordStartRequest, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): UpdateUserPasswordStartRequest;
   static deserializeBinaryFromReader(message: UpdateUserPasswordStartRequest, reader: BinaryReader): UpdateUserPasswordStartRequest;
 }
 
 export type UpdateUserPasswordStartRequestObject = {
   opaqueRegistrationRequest: Uint8Array | string,
 };
 
 declare export class UpdateUserPasswordFinishRequest extends Message {
   getSessionId(): string;
   setSessionId(value: string): UpdateUserPasswordFinishRequest;
 
   getOpaqueRegistrationUpload(): Uint8Array | string;
   getOpaqueRegistrationUpload_asU8(): Uint8Array;
   getOpaqueRegistrationUpload_asB64(): string;
   setOpaqueRegistrationUpload(value: Uint8Array | string): UpdateUserPasswordFinishRequest;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): UpdateUserPasswordFinishRequestObject;
   static toObject(includeInstance: boolean, msg: UpdateUserPasswordFinishRequest): UpdateUserPasswordFinishRequestObject;
   static serializeBinaryToWriter(message: UpdateUserPasswordFinishRequest, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): UpdateUserPasswordFinishRequest;
   static deserializeBinaryFromReader(message: UpdateUserPasswordFinishRequest, reader: BinaryReader): UpdateUserPasswordFinishRequest;
 }
 
 export type UpdateUserPasswordFinishRequestObject = {
   sessionId: string,
   opaqueRegistrationUpload: Uint8Array | string,
 };
 
 declare export class UpdateUserPasswordStartResponse extends Message {
   getSessionId(): string;
   setSessionId(value: string): UpdateUserPasswordStartResponse;
 
   getOpaqueRegistrationResponse(): Uint8Array | string;
   getOpaqueRegistrationResponse_asU8(): Uint8Array;
   getOpaqueRegistrationResponse_asB64(): string;
   setOpaqueRegistrationResponse(value: Uint8Array | string): UpdateUserPasswordStartResponse;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): UpdateUserPasswordStartResponseObject;
   static toObject(includeInstance: boolean, msg: UpdateUserPasswordStartResponse): UpdateUserPasswordStartResponseObject;
   static serializeBinaryToWriter(message: UpdateUserPasswordStartResponse, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): UpdateUserPasswordStartResponse;
   static deserializeBinaryFromReader(message: UpdateUserPasswordStartResponse, reader: BinaryReader): UpdateUserPasswordStartResponse;
 }
 
 export type UpdateUserPasswordStartResponseObject = {
   sessionId: string,
   opaqueRegistrationResponse: Uint8Array | string,
 };
 
 export type SinceTimestampCase = 0 | 2;
 
 declare export class GetDeviceListRequest extends Message {
   getUserId(): string;
   setUserId(value: string): GetDeviceListRequest;
 
   getSinceTimestamp(): number;
   setSinceTimestamp(value: number): GetDeviceListRequest;
   hasSinceTimestamp(): boolean;
   clearSinceTimestamp(): GetDeviceListRequest;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): GetDeviceListRequestObject;
   static toObject(includeInstance: boolean, msg: GetDeviceListRequest): GetDeviceListRequestObject;
   static serializeBinaryToWriter(message: GetDeviceListRequest, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): GetDeviceListRequest;
   static deserializeBinaryFromReader(message: GetDeviceListRequest, reader: BinaryReader): GetDeviceListRequest;
 }
 
 export type GetDeviceListRequestObject = {
   userId: string,
   sinceTimestamp?: number,
 }
 
 declare export class GetDeviceListResponse extends Message {
   getDeviceListUpdatesList(): Array<string>;
   setDeviceListUpdatesList(value: Array<string>): GetDeviceListResponse;
   clearDeviceListUpdatesList(): GetDeviceListResponse;
   addDeviceListUpdates(value: string, index?: number): GetDeviceListResponse;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): GetDeviceListResponseObject;
   static toObject(includeInstance: boolean, msg: GetDeviceListResponse): GetDeviceListResponseObject;
   static serializeBinaryToWriter(message: GetDeviceListResponse, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): GetDeviceListResponse;
   static deserializeBinaryFromReader(message: GetDeviceListResponse, reader: BinaryReader): GetDeviceListResponse;
 }
 
 export type GetDeviceListResponseObject = {
   deviceListUpdatesList: Array<string>,
 }
 
 declare export class UpdateDeviceListRequest extends Message {
   getNewDeviceList(): string;
   setNewDeviceList(value: string): UpdateDeviceListRequest;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): UpdateDeviceListRequestObject;
   static toObject(includeInstance: boolean, msg: UpdateDeviceListRequest): UpdateDeviceListRequestObject;
   static serializeBinaryToWriter(message: UpdateDeviceListRequest, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): UpdateDeviceListRequest;
   static deserializeBinaryFromReader(message: UpdateDeviceListRequest, reader: BinaryReader): UpdateDeviceListRequest;
 }
 
 export type UpdateDeviceListRequestObject = {
   newDeviceList: string,
 }
 
 declare export class LinkFarcasterAccountRequest extends Message {
   getFarcasterId(): string;
   setFarcasterId(value: string): LinkFarcasterAccountRequest;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): LinkFarcasterAccountRequestObject;
   static toObject(includeInstance: boolean, msg: LinkFarcasterAccountRequest): LinkFarcasterAccountRequestObject;
   static serializeBinaryToWriter(message: LinkFarcasterAccountRequest, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): LinkFarcasterAccountRequest;
   static deserializeBinaryFromReader(message: LinkFarcasterAccountRequest, reader: BinaryReader): LinkFarcasterAccountRequest;
 }
 
 export type LinkFarcasterAccountRequestObject = {
   farcasterId: string,
 }
 
 declare export class UserIdentityRequest extends Message {
   getUserId(): string;
   setUserId(value: string): UserIdentityRequest;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): UserIdentityRequestObject;
   static toObject(includeInstance: boolean, msg: UserIdentityRequest): UserIdentityRequestObject;
   static serializeBinaryToWriter(message: UserIdentityRequest, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): UserIdentityRequest;
   static deserializeBinaryFromReader(message: UserIdentityRequest, reader: BinaryReader): UserIdentityRequest;
 }
 
 export type UserIdentityRequestObject = {
   userId: string,
 }
 
 declare export class UserIdentityResponse extends Message {
   getIdentity(): Identity | void;
   setIdentity(value?: Identity): UserIdentityResponse;
   hasIdentity(): boolean;
   clearIdentity(): UserIdentityResponse;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): UserIdentityResponseObject;
   static toObject(includeInstance: boolean, msg: UserIdentityResponse): UserIdentityResponseObject;
   static serializeBinaryToWriter(message: UserIdentityResponse, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): UserIdentityResponse;
   static deserializeBinaryFromReader(message: UserIdentityResponse, reader: BinaryReader): UserIdentityResponse;
 }
 
 export type UserIdentityResponseObject = {
   identity: ?IdentityObject,
 }