diff --git a/services/identity/src/client_service.rs b/services/identity/src/client_service.rs
index 374b610e1..30aecbd24 100644
--- a/services/identity/src/client_service.rs
+++ b/services/identity/src/client_service.rs
@@ -1,1055 +1,1063 @@
 // Standard library imports
 use std::str::FromStr;
 
 // External crate imports
 use comm_lib::aws::DynamoDBError;
 use comm_lib::shared::reserved_users::RESERVED_USERNAME_SET;
 use comm_opaque2::grpc::protocol_error_to_grpc_status;
 use rand::rngs::OsRng;
 use serde::{Deserialize, Serialize};
 use siwe::eip55;
 use tonic::Response;
 use tracing::{debug, error, info, warn};
 
 // Workspace crate imports
 use crate::config::CONFIG;
 use crate::constants::request_metadata;
 use crate::database::{
   DBDeviceTypeInt, DatabaseClient, DeviceType, KeyPayload,
 };
 use crate::error::{DeviceListError, Error as DBError};
 use crate::grpc_services::protos::unauth::{
   find_user_id_request, AddReservedUsernamesRequest, AuthResponse, Empty,
   FindUserIdRequest, FindUserIdResponse, GenerateNonceResponse,
   OpaqueLoginFinishRequest, OpaqueLoginStartRequest, OpaqueLoginStartResponse,
   RegistrationFinishRequest, RegistrationStartRequest,
   RegistrationStartResponse, RemoveReservedUsernameRequest,
   ReservedRegistrationStartRequest, ReservedWalletRegistrationRequest,
   SecondaryDeviceKeysUploadRequest, VerifyUserAccessTokenRequest,
-  VerifyUserAccessTokenResponse, WalletAuthRequest,
+  VerifyUserAccessTokenResponse, WalletAuthRequest, GetFarcasterUsersRequest,
+  GetFarcasterUsersResponse
 };
 use crate::grpc_services::shared::get_value;
 use crate::grpc_utils::{
   ChallengeResponse, DeviceKeyUploadActions, NonceChallenge,
 };
 use crate::nonce::generate_nonce_data;
 use crate::reserved_users::{
   validate_account_ownership_message_and_get_user_id,
   validate_add_reserved_usernames_message,
   validate_remove_reserved_username_message,
 };
 use crate::siwe::{
   is_valid_ethereum_address, parse_and_verify_siwe_message, SocialProof,
 };
 use crate::token::{AccessTokenData, AuthType};
 pub use crate::grpc_services::protos::unauth::identity_client_service_server::{
     IdentityClientService, IdentityClientServiceServer,
   };
 use crate::regex::is_valid_username;
 
 #[derive(Clone, Serialize, Deserialize)]
 pub enum WorkflowInProgress {
   Registration(Box<UserRegistrationInfo>),
   Login(Box<UserLoginInfo>),
   Update(UpdateState),
 }
 
 #[derive(Clone, Serialize, Deserialize)]
 pub struct UserRegistrationInfo {
   pub username: String,
   pub flattened_device_key_upload: FlattenedDeviceKeyUpload,
   pub user_id: Option<String>,
   pub farcaster_id: Option<String>,
 }
 
 #[derive(Clone, Serialize, Deserialize)]
 pub struct UserLoginInfo {
   pub user_id: String,
   pub flattened_device_key_upload: FlattenedDeviceKeyUpload,
   pub opaque_server_login: comm_opaque2::server::Login,
   pub device_to_remove: Option<String>,
 }
 
 #[derive(Clone, Serialize, Deserialize)]
 pub struct UpdateState {
   pub user_id: String,
 }
 
 #[derive(Clone, Serialize, Deserialize)]
 pub struct FlattenedDeviceKeyUpload {
   pub device_id_key: String,
   pub key_payload: String,
   pub key_payload_signature: String,
   pub content_prekey: String,
   pub content_prekey_signature: String,
   pub content_one_time_keys: Vec<String>,
   pub notif_prekey: String,
   pub notif_prekey_signature: String,
   pub notif_one_time_keys: Vec<String>,
   pub device_type: DeviceType,
 }
 
 #[derive(derive_more::Constructor)]
 pub struct ClientService {
   client: DatabaseClient,
 }
 
 #[tonic::async_trait]
 impl IdentityClientService for ClientService {
   async fn register_password_user_start(
     &self,
     request: tonic::Request<RegistrationStartRequest>,
   ) -> Result<tonic::Response<RegistrationStartResponse>, tonic::Status> {
     let message = request.into_inner();
     debug!("Received registration request for: {}", message.username);
 
     if !is_valid_username(&message.username)
       || is_valid_ethereum_address(&message.username)
     {
       return Err(tonic::Status::invalid_argument("invalid username"));
     }
 
     self.check_username_taken(&message.username).await?;
     let username_in_reserved_usernames_table = self
       .client
       .username_in_reserved_usernames_table(&message.username)
       .await
       .map_err(handle_db_error)?;
 
     if username_in_reserved_usernames_table {
       return Err(tonic::Status::already_exists("username already exists"));
     }
 
     if RESERVED_USERNAME_SET.contains(&message.username) {
       return Err(tonic::Status::invalid_argument("username reserved"));
     }
 
     let registration_state = construct_user_registration_info(
       &message,
       None,
       message.username.clone(),
       message.farcaster_id.clone(),
     )?;
     let server_registration = comm_opaque2::server::Registration::new();
     let server_message = server_registration
       .start(
         &CONFIG.server_setup,
         &message.opaque_registration_request,
         message.username.as_bytes(),
       )
       .map_err(protocol_error_to_grpc_status)?;
     let session_id = self
       .client
       .insert_workflow(WorkflowInProgress::Registration(Box::new(
         registration_state,
       )))
       .await
       .map_err(handle_db_error)?;
 
     let response = RegistrationStartResponse {
       session_id,
       opaque_registration_response: server_message,
     };
     Ok(Response::new(response))
   }
 
   async fn register_reserved_password_user_start(
     &self,
     request: tonic::Request<ReservedRegistrationStartRequest>,
   ) -> Result<tonic::Response<RegistrationStartResponse>, tonic::Status> {
     let message = request.into_inner();
     self.check_username_taken(&message.username).await?;
 
     if RESERVED_USERNAME_SET.contains(&message.username) {
       return Err(tonic::Status::invalid_argument("username reserved"));
     }
 
     let username_in_reserved_usernames_table = self
       .client
       .username_in_reserved_usernames_table(&message.username)
       .await
       .map_err(handle_db_error)?;
     if !username_in_reserved_usernames_table {
       return Err(tonic::Status::permission_denied("username not reserved"));
     }
 
     let user_id = validate_account_ownership_message_and_get_user_id(
       &message.username,
       &message.keyserver_message,
       &message.keyserver_signature,
     )?;
 
     let registration_state = construct_user_registration_info(
       &message,
       Some(user_id),
       message.username.clone(),
       None,
     )?;
     let server_registration = comm_opaque2::server::Registration::new();
     let server_message = server_registration
       .start(
         &CONFIG.server_setup,
         &message.opaque_registration_request,
         message.username.as_bytes(),
       )
       .map_err(protocol_error_to_grpc_status)?;
 
     let session_id = self
       .client
       .insert_workflow(WorkflowInProgress::Registration(Box::new(
         registration_state,
       )))
       .await
       .map_err(handle_db_error)?;
 
     let response = RegistrationStartResponse {
       session_id,
       opaque_registration_response: server_message,
     };
     Ok(Response::new(response))
   }
 
   async fn register_password_user_finish(
     &self,
     request: tonic::Request<RegistrationFinishRequest>,
   ) -> Result<tonic::Response<AuthResponse>, tonic::Status> {
     let code_version = get_code_version(&request);
     let message = request.into_inner();
 
     if let Some(WorkflowInProgress::Registration(state)) = self
       .client
       .get_workflow(message.session_id)
       .await
       .map_err(handle_db_error)?
     {
       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)?;
 
       let login_time = chrono::Utc::now();
       let device_id = state.flattened_device_key_upload.device_id_key.clone();
       let user_id = self
         .client
         .add_password_user_to_users_table(
           *state,
           password_file,
           code_version,
           login_time,
         )
         .await
         .map_err(handle_db_error)?;
 
       // Create access token
       let token = AccessTokenData::with_created_time(
         user_id.clone(),
         device_id,
         login_time,
         crate::token::AuthType::Password,
         &mut OsRng,
       );
 
       let access_token = token.access_token.clone();
 
       self
         .client
         .put_access_token_data(token)
         .await
         .map_err(handle_db_error)?;
 
       let response = AuthResponse {
         user_id,
         access_token,
       };
       Ok(Response::new(response))
     } else {
       Err(tonic::Status::not_found("session not found"))
     }
   }
 
   async fn log_in_password_user_start(
     &self,
     request: tonic::Request<OpaqueLoginStartRequest>,
   ) -> Result<tonic::Response<OpaqueLoginStartResponse>, tonic::Status> {
     let message = request.into_inner();
 
     debug!("Attempting to log in user: {:?}", &message.username);
     let user_id_and_password_file = self
       .client
       .get_user_id_and_password_file_from_username(&message.username)
       .await
       .map_err(handle_db_error)?;
 
     let (user_id, password_file_bytes) =
       if let Some(data) = user_id_and_password_file {
         data
       } else {
         // It's possible that the user attempting login is already registered
         // on Ashoat's keyserver. If they are, we should send back a gRPC status
         // code instructing them to get a signed message from Ashoat's keyserver
         // in order to claim their username and register with the Identity
         // service.
         let username_in_reserved_usernames_table = self
           .client
           .username_in_reserved_usernames_table(&message.username)
           .await
           .map_err(handle_db_error)?;
 
         if username_in_reserved_usernames_table {
           return Err(tonic::Status::failed_precondition(
             "need keyserver message to claim username",
           ));
         }
 
         return Err(tonic::Status::not_found("user not found"));
       };
 
     let flattened_device_key_upload =
       construct_flattened_device_key_upload(&message)?;
 
     let maybe_device_to_remove = self
       .get_keyserver_device_to_remove(
         &user_id,
         &flattened_device_key_upload.device_id_key,
         message.force.unwrap_or(false),
         &flattened_device_key_upload.device_type,
       )
       .await?;
 
     let mut server_login = comm_opaque2::server::Login::new();
     let server_response = server_login
       .start(
         &CONFIG.server_setup,
         &password_file_bytes,
         &message.opaque_login_request,
         message.username.as_bytes(),
       )
       .map_err(protocol_error_to_grpc_status)?;
 
     let login_state = construct_user_login_info(
       user_id,
       server_login,
       flattened_device_key_upload,
       maybe_device_to_remove,
     )?;
 
     let session_id = self
       .client
       .insert_workflow(WorkflowInProgress::Login(Box::new(login_state)))
       .await
       .map_err(handle_db_error)?;
 
     let response = Response::new(OpaqueLoginStartResponse {
       session_id,
       opaque_login_response: server_response,
     });
     Ok(response)
   }
 
   async fn log_in_password_user_finish(
     &self,
     request: tonic::Request<OpaqueLoginFinishRequest>,
   ) -> Result<tonic::Response<AuthResponse>, tonic::Status> {
     let code_version = get_code_version(&request);
     let message = request.into_inner();
 
     if let Some(WorkflowInProgress::Login(state)) = self
       .client
       .get_workflow(message.session_id)
       .await
       .map_err(handle_db_error)?
     {
       let mut server_login = state.opaque_server_login.clone();
       server_login
         .finish(&message.opaque_login_upload)
         .map_err(protocol_error_to_grpc_status)?;
 
       if let Some(device_to_remove) = state.device_to_remove {
         self
           .client
           .remove_device(state.user_id.clone(), device_to_remove)
           .await
           .map_err(handle_db_error)?;
       }
 
       let login_time = chrono::Utc::now();
       self
         .client
         .add_user_device(
           state.user_id.clone(),
           state.flattened_device_key_upload.clone(),
           code_version,
           login_time,
         )
         .await
         .map_err(handle_db_error)?;
 
       // Create access token
       let token = AccessTokenData::with_created_time(
         state.user_id.clone(),
         state.flattened_device_key_upload.device_id_key,
         login_time,
         crate::token::AuthType::Password,
         &mut OsRng,
       );
 
       let access_token = token.access_token.clone();
 
       self
         .client
         .put_access_token_data(token)
         .await
         .map_err(handle_db_error)?;
 
       let response = AuthResponse {
         user_id: state.user_id,
         access_token,
       };
       Ok(Response::new(response))
     } else {
       Err(tonic::Status::not_found("session not found"))
     }
   }
 
   async fn log_in_wallet_user(
     &self,
     request: tonic::Request<WalletAuthRequest>,
   ) -> Result<tonic::Response<AuthResponse>, tonic::Status> {
     let code_version = get_code_version(&request);
     let message = request.into_inner();
 
     let parsed_message = parse_and_verify_siwe_message(
       &message.siwe_message,
       &message.siwe_signature,
     )?;
 
     self.verify_and_remove_nonce(&parsed_message.nonce).await?;
 
     let wallet_address = eip55(&parsed_message.address);
 
     let flattened_device_key_upload =
       construct_flattened_device_key_upload(&message)?;
 
     let login_time = chrono::Utc::now();
     let Some(user_id) = self
       .client
       .get_user_id_from_user_info(wallet_address.clone(), &AuthType::Wallet)
       .await
       .map_err(handle_db_error)?
     else {
       // It's possible that the user attempting login is already registered
       // on Ashoat's keyserver. If they are, we should send back a gRPC status
       // code instructing them to get a signed message from Ashoat's keyserver
       // in order to claim their wallet address and register with the Identity
       // service.
       let username_in_reserved_usernames_table = self
         .client
         .username_in_reserved_usernames_table(&wallet_address)
         .await
         .map_err(handle_db_error)?;
 
       if username_in_reserved_usernames_table {
         return Err(tonic::Status::failed_precondition(
           "need keyserver message to claim username",
         ));
       }
 
       return Err(tonic::Status::not_found("user not found"));
     };
 
     self
       .client
       .add_user_device(
         user_id.clone(),
         flattened_device_key_upload.clone(),
         code_version,
         chrono::Utc::now(),
       )
       .await
       .map_err(handle_db_error)?;
 
     // Create access token
     let token = AccessTokenData::with_created_time(
       user_id.clone(),
       flattened_device_key_upload.device_id_key,
       login_time,
       crate::token::AuthType::Wallet,
       &mut OsRng,
     );
 
     let access_token = token.access_token.clone();
 
     self
       .client
       .put_access_token_data(token)
       .await
       .map_err(handle_db_error)?;
 
     let response = AuthResponse {
       user_id,
       access_token,
     };
     Ok(Response::new(response))
   }
 
   async fn register_wallet_user(
     &self,
     request: tonic::Request<WalletAuthRequest>,
   ) -> Result<tonic::Response<AuthResponse>, tonic::Status> {
     let code_version = get_code_version(&request);
     let message = request.into_inner();
 
     let parsed_message = parse_and_verify_siwe_message(
       &message.siwe_message,
       &message.siwe_signature,
     )?;
 
     match self
       .client
       .get_nonce_from_nonces_table(&parsed_message.nonce)
       .await
       .map_err(handle_db_error)?
     {
       None => return Err(tonic::Status::invalid_argument("invalid nonce")),
       Some(nonce) if nonce.is_expired() => {
         // we don't need to remove the nonce from the table here
         // because the DynamoDB TTL will take care of it
         return Err(tonic::Status::aborted("nonce expired"));
       }
       Some(_) => self
         .client
         .remove_nonce_from_nonces_table(&parsed_message.nonce)
         .await
         .map_err(handle_db_error)?,
     };
 
     let wallet_address = eip55(&parsed_message.address);
 
     self.check_wallet_address_taken(&wallet_address).await?;
     let username_in_reserved_usernames_table = self
       .client
       .username_in_reserved_usernames_table(&wallet_address)
       .await
       .map_err(handle_db_error)?;
 
     if username_in_reserved_usernames_table {
       return Err(tonic::Status::already_exists(
         "wallet address already exists",
       ));
     }
 
     let flattened_device_key_upload =
       construct_flattened_device_key_upload(&message)?;
 
     let login_time = chrono::Utc::now();
 
     let social_proof =
       SocialProof::new(message.siwe_message, message.siwe_signature);
     let serialized_social_proof = serde_json::to_string(&social_proof)
       .map_err(|_| tonic::Status::invalid_argument("invalid_social_proof"))?;
 
     let user_id = self
       .client
       .add_wallet_user_to_users_table(
         flattened_device_key_upload.clone(),
         wallet_address,
         serialized_social_proof,
         None,
         code_version,
         login_time,
         message.farcaster_id,
       )
       .await
       .map_err(handle_db_error)?;
 
     // Create access token
     let token = AccessTokenData::with_created_time(
       user_id.clone(),
       flattened_device_key_upload.device_id_key,
       login_time,
       crate::token::AuthType::Wallet,
       &mut OsRng,
     );
 
     let access_token = token.access_token.clone();
 
     self
       .client
       .put_access_token_data(token)
       .await
       .map_err(handle_db_error)?;
 
     let response = AuthResponse {
       user_id,
       access_token,
     };
     Ok(Response::new(response))
   }
 
   async fn register_reserved_wallet_user(
     &self,
     request: tonic::Request<ReservedWalletRegistrationRequest>,
   ) -> Result<tonic::Response<AuthResponse>, tonic::Status> {
     let code_version = get_code_version(&request);
     let message = request.into_inner();
 
     let parsed_message = parse_and_verify_siwe_message(
       &message.siwe_message,
       &message.siwe_signature,
     )?;
 
     self.verify_and_remove_nonce(&parsed_message.nonce).await?;
 
     let wallet_address = eip55(&parsed_message.address);
 
     self.check_wallet_address_taken(&wallet_address).await?;
 
     let wallet_address_in_reserved_usernames_table = self
       .client
       .username_in_reserved_usernames_table(&wallet_address)
       .await
       .map_err(handle_db_error)?;
     if !wallet_address_in_reserved_usernames_table {
       return Err(tonic::Status::permission_denied(
         "wallet address not reserved",
       ));
     }
 
     let user_id = validate_account_ownership_message_and_get_user_id(
       &wallet_address,
       &message.keyserver_message,
       &message.keyserver_signature,
     )?;
 
     let flattened_device_key_upload =
       construct_flattened_device_key_upload(&message)?;
 
     let social_proof =
       SocialProof::new(message.siwe_message, message.siwe_signature);
     let serialized_social_proof = serde_json::to_string(&social_proof)
       .map_err(|_| tonic::Status::invalid_argument("invalid_social_proof"))?;
 
     let login_time = chrono::Utc::now();
     self
       .client
       .add_wallet_user_to_users_table(
         flattened_device_key_upload.clone(),
         wallet_address,
         serialized_social_proof,
         Some(user_id.clone()),
         code_version,
         login_time,
         None,
       )
       .await
       .map_err(handle_db_error)?;
 
     let token = AccessTokenData::with_created_time(
       user_id.clone(),
       flattened_device_key_upload.device_id_key,
       login_time,
       crate::token::AuthType::Wallet,
       &mut OsRng,
     );
 
     let access_token = token.access_token.clone();
 
     self
       .client
       .put_access_token_data(token)
       .await
       .map_err(handle_db_error)?;
 
     let response = AuthResponse {
       user_id,
       access_token,
     };
 
     Ok(Response::new(response))
   }
 
   async fn upload_keys_for_registered_device_and_log_in(
     &self,
     request: tonic::Request<SecondaryDeviceKeysUploadRequest>,
   ) -> Result<tonic::Response<AuthResponse>, tonic::Status> {
     let code_version = get_code_version(&request);
     let message = request.into_inner();
 
     let challenge_response = ChallengeResponse::try_from(&message)?;
     let flattened_device_key_upload =
       construct_flattened_device_key_upload(&message)?;
 
     let user_id = message.user_id;
     let device_id = flattened_device_key_upload.device_id_key.clone();
 
     let NonceChallenge { nonce } =
       challenge_response.verify_and_get_message(&device_id)?;
 
     self.verify_and_remove_nonce(&nonce).await?;
 
     let Some(device_list) = self
       .client
       .get_current_device_list(&user_id)
       .await
       .map_err(handle_db_error)?
     else {
       warn!("User {} does not have valid device list. Secondary device auth impossible.", user_id);
       return Err(tonic::Status::aborted("device list error"));
     };
 
     if !device_list.device_ids.contains(&device_id) {
       return Err(tonic::Status::permission_denied(
         "device not in device list",
       ));
     }
 
     let login_time = chrono::Utc::now();
 
     let user_identifier = self
       .client
       .get_user_identifier(&user_id)
       .await
       .map_err(handle_db_error)?;
     let token = AccessTokenData::with_created_time(
       user_id.clone(),
       device_id,
       login_time,
       user_identifier.into(),
       &mut OsRng,
     );
     let access_token = token.access_token.clone();
     self
       .client
       .put_access_token_data(token)
       .await
       .map_err(handle_db_error)?;
 
     self
       .client
       .put_device_data(
         &user_id,
         flattened_device_key_upload,
         code_version,
         login_time,
       )
       .await
       .map_err(handle_db_error)?;
 
     let response = AuthResponse {
       user_id,
       access_token,
     };
     Ok(Response::new(response))
   }
 
   async fn generate_nonce(
     &self,
     _request: tonic::Request<Empty>,
   ) -> Result<tonic::Response<GenerateNonceResponse>, tonic::Status> {
     let nonce_data = generate_nonce_data(&mut OsRng);
     match self
       .client
       .add_nonce_to_nonces_table(nonce_data.clone())
       .await
     {
       Ok(_) => Ok(Response::new(GenerateNonceResponse {
         nonce: nonce_data.nonce,
       })),
       Err(e) => Err(handle_db_error(e)),
     }
   }
 
   async fn verify_user_access_token(
     &self,
     request: tonic::Request<VerifyUserAccessTokenRequest>,
   ) -> Result<tonic::Response<VerifyUserAccessTokenResponse>, tonic::Status> {
     let message = request.into_inner();
     debug!("Verifying device: {}", &message.device_id);
 
     let token_valid = self
       .client
       .verify_access_token(
         message.user_id,
         message.device_id.clone(),
         message.access_token,
       )
       .await
       .map_err(handle_db_error)?;
 
     let response = Response::new(VerifyUserAccessTokenResponse { token_valid });
     debug!(
       "device {} was verified: {}",
       &message.device_id, token_valid
     );
     Ok(response)
   }
 
   async fn add_reserved_usernames(
     &self,
     request: tonic::Request<AddReservedUsernamesRequest>,
   ) -> Result<tonic::Response<Empty>, tonic::Status> {
     let message = request.into_inner();
 
     let user_details = validate_add_reserved_usernames_message(
       &message.message,
       &message.signature,
     )?;
 
     let filtered_user_details = self
       .client
       .filter_out_taken_usernames(user_details)
       .await
       .map_err(handle_db_error)?;
 
     self
       .client
       .add_usernames_to_reserved_usernames_table(filtered_user_details)
       .await
       .map_err(handle_db_error)?;
 
     let response = Response::new(Empty {});
     Ok(response)
   }
 
   async fn remove_reserved_username(
     &self,
     request: tonic::Request<RemoveReservedUsernameRequest>,
   ) -> Result<tonic::Response<Empty>, tonic::Status> {
     let message = request.into_inner();
 
     let username = validate_remove_reserved_username_message(
       &message.message,
       &message.signature,
     )?;
 
     self
       .client
       .delete_username_from_reserved_usernames_table(username)
       .await
       .map_err(handle_db_error)?;
 
     let response = Response::new(Empty {});
     Ok(response)
   }
 
   async fn ping(
     &self,
     _request: tonic::Request<Empty>,
   ) -> Result<Response<Empty>, tonic::Status> {
     let response = Response::new(Empty {});
     Ok(response)
   }
 
   async fn find_user_id(
     &self,
     request: tonic::Request<FindUserIdRequest>,
   ) -> Result<tonic::Response<FindUserIdResponse>, tonic::Status> {
     let message = request.into_inner();
 
     use find_user_id_request::Identifier;
     let (user_ident, auth_type) = match message.identifier {
       None => {
         return Err(tonic::Status::invalid_argument("no identifier provided"))
       }
       Some(Identifier::Username(username)) => (username, AuthType::Password),
       Some(Identifier::WalletAddress(address)) => (address, AuthType::Wallet),
     };
 
     let (is_reserved_result, user_id_result) = tokio::join!(
       self
         .client
         .username_in_reserved_usernames_table(&user_ident),
       self
         .client
         .get_user_id_from_user_info(user_ident.clone(), &auth_type),
     );
     let is_reserved = is_reserved_result.map_err(handle_db_error)?;
     let user_id = user_id_result.map_err(handle_db_error)?;
 
     Ok(Response::new(FindUserIdResponse {
       user_id,
       is_reserved,
     }))
   }
+
+  async fn get_farcaster_users(
+    &self,
+    _request: tonic::Request<GetFarcasterUsersRequest>,
+  ) -> Result<tonic::Response<GetFarcasterUsersResponse>, tonic::Status> {
+    unimplemented!();
+  }
 }
 
 impl ClientService {
   async fn check_username_taken(
     &self,
     username: &str,
   ) -> Result<(), tonic::Status> {
     let username_taken = self
       .client
       .username_taken(username.to_string())
       .await
       .map_err(handle_db_error)?;
     if username_taken {
       return Err(tonic::Status::already_exists("username already exists"));
     }
     Ok(())
   }
 
   async fn check_wallet_address_taken(
     &self,
     wallet_address: &str,
   ) -> Result<(), tonic::Status> {
     let wallet_address_taken = self
       .client
       .wallet_address_taken(wallet_address.to_string())
       .await
       .map_err(handle_db_error)?;
     if wallet_address_taken {
       return Err(tonic::Status::already_exists(
         "wallet address already exists",
       ));
     }
     Ok(())
   }
 
   async fn verify_and_remove_nonce(
     &self,
     nonce: &str,
   ) -> Result<(), tonic::Status> {
     match self
       .client
       .get_nonce_from_nonces_table(nonce)
       .await
       .map_err(handle_db_error)?
     {
       None => return Err(tonic::Status::invalid_argument("invalid nonce")),
       Some(nonce) if nonce.is_expired() => {
         // we don't need to remove the nonce from the table here
         // because the DynamoDB TTL will take care of it
         return Err(tonic::Status::aborted("nonce expired"));
       }
       Some(nonce_data) => self
         .client
         .remove_nonce_from_nonces_table(&nonce_data.nonce)
         .await
         .map_err(handle_db_error)?,
     };
     Ok(())
   }
 
   async fn get_keyserver_device_to_remove(
     &self,
     user_id: &str,
     new_keyserver_device_id: &str,
     force: bool,
     device_type: &DeviceType,
   ) -> Result<Option<String>, tonic::Status> {
     if device_type != &DeviceType::Keyserver {
       return Ok(None);
     }
 
     let maybe_keyserver_device_id = self
       .client
       .get_keyserver_device_id_for_user(user_id)
       .await
       .map_err(handle_db_error)?;
 
     let Some(existing_keyserver_device_id) = maybe_keyserver_device_id else {
       return Ok(None);
     };
 
     if new_keyserver_device_id == existing_keyserver_device_id {
       return Ok(None);
     }
 
     if force {
       info!(
         "keyserver {} will be removed from the device list",
         existing_keyserver_device_id
       );
       Ok(Some(existing_keyserver_device_id))
     } else {
       Err(tonic::Status::already_exists(
         "user already has a keyserver",
       ))
     }
   }
 }
 
 pub fn handle_db_error(db_error: DBError) -> tonic::Status {
   match db_error {
     DBError::AwsSdk(DynamoDBError::InternalServerError(_))
     | DBError::AwsSdk(DynamoDBError::ProvisionedThroughputExceededException(
       _,
     ))
     | DBError::AwsSdk(DynamoDBError::RequestLimitExceeded(_)) => {
       tonic::Status::unavailable("please retry")
     }
     DBError::DeviceList(DeviceListError::InvalidDeviceListUpdate) => {
       tonic::Status::invalid_argument("invalid device list update")
     }
     e => {
       error!("Encountered an unexpected error: {}", e);
       tonic::Status::failed_precondition("unexpected error")
     }
   }
 }
 
 fn construct_user_registration_info(
   message: &impl DeviceKeyUploadActions,
   user_id: Option<String>,
   username: String,
   farcaster_id: Option<String>,
 ) -> Result<UserRegistrationInfo, tonic::Status> {
   Ok(UserRegistrationInfo {
     username,
     flattened_device_key_upload: construct_flattened_device_key_upload(
       message,
     )?,
     user_id,
     farcaster_id,
   })
 }
 
 fn construct_user_login_info(
   user_id: String,
   opaque_server_login: comm_opaque2::server::Login,
   flattened_device_key_upload: FlattenedDeviceKeyUpload,
   device_to_remove: Option<String>,
 ) -> Result<UserLoginInfo, tonic::Status> {
   Ok(UserLoginInfo {
     user_id,
     flattened_device_key_upload,
     opaque_server_login,
     device_to_remove,
   })
 }
 
 fn construct_flattened_device_key_upload(
   message: &impl DeviceKeyUploadActions,
 ) -> Result<FlattenedDeviceKeyUpload, tonic::Status> {
   let key_info = KeyPayload::from_str(&message.payload()?)
     .map_err(|_| tonic::Status::invalid_argument("malformed payload"))?;
 
   let flattened_device_key_upload = FlattenedDeviceKeyUpload {
     device_id_key: key_info.primary_identity_public_keys.ed25519,
     key_payload: message.payload()?,
     key_payload_signature: message.payload_signature()?,
     content_prekey: message.content_prekey()?,
     content_prekey_signature: message.content_prekey_signature()?,
     content_one_time_keys: message.one_time_content_prekeys()?,
     notif_prekey: message.notif_prekey()?,
     notif_prekey_signature: message.notif_prekey_signature()?,
     notif_one_time_keys: message.one_time_notif_prekeys()?,
     device_type: DeviceType::try_from(DBDeviceTypeInt(message.device_type()?))
       .map_err(handle_db_error)?,
   };
 
   Ok(flattened_device_key_upload)
 }
 
 fn get_code_version<T: std::fmt::Debug>(req: &tonic::Request<T>) -> u64 {
   get_value(req, request_metadata::CODE_VERSION)
     .and_then(|version| version.parse().ok())
     .unwrap_or_else(|| {
       warn!(
         "Could not retrieve code version from request: {:?}. Defaulting to 0",
         req
       );
       Default::default()
     })
 }
diff --git a/services/identity/src/grpc_services/authenticated.rs b/services/identity/src/grpc_services/authenticated.rs
index 32f2ec288..14085db59 100644
--- a/services/identity/src/grpc_services/authenticated.rs
+++ b/services/identity/src/grpc_services/authenticated.rs
@@ -1,536 +1,544 @@
 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,
-  OutboundKeyInfo, OutboundKeysForUserRequest, OutboundKeysForUserResponse,
-  RefreshUserPrekeysRequest, UpdateDeviceListRequest,
-  UpdateUserPasswordFinishRequest, UpdateUserPasswordStartRequest,
-  UpdateUserPasswordStartResponse, UploadOneTimeKeysRequest,
+  LinkFarcasterAccountRequest, OutboundKeyInfo, OutboundKeysForUserRequest,
+  OutboundKeysForUserResponse, RefreshUserPrekeysRequest,
+  UpdateDeviceListRequest, UpdateUserPasswordFinishRequest,
+  UpdateUserPasswordStartRequest, UpdateUserPasswordStartResponse,
+  UploadOneTimeKeysRequest,
 };
 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)?;
 
     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 keyserver_info = self
       .db_client
       .get_keyserver_keys_for_user(&message.user_id)
       .await
       .map_err(handle_db_error)?
       .map(OutboundKeyInfo::from);
 
     let identifier = self
       .db_client
       .get_user_identifier(&message.user_id)
       .await
       .map_err(handle_db_error)?;
 
     let identity_info = IdentityInfo::try_from(identifier)?;
 
     let identity = Some(Identity {
       identity_info: Some(identity_info),
     });
 
     let response = Response::new(KeyserverKeysResponse {
       keyserver_info,
       identity,
     });
 
     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> {
+    unimplemented!();
+  }
 }
 
 // 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 c3b078897..ef862b87c 100644
--- a/shared/protos/identity_auth.proto
+++ b/shared/protos/identity_auth.proto
@@ -1,194 +1,206 @@
 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 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) {}
 
   // Called by clients to get required keys for opening a connection
   // to a user's keyserver
   rpc GetKeyserverKeys(OutboundKeysForUserRequest) returns
     (KeyserverKeysResponse) {}
 
   // 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) {}
 }
 
 // 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;
   Identity identity = 2;
 }
 
 // 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;
+}
diff --git a/shared/protos/identity_unauth.proto b/shared/protos/identity_unauth.proto
index a69250191..6df29f7cb 100644
--- a/shared/protos/identity_unauth.proto
+++ b/shared/protos/identity_unauth.proto
@@ -1,274 +1,294 @@
 syntax = "proto3";
 
 package identity.unauth;
 
 // RPCs from a client (iOS, Android, or web) to identity service
 service IdentityClientService {
 
   // Account actions
 
   // Called by user to register with the Identity Service (PAKE only)
   // Due to limitations of grpc-web, the Opaque challenge+response
   // needs to be split up over two unary requests
   // Start/Finish is used here to align with opaque protocol
   rpc RegisterPasswordUserStart(RegistrationStartRequest) returns (
     RegistrationStartResponse) {}
   rpc RegisterReservedPasswordUserStart(ReservedRegistrationStartRequest)
     returns (RegistrationStartResponse) {}
   rpc RegisterPasswordUserFinish(RegistrationFinishRequest) returns (
     AuthResponse) {}
   // Called by user to register device and get an access token
   rpc LogInPasswordUserStart(OpaqueLoginStartRequest) returns
     (OpaqueLoginStartResponse) {}
   rpc LogInPasswordUserFinish(OpaqueLoginFinishRequest) returns
     (AuthResponse) {}
   rpc LogInWalletUser(WalletAuthRequest) returns (AuthResponse) {}
   rpc RegisterWalletUser(WalletAuthRequest) returns (AuthResponse) {}
   rpc RegisterReservedWalletUser(ReservedWalletRegistrationRequest) returns
     (AuthResponse) {}
 
   rpc UploadKeysForRegisteredDeviceAndLogIn(SecondaryDeviceKeysUploadRequest)
     returns (AuthResponse) {}
 
   // Sign-In with Ethereum actions
 
   // Called by clients to get a nonce for a Sign-In with Ethereum message
   rpc GenerateNonce(Empty) returns (GenerateNonceResponse) {}
 
   // Service actions
 
   // Called by other services to verify a user's access token
   rpc VerifyUserAccessToken(VerifyUserAccessTokenRequest) returns
     (VerifyUserAccessTokenResponse) {}
 
   // Ashoat's keyserver actions
 
   // Called by Ashoat's keyserver to add usernames to the Identity service's
   // reserved list
   rpc AddReservedUsernames(AddReservedUsernamesRequest) returns (Empty) {}
   // Called by Ashoat's keyserver to remove usernames from the Identity
   // service's reserved list
   rpc RemoveReservedUsername(RemoveReservedUsernameRequest) returns (Empty) {}
 
   // Miscellaneous actions
 
   // Called by users periodically to check if their code version is supported
   rpc Ping(Empty) returns (Empty) {}
 
   // Returns userID for given username or wallet address
   rpc FindUserID(FindUserIDRequest) returns (FindUserIDResponse) {}
+
+  // Farcaster actions
+  rpc GetFarcasterUsers(GetFarcasterUsersRequest) returns
+    (GetFarcasterUsersResponse) {}
 }
 
 // Helper types
 
 message Empty {}
 
 message Prekey {
   string prekey = 1;
   string prekey_signature = 2;
 }
 
 // Key information needed for starting a X3DH session
 message IdentityKeyInfo {
   // JSON payload containing Olm keys
   // Sessions for users will contain both ContentKeys and NotifKeys
   // For keyservers, this will only contain ContentKeys
   string payload = 1;
   // Payload signed with the signing ed25519 key
   string payload_signature = 2;
   // Signed message used for SIWE
   // This correlates a given wallet with a device's content key
   optional string social_proof = 3;
 }
 
 // RegisterUser
 
 // Ephemeral information provided so others can create initial message
 // to this device
 //
 // Prekeys are generally rotated periodically
 // One-time Prekeys are "consumed" after first use, so many need to
 // be provide to avoid exhausting them.
 
 enum DeviceType {
   KEYSERVER = 0;
   WEB = 1;
   // iOS doesn't leave a good option for title to camel case renaming
   IOS = 2;
   ANDROID = 3;
   WINDOWS = 4;
   MAC_OS = 5;
 }
 
 // Bundle of information needed for creating an initial message using X3DH
 message DeviceKeyUpload {
   IdentityKeyInfo device_key_info = 1;
   Prekey content_upload = 2;
   Prekey notif_upload = 3;
   repeated string one_time_content_prekeys = 4;
   repeated string one_time_notif_prekeys = 5;
   DeviceType device_type = 6;
 }
 
 // Request for registering a new user
 message RegistrationStartRequest {
   // Message sent to initiate PAKE registration (step 1)
   bytes opaque_registration_request = 1;
   string username = 2;
   // Information needed to open a new channel to current user's device
   DeviceKeyUpload device_key_upload = 3;
   optional string farcaster_id = 4;
 }
 
 message ReservedRegistrationStartRequest {
   // Message sent to initiate PAKE registration (step 1)
   bytes opaque_registration_request = 1;
   string username = 2;
   // Information needed to open a new channel to current user's device
   DeviceKeyUpload device_key_upload = 3;
   // Message from Ashoat's keyserver attesting that a given user has ownership
   // of a given username
   string keyserver_message = 4;
   // Above message signed with Ashoat's keyserver's signing ed25519 key
   string keyserver_signature = 5;
 }
 
 // Messages sent from a client to Identity Service
 message RegistrationFinishRequest {
   // Identifier to correlate RegisterStart session
   string session_id = 1;
   // Final message in PAKE registration
   bytes opaque_registration_upload = 2;
 }
 
 // Messages sent from Identity Service to client
 message RegistrationStartResponse {
   // Identifier used to correlate start request with finish request
   string session_id = 1;
   // sent to the user upon reception of the PAKE registration attempt
   // (step 2)
   bytes opaque_registration_response = 2;
 }
 
 message AuthResponse {
   // Unique identifier for user
   string user_id = 1;
   string access_token = 2;
 }
 
 // LoginUser
 
 message OpaqueLoginStartRequest {
   string username = 1;
   // Message sent to initiate PAKE login (step 1)
   bytes opaque_login_request = 2;
   // Information specific to a user's device needed to open a new channel of
   // communication with this user
   DeviceKeyUpload device_key_upload = 3;
   // If set to true, the user's existing keyserver will be deleted from the
   // identity service and replaced with this one. This field has no effect if
   // the device is not a keyserver
   optional bool force = 4;
 }
 
 message OpaqueLoginFinishRequest {
   // Identifier used to correlate start request with finish request
   string session_id = 1;
   // Message containing client's reponse to server challenge.
   // Used to verify that client holds password secret (Step 3)
   bytes opaque_login_upload = 2;
 }
 
 message OpaqueLoginStartResponse {
   // Identifier used to correlate start request with finish request
   string session_id = 1;
   // Opaque challenge sent from server to client attempting to login (Step 2)
   bytes opaque_login_response = 2;
 }
 
 message WalletAuthRequest {
   string siwe_message = 1;
   string siwe_signature = 2;
   // Information specific to a user's device needed to open a new channel of
   // communication with this user
   DeviceKeyUpload device_key_upload = 3;
   optional string farcaster_id = 4;
 }
 
 message ReservedWalletRegistrationRequest {
   string siwe_message = 1;
   string siwe_signature = 2;
   // Information specific to a user's device needed to open a new channel of
   // communication with this user
   DeviceKeyUpload device_key_upload = 3;
   // Message from Ashoat's keyserver attesting that a given user has ownership
   // of a given wallet address
   string keyserver_message = 4;
   // Above message signed with Ashoat's keyserver's signing ed25519 key
   string keyserver_signature = 5;
 }
 
 // UploadKeysForRegisteredDeviceAndLogIn
 
 message SecondaryDeviceKeysUploadRequest {
   string user_id = 1;
   string challenge_response = 2;
   // Information specific to a user's device needed to open a new channel of
   // communication with this user
   DeviceKeyUpload device_key_upload = 3;
 }
 
 // GenerateNonce
 
 message GenerateNonceResponse{
   string nonce = 1;
 }
 
 // VerifyUserAccessToken
 
 message VerifyUserAccessTokenRequest {
   string user_id = 1;
   // signing ed25519 key for the given user's device
   string device_id = 2;
   string access_token = 3;
 }
 
 message VerifyUserAccessTokenResponse {
   bool token_valid = 1;
 }
 
 // AddReservedUsernames
 
 message AddReservedUsernamesRequest {
   // Message from Ashoat's keyserver containing the username to be added
   string message = 1;
   // Above message signed with Ashoat's keyserver's signing ed25519 key
   string signature = 2;
 }
 
 // RemoveReservedUsername
 
 message RemoveReservedUsernameRequest {
   // Message from Ashoat's keyserver containing the username to be removed
   string message = 1;
   // Above message signed with Ashoat's keyserver's signing ed25519 key
   string signature = 2;
 }
 
 // FindUserID
 
 message FindUserIDRequest {
   oneof identifier {
     string username = 1;
     string wallet_address = 2;
   }
 }
 
 message FindUserIDResponse {
   // userID if the user is registered with Identity Service, null otherwise
   optional string user_id = 1;
   // true if the identifier (username or wallet address) exists in the
   // reserved usernames list, false otherwise. It doesn't take into account
   // whether the user is registered with Identity Service (userID != null).
   bool is_reserved = 2;
 }
+
+// GetFarcasterUsers
+
+message GetFarcasterUsersRequest {
+  repeated string farcaster_ids = 1;
+}
+
+message GetFarcasterUsersResponse {
+  repeated FarcasterUser farcaster_users = 1;
+}
+
+message FarcasterUser {
+  string user_id = 1;
+  string farcaster_id = 2;
+  string username = 3;
+}
diff --git a/web/protobufs/identity-auth-client.cjs b/web/protobufs/identity-auth-client.cjs
index 1787b534a..14dee1779 100644
--- a/web/protobufs/identity-auth-client.cjs
+++ b/web/protobufs/identity-auth-client.cjs
@@ -1,752 +1,813 @@
 /**
  * @fileoverview gRPC-Web generated client stub for identity.auth
  * @enhanceable
  * @public
  * @generated
  */
 
 // Code generated by protoc-gen-grpc-web. DO NOT EDIT.
 // versions:
 // 	protoc-gen-grpc-web v1.4.2
 // 	protoc              v3.21.12
 // source: identity_auth.proto
 
 
 /* eslint-disable */
 // @ts-nocheck
 
 
 
 const grpc = {};
 grpc.web = require('grpc-web');
 
 
 var identity_unauth_pb = require('./identity-unauth-structs.cjs')
 const proto = {};
 proto.identity = {};
 proto.identity.auth = require('./identity-auth-structs.cjs');
 
 /**
  * @param {string} hostname
  * @param {?Object} credentials
  * @param {?grpc.web.ClientOptions} options
  * @constructor
  * @struct
  * @final
  */
 proto.identity.auth.IdentityClientServiceClient =
     function(hostname, credentials, options) {
   if (!options) options = {};
   options.format = 'text';
 
   /**
    * @private @const {!grpc.web.GrpcWebClientBase} The client
    */
   this.client_ = new grpc.web.GrpcWebClientBase(options);
 
   /**
    * @private @const {string} The hostname
    */
   this.hostname_ = hostname.replace(/\/+$/, '');
 
 };
 
 
 /**
  * @param {string} hostname
  * @param {?Object} credentials
  * @param {?grpc.web.ClientOptions} options
  * @constructor
  * @struct
  * @final
  */
 proto.identity.auth.IdentityClientServicePromiseClient =
     function(hostname, credentials, options) {
   if (!options) options = {};
   options.format = 'text';
 
   /**
    * @private @const {!grpc.web.GrpcWebClientBase} The client
    */
   this.client_ = new grpc.web.GrpcWebClientBase(options);
 
   /**
    * @private @const {string} The hostname
    */
   this.hostname_ = hostname.replace(/\/+$/, '');
 
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.auth.UploadOneTimeKeysRequest,
  *   !proto.identity.unauth.Empty>}
  */
 const methodDescriptor_IdentityClientService_UploadOneTimeKeys = new grpc.web.MethodDescriptor(
   '/identity.auth.IdentityClientService/UploadOneTimeKeys',
   grpc.web.MethodType.UNARY,
   proto.identity.auth.UploadOneTimeKeysRequest,
   identity_unauth_pb.Empty,
   /**
    * @param {!proto.identity.auth.UploadOneTimeKeysRequest} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   identity_unauth_pb.Empty.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.auth.UploadOneTimeKeysRequest} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.unauth.Empty)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.unauth.Empty>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.auth.IdentityClientServiceClient.prototype.uploadOneTimeKeys =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.auth.IdentityClientService/UploadOneTimeKeys',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_UploadOneTimeKeys,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.auth.UploadOneTimeKeysRequest} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.unauth.Empty>}
  *     Promise that resolves to the response
  */
 proto.identity.auth.IdentityClientServicePromiseClient.prototype.uploadOneTimeKeys =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.auth.IdentityClientService/UploadOneTimeKeys',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_UploadOneTimeKeys);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.auth.RefreshUserPrekeysRequest,
  *   !proto.identity.unauth.Empty>}
  */
 const methodDescriptor_IdentityClientService_RefreshUserPrekeys = new grpc.web.MethodDescriptor(
   '/identity.auth.IdentityClientService/RefreshUserPrekeys',
   grpc.web.MethodType.UNARY,
   proto.identity.auth.RefreshUserPrekeysRequest,
   identity_unauth_pb.Empty,
   /**
    * @param {!proto.identity.auth.RefreshUserPrekeysRequest} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   identity_unauth_pb.Empty.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.auth.RefreshUserPrekeysRequest} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.unauth.Empty)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.unauth.Empty>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.auth.IdentityClientServiceClient.prototype.refreshUserPrekeys =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.auth.IdentityClientService/RefreshUserPrekeys',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_RefreshUserPrekeys,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.auth.RefreshUserPrekeysRequest} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.unauth.Empty>}
  *     Promise that resolves to the response
  */
 proto.identity.auth.IdentityClientServicePromiseClient.prototype.refreshUserPrekeys =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.auth.IdentityClientService/RefreshUserPrekeys',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_RefreshUserPrekeys);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.auth.OutboundKeysForUserRequest,
  *   !proto.identity.auth.OutboundKeysForUserResponse>}
  */
 const methodDescriptor_IdentityClientService_GetOutboundKeysForUser = new grpc.web.MethodDescriptor(
   '/identity.auth.IdentityClientService/GetOutboundKeysForUser',
   grpc.web.MethodType.UNARY,
   proto.identity.auth.OutboundKeysForUserRequest,
   proto.identity.auth.OutboundKeysForUserResponse,
   /**
    * @param {!proto.identity.auth.OutboundKeysForUserRequest} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   proto.identity.auth.OutboundKeysForUserResponse.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.auth.OutboundKeysForUserRequest} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.auth.OutboundKeysForUserResponse)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.auth.OutboundKeysForUserResponse>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.auth.IdentityClientServiceClient.prototype.getOutboundKeysForUser =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.auth.IdentityClientService/GetOutboundKeysForUser',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_GetOutboundKeysForUser,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.auth.OutboundKeysForUserRequest} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.auth.OutboundKeysForUserResponse>}
  *     Promise that resolves to the response
  */
 proto.identity.auth.IdentityClientServicePromiseClient.prototype.getOutboundKeysForUser =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.auth.IdentityClientService/GetOutboundKeysForUser',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_GetOutboundKeysForUser);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.auth.InboundKeysForUserRequest,
  *   !proto.identity.auth.InboundKeysForUserResponse>}
  */
 const methodDescriptor_IdentityClientService_GetInboundKeysForUser = new grpc.web.MethodDescriptor(
   '/identity.auth.IdentityClientService/GetInboundKeysForUser',
   grpc.web.MethodType.UNARY,
   proto.identity.auth.InboundKeysForUserRequest,
   proto.identity.auth.InboundKeysForUserResponse,
   /**
    * @param {!proto.identity.auth.InboundKeysForUserRequest} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   proto.identity.auth.InboundKeysForUserResponse.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.auth.InboundKeysForUserRequest} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.auth.InboundKeysForUserResponse)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.auth.InboundKeysForUserResponse>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.auth.IdentityClientServiceClient.prototype.getInboundKeysForUser =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.auth.IdentityClientService/GetInboundKeysForUser',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_GetInboundKeysForUser,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.auth.InboundKeysForUserRequest} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.auth.InboundKeysForUserResponse>}
  *     Promise that resolves to the response
  */
 proto.identity.auth.IdentityClientServicePromiseClient.prototype.getInboundKeysForUser =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.auth.IdentityClientService/GetInboundKeysForUser',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_GetInboundKeysForUser);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.auth.UpdateUserPasswordStartRequest,
  *   !proto.identity.auth.UpdateUserPasswordStartResponse>}
  */
 const methodDescriptor_IdentityClientService_UpdateUserPasswordStart = new grpc.web.MethodDescriptor(
   '/identity.auth.IdentityClientService/UpdateUserPasswordStart',
   grpc.web.MethodType.UNARY,
   proto.identity.auth.UpdateUserPasswordStartRequest,
   proto.identity.auth.UpdateUserPasswordStartResponse,
   /**
    * @param {!proto.identity.auth.UpdateUserPasswordStartRequest} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   proto.identity.auth.UpdateUserPasswordStartResponse.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.auth.UpdateUserPasswordStartRequest} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.auth.UpdateUserPasswordStartResponse)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.auth.UpdateUserPasswordStartResponse>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.auth.IdentityClientServiceClient.prototype.updateUserPasswordStart =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.auth.IdentityClientService/UpdateUserPasswordStart',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_UpdateUserPasswordStart,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.auth.UpdateUserPasswordStartRequest} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.auth.UpdateUserPasswordStartResponse>}
  *     Promise that resolves to the response
  */
 proto.identity.auth.IdentityClientServicePromiseClient.prototype.updateUserPasswordStart =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.auth.IdentityClientService/UpdateUserPasswordStart',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_UpdateUserPasswordStart);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.auth.UpdateUserPasswordFinishRequest,
  *   !proto.identity.unauth.Empty>}
  */
 const methodDescriptor_IdentityClientService_UpdateUserPasswordFinish = new grpc.web.MethodDescriptor(
   '/identity.auth.IdentityClientService/UpdateUserPasswordFinish',
   grpc.web.MethodType.UNARY,
   proto.identity.auth.UpdateUserPasswordFinishRequest,
   identity_unauth_pb.Empty,
   /**
    * @param {!proto.identity.auth.UpdateUserPasswordFinishRequest} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   identity_unauth_pb.Empty.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.auth.UpdateUserPasswordFinishRequest} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.unauth.Empty)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.unauth.Empty>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.auth.IdentityClientServiceClient.prototype.updateUserPasswordFinish =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.auth.IdentityClientService/UpdateUserPasswordFinish',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_UpdateUserPasswordFinish,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.auth.UpdateUserPasswordFinishRequest} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.unauth.Empty>}
  *     Promise that resolves to the response
  */
 proto.identity.auth.IdentityClientServicePromiseClient.prototype.updateUserPasswordFinish =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.auth.IdentityClientService/UpdateUserPasswordFinish',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_UpdateUserPasswordFinish);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.unauth.Empty,
  *   !proto.identity.unauth.Empty>}
  */
 const methodDescriptor_IdentityClientService_LogOutUser = new grpc.web.MethodDescriptor(
   '/identity.auth.IdentityClientService/LogOutUser',
   grpc.web.MethodType.UNARY,
   identity_unauth_pb.Empty,
   identity_unauth_pb.Empty,
   /**
    * @param {!proto.identity.unauth.Empty} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   identity_unauth_pb.Empty.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.unauth.Empty} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.unauth.Empty)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.unauth.Empty>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.auth.IdentityClientServiceClient.prototype.logOutUser =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.auth.IdentityClientService/LogOutUser',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_LogOutUser,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.unauth.Empty} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.unauth.Empty>}
  *     Promise that resolves to the response
  */
 proto.identity.auth.IdentityClientServicePromiseClient.prototype.logOutUser =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.auth.IdentityClientService/LogOutUser',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_LogOutUser);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.unauth.Empty,
  *   !proto.identity.unauth.Empty>}
  */
 const methodDescriptor_IdentityClientService_DeleteUser = new grpc.web.MethodDescriptor(
   '/identity.auth.IdentityClientService/DeleteUser',
   grpc.web.MethodType.UNARY,
   identity_unauth_pb.Empty,
   identity_unauth_pb.Empty,
   /**
    * @param {!proto.identity.unauth.Empty} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   identity_unauth_pb.Empty.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.unauth.Empty} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.unauth.Empty)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.unauth.Empty>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.auth.IdentityClientServiceClient.prototype.deleteUser =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.auth.IdentityClientService/DeleteUser',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_DeleteUser,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.unauth.Empty} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.unauth.Empty>}
  *     Promise that resolves to the response
  */
 proto.identity.auth.IdentityClientServicePromiseClient.prototype.deleteUser =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.auth.IdentityClientService/DeleteUser',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_DeleteUser);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.auth.OutboundKeysForUserRequest,
  *   !proto.identity.auth.KeyserverKeysResponse>}
  */
 const methodDescriptor_IdentityClientService_GetKeyserverKeys = new grpc.web.MethodDescriptor(
   '/identity.auth.IdentityClientService/GetKeyserverKeys',
   grpc.web.MethodType.UNARY,
   proto.identity.auth.OutboundKeysForUserRequest,
   proto.identity.auth.KeyserverKeysResponse,
   /**
    * @param {!proto.identity.auth.OutboundKeysForUserRequest} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   proto.identity.auth.KeyserverKeysResponse.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.auth.OutboundKeysForUserRequest} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.auth.KeyserverKeysResponse)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.auth.KeyserverKeysResponse>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.auth.IdentityClientServiceClient.prototype.getKeyserverKeys =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.auth.IdentityClientService/GetKeyserverKeys',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_GetKeyserverKeys,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.auth.OutboundKeysForUserRequest} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.auth.KeyserverKeysResponse>}
  *     Promise that resolves to the response
  */
 proto.identity.auth.IdentityClientServicePromiseClient.prototype.getKeyserverKeys =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.auth.IdentityClientService/GetKeyserverKeys',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_GetKeyserverKeys);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.auth.GetDeviceListRequest,
  *   !proto.identity.auth.GetDeviceListResponse>}
  */
 const methodDescriptor_IdentityClientService_GetDeviceListForUser = new grpc.web.MethodDescriptor(
   '/identity.auth.IdentityClientService/GetDeviceListForUser',
   grpc.web.MethodType.UNARY,
   proto.identity.auth.GetDeviceListRequest,
   proto.identity.auth.GetDeviceListResponse,
   /**
    * @param {!proto.identity.auth.GetDeviceListRequest} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   proto.identity.auth.GetDeviceListResponse.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.auth.GetDeviceListRequest} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.auth.GetDeviceListResponse)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.auth.GetDeviceListResponse>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.auth.IdentityClientServiceClient.prototype.getDeviceListForUser =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.auth.IdentityClientService/GetDeviceListForUser',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_GetDeviceListForUser,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.auth.GetDeviceListRequest} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.auth.GetDeviceListResponse>}
  *     Promise that resolves to the response
  */
 proto.identity.auth.IdentityClientServicePromiseClient.prototype.getDeviceListForUser =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.auth.IdentityClientService/GetDeviceListForUser',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_GetDeviceListForUser);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.auth.UpdateDeviceListRequest,
  *   !proto.identity.unauth.Empty>}
  */
 const methodDescriptor_IdentityClientService_UpdateDeviceList = new grpc.web.MethodDescriptor(
   '/identity.auth.IdentityClientService/UpdateDeviceList',
   grpc.web.MethodType.UNARY,
   proto.identity.auth.UpdateDeviceListRequest,
   identity_unauth_pb.Empty,
   /**
    * @param {!proto.identity.auth.UpdateDeviceListRequest} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   identity_unauth_pb.Empty.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.auth.UpdateDeviceListRequest} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.unauth.Empty)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.unauth.Empty>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.auth.IdentityClientServiceClient.prototype.updateDeviceList =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.auth.IdentityClientService/UpdateDeviceList',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_UpdateDeviceList,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.auth.UpdateDeviceListRequest} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.unauth.Empty>}
  *     Promise that resolves to the response
  */
 proto.identity.auth.IdentityClientServicePromiseClient.prototype.updateDeviceList =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.auth.IdentityClientService/UpdateDeviceList',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_UpdateDeviceList);
 };
 
 
+/**
+ * @const
+ * @type {!grpc.web.MethodDescriptor<
+ *   !proto.identity.auth.LinkFarcasterAccountRequest,
+ *   !proto.identity.unauth.Empty>}
+ */
+const methodDescriptor_IdentityClientService_LinkFarcasterAccount = new grpc.web.MethodDescriptor(
+  '/identity.auth.IdentityClientService/LinkFarcasterAccount',
+  grpc.web.MethodType.UNARY,
+  proto.identity.auth.LinkFarcasterAccountRequest,
+  identity_unauth_pb.Empty,
+  /**
+   * @param {!proto.identity.auth.LinkFarcasterAccountRequest} request
+   * @return {!Uint8Array}
+   */
+  function(request) {
+    return request.serializeBinary();
+  },
+  identity_unauth_pb.Empty.deserializeBinary
+);
+
+
+/**
+ * @param {!proto.identity.auth.LinkFarcasterAccountRequest} request The
+ *     request proto
+ * @param {?Object<string, string>} metadata User defined
+ *     call metadata
+ * @param {function(?grpc.web.RpcError, ?proto.identity.unauth.Empty)}
+ *     callback The callback function(error, response)
+ * @return {!grpc.web.ClientReadableStream<!proto.identity.unauth.Empty>|undefined}
+ *     The XHR Node Readable Stream
+ */
+proto.identity.auth.IdentityClientServiceClient.prototype.linkFarcasterAccount =
+    function(request, metadata, callback) {
+  return this.client_.rpcCall(this.hostname_ +
+      '/identity.auth.IdentityClientService/LinkFarcasterAccount',
+      request,
+      metadata || {},
+      methodDescriptor_IdentityClientService_LinkFarcasterAccount,
+      callback);
+};
+
+
+/**
+ * @param {!proto.identity.auth.LinkFarcasterAccountRequest} request The
+ *     request proto
+ * @param {?Object<string, string>=} metadata User defined
+ *     call metadata
+ * @return {!Promise<!proto.identity.unauth.Empty>}
+ *     Promise that resolves to the response
+ */
+proto.identity.auth.IdentityClientServicePromiseClient.prototype.linkFarcasterAccount =
+    function(request, metadata) {
+  return this.client_.unaryCall(this.hostname_ +
+      '/identity.auth.IdentityClientService/LinkFarcasterAccount',
+      request,
+      metadata || {},
+      methodDescriptor_IdentityClientService_LinkFarcasterAccount);
+};
+
+
 module.exports = proto.identity.auth;
diff --git a/web/protobufs/identity-auth-client.cjs.flow b/web/protobufs/identity-auth-client.cjs.flow
index d58d0cf2a..455333929 100644
--- a/web/protobufs/identity-auth-client.cjs.flow
+++ b/web/protobufs/identity-auth-client.cjs.flow
@@ -1,151 +1,163 @@
 // @flow
 
 import * as grpcWeb from 'grpc-web';
 
 import * as identityAuthStructs from './identity-auth-structs.cjs';
 import * as identityStructs from './identity-unauth-structs.cjs';
 
 
 declare export class IdentityClientServiceClient {
   constructor (hostname: string,
                credentials?: null | { +[index: string]: string; },
                options?: null | { +[index: string]: any; }): void;
 
   uploadOneTimeKeys(
     request: identityAuthStructs.UploadOneTimeKeysRequest,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityStructs.Empty) => void
   ): grpcWeb.ClientReadableStream<identityStructs.Empty>;
 
   refreshUserPrekeys(
     request: identityAuthStructs.RefreshUserPrekeysRequest,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityStructs.Empty) => void
   ): grpcWeb.ClientReadableStream<identityStructs.Empty>;
 
   getOutboundKeysForUser(
     request: identityAuthStructs.OutboundKeysForUserRequest,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityAuthStructs.OutboundKeysForUserResponse) => void
   ): grpcWeb.ClientReadableStream<identityAuthStructs.OutboundKeysForUserResponse>;
 
   getInboundKeysForUser(
     request: identityAuthStructs.InboundKeysForUserRequest,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityAuthStructs.InboundKeysForUserResponse) => void
   ): grpcWeb.ClientReadableStream<identityAuthStructs.InboundKeysForUserResponse>;
 
   updateUserPasswordStart(
     request: identityAuthStructs.UpdateUserPasswordStartRequest,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityAuthStructs.UpdateUserPasswordStartResponse) => void
   ): grpcWeb.ClientReadableStream<identityAuthStructs.UpdateUserPasswordStartResponse>;
 
   updateUserPasswordFinish(
     request: identityAuthStructs.UpdateUserPasswordFinishRequest,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityStructs.Empty) => void
   ): grpcWeb.ClientReadableStream<identityStructs.Empty>;
 
   logOutUser(
     request: identityStructs.Empty,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityStructs.Empty) => void
   ): grpcWeb.ClientReadableStream<identityStructs.Empty>;
 
   deleteUser(
     request: identityStructs.Empty,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityStructs.Empty) => void
   ): grpcWeb.ClientReadableStream<identityStructs.Empty>;
 
   getKeyserverKeys(
     request: identityAuthStructs.OutboundKeysForUserRequest,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityAuthStructs.KeyserverKeysResponse) => void
   ): grpcWeb.ClientReadableStream<identityAuthStructs.KeyserverKeysResponse>;
 
   getDeviceListForUser(
     request: identityAuthStructs.GetDeviceListRequest,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityAuthStructs.GetDeviceListResponse) => void
   ): grpcWeb.ClientReadableStream<identityAuthStructs.GetDeviceListResponse>;
 
   updateDeviceList(
     request: identityAuthStructs.UpdateDeviceListRequest,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityStructs.Empty) => void
   ): grpcWeb.ClientReadableStream<identityStructs.Empty>;
+
+  linkFarcasterAccount(
+    request: identityAuthStructs.LinkFarcasterAccountRequest,
+    metadata: grpcWeb.Metadata | void,
+    callback: (err: grpcWeb.RpcError,
+               response: identityStructs.Empty) => void
+  ): grpcWeb.ClientReadableStream<identityStructs.Empty>;
 }
 
 declare export class IdentityClientServicePromiseClient {
   constructor (hostname: string,
                credentials?: null | { +[index: string]: string; },
                options?: null | { +[index: string]: any; }): void;
 
   uploadOneTimeKeys(
     request: identityAuthStructs.UploadOneTimeKeysRequest,
     metadata?: grpcWeb.Metadata
   ): Promise<identityStructs.Empty>;
 
   refreshUserPrekeys(
     request: identityAuthStructs.RefreshUserPrekeysRequest,
     metadata?: grpcWeb.Metadata
   ): Promise<identityStructs.Empty>;
 
   getOutboundKeysForUser(
     request: identityAuthStructs.OutboundKeysForUserRequest,
     metadata?: grpcWeb.Metadata
   ): Promise<identityAuthStructs.OutboundKeysForUserResponse>;
 
   getInboundKeysForUser(
     request: identityAuthStructs.InboundKeysForUserRequest,
     metadata?: grpcWeb.Metadata
   ): Promise<identityAuthStructs.InboundKeysForUserResponse>;
 
   updateUserPasswordStart(
     request: identityAuthStructs.UpdateUserPasswordStartRequest,
     metadata?: grpcWeb.Metadata
   ): Promise<identityAuthStructs.UpdateUserPasswordStartResponse>;
 
   updateUserPasswordFinish(
     request: identityAuthStructs.UpdateUserPasswordFinishRequest,
     metadata?: grpcWeb.Metadata
   ): Promise<identityStructs.Empty>;
 
   logOutUser(
     request: identityStructs.Empty,
     metadata?: grpcWeb.Metadata
   ): Promise<identityStructs.Empty>;
 
   deleteUser(
     request: identityStructs.Empty,
     metadata?: grpcWeb.Metadata
   ): Promise<identityStructs.Empty>;
 
   getKeyserverKeys(
     request: identityAuthStructs.OutboundKeysForUserRequest,
     metadata?: grpcWeb.Metadata
   ): Promise<identityAuthStructs.KeyserverKeysResponse>;
 
   getDeviceListForUser(
     request: identityAuthStructs.GetDeviceListRequest,
     metadata?: grpcWeb.Metadata
   ): Promise<identityAuthStructs.GetDeviceListResponse>;
 
   updateDeviceList(
     request: identityAuthStructs.UpdateDeviceListRequest,
     metadata?: grpcWeb.Metadata
   ): Promise<identityStructs.Empty>;
+
+  linkFarcasterAccount(
+    request: identityAuthStructs.LinkFarcasterAccountRequest,
+    metadata?: grpcWeb.Metadata
+  ): Promise<identityStructs.Empty>;
 }
diff --git a/web/protobufs/identity-auth-structs.cjs b/web/protobufs/identity-auth-structs.cjs
index e6db938e8..608116278 100644
--- a/web/protobufs/identity-auth-structs.cjs
+++ b/web/protobufs/identity-auth-structs.cjs
@@ -1,3563 +1,3715 @@
 // source: identity_auth.proto
 /**
  * @fileoverview
  * @enhanceable
  * @suppress {missingRequire} reports error on implicit type usages.
  * @suppress {messageConventions} JS Compiler reports an error if a variable or
  *     field starts with 'MSG_' and isn't a translatable message.
  * @public
  * @generated
  */
 // GENERATED CODE -- DO NOT EDIT!
 /* eslint-disable */
 // @ts-nocheck
 
 var jspb = require('google-protobuf');
 var goog = jspb;
 var global =
     (typeof globalThis !== 'undefined' && globalThis) ||
     (typeof window !== 'undefined' && window) ||
     (typeof global !== 'undefined' && global) ||
     (typeof self !== 'undefined' && self) ||
     (function () { return this; }).call(null) ||
     Function('return this')();
 
 var identity_unauth_pb = require('./identity-unauth-structs.cjs');
 goog.object.extend(proto, identity_unauth_pb);
 goog.exportSymbol('proto.identity.auth.EthereumIdentity', null, global);
 goog.exportSymbol('proto.identity.auth.GetDeviceListRequest', null, global);
 goog.exportSymbol('proto.identity.auth.GetDeviceListResponse', null, global);
 goog.exportSymbol('proto.identity.auth.Identity', null, global);
 goog.exportSymbol('proto.identity.auth.Identity.IdentityInfoCase', null, global);
 goog.exportSymbol('proto.identity.auth.InboundKeyInfo', null, global);
 goog.exportSymbol('proto.identity.auth.InboundKeysForUserRequest', null, global);
 goog.exportSymbol('proto.identity.auth.InboundKeysForUserResponse', null, global);
 goog.exportSymbol('proto.identity.auth.KeyserverKeysResponse', null, global);
+goog.exportSymbol('proto.identity.auth.LinkFarcasterAccountRequest', null, global);
 goog.exportSymbol('proto.identity.auth.OutboundKeyInfo', null, global);
 goog.exportSymbol('proto.identity.auth.OutboundKeysForUserRequest', null, global);
 goog.exportSymbol('proto.identity.auth.OutboundKeysForUserResponse', null, global);
 goog.exportSymbol('proto.identity.auth.RefreshUserPrekeysRequest', null, global);
 goog.exportSymbol('proto.identity.auth.UpdateDeviceListRequest', null, global);
 goog.exportSymbol('proto.identity.auth.UpdateUserPasswordFinishRequest', null, global);
 goog.exportSymbol('proto.identity.auth.UpdateUserPasswordStartRequest', null, global);
 goog.exportSymbol('proto.identity.auth.UpdateUserPasswordStartResponse', null, global);
 goog.exportSymbol('proto.identity.auth.UploadOneTimeKeysRequest', null, global);
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.auth.EthereumIdentity = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.auth.EthereumIdentity, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.auth.EthereumIdentity.displayName = 'proto.identity.auth.EthereumIdentity';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.auth.Identity = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, proto.identity.auth.Identity.oneofGroups_);
 };
 goog.inherits(proto.identity.auth.Identity, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.auth.Identity.displayName = 'proto.identity.auth.Identity';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.auth.UploadOneTimeKeysRequest = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, proto.identity.auth.UploadOneTimeKeysRequest.repeatedFields_, null);
 };
 goog.inherits(proto.identity.auth.UploadOneTimeKeysRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.auth.UploadOneTimeKeysRequest.displayName = 'proto.identity.auth.UploadOneTimeKeysRequest';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.auth.RefreshUserPrekeysRequest = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.auth.RefreshUserPrekeysRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.auth.RefreshUserPrekeysRequest.displayName = 'proto.identity.auth.RefreshUserPrekeysRequest';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.auth.OutboundKeyInfo = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.auth.OutboundKeyInfo, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.auth.OutboundKeyInfo.displayName = 'proto.identity.auth.OutboundKeyInfo';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.auth.KeyserverKeysResponse = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.auth.KeyserverKeysResponse, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.auth.KeyserverKeysResponse.displayName = 'proto.identity.auth.KeyserverKeysResponse';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.auth.OutboundKeysForUserResponse = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.auth.OutboundKeysForUserResponse, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.auth.OutboundKeysForUserResponse.displayName = 'proto.identity.auth.OutboundKeysForUserResponse';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.auth.OutboundKeysForUserRequest = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.auth.OutboundKeysForUserRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.auth.OutboundKeysForUserRequest.displayName = 'proto.identity.auth.OutboundKeysForUserRequest';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.auth.InboundKeyInfo = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.auth.InboundKeyInfo, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.auth.InboundKeyInfo.displayName = 'proto.identity.auth.InboundKeyInfo';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.auth.InboundKeysForUserResponse = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.auth.InboundKeysForUserResponse, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.auth.InboundKeysForUserResponse.displayName = 'proto.identity.auth.InboundKeysForUserResponse';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.auth.InboundKeysForUserRequest = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.auth.InboundKeysForUserRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.auth.InboundKeysForUserRequest.displayName = 'proto.identity.auth.InboundKeysForUserRequest';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.auth.UpdateUserPasswordStartRequest = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.auth.UpdateUserPasswordStartRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.auth.UpdateUserPasswordStartRequest.displayName = 'proto.identity.auth.UpdateUserPasswordStartRequest';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.auth.UpdateUserPasswordFinishRequest = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.auth.UpdateUserPasswordFinishRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.auth.UpdateUserPasswordFinishRequest.displayName = 'proto.identity.auth.UpdateUserPasswordFinishRequest';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.auth.UpdateUserPasswordStartResponse = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.auth.UpdateUserPasswordStartResponse, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.auth.UpdateUserPasswordStartResponse.displayName = 'proto.identity.auth.UpdateUserPasswordStartResponse';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.auth.GetDeviceListRequest = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.auth.GetDeviceListRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.auth.GetDeviceListRequest.displayName = 'proto.identity.auth.GetDeviceListRequest';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.auth.GetDeviceListResponse = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, proto.identity.auth.GetDeviceListResponse.repeatedFields_, null);
 };
 goog.inherits(proto.identity.auth.GetDeviceListResponse, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.auth.GetDeviceListResponse.displayName = 'proto.identity.auth.GetDeviceListResponse';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.auth.UpdateDeviceListRequest = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.auth.UpdateDeviceListRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.auth.UpdateDeviceListRequest.displayName = 'proto.identity.auth.UpdateDeviceListRequest';
 }
+/**
+ * Generated by JsPbCodeGenerator.
+ * @param {Array=} opt_data Optional initial data array, typically from a
+ * server response, or constructed directly in Javascript. The array is used
+ * in place and becomes part of the constructed object. It is not cloned.
+ * If no data is provided, the constructed object will be empty, but still
+ * valid.
+ * @extends {jspb.Message}
+ * @constructor
+ */
+proto.identity.auth.LinkFarcasterAccountRequest = function(opt_data) {
+  jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+};
+goog.inherits(proto.identity.auth.LinkFarcasterAccountRequest, jspb.Message);
+if (goog.DEBUG && !COMPILED) {
+  /**
+   * @public
+   * @override
+   */
+  proto.identity.auth.LinkFarcasterAccountRequest.displayName = 'proto.identity.auth.LinkFarcasterAccountRequest';
+}
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.auth.EthereumIdentity.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.auth.EthereumIdentity.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.auth.EthereumIdentity} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.EthereumIdentity.toObject = function(includeInstance, msg) {
   var f, obj = {
     walletAddress: jspb.Message.getFieldWithDefault(msg, 1, ""),
     socialProof: jspb.Message.getFieldWithDefault(msg, 2, "")
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.auth.EthereumIdentity}
  */
 proto.identity.auth.EthereumIdentity.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.auth.EthereumIdentity;
   return proto.identity.auth.EthereumIdentity.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.auth.EthereumIdentity} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.auth.EthereumIdentity}
  */
 proto.identity.auth.EthereumIdentity.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setWalletAddress(value);
       break;
     case 2:
       var value = /** @type {string} */ (reader.readString());
       msg.setSocialProof(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.auth.EthereumIdentity.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.auth.EthereumIdentity.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.auth.EthereumIdentity} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.EthereumIdentity.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getWalletAddress();
   if (f.length > 0) {
     writer.writeString(
       1,
       f
     );
   }
   f = message.getSocialProof();
   if (f.length > 0) {
     writer.writeString(
       2,
       f
     );
   }
 };
 
 
 /**
  * optional string wallet_address = 1;
  * @return {string}
  */
 proto.identity.auth.EthereumIdentity.prototype.getWalletAddress = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.auth.EthereumIdentity} returns this
  */
 proto.identity.auth.EthereumIdentity.prototype.setWalletAddress = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
 /**
  * optional string social_proof = 2;
  * @return {string}
  */
 proto.identity.auth.EthereumIdentity.prototype.getSocialProof = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.auth.EthereumIdentity} returns this
  */
 proto.identity.auth.EthereumIdentity.prototype.setSocialProof = function(value) {
   return jspb.Message.setProto3StringField(this, 2, value);
 };
 
 
 
 /**
  * Oneof group definitions for this message. Each group defines the field
  * numbers belonging to that group. When of these fields' value is set, all
  * other fields in the group are cleared. During deserialization, if multiple
  * fields are encountered for a group, only the last value seen will be kept.
  * @private {!Array<!Array<number>>}
  * @const
  */
 proto.identity.auth.Identity.oneofGroups_ = [[1,2]];
 
 /**
  * @enum {number}
  */
 proto.identity.auth.Identity.IdentityInfoCase = {
   IDENTITY_INFO_NOT_SET: 0,
   USERNAME: 1,
   ETH_IDENTITY: 2
 };
 
 /**
  * @return {proto.identity.auth.Identity.IdentityInfoCase}
  */
 proto.identity.auth.Identity.prototype.getIdentityInfoCase = function() {
   return /** @type {proto.identity.auth.Identity.IdentityInfoCase} */(jspb.Message.computeOneofCase(this, proto.identity.auth.Identity.oneofGroups_[0]));
 };
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.auth.Identity.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.auth.Identity.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.auth.Identity} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.Identity.toObject = function(includeInstance, msg) {
   var f, obj = {
     username: jspb.Message.getFieldWithDefault(msg, 1, ""),
     ethIdentity: (f = msg.getEthIdentity()) && proto.identity.auth.EthereumIdentity.toObject(includeInstance, f)
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.auth.Identity}
  */
 proto.identity.auth.Identity.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.auth.Identity;
   return proto.identity.auth.Identity.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.auth.Identity} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.auth.Identity}
  */
 proto.identity.auth.Identity.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setUsername(value);
       break;
     case 2:
       var value = new proto.identity.auth.EthereumIdentity;
       reader.readMessage(value,proto.identity.auth.EthereumIdentity.deserializeBinaryFromReader);
       msg.setEthIdentity(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.auth.Identity.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.auth.Identity.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.auth.Identity} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.Identity.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = /** @type {string} */ (jspb.Message.getField(message, 1));
   if (f != null) {
     writer.writeString(
       1,
       f
     );
   }
   f = message.getEthIdentity();
   if (f != null) {
     writer.writeMessage(
       2,
       f,
       proto.identity.auth.EthereumIdentity.serializeBinaryToWriter
     );
   }
 };
 
 
 /**
  * optional string username = 1;
  * @return {string}
  */
 proto.identity.auth.Identity.prototype.getUsername = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.auth.Identity} returns this
  */
 proto.identity.auth.Identity.prototype.setUsername = function(value) {
   return jspb.Message.setOneofField(this, 1, proto.identity.auth.Identity.oneofGroups_[0], value);
 };
 
 
 /**
  * Clears the field making it undefined.
  * @return {!proto.identity.auth.Identity} returns this
  */
 proto.identity.auth.Identity.prototype.clearUsername = function() {
   return jspb.Message.setOneofField(this, 1, proto.identity.auth.Identity.oneofGroups_[0], undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.auth.Identity.prototype.hasUsername = function() {
   return jspb.Message.getField(this, 1) != null;
 };
 
 
 /**
  * optional EthereumIdentity eth_identity = 2;
  * @return {?proto.identity.auth.EthereumIdentity}
  */
 proto.identity.auth.Identity.prototype.getEthIdentity = function() {
   return /** @type{?proto.identity.auth.EthereumIdentity} */ (
     jspb.Message.getWrapperField(this, proto.identity.auth.EthereumIdentity, 2));
 };
 
 
 /**
  * @param {?proto.identity.auth.EthereumIdentity|undefined} value
  * @return {!proto.identity.auth.Identity} returns this
 */
 proto.identity.auth.Identity.prototype.setEthIdentity = function(value) {
   return jspb.Message.setOneofWrapperField(this, 2, proto.identity.auth.Identity.oneofGroups_[0], value);
 };
 
 
 /**
  * Clears the message field making it undefined.
  * @return {!proto.identity.auth.Identity} returns this
  */
 proto.identity.auth.Identity.prototype.clearEthIdentity = function() {
   return this.setEthIdentity(undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.auth.Identity.prototype.hasEthIdentity = function() {
   return jspb.Message.getField(this, 2) != null;
 };
 
 
 
 /**
  * List of repeated fields within this message type.
  * @private {!Array<number>}
  * @const
  */
 proto.identity.auth.UploadOneTimeKeysRequest.repeatedFields_ = [1,2];
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.auth.UploadOneTimeKeysRequest.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.auth.UploadOneTimeKeysRequest.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.auth.UploadOneTimeKeysRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.UploadOneTimeKeysRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
     contentOneTimePrekeysList: (f = jspb.Message.getRepeatedField(msg, 1)) == null ? undefined : f,
     notifOneTimePrekeysList: (f = jspb.Message.getRepeatedField(msg, 2)) == null ? undefined : f
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.auth.UploadOneTimeKeysRequest}
  */
 proto.identity.auth.UploadOneTimeKeysRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.auth.UploadOneTimeKeysRequest;
   return proto.identity.auth.UploadOneTimeKeysRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.auth.UploadOneTimeKeysRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.auth.UploadOneTimeKeysRequest}
  */
 proto.identity.auth.UploadOneTimeKeysRequest.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.addContentOneTimePrekeys(value);
       break;
     case 2:
       var value = /** @type {string} */ (reader.readString());
       msg.addNotifOneTimePrekeys(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.auth.UploadOneTimeKeysRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.auth.UploadOneTimeKeysRequest.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.auth.UploadOneTimeKeysRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.UploadOneTimeKeysRequest.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getContentOneTimePrekeysList();
   if (f.length > 0) {
     writer.writeRepeatedString(
       1,
       f
     );
   }
   f = message.getNotifOneTimePrekeysList();
   if (f.length > 0) {
     writer.writeRepeatedString(
       2,
       f
     );
   }
 };
 
 
 /**
  * repeated string content_one_time_prekeys = 1;
  * @return {!Array<string>}
  */
 proto.identity.auth.UploadOneTimeKeysRequest.prototype.getContentOneTimePrekeysList = function() {
   return /** @type {!Array<string>} */ (jspb.Message.getRepeatedField(this, 1));
 };
 
 
 /**
  * @param {!Array<string>} value
  * @return {!proto.identity.auth.UploadOneTimeKeysRequest} returns this
  */
 proto.identity.auth.UploadOneTimeKeysRequest.prototype.setContentOneTimePrekeysList = function(value) {
   return jspb.Message.setField(this, 1, value || []);
 };
 
 
 /**
  * @param {string} value
  * @param {number=} opt_index
  * @return {!proto.identity.auth.UploadOneTimeKeysRequest} returns this
  */
 proto.identity.auth.UploadOneTimeKeysRequest.prototype.addContentOneTimePrekeys = function(value, opt_index) {
   return jspb.Message.addToRepeatedField(this, 1, value, opt_index);
 };
 
 
 /**
  * Clears the list making it empty but non-null.
  * @return {!proto.identity.auth.UploadOneTimeKeysRequest} returns this
  */
 proto.identity.auth.UploadOneTimeKeysRequest.prototype.clearContentOneTimePrekeysList = function() {
   return this.setContentOneTimePrekeysList([]);
 };
 
 
 /**
  * repeated string notif_one_time_prekeys = 2;
  * @return {!Array<string>}
  */
 proto.identity.auth.UploadOneTimeKeysRequest.prototype.getNotifOneTimePrekeysList = function() {
   return /** @type {!Array<string>} */ (jspb.Message.getRepeatedField(this, 2));
 };
 
 
 /**
  * @param {!Array<string>} value
  * @return {!proto.identity.auth.UploadOneTimeKeysRequest} returns this
  */
 proto.identity.auth.UploadOneTimeKeysRequest.prototype.setNotifOneTimePrekeysList = function(value) {
   return jspb.Message.setField(this, 2, value || []);
 };
 
 
 /**
  * @param {string} value
  * @param {number=} opt_index
  * @return {!proto.identity.auth.UploadOneTimeKeysRequest} returns this
  */
 proto.identity.auth.UploadOneTimeKeysRequest.prototype.addNotifOneTimePrekeys = function(value, opt_index) {
   return jspb.Message.addToRepeatedField(this, 2, value, opt_index);
 };
 
 
 /**
  * Clears the list making it empty but non-null.
  * @return {!proto.identity.auth.UploadOneTimeKeysRequest} returns this
  */
 proto.identity.auth.UploadOneTimeKeysRequest.prototype.clearNotifOneTimePrekeysList = function() {
   return this.setNotifOneTimePrekeysList([]);
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.auth.RefreshUserPrekeysRequest.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.auth.RefreshUserPrekeysRequest.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.auth.RefreshUserPrekeysRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.RefreshUserPrekeysRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
     newContentPrekeys: (f = msg.getNewContentPrekeys()) && identity_unauth_pb.Prekey.toObject(includeInstance, f),
     newNotifPrekeys: (f = msg.getNewNotifPrekeys()) && identity_unauth_pb.Prekey.toObject(includeInstance, f)
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.auth.RefreshUserPrekeysRequest}
  */
 proto.identity.auth.RefreshUserPrekeysRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.auth.RefreshUserPrekeysRequest;
   return proto.identity.auth.RefreshUserPrekeysRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.auth.RefreshUserPrekeysRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.auth.RefreshUserPrekeysRequest}
  */
 proto.identity.auth.RefreshUserPrekeysRequest.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = new identity_unauth_pb.Prekey;
       reader.readMessage(value,identity_unauth_pb.Prekey.deserializeBinaryFromReader);
       msg.setNewContentPrekeys(value);
       break;
     case 2:
       var value = new identity_unauth_pb.Prekey;
       reader.readMessage(value,identity_unauth_pb.Prekey.deserializeBinaryFromReader);
       msg.setNewNotifPrekeys(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.auth.RefreshUserPrekeysRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.auth.RefreshUserPrekeysRequest.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.auth.RefreshUserPrekeysRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.RefreshUserPrekeysRequest.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getNewContentPrekeys();
   if (f != null) {
     writer.writeMessage(
       1,
       f,
       identity_unauth_pb.Prekey.serializeBinaryToWriter
     );
   }
   f = message.getNewNotifPrekeys();
   if (f != null) {
     writer.writeMessage(
       2,
       f,
       identity_unauth_pb.Prekey.serializeBinaryToWriter
     );
   }
 };
 
 
 /**
  * optional identity.unauth.Prekey new_content_prekeys = 1;
  * @return {?proto.identity.unauth.Prekey}
  */
 proto.identity.auth.RefreshUserPrekeysRequest.prototype.getNewContentPrekeys = function() {
   return /** @type{?proto.identity.unauth.Prekey} */ (
     jspb.Message.getWrapperField(this, identity_unauth_pb.Prekey, 1));
 };
 
 
 /**
  * @param {?proto.identity.unauth.Prekey|undefined} value
  * @return {!proto.identity.auth.RefreshUserPrekeysRequest} returns this
 */
 proto.identity.auth.RefreshUserPrekeysRequest.prototype.setNewContentPrekeys = function(value) {
   return jspb.Message.setWrapperField(this, 1, value);
 };
 
 
 /**
  * Clears the message field making it undefined.
  * @return {!proto.identity.auth.RefreshUserPrekeysRequest} returns this
  */
 proto.identity.auth.RefreshUserPrekeysRequest.prototype.clearNewContentPrekeys = function() {
   return this.setNewContentPrekeys(undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.auth.RefreshUserPrekeysRequest.prototype.hasNewContentPrekeys = function() {
   return jspb.Message.getField(this, 1) != null;
 };
 
 
 /**
  * optional identity.unauth.Prekey new_notif_prekeys = 2;
  * @return {?proto.identity.unauth.Prekey}
  */
 proto.identity.auth.RefreshUserPrekeysRequest.prototype.getNewNotifPrekeys = function() {
   return /** @type{?proto.identity.unauth.Prekey} */ (
     jspb.Message.getWrapperField(this, identity_unauth_pb.Prekey, 2));
 };
 
 
 /**
  * @param {?proto.identity.unauth.Prekey|undefined} value
  * @return {!proto.identity.auth.RefreshUserPrekeysRequest} returns this
 */
 proto.identity.auth.RefreshUserPrekeysRequest.prototype.setNewNotifPrekeys = function(value) {
   return jspb.Message.setWrapperField(this, 2, value);
 };
 
 
 /**
  * Clears the message field making it undefined.
  * @return {!proto.identity.auth.RefreshUserPrekeysRequest} returns this
  */
 proto.identity.auth.RefreshUserPrekeysRequest.prototype.clearNewNotifPrekeys = function() {
   return this.setNewNotifPrekeys(undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.auth.RefreshUserPrekeysRequest.prototype.hasNewNotifPrekeys = function() {
   return jspb.Message.getField(this, 2) != null;
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.auth.OutboundKeyInfo.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.auth.OutboundKeyInfo.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.auth.OutboundKeyInfo} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.OutboundKeyInfo.toObject = function(includeInstance, msg) {
   var f, obj = {
     identityInfo: (f = msg.getIdentityInfo()) && identity_unauth_pb.IdentityKeyInfo.toObject(includeInstance, f),
     contentPrekey: (f = msg.getContentPrekey()) && identity_unauth_pb.Prekey.toObject(includeInstance, f),
     notifPrekey: (f = msg.getNotifPrekey()) && identity_unauth_pb.Prekey.toObject(includeInstance, f),
     oneTimeContentPrekey: jspb.Message.getFieldWithDefault(msg, 4, ""),
     oneTimeNotifPrekey: jspb.Message.getFieldWithDefault(msg, 5, "")
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.auth.OutboundKeyInfo}
  */
 proto.identity.auth.OutboundKeyInfo.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.auth.OutboundKeyInfo;
   return proto.identity.auth.OutboundKeyInfo.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.auth.OutboundKeyInfo} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.auth.OutboundKeyInfo}
  */
 proto.identity.auth.OutboundKeyInfo.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = new identity_unauth_pb.IdentityKeyInfo;
       reader.readMessage(value,identity_unauth_pb.IdentityKeyInfo.deserializeBinaryFromReader);
       msg.setIdentityInfo(value);
       break;
     case 2:
       var value = new identity_unauth_pb.Prekey;
       reader.readMessage(value,identity_unauth_pb.Prekey.deserializeBinaryFromReader);
       msg.setContentPrekey(value);
       break;
     case 3:
       var value = new identity_unauth_pb.Prekey;
       reader.readMessage(value,identity_unauth_pb.Prekey.deserializeBinaryFromReader);
       msg.setNotifPrekey(value);
       break;
     case 4:
       var value = /** @type {string} */ (reader.readString());
       msg.setOneTimeContentPrekey(value);
       break;
     case 5:
       var value = /** @type {string} */ (reader.readString());
       msg.setOneTimeNotifPrekey(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.auth.OutboundKeyInfo.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.auth.OutboundKeyInfo.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.auth.OutboundKeyInfo} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.OutboundKeyInfo.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getIdentityInfo();
   if (f != null) {
     writer.writeMessage(
       1,
       f,
       identity_unauth_pb.IdentityKeyInfo.serializeBinaryToWriter
     );
   }
   f = message.getContentPrekey();
   if (f != null) {
     writer.writeMessage(
       2,
       f,
       identity_unauth_pb.Prekey.serializeBinaryToWriter
     );
   }
   f = message.getNotifPrekey();
   if (f != null) {
     writer.writeMessage(
       3,
       f,
       identity_unauth_pb.Prekey.serializeBinaryToWriter
     );
   }
   f = /** @type {string} */ (jspb.Message.getField(message, 4));
   if (f != null) {
     writer.writeString(
       4,
       f
     );
   }
   f = /** @type {string} */ (jspb.Message.getField(message, 5));
   if (f != null) {
     writer.writeString(
       5,
       f
     );
   }
 };
 
 
 /**
  * optional identity.unauth.IdentityKeyInfo identity_info = 1;
  * @return {?proto.identity.unauth.IdentityKeyInfo}
  */
 proto.identity.auth.OutboundKeyInfo.prototype.getIdentityInfo = function() {
   return /** @type{?proto.identity.unauth.IdentityKeyInfo} */ (
     jspb.Message.getWrapperField(this, identity_unauth_pb.IdentityKeyInfo, 1));
 };
 
 
 /**
  * @param {?proto.identity.unauth.IdentityKeyInfo|undefined} value
  * @return {!proto.identity.auth.OutboundKeyInfo} returns this
 */
 proto.identity.auth.OutboundKeyInfo.prototype.setIdentityInfo = function(value) {
   return jspb.Message.setWrapperField(this, 1, value);
 };
 
 
 /**
  * Clears the message field making it undefined.
  * @return {!proto.identity.auth.OutboundKeyInfo} returns this
  */
 proto.identity.auth.OutboundKeyInfo.prototype.clearIdentityInfo = function() {
   return this.setIdentityInfo(undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.auth.OutboundKeyInfo.prototype.hasIdentityInfo = function() {
   return jspb.Message.getField(this, 1) != null;
 };
 
 
 /**
  * optional identity.unauth.Prekey content_prekey = 2;
  * @return {?proto.identity.unauth.Prekey}
  */
 proto.identity.auth.OutboundKeyInfo.prototype.getContentPrekey = function() {
   return /** @type{?proto.identity.unauth.Prekey} */ (
     jspb.Message.getWrapperField(this, identity_unauth_pb.Prekey, 2));
 };
 
 
 /**
  * @param {?proto.identity.unauth.Prekey|undefined} value
  * @return {!proto.identity.auth.OutboundKeyInfo} returns this
 */
 proto.identity.auth.OutboundKeyInfo.prototype.setContentPrekey = function(value) {
   return jspb.Message.setWrapperField(this, 2, value);
 };
 
 
 /**
  * Clears the message field making it undefined.
  * @return {!proto.identity.auth.OutboundKeyInfo} returns this
  */
 proto.identity.auth.OutboundKeyInfo.prototype.clearContentPrekey = function() {
   return this.setContentPrekey(undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.auth.OutboundKeyInfo.prototype.hasContentPrekey = function() {
   return jspb.Message.getField(this, 2) != null;
 };
 
 
 /**
  * optional identity.unauth.Prekey notif_prekey = 3;
  * @return {?proto.identity.unauth.Prekey}
  */
 proto.identity.auth.OutboundKeyInfo.prototype.getNotifPrekey = function() {
   return /** @type{?proto.identity.unauth.Prekey} */ (
     jspb.Message.getWrapperField(this, identity_unauth_pb.Prekey, 3));
 };
 
 
 /**
  * @param {?proto.identity.unauth.Prekey|undefined} value
  * @return {!proto.identity.auth.OutboundKeyInfo} returns this
 */
 proto.identity.auth.OutboundKeyInfo.prototype.setNotifPrekey = function(value) {
   return jspb.Message.setWrapperField(this, 3, value);
 };
 
 
 /**
  * Clears the message field making it undefined.
  * @return {!proto.identity.auth.OutboundKeyInfo} returns this
  */
 proto.identity.auth.OutboundKeyInfo.prototype.clearNotifPrekey = function() {
   return this.setNotifPrekey(undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.auth.OutboundKeyInfo.prototype.hasNotifPrekey = function() {
   return jspb.Message.getField(this, 3) != null;
 };
 
 
 /**
  * optional string one_time_content_prekey = 4;
  * @return {string}
  */
 proto.identity.auth.OutboundKeyInfo.prototype.getOneTimeContentPrekey = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.auth.OutboundKeyInfo} returns this
  */
 proto.identity.auth.OutboundKeyInfo.prototype.setOneTimeContentPrekey = function(value) {
   return jspb.Message.setField(this, 4, value);
 };
 
 
 /**
  * Clears the field making it undefined.
  * @return {!proto.identity.auth.OutboundKeyInfo} returns this
  */
 proto.identity.auth.OutboundKeyInfo.prototype.clearOneTimeContentPrekey = function() {
   return jspb.Message.setField(this, 4, undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.auth.OutboundKeyInfo.prototype.hasOneTimeContentPrekey = function() {
   return jspb.Message.getField(this, 4) != null;
 };
 
 
 /**
  * optional string one_time_notif_prekey = 5;
  * @return {string}
  */
 proto.identity.auth.OutboundKeyInfo.prototype.getOneTimeNotifPrekey = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.auth.OutboundKeyInfo} returns this
  */
 proto.identity.auth.OutboundKeyInfo.prototype.setOneTimeNotifPrekey = function(value) {
   return jspb.Message.setField(this, 5, value);
 };
 
 
 /**
  * Clears the field making it undefined.
  * @return {!proto.identity.auth.OutboundKeyInfo} returns this
  */
 proto.identity.auth.OutboundKeyInfo.prototype.clearOneTimeNotifPrekey = function() {
   return jspb.Message.setField(this, 5, undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.auth.OutboundKeyInfo.prototype.hasOneTimeNotifPrekey = function() {
   return jspb.Message.getField(this, 5) != null;
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.auth.KeyserverKeysResponse.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.auth.KeyserverKeysResponse.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.auth.KeyserverKeysResponse} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.KeyserverKeysResponse.toObject = function(includeInstance, msg) {
   var f, obj = {
     keyserverInfo: (f = msg.getKeyserverInfo()) && proto.identity.auth.OutboundKeyInfo.toObject(includeInstance, f),
     identity: (f = msg.getIdentity()) && proto.identity.auth.Identity.toObject(includeInstance, f)
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.auth.KeyserverKeysResponse}
  */
 proto.identity.auth.KeyserverKeysResponse.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.auth.KeyserverKeysResponse;
   return proto.identity.auth.KeyserverKeysResponse.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.auth.KeyserverKeysResponse} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.auth.KeyserverKeysResponse}
  */
 proto.identity.auth.KeyserverKeysResponse.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = new proto.identity.auth.OutboundKeyInfo;
       reader.readMessage(value,proto.identity.auth.OutboundKeyInfo.deserializeBinaryFromReader);
       msg.setKeyserverInfo(value);
       break;
     case 2:
       var value = new proto.identity.auth.Identity;
       reader.readMessage(value,proto.identity.auth.Identity.deserializeBinaryFromReader);
       msg.setIdentity(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.auth.KeyserverKeysResponse.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.auth.KeyserverKeysResponse.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.auth.KeyserverKeysResponse} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.KeyserverKeysResponse.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getKeyserverInfo();
   if (f != null) {
     writer.writeMessage(
       1,
       f,
       proto.identity.auth.OutboundKeyInfo.serializeBinaryToWriter
     );
   }
   f = message.getIdentity();
   if (f != null) {
     writer.writeMessage(
       2,
       f,
       proto.identity.auth.Identity.serializeBinaryToWriter
     );
   }
 };
 
 
 /**
  * optional OutboundKeyInfo keyserver_info = 1;
  * @return {?proto.identity.auth.OutboundKeyInfo}
  */
 proto.identity.auth.KeyserverKeysResponse.prototype.getKeyserverInfo = function() {
   return /** @type{?proto.identity.auth.OutboundKeyInfo} */ (
     jspb.Message.getWrapperField(this, proto.identity.auth.OutboundKeyInfo, 1));
 };
 
 
 /**
  * @param {?proto.identity.auth.OutboundKeyInfo|undefined} value
  * @return {!proto.identity.auth.KeyserverKeysResponse} returns this
 */
 proto.identity.auth.KeyserverKeysResponse.prototype.setKeyserverInfo = function(value) {
   return jspb.Message.setWrapperField(this, 1, value);
 };
 
 
 /**
  * Clears the message field making it undefined.
  * @return {!proto.identity.auth.KeyserverKeysResponse} returns this
  */
 proto.identity.auth.KeyserverKeysResponse.prototype.clearKeyserverInfo = function() {
   return this.setKeyserverInfo(undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.auth.KeyserverKeysResponse.prototype.hasKeyserverInfo = function() {
   return jspb.Message.getField(this, 1) != null;
 };
 
 
 /**
  * optional Identity identity = 2;
  * @return {?proto.identity.auth.Identity}
  */
 proto.identity.auth.KeyserverKeysResponse.prototype.getIdentity = function() {
   return /** @type{?proto.identity.auth.Identity} */ (
     jspb.Message.getWrapperField(this, proto.identity.auth.Identity, 2));
 };
 
 
 /**
  * @param {?proto.identity.auth.Identity|undefined} value
  * @return {!proto.identity.auth.KeyserverKeysResponse} returns this
 */
 proto.identity.auth.KeyserverKeysResponse.prototype.setIdentity = function(value) {
   return jspb.Message.setWrapperField(this, 2, value);
 };
 
 
 /**
  * Clears the message field making it undefined.
  * @return {!proto.identity.auth.KeyserverKeysResponse} returns this
  */
 proto.identity.auth.KeyserverKeysResponse.prototype.clearIdentity = function() {
   return this.setIdentity(undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.auth.KeyserverKeysResponse.prototype.hasIdentity = function() {
   return jspb.Message.getField(this, 2) != null;
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.auth.OutboundKeysForUserResponse.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.auth.OutboundKeysForUserResponse.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.auth.OutboundKeysForUserResponse} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.OutboundKeysForUserResponse.toObject = function(includeInstance, msg) {
   var f, obj = {
     devicesMap: (f = msg.getDevicesMap()) ? f.toObject(includeInstance, proto.identity.auth.OutboundKeyInfo.toObject) : []
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.auth.OutboundKeysForUserResponse}
  */
 proto.identity.auth.OutboundKeysForUserResponse.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.auth.OutboundKeysForUserResponse;
   return proto.identity.auth.OutboundKeysForUserResponse.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.auth.OutboundKeysForUserResponse} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.auth.OutboundKeysForUserResponse}
  */
 proto.identity.auth.OutboundKeysForUserResponse.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = msg.getDevicesMap();
       reader.readMessage(value, function(message, reader) {
         jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.identity.auth.OutboundKeyInfo.deserializeBinaryFromReader, "", new proto.identity.auth.OutboundKeyInfo());
          });
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.auth.OutboundKeysForUserResponse.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.auth.OutboundKeysForUserResponse.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.auth.OutboundKeysForUserResponse} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.OutboundKeysForUserResponse.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getDevicesMap(true);
   if (f && f.getLength() > 0) {
     f.serializeBinary(1, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.identity.auth.OutboundKeyInfo.serializeBinaryToWriter);
   }
 };
 
 
 /**
  * map<string, OutboundKeyInfo> devices = 1;
  * @param {boolean=} opt_noLazyCreate Do not create the map if
  * empty, instead returning `undefined`
  * @return {!jspb.Map<string,!proto.identity.auth.OutboundKeyInfo>}
  */
 proto.identity.auth.OutboundKeysForUserResponse.prototype.getDevicesMap = function(opt_noLazyCreate) {
   return /** @type {!jspb.Map<string,!proto.identity.auth.OutboundKeyInfo>} */ (
       jspb.Message.getMapField(this, 1, opt_noLazyCreate,
       proto.identity.auth.OutboundKeyInfo));
 };
 
 
 /**
  * Clears values from the map. The map will be non-null.
  * @return {!proto.identity.auth.OutboundKeysForUserResponse} returns this
  */
 proto.identity.auth.OutboundKeysForUserResponse.prototype.clearDevicesMap = function() {
   this.getDevicesMap().clear();
   return this;
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.auth.OutboundKeysForUserRequest.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.auth.OutboundKeysForUserRequest.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.auth.OutboundKeysForUserRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.OutboundKeysForUserRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
     userId: jspb.Message.getFieldWithDefault(msg, 1, "")
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.auth.OutboundKeysForUserRequest}
  */
 proto.identity.auth.OutboundKeysForUserRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.auth.OutboundKeysForUserRequest;
   return proto.identity.auth.OutboundKeysForUserRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.auth.OutboundKeysForUserRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.auth.OutboundKeysForUserRequest}
  */
 proto.identity.auth.OutboundKeysForUserRequest.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setUserId(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.auth.OutboundKeysForUserRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.auth.OutboundKeysForUserRequest.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.auth.OutboundKeysForUserRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.OutboundKeysForUserRequest.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getUserId();
   if (f.length > 0) {
     writer.writeString(
       1,
       f
     );
   }
 };
 
 
 /**
  * optional string user_id = 1;
  * @return {string}
  */
 proto.identity.auth.OutboundKeysForUserRequest.prototype.getUserId = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.auth.OutboundKeysForUserRequest} returns this
  */
 proto.identity.auth.OutboundKeysForUserRequest.prototype.setUserId = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.auth.InboundKeyInfo.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.auth.InboundKeyInfo.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.auth.InboundKeyInfo} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.InboundKeyInfo.toObject = function(includeInstance, msg) {
   var f, obj = {
     identityInfo: (f = msg.getIdentityInfo()) && identity_unauth_pb.IdentityKeyInfo.toObject(includeInstance, f),
     contentPrekey: (f = msg.getContentPrekey()) && identity_unauth_pb.Prekey.toObject(includeInstance, f),
     notifPrekey: (f = msg.getNotifPrekey()) && identity_unauth_pb.Prekey.toObject(includeInstance, f)
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.auth.InboundKeyInfo}
  */
 proto.identity.auth.InboundKeyInfo.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.auth.InboundKeyInfo;
   return proto.identity.auth.InboundKeyInfo.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.auth.InboundKeyInfo} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.auth.InboundKeyInfo}
  */
 proto.identity.auth.InboundKeyInfo.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = new identity_unauth_pb.IdentityKeyInfo;
       reader.readMessage(value,identity_unauth_pb.IdentityKeyInfo.deserializeBinaryFromReader);
       msg.setIdentityInfo(value);
       break;
     case 2:
       var value = new identity_unauth_pb.Prekey;
       reader.readMessage(value,identity_unauth_pb.Prekey.deserializeBinaryFromReader);
       msg.setContentPrekey(value);
       break;
     case 3:
       var value = new identity_unauth_pb.Prekey;
       reader.readMessage(value,identity_unauth_pb.Prekey.deserializeBinaryFromReader);
       msg.setNotifPrekey(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.auth.InboundKeyInfo.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.auth.InboundKeyInfo.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.auth.InboundKeyInfo} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.InboundKeyInfo.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getIdentityInfo();
   if (f != null) {
     writer.writeMessage(
       1,
       f,
       identity_unauth_pb.IdentityKeyInfo.serializeBinaryToWriter
     );
   }
   f = message.getContentPrekey();
   if (f != null) {
     writer.writeMessage(
       2,
       f,
       identity_unauth_pb.Prekey.serializeBinaryToWriter
     );
   }
   f = message.getNotifPrekey();
   if (f != null) {
     writer.writeMessage(
       3,
       f,
       identity_unauth_pb.Prekey.serializeBinaryToWriter
     );
   }
 };
 
 
 /**
  * optional identity.unauth.IdentityKeyInfo identity_info = 1;
  * @return {?proto.identity.unauth.IdentityKeyInfo}
  */
 proto.identity.auth.InboundKeyInfo.prototype.getIdentityInfo = function() {
   return /** @type{?proto.identity.unauth.IdentityKeyInfo} */ (
     jspb.Message.getWrapperField(this, identity_unauth_pb.IdentityKeyInfo, 1));
 };
 
 
 /**
  * @param {?proto.identity.unauth.IdentityKeyInfo|undefined} value
  * @return {!proto.identity.auth.InboundKeyInfo} returns this
 */
 proto.identity.auth.InboundKeyInfo.prototype.setIdentityInfo = function(value) {
   return jspb.Message.setWrapperField(this, 1, value);
 };
 
 
 /**
  * Clears the message field making it undefined.
  * @return {!proto.identity.auth.InboundKeyInfo} returns this
  */
 proto.identity.auth.InboundKeyInfo.prototype.clearIdentityInfo = function() {
   return this.setIdentityInfo(undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.auth.InboundKeyInfo.prototype.hasIdentityInfo = function() {
   return jspb.Message.getField(this, 1) != null;
 };
 
 
 /**
  * optional identity.unauth.Prekey content_prekey = 2;
  * @return {?proto.identity.unauth.Prekey}
  */
 proto.identity.auth.InboundKeyInfo.prototype.getContentPrekey = function() {
   return /** @type{?proto.identity.unauth.Prekey} */ (
     jspb.Message.getWrapperField(this, identity_unauth_pb.Prekey, 2));
 };
 
 
 /**
  * @param {?proto.identity.unauth.Prekey|undefined} value
  * @return {!proto.identity.auth.InboundKeyInfo} returns this
 */
 proto.identity.auth.InboundKeyInfo.prototype.setContentPrekey = function(value) {
   return jspb.Message.setWrapperField(this, 2, value);
 };
 
 
 /**
  * Clears the message field making it undefined.
  * @return {!proto.identity.auth.InboundKeyInfo} returns this
  */
 proto.identity.auth.InboundKeyInfo.prototype.clearContentPrekey = function() {
   return this.setContentPrekey(undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.auth.InboundKeyInfo.prototype.hasContentPrekey = function() {
   return jspb.Message.getField(this, 2) != null;
 };
 
 
 /**
  * optional identity.unauth.Prekey notif_prekey = 3;
  * @return {?proto.identity.unauth.Prekey}
  */
 proto.identity.auth.InboundKeyInfo.prototype.getNotifPrekey = function() {
   return /** @type{?proto.identity.unauth.Prekey} */ (
     jspb.Message.getWrapperField(this, identity_unauth_pb.Prekey, 3));
 };
 
 
 /**
  * @param {?proto.identity.unauth.Prekey|undefined} value
  * @return {!proto.identity.auth.InboundKeyInfo} returns this
 */
 proto.identity.auth.InboundKeyInfo.prototype.setNotifPrekey = function(value) {
   return jspb.Message.setWrapperField(this, 3, value);
 };
 
 
 /**
  * Clears the message field making it undefined.
  * @return {!proto.identity.auth.InboundKeyInfo} returns this
  */
 proto.identity.auth.InboundKeyInfo.prototype.clearNotifPrekey = function() {
   return this.setNotifPrekey(undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.auth.InboundKeyInfo.prototype.hasNotifPrekey = function() {
   return jspb.Message.getField(this, 3) != null;
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.auth.InboundKeysForUserResponse.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.auth.InboundKeysForUserResponse.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.auth.InboundKeysForUserResponse} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.InboundKeysForUserResponse.toObject = function(includeInstance, msg) {
   var f, obj = {
     devicesMap: (f = msg.getDevicesMap()) ? f.toObject(includeInstance, proto.identity.auth.InboundKeyInfo.toObject) : [],
     identity: (f = msg.getIdentity()) && proto.identity.auth.Identity.toObject(includeInstance, f)
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.auth.InboundKeysForUserResponse}
  */
 proto.identity.auth.InboundKeysForUserResponse.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.auth.InboundKeysForUserResponse;
   return proto.identity.auth.InboundKeysForUserResponse.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.auth.InboundKeysForUserResponse} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.auth.InboundKeysForUserResponse}
  */
 proto.identity.auth.InboundKeysForUserResponse.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = msg.getDevicesMap();
       reader.readMessage(value, function(message, reader) {
         jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.identity.auth.InboundKeyInfo.deserializeBinaryFromReader, "", new proto.identity.auth.InboundKeyInfo());
          });
       break;
     case 2:
       var value = new proto.identity.auth.Identity;
       reader.readMessage(value,proto.identity.auth.Identity.deserializeBinaryFromReader);
       msg.setIdentity(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.auth.InboundKeysForUserResponse.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.auth.InboundKeysForUserResponse.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.auth.InboundKeysForUserResponse} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.InboundKeysForUserResponse.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getDevicesMap(true);
   if (f && f.getLength() > 0) {
     f.serializeBinary(1, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.identity.auth.InboundKeyInfo.serializeBinaryToWriter);
   }
   f = message.getIdentity();
   if (f != null) {
     writer.writeMessage(
       2,
       f,
       proto.identity.auth.Identity.serializeBinaryToWriter
     );
   }
 };
 
 
 /**
  * map<string, InboundKeyInfo> devices = 1;
  * @param {boolean=} opt_noLazyCreate Do not create the map if
  * empty, instead returning `undefined`
  * @return {!jspb.Map<string,!proto.identity.auth.InboundKeyInfo>}
  */
 proto.identity.auth.InboundKeysForUserResponse.prototype.getDevicesMap = function(opt_noLazyCreate) {
   return /** @type {!jspb.Map<string,!proto.identity.auth.InboundKeyInfo>} */ (
       jspb.Message.getMapField(this, 1, opt_noLazyCreate,
       proto.identity.auth.InboundKeyInfo));
 };
 
 
 /**
  * Clears values from the map. The map will be non-null.
  * @return {!proto.identity.auth.InboundKeysForUserResponse} returns this
  */
 proto.identity.auth.InboundKeysForUserResponse.prototype.clearDevicesMap = function() {
   this.getDevicesMap().clear();
   return this;
 };
 
 
 /**
  * optional Identity identity = 2;
  * @return {?proto.identity.auth.Identity}
  */
 proto.identity.auth.InboundKeysForUserResponse.prototype.getIdentity = function() {
   return /** @type{?proto.identity.auth.Identity} */ (
     jspb.Message.getWrapperField(this, proto.identity.auth.Identity, 2));
 };
 
 
 /**
  * @param {?proto.identity.auth.Identity|undefined} value
  * @return {!proto.identity.auth.InboundKeysForUserResponse} returns this
 */
 proto.identity.auth.InboundKeysForUserResponse.prototype.setIdentity = function(value) {
   return jspb.Message.setWrapperField(this, 2, value);
 };
 
 
 /**
  * Clears the message field making it undefined.
  * @return {!proto.identity.auth.InboundKeysForUserResponse} returns this
  */
 proto.identity.auth.InboundKeysForUserResponse.prototype.clearIdentity = function() {
   return this.setIdentity(undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.auth.InboundKeysForUserResponse.prototype.hasIdentity = function() {
   return jspb.Message.getField(this, 2) != null;
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.auth.InboundKeysForUserRequest.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.auth.InboundKeysForUserRequest.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.auth.InboundKeysForUserRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.InboundKeysForUserRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
     userId: jspb.Message.getFieldWithDefault(msg, 1, "")
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.auth.InboundKeysForUserRequest}
  */
 proto.identity.auth.InboundKeysForUserRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.auth.InboundKeysForUserRequest;
   return proto.identity.auth.InboundKeysForUserRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.auth.InboundKeysForUserRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.auth.InboundKeysForUserRequest}
  */
 proto.identity.auth.InboundKeysForUserRequest.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setUserId(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.auth.InboundKeysForUserRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.auth.InboundKeysForUserRequest.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.auth.InboundKeysForUserRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.InboundKeysForUserRequest.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getUserId();
   if (f.length > 0) {
     writer.writeString(
       1,
       f
     );
   }
 };
 
 
 /**
  * optional string user_id = 1;
  * @return {string}
  */
 proto.identity.auth.InboundKeysForUserRequest.prototype.getUserId = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.auth.InboundKeysForUserRequest} returns this
  */
 proto.identity.auth.InboundKeysForUserRequest.prototype.setUserId = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.auth.UpdateUserPasswordStartRequest.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.auth.UpdateUserPasswordStartRequest.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.auth.UpdateUserPasswordStartRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.UpdateUserPasswordStartRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
     opaqueRegistrationRequest: msg.getOpaqueRegistrationRequest_asB64()
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.auth.UpdateUserPasswordStartRequest}
  */
 proto.identity.auth.UpdateUserPasswordStartRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.auth.UpdateUserPasswordStartRequest;
   return proto.identity.auth.UpdateUserPasswordStartRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.auth.UpdateUserPasswordStartRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.auth.UpdateUserPasswordStartRequest}
  */
 proto.identity.auth.UpdateUserPasswordStartRequest.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {!Uint8Array} */ (reader.readBytes());
       msg.setOpaqueRegistrationRequest(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.auth.UpdateUserPasswordStartRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.auth.UpdateUserPasswordStartRequest.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.auth.UpdateUserPasswordStartRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.UpdateUserPasswordStartRequest.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getOpaqueRegistrationRequest_asU8();
   if (f.length > 0) {
     writer.writeBytes(
       1,
       f
     );
   }
 };
 
 
 /**
  * optional bytes opaque_registration_request = 1;
  * @return {string}
  */
 proto.identity.auth.UpdateUserPasswordStartRequest.prototype.getOpaqueRegistrationRequest = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * optional bytes opaque_registration_request = 1;
  * This is a type-conversion wrapper around `getOpaqueRegistrationRequest()`
  * @return {string}
  */
 proto.identity.auth.UpdateUserPasswordStartRequest.prototype.getOpaqueRegistrationRequest_asB64 = function() {
   return /** @type {string} */ (jspb.Message.bytesAsB64(
       this.getOpaqueRegistrationRequest()));
 };
 
 
 /**
  * optional bytes opaque_registration_request = 1;
  * Note that Uint8Array is not supported on all browsers.
  * @see http://caniuse.com/Uint8Array
  * This is a type-conversion wrapper around `getOpaqueRegistrationRequest()`
  * @return {!Uint8Array}
  */
 proto.identity.auth.UpdateUserPasswordStartRequest.prototype.getOpaqueRegistrationRequest_asU8 = function() {
   return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
       this.getOpaqueRegistrationRequest()));
 };
 
 
 /**
  * @param {!(string|Uint8Array)} value
  * @return {!proto.identity.auth.UpdateUserPasswordStartRequest} returns this
  */
 proto.identity.auth.UpdateUserPasswordStartRequest.prototype.setOpaqueRegistrationRequest = function(value) {
   return jspb.Message.setProto3BytesField(this, 1, value);
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.auth.UpdateUserPasswordFinishRequest.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.auth.UpdateUserPasswordFinishRequest.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.auth.UpdateUserPasswordFinishRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.UpdateUserPasswordFinishRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
     sessionId: jspb.Message.getFieldWithDefault(msg, 1, ""),
     opaqueRegistrationUpload: msg.getOpaqueRegistrationUpload_asB64()
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.auth.UpdateUserPasswordFinishRequest}
  */
 proto.identity.auth.UpdateUserPasswordFinishRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.auth.UpdateUserPasswordFinishRequest;
   return proto.identity.auth.UpdateUserPasswordFinishRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.auth.UpdateUserPasswordFinishRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.auth.UpdateUserPasswordFinishRequest}
  */
 proto.identity.auth.UpdateUserPasswordFinishRequest.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setSessionId(value);
       break;
     case 2:
       var value = /** @type {!Uint8Array} */ (reader.readBytes());
       msg.setOpaqueRegistrationUpload(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.auth.UpdateUserPasswordFinishRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.auth.UpdateUserPasswordFinishRequest.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.auth.UpdateUserPasswordFinishRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.UpdateUserPasswordFinishRequest.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getSessionId();
   if (f.length > 0) {
     writer.writeString(
       1,
       f
     );
   }
   f = message.getOpaqueRegistrationUpload_asU8();
   if (f.length > 0) {
     writer.writeBytes(
       2,
       f
     );
   }
 };
 
 
 /**
  * optional string session_id = 1;
  * @return {string}
  */
 proto.identity.auth.UpdateUserPasswordFinishRequest.prototype.getSessionId = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.auth.UpdateUserPasswordFinishRequest} returns this
  */
 proto.identity.auth.UpdateUserPasswordFinishRequest.prototype.setSessionId = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
 /**
  * optional bytes opaque_registration_upload = 2;
  * @return {string}
  */
 proto.identity.auth.UpdateUserPasswordFinishRequest.prototype.getOpaqueRegistrationUpload = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * optional bytes opaque_registration_upload = 2;
  * This is a type-conversion wrapper around `getOpaqueRegistrationUpload()`
  * @return {string}
  */
 proto.identity.auth.UpdateUserPasswordFinishRequest.prototype.getOpaqueRegistrationUpload_asB64 = function() {
   return /** @type {string} */ (jspb.Message.bytesAsB64(
       this.getOpaqueRegistrationUpload()));
 };
 
 
 /**
  * optional bytes opaque_registration_upload = 2;
  * Note that Uint8Array is not supported on all browsers.
  * @see http://caniuse.com/Uint8Array
  * This is a type-conversion wrapper around `getOpaqueRegistrationUpload()`
  * @return {!Uint8Array}
  */
 proto.identity.auth.UpdateUserPasswordFinishRequest.prototype.getOpaqueRegistrationUpload_asU8 = function() {
   return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
       this.getOpaqueRegistrationUpload()));
 };
 
 
 /**
  * @param {!(string|Uint8Array)} value
  * @return {!proto.identity.auth.UpdateUserPasswordFinishRequest} returns this
  */
 proto.identity.auth.UpdateUserPasswordFinishRequest.prototype.setOpaqueRegistrationUpload = function(value) {
   return jspb.Message.setProto3BytesField(this, 2, value);
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.auth.UpdateUserPasswordStartResponse.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.auth.UpdateUserPasswordStartResponse.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.auth.UpdateUserPasswordStartResponse} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.UpdateUserPasswordStartResponse.toObject = function(includeInstance, msg) {
   var f, obj = {
     sessionId: jspb.Message.getFieldWithDefault(msg, 1, ""),
     opaqueRegistrationResponse: msg.getOpaqueRegistrationResponse_asB64()
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.auth.UpdateUserPasswordStartResponse}
  */
 proto.identity.auth.UpdateUserPasswordStartResponse.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.auth.UpdateUserPasswordStartResponse;
   return proto.identity.auth.UpdateUserPasswordStartResponse.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.auth.UpdateUserPasswordStartResponse} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.auth.UpdateUserPasswordStartResponse}
  */
 proto.identity.auth.UpdateUserPasswordStartResponse.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setSessionId(value);
       break;
     case 2:
       var value = /** @type {!Uint8Array} */ (reader.readBytes());
       msg.setOpaqueRegistrationResponse(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.auth.UpdateUserPasswordStartResponse.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.auth.UpdateUserPasswordStartResponse.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.auth.UpdateUserPasswordStartResponse} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.UpdateUserPasswordStartResponse.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getSessionId();
   if (f.length > 0) {
     writer.writeString(
       1,
       f
     );
   }
   f = message.getOpaqueRegistrationResponse_asU8();
   if (f.length > 0) {
     writer.writeBytes(
       2,
       f
     );
   }
 };
 
 
 /**
  * optional string session_id = 1;
  * @return {string}
  */
 proto.identity.auth.UpdateUserPasswordStartResponse.prototype.getSessionId = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.auth.UpdateUserPasswordStartResponse} returns this
  */
 proto.identity.auth.UpdateUserPasswordStartResponse.prototype.setSessionId = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
 /**
  * optional bytes opaque_registration_response = 2;
  * @return {string}
  */
 proto.identity.auth.UpdateUserPasswordStartResponse.prototype.getOpaqueRegistrationResponse = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * optional bytes opaque_registration_response = 2;
  * This is a type-conversion wrapper around `getOpaqueRegistrationResponse()`
  * @return {string}
  */
 proto.identity.auth.UpdateUserPasswordStartResponse.prototype.getOpaqueRegistrationResponse_asB64 = function() {
   return /** @type {string} */ (jspb.Message.bytesAsB64(
       this.getOpaqueRegistrationResponse()));
 };
 
 
 /**
  * optional bytes opaque_registration_response = 2;
  * Note that Uint8Array is not supported on all browsers.
  * @see http://caniuse.com/Uint8Array
  * This is a type-conversion wrapper around `getOpaqueRegistrationResponse()`
  * @return {!Uint8Array}
  */
 proto.identity.auth.UpdateUserPasswordStartResponse.prototype.getOpaqueRegistrationResponse_asU8 = function() {
   return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
       this.getOpaqueRegistrationResponse()));
 };
 
 
 /**
  * @param {!(string|Uint8Array)} value
  * @return {!proto.identity.auth.UpdateUserPasswordStartResponse} returns this
  */
 proto.identity.auth.UpdateUserPasswordStartResponse.prototype.setOpaqueRegistrationResponse = function(value) {
   return jspb.Message.setProto3BytesField(this, 2, value);
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.auth.GetDeviceListRequest.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.auth.GetDeviceListRequest.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.auth.GetDeviceListRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.GetDeviceListRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
     userId: jspb.Message.getFieldWithDefault(msg, 1, ""),
     sinceTimestamp: jspb.Message.getFieldWithDefault(msg, 2, 0)
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.auth.GetDeviceListRequest}
  */
 proto.identity.auth.GetDeviceListRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.auth.GetDeviceListRequest;
   return proto.identity.auth.GetDeviceListRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.auth.GetDeviceListRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.auth.GetDeviceListRequest}
  */
 proto.identity.auth.GetDeviceListRequest.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setUserId(value);
       break;
     case 2:
       var value = /** @type {number} */ (reader.readInt64());
       msg.setSinceTimestamp(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.auth.GetDeviceListRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.auth.GetDeviceListRequest.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.auth.GetDeviceListRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.GetDeviceListRequest.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getUserId();
   if (f.length > 0) {
     writer.writeString(
       1,
       f
     );
   }
   f = /** @type {number} */ (jspb.Message.getField(message, 2));
   if (f != null) {
     writer.writeInt64(
       2,
       f
     );
   }
 };
 
 
 /**
  * optional string user_id = 1;
  * @return {string}
  */
 proto.identity.auth.GetDeviceListRequest.prototype.getUserId = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.auth.GetDeviceListRequest} returns this
  */
 proto.identity.auth.GetDeviceListRequest.prototype.setUserId = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
 /**
  * optional int64 since_timestamp = 2;
  * @return {number}
  */
 proto.identity.auth.GetDeviceListRequest.prototype.getSinceTimestamp = function() {
   return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0));
 };
 
 
 /**
  * @param {number} value
  * @return {!proto.identity.auth.GetDeviceListRequest} returns this
  */
 proto.identity.auth.GetDeviceListRequest.prototype.setSinceTimestamp = function(value) {
   return jspb.Message.setField(this, 2, value);
 };
 
 
 /**
  * Clears the field making it undefined.
  * @return {!proto.identity.auth.GetDeviceListRequest} returns this
  */
 proto.identity.auth.GetDeviceListRequest.prototype.clearSinceTimestamp = function() {
   return jspb.Message.setField(this, 2, undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.auth.GetDeviceListRequest.prototype.hasSinceTimestamp = function() {
   return jspb.Message.getField(this, 2) != null;
 };
 
 
 
 /**
  * List of repeated fields within this message type.
  * @private {!Array<number>}
  * @const
  */
 proto.identity.auth.GetDeviceListResponse.repeatedFields_ = [1];
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.auth.GetDeviceListResponse.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.auth.GetDeviceListResponse.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.auth.GetDeviceListResponse} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.GetDeviceListResponse.toObject = function(includeInstance, msg) {
   var f, obj = {
     deviceListUpdatesList: (f = jspb.Message.getRepeatedField(msg, 1)) == null ? undefined : f
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.auth.GetDeviceListResponse}
  */
 proto.identity.auth.GetDeviceListResponse.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.auth.GetDeviceListResponse;
   return proto.identity.auth.GetDeviceListResponse.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.auth.GetDeviceListResponse} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.auth.GetDeviceListResponse}
  */
 proto.identity.auth.GetDeviceListResponse.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.addDeviceListUpdates(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.auth.GetDeviceListResponse.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.auth.GetDeviceListResponse.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.auth.GetDeviceListResponse} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.GetDeviceListResponse.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getDeviceListUpdatesList();
   if (f.length > 0) {
     writer.writeRepeatedString(
       1,
       f
     );
   }
 };
 
 
 /**
  * repeated string device_list_updates = 1;
  * @return {!Array<string>}
  */
 proto.identity.auth.GetDeviceListResponse.prototype.getDeviceListUpdatesList = function() {
   return /** @type {!Array<string>} */ (jspb.Message.getRepeatedField(this, 1));
 };
 
 
 /**
  * @param {!Array<string>} value
  * @return {!proto.identity.auth.GetDeviceListResponse} returns this
  */
 proto.identity.auth.GetDeviceListResponse.prototype.setDeviceListUpdatesList = function(value) {
   return jspb.Message.setField(this, 1, value || []);
 };
 
 
 /**
  * @param {string} value
  * @param {number=} opt_index
  * @return {!proto.identity.auth.GetDeviceListResponse} returns this
  */
 proto.identity.auth.GetDeviceListResponse.prototype.addDeviceListUpdates = function(value, opt_index) {
   return jspb.Message.addToRepeatedField(this, 1, value, opt_index);
 };
 
 
 /**
  * Clears the list making it empty but non-null.
  * @return {!proto.identity.auth.GetDeviceListResponse} returns this
  */
 proto.identity.auth.GetDeviceListResponse.prototype.clearDeviceListUpdatesList = function() {
   return this.setDeviceListUpdatesList([]);
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.auth.UpdateDeviceListRequest.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.auth.UpdateDeviceListRequest.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.auth.UpdateDeviceListRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.UpdateDeviceListRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
     newDeviceList: jspb.Message.getFieldWithDefault(msg, 1, "")
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.auth.UpdateDeviceListRequest}
  */
 proto.identity.auth.UpdateDeviceListRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.auth.UpdateDeviceListRequest;
   return proto.identity.auth.UpdateDeviceListRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.auth.UpdateDeviceListRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.auth.UpdateDeviceListRequest}
  */
 proto.identity.auth.UpdateDeviceListRequest.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setNewDeviceList(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.auth.UpdateDeviceListRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.auth.UpdateDeviceListRequest.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.auth.UpdateDeviceListRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.auth.UpdateDeviceListRequest.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getNewDeviceList();
   if (f.length > 0) {
     writer.writeString(
       1,
       f
     );
   }
 };
 
 
 /**
  * optional string new_device_list = 1;
  * @return {string}
  */
 proto.identity.auth.UpdateDeviceListRequest.prototype.getNewDeviceList = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.auth.UpdateDeviceListRequest} returns this
  */
 proto.identity.auth.UpdateDeviceListRequest.prototype.setNewDeviceList = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
+
+
+
+if (jspb.Message.GENERATE_TO_OBJECT) {
+/**
+ * Creates an object representation of this proto.
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
+ * Optional fields that are not set will be set to undefined.
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
+ * For the list of reserved names please see:
+ *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
+ *     JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @return {!Object}
+ */
+proto.identity.auth.LinkFarcasterAccountRequest.prototype.toObject = function(opt_includeInstance) {
+  return proto.identity.auth.LinkFarcasterAccountRequest.toObject(opt_includeInstance, this);
+};
+
+
+/**
+ * Static version of the {@see toObject} method.
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
+ *     the JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @param {!proto.identity.auth.LinkFarcasterAccountRequest} msg The msg instance to transform.
+ * @return {!Object}
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.identity.auth.LinkFarcasterAccountRequest.toObject = function(includeInstance, msg) {
+  var f, obj = {
+    farcasterId: jspb.Message.getFieldWithDefault(msg, 1, "")
+  };
+
+  if (includeInstance) {
+    obj.$jspbMessageInstance = msg;
+  }
+  return obj;
+};
+}
+
+
+/**
+ * Deserializes binary data (in protobuf wire format).
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
+ * @return {!proto.identity.auth.LinkFarcasterAccountRequest}
+ */
+proto.identity.auth.LinkFarcasterAccountRequest.deserializeBinary = function(bytes) {
+  var reader = new jspb.BinaryReader(bytes);
+  var msg = new proto.identity.auth.LinkFarcasterAccountRequest;
+  return proto.identity.auth.LinkFarcasterAccountRequest.deserializeBinaryFromReader(msg, reader);
+};
+
+
+/**
+ * Deserializes binary data (in protobuf wire format) from the
+ * given reader into the given message object.
+ * @param {!proto.identity.auth.LinkFarcasterAccountRequest} msg The message object to deserialize into.
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
+ * @return {!proto.identity.auth.LinkFarcasterAccountRequest}
+ */
+proto.identity.auth.LinkFarcasterAccountRequest.deserializeBinaryFromReader = function(msg, reader) {
+  while (reader.nextField()) {
+    if (reader.isEndGroup()) {
+      break;
+    }
+    var field = reader.getFieldNumber();
+    switch (field) {
+    case 1:
+      var value = /** @type {string} */ (reader.readString());
+      msg.setFarcasterId(value);
+      break;
+    default:
+      reader.skipField();
+      break;
+    }
+  }
+  return msg;
+};
+
+
+/**
+ * Serializes the message to binary data (in protobuf wire format).
+ * @return {!Uint8Array}
+ */
+proto.identity.auth.LinkFarcasterAccountRequest.prototype.serializeBinary = function() {
+  var writer = new jspb.BinaryWriter();
+  proto.identity.auth.LinkFarcasterAccountRequest.serializeBinaryToWriter(this, writer);
+  return writer.getResultBuffer();
+};
+
+
+/**
+ * Serializes the given message to binary data (in protobuf wire
+ * format), writing to the given BinaryWriter.
+ * @param {!proto.identity.auth.LinkFarcasterAccountRequest} message
+ * @param {!jspb.BinaryWriter} writer
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.identity.auth.LinkFarcasterAccountRequest.serializeBinaryToWriter = function(message, writer) {
+  var f = undefined;
+  f = message.getFarcasterId();
+  if (f.length > 0) {
+    writer.writeString(
+      1,
+      f
+    );
+  }
+};
+
+
+/**
+ * optional string farcaster_id = 1;
+ * @return {string}
+ */
+proto.identity.auth.LinkFarcasterAccountRequest.prototype.getFarcasterId = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
+};
+
+
+/**
+ * @param {string} value
+ * @return {!proto.identity.auth.LinkFarcasterAccountRequest} returns this
+ */
+proto.identity.auth.LinkFarcasterAccountRequest.prototype.setFarcasterId = function(value) {
+  return jspb.Message.setProto3StringField(this, 1, value);
+};
+
+
 goog.object.extend(exports, proto.identity.auth);
diff --git a/web/protobufs/identity-auth-structs.cjs.flow b/web/protobufs/identity-auth-structs.cjs.flow
index a50bf1da9..ba8f68465 100644
--- a/web/protobufs/identity-auth-structs.cjs.flow
+++ b/web/protobufs/identity-auth-structs.cjs.flow
@@ -1,391 +1,406 @@
 // @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;
 
   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,
   identity: ?IdentityObject,
 };
 
 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,
+}
diff --git a/web/protobufs/identity-unauth-structs.cjs b/web/protobufs/identity-unauth-structs.cjs
index bd3b4a5fa..777dc465f 100644
--- a/web/protobufs/identity-unauth-structs.cjs
+++ b/web/protobufs/identity-unauth-structs.cjs
@@ -1,5048 +1,5620 @@
 // source: identity_unauth.proto
 /**
  * @fileoverview
  * @enhanceable
  * @suppress {missingRequire} reports error on implicit type usages.
  * @suppress {messageConventions} JS Compiler reports an error if a variable or
  *     field starts with 'MSG_' and isn't a translatable message.
  * @public
  * @generated
  */
 // GENERATED CODE -- DO NOT EDIT!
 /* eslint-disable */
 // @ts-nocheck
 
 var jspb = require('google-protobuf');
 var goog = jspb;
 var global =
     (typeof globalThis !== 'undefined' && globalThis) ||
     (typeof window !== 'undefined' && window) ||
     (typeof global !== 'undefined' && global) ||
     (typeof self !== 'undefined' && self) ||
     (function () { return this; }).call(null) ||
     Function('return this')();
 
 goog.exportSymbol('proto.identity.unauth.AddReservedUsernamesRequest', null, global);
 goog.exportSymbol('proto.identity.unauth.AuthResponse', null, global);
 goog.exportSymbol('proto.identity.unauth.DeviceKeyUpload', null, global);
 goog.exportSymbol('proto.identity.unauth.DeviceType', null, global);
 goog.exportSymbol('proto.identity.unauth.Empty', null, global);
+goog.exportSymbol('proto.identity.unauth.FarcasterUser', null, global);
 goog.exportSymbol('proto.identity.unauth.FindUserIDRequest', null, global);
 goog.exportSymbol('proto.identity.unauth.FindUserIDRequest.IdentifierCase', null, global);
 goog.exportSymbol('proto.identity.unauth.FindUserIDResponse', null, global);
 goog.exportSymbol('proto.identity.unauth.GenerateNonceResponse', null, global);
+goog.exportSymbol('proto.identity.unauth.GetFarcasterUsersRequest', null, global);
+goog.exportSymbol('proto.identity.unauth.GetFarcasterUsersResponse', null, global);
 goog.exportSymbol('proto.identity.unauth.IdentityKeyInfo', null, global);
 goog.exportSymbol('proto.identity.unauth.OpaqueLoginFinishRequest', null, global);
 goog.exportSymbol('proto.identity.unauth.OpaqueLoginStartRequest', null, global);
 goog.exportSymbol('proto.identity.unauth.OpaqueLoginStartResponse', null, global);
 goog.exportSymbol('proto.identity.unauth.Prekey', null, global);
 goog.exportSymbol('proto.identity.unauth.RegistrationFinishRequest', null, global);
 goog.exportSymbol('proto.identity.unauth.RegistrationStartRequest', null, global);
 goog.exportSymbol('proto.identity.unauth.RegistrationStartResponse', null, global);
 goog.exportSymbol('proto.identity.unauth.RemoveReservedUsernameRequest', null, global);
 goog.exportSymbol('proto.identity.unauth.ReservedRegistrationStartRequest', null, global);
 goog.exportSymbol('proto.identity.unauth.ReservedWalletRegistrationRequest', null, global);
 goog.exportSymbol('proto.identity.unauth.SecondaryDeviceKeysUploadRequest', null, global);
 goog.exportSymbol('proto.identity.unauth.VerifyUserAccessTokenRequest', null, global);
 goog.exportSymbol('proto.identity.unauth.VerifyUserAccessTokenResponse', null, global);
 goog.exportSymbol('proto.identity.unauth.WalletAuthRequest', null, global);
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.unauth.Empty = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.unauth.Empty, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.unauth.Empty.displayName = 'proto.identity.unauth.Empty';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.unauth.Prekey = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.unauth.Prekey, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.unauth.Prekey.displayName = 'proto.identity.unauth.Prekey';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.unauth.IdentityKeyInfo = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.unauth.IdentityKeyInfo, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.unauth.IdentityKeyInfo.displayName = 'proto.identity.unauth.IdentityKeyInfo';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.unauth.DeviceKeyUpload = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, proto.identity.unauth.DeviceKeyUpload.repeatedFields_, null);
 };
 goog.inherits(proto.identity.unauth.DeviceKeyUpload, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.unauth.DeviceKeyUpload.displayName = 'proto.identity.unauth.DeviceKeyUpload';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.unauth.RegistrationStartRequest = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.unauth.RegistrationStartRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.unauth.RegistrationStartRequest.displayName = 'proto.identity.unauth.RegistrationStartRequest';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.unauth.ReservedRegistrationStartRequest = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.unauth.ReservedRegistrationStartRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.unauth.ReservedRegistrationStartRequest.displayName = 'proto.identity.unauth.ReservedRegistrationStartRequest';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.unauth.RegistrationFinishRequest = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.unauth.RegistrationFinishRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.unauth.RegistrationFinishRequest.displayName = 'proto.identity.unauth.RegistrationFinishRequest';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.unauth.RegistrationStartResponse = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.unauth.RegistrationStartResponse, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.unauth.RegistrationStartResponse.displayName = 'proto.identity.unauth.RegistrationStartResponse';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.unauth.AuthResponse = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.unauth.AuthResponse, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.unauth.AuthResponse.displayName = 'proto.identity.unauth.AuthResponse';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.unauth.OpaqueLoginStartRequest = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.unauth.OpaqueLoginStartRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.unauth.OpaqueLoginStartRequest.displayName = 'proto.identity.unauth.OpaqueLoginStartRequest';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.unauth.OpaqueLoginFinishRequest = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.unauth.OpaqueLoginFinishRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.unauth.OpaqueLoginFinishRequest.displayName = 'proto.identity.unauth.OpaqueLoginFinishRequest';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.unauth.OpaqueLoginStartResponse = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.unauth.OpaqueLoginStartResponse, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.unauth.OpaqueLoginStartResponse.displayName = 'proto.identity.unauth.OpaqueLoginStartResponse';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.unauth.WalletAuthRequest = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.unauth.WalletAuthRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.unauth.WalletAuthRequest.displayName = 'proto.identity.unauth.WalletAuthRequest';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.unauth.ReservedWalletRegistrationRequest = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.unauth.ReservedWalletRegistrationRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.unauth.ReservedWalletRegistrationRequest.displayName = 'proto.identity.unauth.ReservedWalletRegistrationRequest';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.unauth.SecondaryDeviceKeysUploadRequest = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.unauth.SecondaryDeviceKeysUploadRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.unauth.SecondaryDeviceKeysUploadRequest.displayName = 'proto.identity.unauth.SecondaryDeviceKeysUploadRequest';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.unauth.GenerateNonceResponse = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.unauth.GenerateNonceResponse, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.unauth.GenerateNonceResponse.displayName = 'proto.identity.unauth.GenerateNonceResponse';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.unauth.VerifyUserAccessTokenRequest = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.unauth.VerifyUserAccessTokenRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.unauth.VerifyUserAccessTokenRequest.displayName = 'proto.identity.unauth.VerifyUserAccessTokenRequest';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.unauth.VerifyUserAccessTokenResponse = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.unauth.VerifyUserAccessTokenResponse, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.unauth.VerifyUserAccessTokenResponse.displayName = 'proto.identity.unauth.VerifyUserAccessTokenResponse';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.unauth.AddReservedUsernamesRequest = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.unauth.AddReservedUsernamesRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.unauth.AddReservedUsernamesRequest.displayName = 'proto.identity.unauth.AddReservedUsernamesRequest';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.unauth.RemoveReservedUsernameRequest = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.unauth.RemoveReservedUsernameRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.unauth.RemoveReservedUsernameRequest.displayName = 'proto.identity.unauth.RemoveReservedUsernameRequest';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.unauth.FindUserIDRequest = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, proto.identity.unauth.FindUserIDRequest.oneofGroups_);
 };
 goog.inherits(proto.identity.unauth.FindUserIDRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.unauth.FindUserIDRequest.displayName = 'proto.identity.unauth.FindUserIDRequest';
 }
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
  * server response, or constructed directly in Javascript. The array is used
  * in place and becomes part of the constructed object. It is not cloned.
  * If no data is provided, the constructed object will be empty, but still
  * valid.
  * @extends {jspb.Message}
  * @constructor
  */
 proto.identity.unauth.FindUserIDResponse = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.unauth.FindUserIDResponse, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.unauth.FindUserIDResponse.displayName = 'proto.identity.unauth.FindUserIDResponse';
 }
+/**
+ * Generated by JsPbCodeGenerator.
+ * @param {Array=} opt_data Optional initial data array, typically from a
+ * server response, or constructed directly in Javascript. The array is used
+ * in place and becomes part of the constructed object. It is not cloned.
+ * If no data is provided, the constructed object will be empty, but still
+ * valid.
+ * @extends {jspb.Message}
+ * @constructor
+ */
+proto.identity.unauth.GetFarcasterUsersRequest = function(opt_data) {
+  jspb.Message.initialize(this, opt_data, 0, -1, proto.identity.unauth.GetFarcasterUsersRequest.repeatedFields_, null);
+};
+goog.inherits(proto.identity.unauth.GetFarcasterUsersRequest, jspb.Message);
+if (goog.DEBUG && !COMPILED) {
+  /**
+   * @public
+   * @override
+   */
+  proto.identity.unauth.GetFarcasterUsersRequest.displayName = 'proto.identity.unauth.GetFarcasterUsersRequest';
+}
+/**
+ * Generated by JsPbCodeGenerator.
+ * @param {Array=} opt_data Optional initial data array, typically from a
+ * server response, or constructed directly in Javascript. The array is used
+ * in place and becomes part of the constructed object. It is not cloned.
+ * If no data is provided, the constructed object will be empty, but still
+ * valid.
+ * @extends {jspb.Message}
+ * @constructor
+ */
+proto.identity.unauth.GetFarcasterUsersResponse = function(opt_data) {
+  jspb.Message.initialize(this, opt_data, 0, -1, proto.identity.unauth.GetFarcasterUsersResponse.repeatedFields_, null);
+};
+goog.inherits(proto.identity.unauth.GetFarcasterUsersResponse, jspb.Message);
+if (goog.DEBUG && !COMPILED) {
+  /**
+   * @public
+   * @override
+   */
+  proto.identity.unauth.GetFarcasterUsersResponse.displayName = 'proto.identity.unauth.GetFarcasterUsersResponse';
+}
+/**
+ * Generated by JsPbCodeGenerator.
+ * @param {Array=} opt_data Optional initial data array, typically from a
+ * server response, or constructed directly in Javascript. The array is used
+ * in place and becomes part of the constructed object. It is not cloned.
+ * If no data is provided, the constructed object will be empty, but still
+ * valid.
+ * @extends {jspb.Message}
+ * @constructor
+ */
+proto.identity.unauth.FarcasterUser = function(opt_data) {
+  jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+};
+goog.inherits(proto.identity.unauth.FarcasterUser, jspb.Message);
+if (goog.DEBUG && !COMPILED) {
+  /**
+   * @public
+   * @override
+   */
+  proto.identity.unauth.FarcasterUser.displayName = 'proto.identity.unauth.FarcasterUser';
+}
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.unauth.Empty.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.unauth.Empty.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.unauth.Empty} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.Empty.toObject = function(includeInstance, msg) {
   var f, obj = {
 
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.unauth.Empty}
  */
 proto.identity.unauth.Empty.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.unauth.Empty;
   return proto.identity.unauth.Empty.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.unauth.Empty} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.unauth.Empty}
  */
 proto.identity.unauth.Empty.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.unauth.Empty.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.unauth.Empty.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.unauth.Empty} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.Empty.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.unauth.Prekey.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.unauth.Prekey.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.unauth.Prekey} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.Prekey.toObject = function(includeInstance, msg) {
   var f, obj = {
     prekey: jspb.Message.getFieldWithDefault(msg, 1, ""),
     prekeySignature: jspb.Message.getFieldWithDefault(msg, 2, "")
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.unauth.Prekey}
  */
 proto.identity.unauth.Prekey.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.unauth.Prekey;
   return proto.identity.unauth.Prekey.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.unauth.Prekey} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.unauth.Prekey}
  */
 proto.identity.unauth.Prekey.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setPrekey(value);
       break;
     case 2:
       var value = /** @type {string} */ (reader.readString());
       msg.setPrekeySignature(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.unauth.Prekey.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.unauth.Prekey.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.unauth.Prekey} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.Prekey.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getPrekey();
   if (f.length > 0) {
     writer.writeString(
       1,
       f
     );
   }
   f = message.getPrekeySignature();
   if (f.length > 0) {
     writer.writeString(
       2,
       f
     );
   }
 };
 
 
 /**
  * optional string prekey = 1;
  * @return {string}
  */
 proto.identity.unauth.Prekey.prototype.getPrekey = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.Prekey} returns this
  */
 proto.identity.unauth.Prekey.prototype.setPrekey = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
 /**
  * optional string prekey_signature = 2;
  * @return {string}
  */
 proto.identity.unauth.Prekey.prototype.getPrekeySignature = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.Prekey} returns this
  */
 proto.identity.unauth.Prekey.prototype.setPrekeySignature = function(value) {
   return jspb.Message.setProto3StringField(this, 2, value);
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.unauth.IdentityKeyInfo.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.unauth.IdentityKeyInfo.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.unauth.IdentityKeyInfo} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.IdentityKeyInfo.toObject = function(includeInstance, msg) {
   var f, obj = {
     payload: jspb.Message.getFieldWithDefault(msg, 1, ""),
     payloadSignature: jspb.Message.getFieldWithDefault(msg, 2, ""),
     socialProof: jspb.Message.getFieldWithDefault(msg, 3, "")
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.unauth.IdentityKeyInfo}
  */
 proto.identity.unauth.IdentityKeyInfo.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.unauth.IdentityKeyInfo;
   return proto.identity.unauth.IdentityKeyInfo.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.unauth.IdentityKeyInfo} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.unauth.IdentityKeyInfo}
  */
 proto.identity.unauth.IdentityKeyInfo.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setPayload(value);
       break;
     case 2:
       var value = /** @type {string} */ (reader.readString());
       msg.setPayloadSignature(value);
       break;
     case 3:
       var value = /** @type {string} */ (reader.readString());
       msg.setSocialProof(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.unauth.IdentityKeyInfo.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.unauth.IdentityKeyInfo.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.unauth.IdentityKeyInfo} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.IdentityKeyInfo.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getPayload();
   if (f.length > 0) {
     writer.writeString(
       1,
       f
     );
   }
   f = message.getPayloadSignature();
   if (f.length > 0) {
     writer.writeString(
       2,
       f
     );
   }
   f = /** @type {string} */ (jspb.Message.getField(message, 3));
   if (f != null) {
     writer.writeString(
       3,
       f
     );
   }
 };
 
 
 /**
  * optional string payload = 1;
  * @return {string}
  */
 proto.identity.unauth.IdentityKeyInfo.prototype.getPayload = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.IdentityKeyInfo} returns this
  */
 proto.identity.unauth.IdentityKeyInfo.prototype.setPayload = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
 /**
  * optional string payload_signature = 2;
  * @return {string}
  */
 proto.identity.unauth.IdentityKeyInfo.prototype.getPayloadSignature = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.IdentityKeyInfo} returns this
  */
 proto.identity.unauth.IdentityKeyInfo.prototype.setPayloadSignature = function(value) {
   return jspb.Message.setProto3StringField(this, 2, value);
 };
 
 
 /**
  * optional string social_proof = 3;
  * @return {string}
  */
 proto.identity.unauth.IdentityKeyInfo.prototype.getSocialProof = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.IdentityKeyInfo} returns this
  */
 proto.identity.unauth.IdentityKeyInfo.prototype.setSocialProof = function(value) {
   return jspb.Message.setField(this, 3, value);
 };
 
 
 /**
  * Clears the field making it undefined.
  * @return {!proto.identity.unauth.IdentityKeyInfo} returns this
  */
 proto.identity.unauth.IdentityKeyInfo.prototype.clearSocialProof = function() {
   return jspb.Message.setField(this, 3, undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.unauth.IdentityKeyInfo.prototype.hasSocialProof = function() {
   return jspb.Message.getField(this, 3) != null;
 };
 
 
 
 /**
  * List of repeated fields within this message type.
  * @private {!Array<number>}
  * @const
  */
 proto.identity.unauth.DeviceKeyUpload.repeatedFields_ = [4,5];
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.unauth.DeviceKeyUpload.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.unauth.DeviceKeyUpload.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.unauth.DeviceKeyUpload} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.DeviceKeyUpload.toObject = function(includeInstance, msg) {
   var f, obj = {
     deviceKeyInfo: (f = msg.getDeviceKeyInfo()) && proto.identity.unauth.IdentityKeyInfo.toObject(includeInstance, f),
     contentUpload: (f = msg.getContentUpload()) && proto.identity.unauth.Prekey.toObject(includeInstance, f),
     notifUpload: (f = msg.getNotifUpload()) && proto.identity.unauth.Prekey.toObject(includeInstance, f),
     oneTimeContentPrekeysList: (f = jspb.Message.getRepeatedField(msg, 4)) == null ? undefined : f,
     oneTimeNotifPrekeysList: (f = jspb.Message.getRepeatedField(msg, 5)) == null ? undefined : f,
     deviceType: jspb.Message.getFieldWithDefault(msg, 6, 0)
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.unauth.DeviceKeyUpload}
  */
 proto.identity.unauth.DeviceKeyUpload.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.unauth.DeviceKeyUpload;
   return proto.identity.unauth.DeviceKeyUpload.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.unauth.DeviceKeyUpload} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.unauth.DeviceKeyUpload}
  */
 proto.identity.unauth.DeviceKeyUpload.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = new proto.identity.unauth.IdentityKeyInfo;
       reader.readMessage(value,proto.identity.unauth.IdentityKeyInfo.deserializeBinaryFromReader);
       msg.setDeviceKeyInfo(value);
       break;
     case 2:
       var value = new proto.identity.unauth.Prekey;
       reader.readMessage(value,proto.identity.unauth.Prekey.deserializeBinaryFromReader);
       msg.setContentUpload(value);
       break;
     case 3:
       var value = new proto.identity.unauth.Prekey;
       reader.readMessage(value,proto.identity.unauth.Prekey.deserializeBinaryFromReader);
       msg.setNotifUpload(value);
       break;
     case 4:
       var value = /** @type {string} */ (reader.readString());
       msg.addOneTimeContentPrekeys(value);
       break;
     case 5:
       var value = /** @type {string} */ (reader.readString());
       msg.addOneTimeNotifPrekeys(value);
       break;
     case 6:
       var value = /** @type {!proto.identity.unauth.DeviceType} */ (reader.readEnum());
       msg.setDeviceType(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.unauth.DeviceKeyUpload.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.unauth.DeviceKeyUpload.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.unauth.DeviceKeyUpload} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.DeviceKeyUpload.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getDeviceKeyInfo();
   if (f != null) {
     writer.writeMessage(
       1,
       f,
       proto.identity.unauth.IdentityKeyInfo.serializeBinaryToWriter
     );
   }
   f = message.getContentUpload();
   if (f != null) {
     writer.writeMessage(
       2,
       f,
       proto.identity.unauth.Prekey.serializeBinaryToWriter
     );
   }
   f = message.getNotifUpload();
   if (f != null) {
     writer.writeMessage(
       3,
       f,
       proto.identity.unauth.Prekey.serializeBinaryToWriter
     );
   }
   f = message.getOneTimeContentPrekeysList();
   if (f.length > 0) {
     writer.writeRepeatedString(
       4,
       f
     );
   }
   f = message.getOneTimeNotifPrekeysList();
   if (f.length > 0) {
     writer.writeRepeatedString(
       5,
       f
     );
   }
   f = message.getDeviceType();
   if (f !== 0.0) {
     writer.writeEnum(
       6,
       f
     );
   }
 };
 
 
 /**
  * optional IdentityKeyInfo device_key_info = 1;
  * @return {?proto.identity.unauth.IdentityKeyInfo}
  */
 proto.identity.unauth.DeviceKeyUpload.prototype.getDeviceKeyInfo = function() {
   return /** @type{?proto.identity.unauth.IdentityKeyInfo} */ (
     jspb.Message.getWrapperField(this, proto.identity.unauth.IdentityKeyInfo, 1));
 };
 
 
 /**
  * @param {?proto.identity.unauth.IdentityKeyInfo|undefined} value
  * @return {!proto.identity.unauth.DeviceKeyUpload} returns this
 */
 proto.identity.unauth.DeviceKeyUpload.prototype.setDeviceKeyInfo = function(value) {
   return jspb.Message.setWrapperField(this, 1, value);
 };
 
 
 /**
  * Clears the message field making it undefined.
  * @return {!proto.identity.unauth.DeviceKeyUpload} returns this
  */
 proto.identity.unauth.DeviceKeyUpload.prototype.clearDeviceKeyInfo = function() {
   return this.setDeviceKeyInfo(undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.unauth.DeviceKeyUpload.prototype.hasDeviceKeyInfo = function() {
   return jspb.Message.getField(this, 1) != null;
 };
 
 
 /**
  * optional Prekey content_upload = 2;
  * @return {?proto.identity.unauth.Prekey}
  */
 proto.identity.unauth.DeviceKeyUpload.prototype.getContentUpload = function() {
   return /** @type{?proto.identity.unauth.Prekey} */ (
     jspb.Message.getWrapperField(this, proto.identity.unauth.Prekey, 2));
 };
 
 
 /**
  * @param {?proto.identity.unauth.Prekey|undefined} value
  * @return {!proto.identity.unauth.DeviceKeyUpload} returns this
 */
 proto.identity.unauth.DeviceKeyUpload.prototype.setContentUpload = function(value) {
   return jspb.Message.setWrapperField(this, 2, value);
 };
 
 
 /**
  * Clears the message field making it undefined.
  * @return {!proto.identity.unauth.DeviceKeyUpload} returns this
  */
 proto.identity.unauth.DeviceKeyUpload.prototype.clearContentUpload = function() {
   return this.setContentUpload(undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.unauth.DeviceKeyUpload.prototype.hasContentUpload = function() {
   return jspb.Message.getField(this, 2) != null;
 };
 
 
 /**
  * optional Prekey notif_upload = 3;
  * @return {?proto.identity.unauth.Prekey}
  */
 proto.identity.unauth.DeviceKeyUpload.prototype.getNotifUpload = function() {
   return /** @type{?proto.identity.unauth.Prekey} */ (
     jspb.Message.getWrapperField(this, proto.identity.unauth.Prekey, 3));
 };
 
 
 /**
  * @param {?proto.identity.unauth.Prekey|undefined} value
  * @return {!proto.identity.unauth.DeviceKeyUpload} returns this
 */
 proto.identity.unauth.DeviceKeyUpload.prototype.setNotifUpload = function(value) {
   return jspb.Message.setWrapperField(this, 3, value);
 };
 
 
 /**
  * Clears the message field making it undefined.
  * @return {!proto.identity.unauth.DeviceKeyUpload} returns this
  */
 proto.identity.unauth.DeviceKeyUpload.prototype.clearNotifUpload = function() {
   return this.setNotifUpload(undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.unauth.DeviceKeyUpload.prototype.hasNotifUpload = function() {
   return jspb.Message.getField(this, 3) != null;
 };
 
 
 /**
  * repeated string one_time_content_prekeys = 4;
  * @return {!Array<string>}
  */
 proto.identity.unauth.DeviceKeyUpload.prototype.getOneTimeContentPrekeysList = function() {
   return /** @type {!Array<string>} */ (jspb.Message.getRepeatedField(this, 4));
 };
 
 
 /**
  * @param {!Array<string>} value
  * @return {!proto.identity.unauth.DeviceKeyUpload} returns this
  */
 proto.identity.unauth.DeviceKeyUpload.prototype.setOneTimeContentPrekeysList = function(value) {
   return jspb.Message.setField(this, 4, value || []);
 };
 
 
 /**
  * @param {string} value
  * @param {number=} opt_index
  * @return {!proto.identity.unauth.DeviceKeyUpload} returns this
  */
 proto.identity.unauth.DeviceKeyUpload.prototype.addOneTimeContentPrekeys = function(value, opt_index) {
   return jspb.Message.addToRepeatedField(this, 4, value, opt_index);
 };
 
 
 /**
  * Clears the list making it empty but non-null.
  * @return {!proto.identity.unauth.DeviceKeyUpload} returns this
  */
 proto.identity.unauth.DeviceKeyUpload.prototype.clearOneTimeContentPrekeysList = function() {
   return this.setOneTimeContentPrekeysList([]);
 };
 
 
 /**
  * repeated string one_time_notif_prekeys = 5;
  * @return {!Array<string>}
  */
 proto.identity.unauth.DeviceKeyUpload.prototype.getOneTimeNotifPrekeysList = function() {
   return /** @type {!Array<string>} */ (jspb.Message.getRepeatedField(this, 5));
 };
 
 
 /**
  * @param {!Array<string>} value
  * @return {!proto.identity.unauth.DeviceKeyUpload} returns this
  */
 proto.identity.unauth.DeviceKeyUpload.prototype.setOneTimeNotifPrekeysList = function(value) {
   return jspb.Message.setField(this, 5, value || []);
 };
 
 
 /**
  * @param {string} value
  * @param {number=} opt_index
  * @return {!proto.identity.unauth.DeviceKeyUpload} returns this
  */
 proto.identity.unauth.DeviceKeyUpload.prototype.addOneTimeNotifPrekeys = function(value, opt_index) {
   return jspb.Message.addToRepeatedField(this, 5, value, opt_index);
 };
 
 
 /**
  * Clears the list making it empty but non-null.
  * @return {!proto.identity.unauth.DeviceKeyUpload} returns this
  */
 proto.identity.unauth.DeviceKeyUpload.prototype.clearOneTimeNotifPrekeysList = function() {
   return this.setOneTimeNotifPrekeysList([]);
 };
 
 
 /**
  * optional DeviceType device_type = 6;
  * @return {!proto.identity.unauth.DeviceType}
  */
 proto.identity.unauth.DeviceKeyUpload.prototype.getDeviceType = function() {
   return /** @type {!proto.identity.unauth.DeviceType} */ (jspb.Message.getFieldWithDefault(this, 6, 0));
 };
 
 
 /**
  * @param {!proto.identity.unauth.DeviceType} value
  * @return {!proto.identity.unauth.DeviceKeyUpload} returns this
  */
 proto.identity.unauth.DeviceKeyUpload.prototype.setDeviceType = function(value) {
   return jspb.Message.setProto3EnumField(this, 6, value);
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.unauth.RegistrationStartRequest.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.unauth.RegistrationStartRequest.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.unauth.RegistrationStartRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.RegistrationStartRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
     opaqueRegistrationRequest: msg.getOpaqueRegistrationRequest_asB64(),
     username: jspb.Message.getFieldWithDefault(msg, 2, ""),
     deviceKeyUpload: (f = msg.getDeviceKeyUpload()) && proto.identity.unauth.DeviceKeyUpload.toObject(includeInstance, f),
     farcasterId: jspb.Message.getFieldWithDefault(msg, 4, "")
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.unauth.RegistrationStartRequest}
  */
 proto.identity.unauth.RegistrationStartRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.unauth.RegistrationStartRequest;
   return proto.identity.unauth.RegistrationStartRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.unauth.RegistrationStartRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.unauth.RegistrationStartRequest}
  */
 proto.identity.unauth.RegistrationStartRequest.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {!Uint8Array} */ (reader.readBytes());
       msg.setOpaqueRegistrationRequest(value);
       break;
     case 2:
       var value = /** @type {string} */ (reader.readString());
       msg.setUsername(value);
       break;
     case 3:
       var value = new proto.identity.unauth.DeviceKeyUpload;
       reader.readMessage(value,proto.identity.unauth.DeviceKeyUpload.deserializeBinaryFromReader);
       msg.setDeviceKeyUpload(value);
       break;
     case 4:
       var value = /** @type {string} */ (reader.readString());
       msg.setFarcasterId(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.unauth.RegistrationStartRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.unauth.RegistrationStartRequest.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.unauth.RegistrationStartRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.RegistrationStartRequest.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getOpaqueRegistrationRequest_asU8();
   if (f.length > 0) {
     writer.writeBytes(
       1,
       f
     );
   }
   f = message.getUsername();
   if (f.length > 0) {
     writer.writeString(
       2,
       f
     );
   }
   f = message.getDeviceKeyUpload();
   if (f != null) {
     writer.writeMessage(
       3,
       f,
       proto.identity.unauth.DeviceKeyUpload.serializeBinaryToWriter
     );
   }
   f = /** @type {string} */ (jspb.Message.getField(message, 4));
   if (f != null) {
     writer.writeString(
       4,
       f
     );
   }
 };
 
 
 /**
  * optional bytes opaque_registration_request = 1;
  * @return {string}
  */
 proto.identity.unauth.RegistrationStartRequest.prototype.getOpaqueRegistrationRequest = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * optional bytes opaque_registration_request = 1;
  * This is a type-conversion wrapper around `getOpaqueRegistrationRequest()`
  * @return {string}
  */
 proto.identity.unauth.RegistrationStartRequest.prototype.getOpaqueRegistrationRequest_asB64 = function() {
   return /** @type {string} */ (jspb.Message.bytesAsB64(
       this.getOpaqueRegistrationRequest()));
 };
 
 
 /**
  * optional bytes opaque_registration_request = 1;
  * Note that Uint8Array is not supported on all browsers.
  * @see http://caniuse.com/Uint8Array
  * This is a type-conversion wrapper around `getOpaqueRegistrationRequest()`
  * @return {!Uint8Array}
  */
 proto.identity.unauth.RegistrationStartRequest.prototype.getOpaqueRegistrationRequest_asU8 = function() {
   return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
       this.getOpaqueRegistrationRequest()));
 };
 
 
 /**
  * @param {!(string|Uint8Array)} value
  * @return {!proto.identity.unauth.RegistrationStartRequest} returns this
  */
 proto.identity.unauth.RegistrationStartRequest.prototype.setOpaqueRegistrationRequest = function(value) {
   return jspb.Message.setProto3BytesField(this, 1, value);
 };
 
 
 /**
  * optional string username = 2;
  * @return {string}
  */
 proto.identity.unauth.RegistrationStartRequest.prototype.getUsername = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.RegistrationStartRequest} returns this
  */
 proto.identity.unauth.RegistrationStartRequest.prototype.setUsername = function(value) {
   return jspb.Message.setProto3StringField(this, 2, value);
 };
 
 
 /**
  * optional DeviceKeyUpload device_key_upload = 3;
  * @return {?proto.identity.unauth.DeviceKeyUpload}
  */
 proto.identity.unauth.RegistrationStartRequest.prototype.getDeviceKeyUpload = function() {
   return /** @type{?proto.identity.unauth.DeviceKeyUpload} */ (
     jspb.Message.getWrapperField(this, proto.identity.unauth.DeviceKeyUpload, 3));
 };
 
 
 /**
  * @param {?proto.identity.unauth.DeviceKeyUpload|undefined} value
  * @return {!proto.identity.unauth.RegistrationStartRequest} returns this
 */
 proto.identity.unauth.RegistrationStartRequest.prototype.setDeviceKeyUpload = function(value) {
   return jspb.Message.setWrapperField(this, 3, value);
 };
 
 
 /**
  * Clears the message field making it undefined.
  * @return {!proto.identity.unauth.RegistrationStartRequest} returns this
  */
 proto.identity.unauth.RegistrationStartRequest.prototype.clearDeviceKeyUpload = function() {
   return this.setDeviceKeyUpload(undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.unauth.RegistrationStartRequest.prototype.hasDeviceKeyUpload = function() {
   return jspb.Message.getField(this, 3) != null;
 };
 
 
 /**
  * optional string farcaster_id = 4;
  * @return {string}
  */
 proto.identity.unauth.RegistrationStartRequest.prototype.getFarcasterId = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.RegistrationStartRequest} returns this
  */
 proto.identity.unauth.RegistrationStartRequest.prototype.setFarcasterId = function(value) {
   return jspb.Message.setField(this, 4, value);
 };
 
 
 /**
  * Clears the field making it undefined.
  * @return {!proto.identity.unauth.RegistrationStartRequest} returns this
  */
 proto.identity.unauth.RegistrationStartRequest.prototype.clearFarcasterId = function() {
   return jspb.Message.setField(this, 4, undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.unauth.RegistrationStartRequest.prototype.hasFarcasterId = function() {
   return jspb.Message.getField(this, 4) != null;
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.unauth.ReservedRegistrationStartRequest.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.unauth.ReservedRegistrationStartRequest.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.unauth.ReservedRegistrationStartRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.ReservedRegistrationStartRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
     opaqueRegistrationRequest: msg.getOpaqueRegistrationRequest_asB64(),
     username: jspb.Message.getFieldWithDefault(msg, 2, ""),
     deviceKeyUpload: (f = msg.getDeviceKeyUpload()) && proto.identity.unauth.DeviceKeyUpload.toObject(includeInstance, f),
     keyserverMessage: jspb.Message.getFieldWithDefault(msg, 4, ""),
     keyserverSignature: jspb.Message.getFieldWithDefault(msg, 5, "")
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.unauth.ReservedRegistrationStartRequest}
  */
 proto.identity.unauth.ReservedRegistrationStartRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.unauth.ReservedRegistrationStartRequest;
   return proto.identity.unauth.ReservedRegistrationStartRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.unauth.ReservedRegistrationStartRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.unauth.ReservedRegistrationStartRequest}
  */
 proto.identity.unauth.ReservedRegistrationStartRequest.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {!Uint8Array} */ (reader.readBytes());
       msg.setOpaqueRegistrationRequest(value);
       break;
     case 2:
       var value = /** @type {string} */ (reader.readString());
       msg.setUsername(value);
       break;
     case 3:
       var value = new proto.identity.unauth.DeviceKeyUpload;
       reader.readMessage(value,proto.identity.unauth.DeviceKeyUpload.deserializeBinaryFromReader);
       msg.setDeviceKeyUpload(value);
       break;
     case 4:
       var value = /** @type {string} */ (reader.readString());
       msg.setKeyserverMessage(value);
       break;
     case 5:
       var value = /** @type {string} */ (reader.readString());
       msg.setKeyserverSignature(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.unauth.ReservedRegistrationStartRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.unauth.ReservedRegistrationStartRequest.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.unauth.ReservedRegistrationStartRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.ReservedRegistrationStartRequest.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getOpaqueRegistrationRequest_asU8();
   if (f.length > 0) {
     writer.writeBytes(
       1,
       f
     );
   }
   f = message.getUsername();
   if (f.length > 0) {
     writer.writeString(
       2,
       f
     );
   }
   f = message.getDeviceKeyUpload();
   if (f != null) {
     writer.writeMessage(
       3,
       f,
       proto.identity.unauth.DeviceKeyUpload.serializeBinaryToWriter
     );
   }
   f = message.getKeyserverMessage();
   if (f.length > 0) {
     writer.writeString(
       4,
       f
     );
   }
   f = message.getKeyserverSignature();
   if (f.length > 0) {
     writer.writeString(
       5,
       f
     );
   }
 };
 
 
 /**
  * optional bytes opaque_registration_request = 1;
  * @return {string}
  */
 proto.identity.unauth.ReservedRegistrationStartRequest.prototype.getOpaqueRegistrationRequest = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * optional bytes opaque_registration_request = 1;
  * This is a type-conversion wrapper around `getOpaqueRegistrationRequest()`
  * @return {string}
  */
 proto.identity.unauth.ReservedRegistrationStartRequest.prototype.getOpaqueRegistrationRequest_asB64 = function() {
   return /** @type {string} */ (jspb.Message.bytesAsB64(
       this.getOpaqueRegistrationRequest()));
 };
 
 
 /**
  * optional bytes opaque_registration_request = 1;
  * Note that Uint8Array is not supported on all browsers.
  * @see http://caniuse.com/Uint8Array
  * This is a type-conversion wrapper around `getOpaqueRegistrationRequest()`
  * @return {!Uint8Array}
  */
 proto.identity.unauth.ReservedRegistrationStartRequest.prototype.getOpaqueRegistrationRequest_asU8 = function() {
   return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
       this.getOpaqueRegistrationRequest()));
 };
 
 
 /**
  * @param {!(string|Uint8Array)} value
  * @return {!proto.identity.unauth.ReservedRegistrationStartRequest} returns this
  */
 proto.identity.unauth.ReservedRegistrationStartRequest.prototype.setOpaqueRegistrationRequest = function(value) {
   return jspb.Message.setProto3BytesField(this, 1, value);
 };
 
 
 /**
  * optional string username = 2;
  * @return {string}
  */
 proto.identity.unauth.ReservedRegistrationStartRequest.prototype.getUsername = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.ReservedRegistrationStartRequest} returns this
  */
 proto.identity.unauth.ReservedRegistrationStartRequest.prototype.setUsername = function(value) {
   return jspb.Message.setProto3StringField(this, 2, value);
 };
 
 
 /**
  * optional DeviceKeyUpload device_key_upload = 3;
  * @return {?proto.identity.unauth.DeviceKeyUpload}
  */
 proto.identity.unauth.ReservedRegistrationStartRequest.prototype.getDeviceKeyUpload = function() {
   return /** @type{?proto.identity.unauth.DeviceKeyUpload} */ (
     jspb.Message.getWrapperField(this, proto.identity.unauth.DeviceKeyUpload, 3));
 };
 
 
 /**
  * @param {?proto.identity.unauth.DeviceKeyUpload|undefined} value
  * @return {!proto.identity.unauth.ReservedRegistrationStartRequest} returns this
 */
 proto.identity.unauth.ReservedRegistrationStartRequest.prototype.setDeviceKeyUpload = function(value) {
   return jspb.Message.setWrapperField(this, 3, value);
 };
 
 
 /**
  * Clears the message field making it undefined.
  * @return {!proto.identity.unauth.ReservedRegistrationStartRequest} returns this
  */
 proto.identity.unauth.ReservedRegistrationStartRequest.prototype.clearDeviceKeyUpload = function() {
   return this.setDeviceKeyUpload(undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.unauth.ReservedRegistrationStartRequest.prototype.hasDeviceKeyUpload = function() {
   return jspb.Message.getField(this, 3) != null;
 };
 
 
 /**
  * optional string keyserver_message = 4;
  * @return {string}
  */
 proto.identity.unauth.ReservedRegistrationStartRequest.prototype.getKeyserverMessage = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.ReservedRegistrationStartRequest} returns this
  */
 proto.identity.unauth.ReservedRegistrationStartRequest.prototype.setKeyserverMessage = function(value) {
   return jspb.Message.setProto3StringField(this, 4, value);
 };
 
 
 /**
  * optional string keyserver_signature = 5;
  * @return {string}
  */
 proto.identity.unauth.ReservedRegistrationStartRequest.prototype.getKeyserverSignature = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.ReservedRegistrationStartRequest} returns this
  */
 proto.identity.unauth.ReservedRegistrationStartRequest.prototype.setKeyserverSignature = function(value) {
   return jspb.Message.setProto3StringField(this, 5, value);
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.unauth.RegistrationFinishRequest.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.unauth.RegistrationFinishRequest.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.unauth.RegistrationFinishRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.RegistrationFinishRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
     sessionId: jspb.Message.getFieldWithDefault(msg, 1, ""),
     opaqueRegistrationUpload: msg.getOpaqueRegistrationUpload_asB64()
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.unauth.RegistrationFinishRequest}
  */
 proto.identity.unauth.RegistrationFinishRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.unauth.RegistrationFinishRequest;
   return proto.identity.unauth.RegistrationFinishRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.unauth.RegistrationFinishRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.unauth.RegistrationFinishRequest}
  */
 proto.identity.unauth.RegistrationFinishRequest.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setSessionId(value);
       break;
     case 2:
       var value = /** @type {!Uint8Array} */ (reader.readBytes());
       msg.setOpaqueRegistrationUpload(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.unauth.RegistrationFinishRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.unauth.RegistrationFinishRequest.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.unauth.RegistrationFinishRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.RegistrationFinishRequest.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getSessionId();
   if (f.length > 0) {
     writer.writeString(
       1,
       f
     );
   }
   f = message.getOpaqueRegistrationUpload_asU8();
   if (f.length > 0) {
     writer.writeBytes(
       2,
       f
     );
   }
 };
 
 
 /**
  * optional string session_id = 1;
  * @return {string}
  */
 proto.identity.unauth.RegistrationFinishRequest.prototype.getSessionId = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.RegistrationFinishRequest} returns this
  */
 proto.identity.unauth.RegistrationFinishRequest.prototype.setSessionId = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
 /**
  * optional bytes opaque_registration_upload = 2;
  * @return {string}
  */
 proto.identity.unauth.RegistrationFinishRequest.prototype.getOpaqueRegistrationUpload = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * optional bytes opaque_registration_upload = 2;
  * This is a type-conversion wrapper around `getOpaqueRegistrationUpload()`
  * @return {string}
  */
 proto.identity.unauth.RegistrationFinishRequest.prototype.getOpaqueRegistrationUpload_asB64 = function() {
   return /** @type {string} */ (jspb.Message.bytesAsB64(
       this.getOpaqueRegistrationUpload()));
 };
 
 
 /**
  * optional bytes opaque_registration_upload = 2;
  * Note that Uint8Array is not supported on all browsers.
  * @see http://caniuse.com/Uint8Array
  * This is a type-conversion wrapper around `getOpaqueRegistrationUpload()`
  * @return {!Uint8Array}
  */
 proto.identity.unauth.RegistrationFinishRequest.prototype.getOpaqueRegistrationUpload_asU8 = function() {
   return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
       this.getOpaqueRegistrationUpload()));
 };
 
 
 /**
  * @param {!(string|Uint8Array)} value
  * @return {!proto.identity.unauth.RegistrationFinishRequest} returns this
  */
 proto.identity.unauth.RegistrationFinishRequest.prototype.setOpaqueRegistrationUpload = function(value) {
   return jspb.Message.setProto3BytesField(this, 2, value);
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.unauth.RegistrationStartResponse.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.unauth.RegistrationStartResponse.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.unauth.RegistrationStartResponse} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.RegistrationStartResponse.toObject = function(includeInstance, msg) {
   var f, obj = {
     sessionId: jspb.Message.getFieldWithDefault(msg, 1, ""),
     opaqueRegistrationResponse: msg.getOpaqueRegistrationResponse_asB64()
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.unauth.RegistrationStartResponse}
  */
 proto.identity.unauth.RegistrationStartResponse.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.unauth.RegistrationStartResponse;
   return proto.identity.unauth.RegistrationStartResponse.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.unauth.RegistrationStartResponse} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.unauth.RegistrationStartResponse}
  */
 proto.identity.unauth.RegistrationStartResponse.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setSessionId(value);
       break;
     case 2:
       var value = /** @type {!Uint8Array} */ (reader.readBytes());
       msg.setOpaqueRegistrationResponse(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.unauth.RegistrationStartResponse.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.unauth.RegistrationStartResponse.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.unauth.RegistrationStartResponse} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.RegistrationStartResponse.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getSessionId();
   if (f.length > 0) {
     writer.writeString(
       1,
       f
     );
   }
   f = message.getOpaqueRegistrationResponse_asU8();
   if (f.length > 0) {
     writer.writeBytes(
       2,
       f
     );
   }
 };
 
 
 /**
  * optional string session_id = 1;
  * @return {string}
  */
 proto.identity.unauth.RegistrationStartResponse.prototype.getSessionId = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.RegistrationStartResponse} returns this
  */
 proto.identity.unauth.RegistrationStartResponse.prototype.setSessionId = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
 /**
  * optional bytes opaque_registration_response = 2;
  * @return {string}
  */
 proto.identity.unauth.RegistrationStartResponse.prototype.getOpaqueRegistrationResponse = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * optional bytes opaque_registration_response = 2;
  * This is a type-conversion wrapper around `getOpaqueRegistrationResponse()`
  * @return {string}
  */
 proto.identity.unauth.RegistrationStartResponse.prototype.getOpaqueRegistrationResponse_asB64 = function() {
   return /** @type {string} */ (jspb.Message.bytesAsB64(
       this.getOpaqueRegistrationResponse()));
 };
 
 
 /**
  * optional bytes opaque_registration_response = 2;
  * Note that Uint8Array is not supported on all browsers.
  * @see http://caniuse.com/Uint8Array
  * This is a type-conversion wrapper around `getOpaqueRegistrationResponse()`
  * @return {!Uint8Array}
  */
 proto.identity.unauth.RegistrationStartResponse.prototype.getOpaqueRegistrationResponse_asU8 = function() {
   return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
       this.getOpaqueRegistrationResponse()));
 };
 
 
 /**
  * @param {!(string|Uint8Array)} value
  * @return {!proto.identity.unauth.RegistrationStartResponse} returns this
  */
 proto.identity.unauth.RegistrationStartResponse.prototype.setOpaqueRegistrationResponse = function(value) {
   return jspb.Message.setProto3BytesField(this, 2, value);
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.unauth.AuthResponse.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.unauth.AuthResponse.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.unauth.AuthResponse} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.AuthResponse.toObject = function(includeInstance, msg) {
   var f, obj = {
     userId: jspb.Message.getFieldWithDefault(msg, 1, ""),
     accessToken: jspb.Message.getFieldWithDefault(msg, 2, "")
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.unauth.AuthResponse}
  */
 proto.identity.unauth.AuthResponse.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.unauth.AuthResponse;
   return proto.identity.unauth.AuthResponse.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.unauth.AuthResponse} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.unauth.AuthResponse}
  */
 proto.identity.unauth.AuthResponse.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setUserId(value);
       break;
     case 2:
       var value = /** @type {string} */ (reader.readString());
       msg.setAccessToken(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.unauth.AuthResponse.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.unauth.AuthResponse.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.unauth.AuthResponse} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.AuthResponse.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getUserId();
   if (f.length > 0) {
     writer.writeString(
       1,
       f
     );
   }
   f = message.getAccessToken();
   if (f.length > 0) {
     writer.writeString(
       2,
       f
     );
   }
 };
 
 
 /**
  * optional string user_id = 1;
  * @return {string}
  */
 proto.identity.unauth.AuthResponse.prototype.getUserId = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.AuthResponse} returns this
  */
 proto.identity.unauth.AuthResponse.prototype.setUserId = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
 /**
  * optional string access_token = 2;
  * @return {string}
  */
 proto.identity.unauth.AuthResponse.prototype.getAccessToken = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.AuthResponse} returns this
  */
 proto.identity.unauth.AuthResponse.prototype.setAccessToken = function(value) {
   return jspb.Message.setProto3StringField(this, 2, value);
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.unauth.OpaqueLoginStartRequest.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.unauth.OpaqueLoginStartRequest.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.unauth.OpaqueLoginStartRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.OpaqueLoginStartRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
     username: jspb.Message.getFieldWithDefault(msg, 1, ""),
     opaqueLoginRequest: msg.getOpaqueLoginRequest_asB64(),
     deviceKeyUpload: (f = msg.getDeviceKeyUpload()) && proto.identity.unauth.DeviceKeyUpload.toObject(includeInstance, f),
     force: jspb.Message.getBooleanFieldWithDefault(msg, 4, false)
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.unauth.OpaqueLoginStartRequest}
  */
 proto.identity.unauth.OpaqueLoginStartRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.unauth.OpaqueLoginStartRequest;
   return proto.identity.unauth.OpaqueLoginStartRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.unauth.OpaqueLoginStartRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.unauth.OpaqueLoginStartRequest}
  */
 proto.identity.unauth.OpaqueLoginStartRequest.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setUsername(value);
       break;
     case 2:
       var value = /** @type {!Uint8Array} */ (reader.readBytes());
       msg.setOpaqueLoginRequest(value);
       break;
     case 3:
       var value = new proto.identity.unauth.DeviceKeyUpload;
       reader.readMessage(value,proto.identity.unauth.DeviceKeyUpload.deserializeBinaryFromReader);
       msg.setDeviceKeyUpload(value);
       break;
     case 4:
       var value = /** @type {boolean} */ (reader.readBool());
       msg.setForce(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.unauth.OpaqueLoginStartRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.unauth.OpaqueLoginStartRequest.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.unauth.OpaqueLoginStartRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.OpaqueLoginStartRequest.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getUsername();
   if (f.length > 0) {
     writer.writeString(
       1,
       f
     );
   }
   f = message.getOpaqueLoginRequest_asU8();
   if (f.length > 0) {
     writer.writeBytes(
       2,
       f
     );
   }
   f = message.getDeviceKeyUpload();
   if (f != null) {
     writer.writeMessage(
       3,
       f,
       proto.identity.unauth.DeviceKeyUpload.serializeBinaryToWriter
     );
   }
   f = /** @type {boolean} */ (jspb.Message.getField(message, 4));
   if (f != null) {
     writer.writeBool(
       4,
       f
     );
   }
 };
 
 
 /**
  * optional string username = 1;
  * @return {string}
  */
 proto.identity.unauth.OpaqueLoginStartRequest.prototype.getUsername = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.OpaqueLoginStartRequest} returns this
  */
 proto.identity.unauth.OpaqueLoginStartRequest.prototype.setUsername = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
 /**
  * optional bytes opaque_login_request = 2;
  * @return {string}
  */
 proto.identity.unauth.OpaqueLoginStartRequest.prototype.getOpaqueLoginRequest = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * optional bytes opaque_login_request = 2;
  * This is a type-conversion wrapper around `getOpaqueLoginRequest()`
  * @return {string}
  */
 proto.identity.unauth.OpaqueLoginStartRequest.prototype.getOpaqueLoginRequest_asB64 = function() {
   return /** @type {string} */ (jspb.Message.bytesAsB64(
       this.getOpaqueLoginRequest()));
 };
 
 
 /**
  * optional bytes opaque_login_request = 2;
  * Note that Uint8Array is not supported on all browsers.
  * @see http://caniuse.com/Uint8Array
  * This is a type-conversion wrapper around `getOpaqueLoginRequest()`
  * @return {!Uint8Array}
  */
 proto.identity.unauth.OpaqueLoginStartRequest.prototype.getOpaqueLoginRequest_asU8 = function() {
   return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
       this.getOpaqueLoginRequest()));
 };
 
 
 /**
  * @param {!(string|Uint8Array)} value
  * @return {!proto.identity.unauth.OpaqueLoginStartRequest} returns this
  */
 proto.identity.unauth.OpaqueLoginStartRequest.prototype.setOpaqueLoginRequest = function(value) {
   return jspb.Message.setProto3BytesField(this, 2, value);
 };
 
 
 /**
  * optional DeviceKeyUpload device_key_upload = 3;
  * @return {?proto.identity.unauth.DeviceKeyUpload}
  */
 proto.identity.unauth.OpaqueLoginStartRequest.prototype.getDeviceKeyUpload = function() {
   return /** @type{?proto.identity.unauth.DeviceKeyUpload} */ (
     jspb.Message.getWrapperField(this, proto.identity.unauth.DeviceKeyUpload, 3));
 };
 
 
 /**
  * @param {?proto.identity.unauth.DeviceKeyUpload|undefined} value
  * @return {!proto.identity.unauth.OpaqueLoginStartRequest} returns this
 */
 proto.identity.unauth.OpaqueLoginStartRequest.prototype.setDeviceKeyUpload = function(value) {
   return jspb.Message.setWrapperField(this, 3, value);
 };
 
 
 /**
  * Clears the message field making it undefined.
  * @return {!proto.identity.unauth.OpaqueLoginStartRequest} returns this
  */
 proto.identity.unauth.OpaqueLoginStartRequest.prototype.clearDeviceKeyUpload = function() {
   return this.setDeviceKeyUpload(undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.unauth.OpaqueLoginStartRequest.prototype.hasDeviceKeyUpload = function() {
   return jspb.Message.getField(this, 3) != null;
 };
 
 
 /**
  * optional bool force = 4;
  * @return {boolean}
  */
 proto.identity.unauth.OpaqueLoginStartRequest.prototype.getForce = function() {
   return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 4, false));
 };
 
 
 /**
  * @param {boolean} value
  * @return {!proto.identity.unauth.OpaqueLoginStartRequest} returns this
  */
 proto.identity.unauth.OpaqueLoginStartRequest.prototype.setForce = function(value) {
   return jspb.Message.setField(this, 4, value);
 };
 
 
 /**
  * Clears the field making it undefined.
  * @return {!proto.identity.unauth.OpaqueLoginStartRequest} returns this
  */
 proto.identity.unauth.OpaqueLoginStartRequest.prototype.clearForce = function() {
   return jspb.Message.setField(this, 4, undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.unauth.OpaqueLoginStartRequest.prototype.hasForce = function() {
   return jspb.Message.getField(this, 4) != null;
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.unauth.OpaqueLoginFinishRequest.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.unauth.OpaqueLoginFinishRequest.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.unauth.OpaqueLoginFinishRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.OpaqueLoginFinishRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
     sessionId: jspb.Message.getFieldWithDefault(msg, 1, ""),
     opaqueLoginUpload: msg.getOpaqueLoginUpload_asB64()
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.unauth.OpaqueLoginFinishRequest}
  */
 proto.identity.unauth.OpaqueLoginFinishRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.unauth.OpaqueLoginFinishRequest;
   return proto.identity.unauth.OpaqueLoginFinishRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.unauth.OpaqueLoginFinishRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.unauth.OpaqueLoginFinishRequest}
  */
 proto.identity.unauth.OpaqueLoginFinishRequest.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setSessionId(value);
       break;
     case 2:
       var value = /** @type {!Uint8Array} */ (reader.readBytes());
       msg.setOpaqueLoginUpload(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.unauth.OpaqueLoginFinishRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.unauth.OpaqueLoginFinishRequest.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.unauth.OpaqueLoginFinishRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.OpaqueLoginFinishRequest.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getSessionId();
   if (f.length > 0) {
     writer.writeString(
       1,
       f
     );
   }
   f = message.getOpaqueLoginUpload_asU8();
   if (f.length > 0) {
     writer.writeBytes(
       2,
       f
     );
   }
 };
 
 
 /**
  * optional string session_id = 1;
  * @return {string}
  */
 proto.identity.unauth.OpaqueLoginFinishRequest.prototype.getSessionId = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.OpaqueLoginFinishRequest} returns this
  */
 proto.identity.unauth.OpaqueLoginFinishRequest.prototype.setSessionId = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
 /**
  * optional bytes opaque_login_upload = 2;
  * @return {string}
  */
 proto.identity.unauth.OpaqueLoginFinishRequest.prototype.getOpaqueLoginUpload = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * optional bytes opaque_login_upload = 2;
  * This is a type-conversion wrapper around `getOpaqueLoginUpload()`
  * @return {string}
  */
 proto.identity.unauth.OpaqueLoginFinishRequest.prototype.getOpaqueLoginUpload_asB64 = function() {
   return /** @type {string} */ (jspb.Message.bytesAsB64(
       this.getOpaqueLoginUpload()));
 };
 
 
 /**
  * optional bytes opaque_login_upload = 2;
  * Note that Uint8Array is not supported on all browsers.
  * @see http://caniuse.com/Uint8Array
  * This is a type-conversion wrapper around `getOpaqueLoginUpload()`
  * @return {!Uint8Array}
  */
 proto.identity.unauth.OpaqueLoginFinishRequest.prototype.getOpaqueLoginUpload_asU8 = function() {
   return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
       this.getOpaqueLoginUpload()));
 };
 
 
 /**
  * @param {!(string|Uint8Array)} value
  * @return {!proto.identity.unauth.OpaqueLoginFinishRequest} returns this
  */
 proto.identity.unauth.OpaqueLoginFinishRequest.prototype.setOpaqueLoginUpload = function(value) {
   return jspb.Message.setProto3BytesField(this, 2, value);
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.unauth.OpaqueLoginStartResponse.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.unauth.OpaqueLoginStartResponse.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.unauth.OpaqueLoginStartResponse} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.OpaqueLoginStartResponse.toObject = function(includeInstance, msg) {
   var f, obj = {
     sessionId: jspb.Message.getFieldWithDefault(msg, 1, ""),
     opaqueLoginResponse: msg.getOpaqueLoginResponse_asB64()
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.unauth.OpaqueLoginStartResponse}
  */
 proto.identity.unauth.OpaqueLoginStartResponse.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.unauth.OpaqueLoginStartResponse;
   return proto.identity.unauth.OpaqueLoginStartResponse.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.unauth.OpaqueLoginStartResponse} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.unauth.OpaqueLoginStartResponse}
  */
 proto.identity.unauth.OpaqueLoginStartResponse.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setSessionId(value);
       break;
     case 2:
       var value = /** @type {!Uint8Array} */ (reader.readBytes());
       msg.setOpaqueLoginResponse(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.unauth.OpaqueLoginStartResponse.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.unauth.OpaqueLoginStartResponse.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.unauth.OpaqueLoginStartResponse} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.OpaqueLoginStartResponse.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getSessionId();
   if (f.length > 0) {
     writer.writeString(
       1,
       f
     );
   }
   f = message.getOpaqueLoginResponse_asU8();
   if (f.length > 0) {
     writer.writeBytes(
       2,
       f
     );
   }
 };
 
 
 /**
  * optional string session_id = 1;
  * @return {string}
  */
 proto.identity.unauth.OpaqueLoginStartResponse.prototype.getSessionId = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.OpaqueLoginStartResponse} returns this
  */
 proto.identity.unauth.OpaqueLoginStartResponse.prototype.setSessionId = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
 /**
  * optional bytes opaque_login_response = 2;
  * @return {string}
  */
 proto.identity.unauth.OpaqueLoginStartResponse.prototype.getOpaqueLoginResponse = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * optional bytes opaque_login_response = 2;
  * This is a type-conversion wrapper around `getOpaqueLoginResponse()`
  * @return {string}
  */
 proto.identity.unauth.OpaqueLoginStartResponse.prototype.getOpaqueLoginResponse_asB64 = function() {
   return /** @type {string} */ (jspb.Message.bytesAsB64(
       this.getOpaqueLoginResponse()));
 };
 
 
 /**
  * optional bytes opaque_login_response = 2;
  * Note that Uint8Array is not supported on all browsers.
  * @see http://caniuse.com/Uint8Array
  * This is a type-conversion wrapper around `getOpaqueLoginResponse()`
  * @return {!Uint8Array}
  */
 proto.identity.unauth.OpaqueLoginStartResponse.prototype.getOpaqueLoginResponse_asU8 = function() {
   return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
       this.getOpaqueLoginResponse()));
 };
 
 
 /**
  * @param {!(string|Uint8Array)} value
  * @return {!proto.identity.unauth.OpaqueLoginStartResponse} returns this
  */
 proto.identity.unauth.OpaqueLoginStartResponse.prototype.setOpaqueLoginResponse = function(value) {
   return jspb.Message.setProto3BytesField(this, 2, value);
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.unauth.WalletAuthRequest.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.unauth.WalletAuthRequest.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.unauth.WalletAuthRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.WalletAuthRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
     siweMessage: jspb.Message.getFieldWithDefault(msg, 1, ""),
     siweSignature: jspb.Message.getFieldWithDefault(msg, 2, ""),
     deviceKeyUpload: (f = msg.getDeviceKeyUpload()) && proto.identity.unauth.DeviceKeyUpload.toObject(includeInstance, f),
     farcasterId: jspb.Message.getFieldWithDefault(msg, 4, "")
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.unauth.WalletAuthRequest}
  */
 proto.identity.unauth.WalletAuthRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.unauth.WalletAuthRequest;
   return proto.identity.unauth.WalletAuthRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.unauth.WalletAuthRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.unauth.WalletAuthRequest}
  */
 proto.identity.unauth.WalletAuthRequest.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setSiweMessage(value);
       break;
     case 2:
       var value = /** @type {string} */ (reader.readString());
       msg.setSiweSignature(value);
       break;
     case 3:
       var value = new proto.identity.unauth.DeviceKeyUpload;
       reader.readMessage(value,proto.identity.unauth.DeviceKeyUpload.deserializeBinaryFromReader);
       msg.setDeviceKeyUpload(value);
       break;
     case 4:
       var value = /** @type {string} */ (reader.readString());
       msg.setFarcasterId(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.unauth.WalletAuthRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.unauth.WalletAuthRequest.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.unauth.WalletAuthRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.WalletAuthRequest.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getSiweMessage();
   if (f.length > 0) {
     writer.writeString(
       1,
       f
     );
   }
   f = message.getSiweSignature();
   if (f.length > 0) {
     writer.writeString(
       2,
       f
     );
   }
   f = message.getDeviceKeyUpload();
   if (f != null) {
     writer.writeMessage(
       3,
       f,
       proto.identity.unauth.DeviceKeyUpload.serializeBinaryToWriter
     );
   }
   f = /** @type {string} */ (jspb.Message.getField(message, 4));
   if (f != null) {
     writer.writeString(
       4,
       f
     );
   }
 };
 
 
 /**
  * optional string siwe_message = 1;
  * @return {string}
  */
 proto.identity.unauth.WalletAuthRequest.prototype.getSiweMessage = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.WalletAuthRequest} returns this
  */
 proto.identity.unauth.WalletAuthRequest.prototype.setSiweMessage = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
 /**
  * optional string siwe_signature = 2;
  * @return {string}
  */
 proto.identity.unauth.WalletAuthRequest.prototype.getSiweSignature = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.WalletAuthRequest} returns this
  */
 proto.identity.unauth.WalletAuthRequest.prototype.setSiweSignature = function(value) {
   return jspb.Message.setProto3StringField(this, 2, value);
 };
 
 
 /**
  * optional DeviceKeyUpload device_key_upload = 3;
  * @return {?proto.identity.unauth.DeviceKeyUpload}
  */
 proto.identity.unauth.WalletAuthRequest.prototype.getDeviceKeyUpload = function() {
   return /** @type{?proto.identity.unauth.DeviceKeyUpload} */ (
     jspb.Message.getWrapperField(this, proto.identity.unauth.DeviceKeyUpload, 3));
 };
 
 
 /**
  * @param {?proto.identity.unauth.DeviceKeyUpload|undefined} value
  * @return {!proto.identity.unauth.WalletAuthRequest} returns this
 */
 proto.identity.unauth.WalletAuthRequest.prototype.setDeviceKeyUpload = function(value) {
   return jspb.Message.setWrapperField(this, 3, value);
 };
 
 
 /**
  * Clears the message field making it undefined.
  * @return {!proto.identity.unauth.WalletAuthRequest} returns this
  */
 proto.identity.unauth.WalletAuthRequest.prototype.clearDeviceKeyUpload = function() {
   return this.setDeviceKeyUpload(undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.unauth.WalletAuthRequest.prototype.hasDeviceKeyUpload = function() {
   return jspb.Message.getField(this, 3) != null;
 };
 
 
 /**
  * optional string farcaster_id = 4;
  * @return {string}
  */
 proto.identity.unauth.WalletAuthRequest.prototype.getFarcasterId = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.WalletAuthRequest} returns this
  */
 proto.identity.unauth.WalletAuthRequest.prototype.setFarcasterId = function(value) {
   return jspb.Message.setField(this, 4, value);
 };
 
 
 /**
  * Clears the field making it undefined.
  * @return {!proto.identity.unauth.WalletAuthRequest} returns this
  */
 proto.identity.unauth.WalletAuthRequest.prototype.clearFarcasterId = function() {
   return jspb.Message.setField(this, 4, undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.unauth.WalletAuthRequest.prototype.hasFarcasterId = function() {
   return jspb.Message.getField(this, 4) != null;
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.unauth.ReservedWalletRegistrationRequest.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.unauth.ReservedWalletRegistrationRequest.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.unauth.ReservedWalletRegistrationRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.ReservedWalletRegistrationRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
     siweMessage: jspb.Message.getFieldWithDefault(msg, 1, ""),
     siweSignature: jspb.Message.getFieldWithDefault(msg, 2, ""),
     deviceKeyUpload: (f = msg.getDeviceKeyUpload()) && proto.identity.unauth.DeviceKeyUpload.toObject(includeInstance, f),
     keyserverMessage: jspb.Message.getFieldWithDefault(msg, 4, ""),
     keyserverSignature: jspb.Message.getFieldWithDefault(msg, 5, "")
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.unauth.ReservedWalletRegistrationRequest}
  */
 proto.identity.unauth.ReservedWalletRegistrationRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.unauth.ReservedWalletRegistrationRequest;
   return proto.identity.unauth.ReservedWalletRegistrationRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.unauth.ReservedWalletRegistrationRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.unauth.ReservedWalletRegistrationRequest}
  */
 proto.identity.unauth.ReservedWalletRegistrationRequest.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setSiweMessage(value);
       break;
     case 2:
       var value = /** @type {string} */ (reader.readString());
       msg.setSiweSignature(value);
       break;
     case 3:
       var value = new proto.identity.unauth.DeviceKeyUpload;
       reader.readMessage(value,proto.identity.unauth.DeviceKeyUpload.deserializeBinaryFromReader);
       msg.setDeviceKeyUpload(value);
       break;
     case 4:
       var value = /** @type {string} */ (reader.readString());
       msg.setKeyserverMessage(value);
       break;
     case 5:
       var value = /** @type {string} */ (reader.readString());
       msg.setKeyserverSignature(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.unauth.ReservedWalletRegistrationRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.unauth.ReservedWalletRegistrationRequest.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.unauth.ReservedWalletRegistrationRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.ReservedWalletRegistrationRequest.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getSiweMessage();
   if (f.length > 0) {
     writer.writeString(
       1,
       f
     );
   }
   f = message.getSiweSignature();
   if (f.length > 0) {
     writer.writeString(
       2,
       f
     );
   }
   f = message.getDeviceKeyUpload();
   if (f != null) {
     writer.writeMessage(
       3,
       f,
       proto.identity.unauth.DeviceKeyUpload.serializeBinaryToWriter
     );
   }
   f = message.getKeyserverMessage();
   if (f.length > 0) {
     writer.writeString(
       4,
       f
     );
   }
   f = message.getKeyserverSignature();
   if (f.length > 0) {
     writer.writeString(
       5,
       f
     );
   }
 };
 
 
 /**
  * optional string siwe_message = 1;
  * @return {string}
  */
 proto.identity.unauth.ReservedWalletRegistrationRequest.prototype.getSiweMessage = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.ReservedWalletRegistrationRequest} returns this
  */
 proto.identity.unauth.ReservedWalletRegistrationRequest.prototype.setSiweMessage = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
 /**
  * optional string siwe_signature = 2;
  * @return {string}
  */
 proto.identity.unauth.ReservedWalletRegistrationRequest.prototype.getSiweSignature = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.ReservedWalletRegistrationRequest} returns this
  */
 proto.identity.unauth.ReservedWalletRegistrationRequest.prototype.setSiweSignature = function(value) {
   return jspb.Message.setProto3StringField(this, 2, value);
 };
 
 
 /**
  * optional DeviceKeyUpload device_key_upload = 3;
  * @return {?proto.identity.unauth.DeviceKeyUpload}
  */
 proto.identity.unauth.ReservedWalletRegistrationRequest.prototype.getDeviceKeyUpload = function() {
   return /** @type{?proto.identity.unauth.DeviceKeyUpload} */ (
     jspb.Message.getWrapperField(this, proto.identity.unauth.DeviceKeyUpload, 3));
 };
 
 
 /**
  * @param {?proto.identity.unauth.DeviceKeyUpload|undefined} value
  * @return {!proto.identity.unauth.ReservedWalletRegistrationRequest} returns this
 */
 proto.identity.unauth.ReservedWalletRegistrationRequest.prototype.setDeviceKeyUpload = function(value) {
   return jspb.Message.setWrapperField(this, 3, value);
 };
 
 
 /**
  * Clears the message field making it undefined.
  * @return {!proto.identity.unauth.ReservedWalletRegistrationRequest} returns this
  */
 proto.identity.unauth.ReservedWalletRegistrationRequest.prototype.clearDeviceKeyUpload = function() {
   return this.setDeviceKeyUpload(undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.unauth.ReservedWalletRegistrationRequest.prototype.hasDeviceKeyUpload = function() {
   return jspb.Message.getField(this, 3) != null;
 };
 
 
 /**
  * optional string keyserver_message = 4;
  * @return {string}
  */
 proto.identity.unauth.ReservedWalletRegistrationRequest.prototype.getKeyserverMessage = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.ReservedWalletRegistrationRequest} returns this
  */
 proto.identity.unauth.ReservedWalletRegistrationRequest.prototype.setKeyserverMessage = function(value) {
   return jspb.Message.setProto3StringField(this, 4, value);
 };
 
 
 /**
  * optional string keyserver_signature = 5;
  * @return {string}
  */
 proto.identity.unauth.ReservedWalletRegistrationRequest.prototype.getKeyserverSignature = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.ReservedWalletRegistrationRequest} returns this
  */
 proto.identity.unauth.ReservedWalletRegistrationRequest.prototype.setKeyserverSignature = function(value) {
   return jspb.Message.setProto3StringField(this, 5, value);
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.unauth.SecondaryDeviceKeysUploadRequest.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.unauth.SecondaryDeviceKeysUploadRequest.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.unauth.SecondaryDeviceKeysUploadRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.SecondaryDeviceKeysUploadRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
     userId: jspb.Message.getFieldWithDefault(msg, 1, ""),
     challengeResponse: jspb.Message.getFieldWithDefault(msg, 2, ""),
     deviceKeyUpload: (f = msg.getDeviceKeyUpload()) && proto.identity.unauth.DeviceKeyUpload.toObject(includeInstance, f)
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.unauth.SecondaryDeviceKeysUploadRequest}
  */
 proto.identity.unauth.SecondaryDeviceKeysUploadRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.unauth.SecondaryDeviceKeysUploadRequest;
   return proto.identity.unauth.SecondaryDeviceKeysUploadRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.unauth.SecondaryDeviceKeysUploadRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.unauth.SecondaryDeviceKeysUploadRequest}
  */
 proto.identity.unauth.SecondaryDeviceKeysUploadRequest.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setUserId(value);
       break;
     case 2:
       var value = /** @type {string} */ (reader.readString());
       msg.setChallengeResponse(value);
       break;
     case 3:
       var value = new proto.identity.unauth.DeviceKeyUpload;
       reader.readMessage(value,proto.identity.unauth.DeviceKeyUpload.deserializeBinaryFromReader);
       msg.setDeviceKeyUpload(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.unauth.SecondaryDeviceKeysUploadRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.unauth.SecondaryDeviceKeysUploadRequest.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.unauth.SecondaryDeviceKeysUploadRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.SecondaryDeviceKeysUploadRequest.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getUserId();
   if (f.length > 0) {
     writer.writeString(
       1,
       f
     );
   }
   f = message.getChallengeResponse();
   if (f.length > 0) {
     writer.writeString(
       2,
       f
     );
   }
   f = message.getDeviceKeyUpload();
   if (f != null) {
     writer.writeMessage(
       3,
       f,
       proto.identity.unauth.DeviceKeyUpload.serializeBinaryToWriter
     );
   }
 };
 
 
 /**
  * optional string user_id = 1;
  * @return {string}
  */
 proto.identity.unauth.SecondaryDeviceKeysUploadRequest.prototype.getUserId = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.SecondaryDeviceKeysUploadRequest} returns this
  */
 proto.identity.unauth.SecondaryDeviceKeysUploadRequest.prototype.setUserId = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
 /**
  * optional string challenge_response = 2;
  * @return {string}
  */
 proto.identity.unauth.SecondaryDeviceKeysUploadRequest.prototype.getChallengeResponse = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.SecondaryDeviceKeysUploadRequest} returns this
  */
 proto.identity.unauth.SecondaryDeviceKeysUploadRequest.prototype.setChallengeResponse = function(value) {
   return jspb.Message.setProto3StringField(this, 2, value);
 };
 
 
 /**
  * optional DeviceKeyUpload device_key_upload = 3;
  * @return {?proto.identity.unauth.DeviceKeyUpload}
  */
 proto.identity.unauth.SecondaryDeviceKeysUploadRequest.prototype.getDeviceKeyUpload = function() {
   return /** @type{?proto.identity.unauth.DeviceKeyUpload} */ (
     jspb.Message.getWrapperField(this, proto.identity.unauth.DeviceKeyUpload, 3));
 };
 
 
 /**
  * @param {?proto.identity.unauth.DeviceKeyUpload|undefined} value
  * @return {!proto.identity.unauth.SecondaryDeviceKeysUploadRequest} returns this
 */
 proto.identity.unauth.SecondaryDeviceKeysUploadRequest.prototype.setDeviceKeyUpload = function(value) {
   return jspb.Message.setWrapperField(this, 3, value);
 };
 
 
 /**
  * Clears the message field making it undefined.
  * @return {!proto.identity.unauth.SecondaryDeviceKeysUploadRequest} returns this
  */
 proto.identity.unauth.SecondaryDeviceKeysUploadRequest.prototype.clearDeviceKeyUpload = function() {
   return this.setDeviceKeyUpload(undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.unauth.SecondaryDeviceKeysUploadRequest.prototype.hasDeviceKeyUpload = function() {
   return jspb.Message.getField(this, 3) != null;
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.unauth.GenerateNonceResponse.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.unauth.GenerateNonceResponse.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.unauth.GenerateNonceResponse} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.GenerateNonceResponse.toObject = function(includeInstance, msg) {
   var f, obj = {
     nonce: jspb.Message.getFieldWithDefault(msg, 1, "")
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.unauth.GenerateNonceResponse}
  */
 proto.identity.unauth.GenerateNonceResponse.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.unauth.GenerateNonceResponse;
   return proto.identity.unauth.GenerateNonceResponse.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.unauth.GenerateNonceResponse} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.unauth.GenerateNonceResponse}
  */
 proto.identity.unauth.GenerateNonceResponse.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setNonce(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.unauth.GenerateNonceResponse.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.unauth.GenerateNonceResponse.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.unauth.GenerateNonceResponse} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.GenerateNonceResponse.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getNonce();
   if (f.length > 0) {
     writer.writeString(
       1,
       f
     );
   }
 };
 
 
 /**
  * optional string nonce = 1;
  * @return {string}
  */
 proto.identity.unauth.GenerateNonceResponse.prototype.getNonce = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.GenerateNonceResponse} returns this
  */
 proto.identity.unauth.GenerateNonceResponse.prototype.setNonce = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.unauth.VerifyUserAccessTokenRequest.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.unauth.VerifyUserAccessTokenRequest.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.unauth.VerifyUserAccessTokenRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.VerifyUserAccessTokenRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
     userId: jspb.Message.getFieldWithDefault(msg, 1, ""),
     deviceId: jspb.Message.getFieldWithDefault(msg, 2, ""),
     accessToken: jspb.Message.getFieldWithDefault(msg, 3, "")
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.unauth.VerifyUserAccessTokenRequest}
  */
 proto.identity.unauth.VerifyUserAccessTokenRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.unauth.VerifyUserAccessTokenRequest;
   return proto.identity.unauth.VerifyUserAccessTokenRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.unauth.VerifyUserAccessTokenRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.unauth.VerifyUserAccessTokenRequest}
  */
 proto.identity.unauth.VerifyUserAccessTokenRequest.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setUserId(value);
       break;
     case 2:
       var value = /** @type {string} */ (reader.readString());
       msg.setDeviceId(value);
       break;
     case 3:
       var value = /** @type {string} */ (reader.readString());
       msg.setAccessToken(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.unauth.VerifyUserAccessTokenRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.unauth.VerifyUserAccessTokenRequest.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.unauth.VerifyUserAccessTokenRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.VerifyUserAccessTokenRequest.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getUserId();
   if (f.length > 0) {
     writer.writeString(
       1,
       f
     );
   }
   f = message.getDeviceId();
   if (f.length > 0) {
     writer.writeString(
       2,
       f
     );
   }
   f = message.getAccessToken();
   if (f.length > 0) {
     writer.writeString(
       3,
       f
     );
   }
 };
 
 
 /**
  * optional string user_id = 1;
  * @return {string}
  */
 proto.identity.unauth.VerifyUserAccessTokenRequest.prototype.getUserId = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.VerifyUserAccessTokenRequest} returns this
  */
 proto.identity.unauth.VerifyUserAccessTokenRequest.prototype.setUserId = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
 /**
  * optional string device_id = 2;
  * @return {string}
  */
 proto.identity.unauth.VerifyUserAccessTokenRequest.prototype.getDeviceId = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.VerifyUserAccessTokenRequest} returns this
  */
 proto.identity.unauth.VerifyUserAccessTokenRequest.prototype.setDeviceId = function(value) {
   return jspb.Message.setProto3StringField(this, 2, value);
 };
 
 
 /**
  * optional string access_token = 3;
  * @return {string}
  */
 proto.identity.unauth.VerifyUserAccessTokenRequest.prototype.getAccessToken = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.VerifyUserAccessTokenRequest} returns this
  */
 proto.identity.unauth.VerifyUserAccessTokenRequest.prototype.setAccessToken = function(value) {
   return jspb.Message.setProto3StringField(this, 3, value);
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.unauth.VerifyUserAccessTokenResponse.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.unauth.VerifyUserAccessTokenResponse.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.unauth.VerifyUserAccessTokenResponse} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.VerifyUserAccessTokenResponse.toObject = function(includeInstance, msg) {
   var f, obj = {
     tokenValid: jspb.Message.getBooleanFieldWithDefault(msg, 1, false)
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.unauth.VerifyUserAccessTokenResponse}
  */
 proto.identity.unauth.VerifyUserAccessTokenResponse.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.unauth.VerifyUserAccessTokenResponse;
   return proto.identity.unauth.VerifyUserAccessTokenResponse.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.unauth.VerifyUserAccessTokenResponse} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.unauth.VerifyUserAccessTokenResponse}
  */
 proto.identity.unauth.VerifyUserAccessTokenResponse.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {boolean} */ (reader.readBool());
       msg.setTokenValid(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.unauth.VerifyUserAccessTokenResponse.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.unauth.VerifyUserAccessTokenResponse.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.unauth.VerifyUserAccessTokenResponse} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.VerifyUserAccessTokenResponse.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getTokenValid();
   if (f) {
     writer.writeBool(
       1,
       f
     );
   }
 };
 
 
 /**
  * optional bool token_valid = 1;
  * @return {boolean}
  */
 proto.identity.unauth.VerifyUserAccessTokenResponse.prototype.getTokenValid = function() {
   return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 1, false));
 };
 
 
 /**
  * @param {boolean} value
  * @return {!proto.identity.unauth.VerifyUserAccessTokenResponse} returns this
  */
 proto.identity.unauth.VerifyUserAccessTokenResponse.prototype.setTokenValid = function(value) {
   return jspb.Message.setProto3BooleanField(this, 1, value);
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.unauth.AddReservedUsernamesRequest.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.unauth.AddReservedUsernamesRequest.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.unauth.AddReservedUsernamesRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.AddReservedUsernamesRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
     message: jspb.Message.getFieldWithDefault(msg, 1, ""),
     signature: jspb.Message.getFieldWithDefault(msg, 2, "")
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.unauth.AddReservedUsernamesRequest}
  */
 proto.identity.unauth.AddReservedUsernamesRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.unauth.AddReservedUsernamesRequest;
   return proto.identity.unauth.AddReservedUsernamesRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.unauth.AddReservedUsernamesRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.unauth.AddReservedUsernamesRequest}
  */
 proto.identity.unauth.AddReservedUsernamesRequest.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setMessage(value);
       break;
     case 2:
       var value = /** @type {string} */ (reader.readString());
       msg.setSignature(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.unauth.AddReservedUsernamesRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.unauth.AddReservedUsernamesRequest.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.unauth.AddReservedUsernamesRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.AddReservedUsernamesRequest.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getMessage();
   if (f.length > 0) {
     writer.writeString(
       1,
       f
     );
   }
   f = message.getSignature();
   if (f.length > 0) {
     writer.writeString(
       2,
       f
     );
   }
 };
 
 
 /**
  * optional string message = 1;
  * @return {string}
  */
 proto.identity.unauth.AddReservedUsernamesRequest.prototype.getMessage = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.AddReservedUsernamesRequest} returns this
  */
 proto.identity.unauth.AddReservedUsernamesRequest.prototype.setMessage = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
 /**
  * optional string signature = 2;
  * @return {string}
  */
 proto.identity.unauth.AddReservedUsernamesRequest.prototype.getSignature = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.AddReservedUsernamesRequest} returns this
  */
 proto.identity.unauth.AddReservedUsernamesRequest.prototype.setSignature = function(value) {
   return jspb.Message.setProto3StringField(this, 2, value);
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.unauth.RemoveReservedUsernameRequest.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.unauth.RemoveReservedUsernameRequest.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.unauth.RemoveReservedUsernameRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.RemoveReservedUsernameRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
     message: jspb.Message.getFieldWithDefault(msg, 1, ""),
     signature: jspb.Message.getFieldWithDefault(msg, 2, "")
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.unauth.RemoveReservedUsernameRequest}
  */
 proto.identity.unauth.RemoveReservedUsernameRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.unauth.RemoveReservedUsernameRequest;
   return proto.identity.unauth.RemoveReservedUsernameRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.unauth.RemoveReservedUsernameRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.unauth.RemoveReservedUsernameRequest}
  */
 proto.identity.unauth.RemoveReservedUsernameRequest.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setMessage(value);
       break;
     case 2:
       var value = /** @type {string} */ (reader.readString());
       msg.setSignature(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.unauth.RemoveReservedUsernameRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.unauth.RemoveReservedUsernameRequest.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.unauth.RemoveReservedUsernameRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.RemoveReservedUsernameRequest.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getMessage();
   if (f.length > 0) {
     writer.writeString(
       1,
       f
     );
   }
   f = message.getSignature();
   if (f.length > 0) {
     writer.writeString(
       2,
       f
     );
   }
 };
 
 
 /**
  * optional string message = 1;
  * @return {string}
  */
 proto.identity.unauth.RemoveReservedUsernameRequest.prototype.getMessage = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.RemoveReservedUsernameRequest} returns this
  */
 proto.identity.unauth.RemoveReservedUsernameRequest.prototype.setMessage = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
 /**
  * optional string signature = 2;
  * @return {string}
  */
 proto.identity.unauth.RemoveReservedUsernameRequest.prototype.getSignature = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.RemoveReservedUsernameRequest} returns this
  */
 proto.identity.unauth.RemoveReservedUsernameRequest.prototype.setSignature = function(value) {
   return jspb.Message.setProto3StringField(this, 2, value);
 };
 
 
 
 /**
  * Oneof group definitions for this message. Each group defines the field
  * numbers belonging to that group. When of these fields' value is set, all
  * other fields in the group are cleared. During deserialization, if multiple
  * fields are encountered for a group, only the last value seen will be kept.
  * @private {!Array<!Array<number>>}
  * @const
  */
 proto.identity.unauth.FindUserIDRequest.oneofGroups_ = [[1,2]];
 
 /**
  * @enum {number}
  */
 proto.identity.unauth.FindUserIDRequest.IdentifierCase = {
   IDENTIFIER_NOT_SET: 0,
   USERNAME: 1,
   WALLET_ADDRESS: 2
 };
 
 /**
  * @return {proto.identity.unauth.FindUserIDRequest.IdentifierCase}
  */
 proto.identity.unauth.FindUserIDRequest.prototype.getIdentifierCase = function() {
   return /** @type {proto.identity.unauth.FindUserIDRequest.IdentifierCase} */(jspb.Message.computeOneofCase(this, proto.identity.unauth.FindUserIDRequest.oneofGroups_[0]));
 };
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.unauth.FindUserIDRequest.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.unauth.FindUserIDRequest.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.unauth.FindUserIDRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.FindUserIDRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
     username: jspb.Message.getFieldWithDefault(msg, 1, ""),
     walletAddress: jspb.Message.getFieldWithDefault(msg, 2, "")
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.unauth.FindUserIDRequest}
  */
 proto.identity.unauth.FindUserIDRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.unauth.FindUserIDRequest;
   return proto.identity.unauth.FindUserIDRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.unauth.FindUserIDRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.unauth.FindUserIDRequest}
  */
 proto.identity.unauth.FindUserIDRequest.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setUsername(value);
       break;
     case 2:
       var value = /** @type {string} */ (reader.readString());
       msg.setWalletAddress(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.unauth.FindUserIDRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.unauth.FindUserIDRequest.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.unauth.FindUserIDRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.FindUserIDRequest.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = /** @type {string} */ (jspb.Message.getField(message, 1));
   if (f != null) {
     writer.writeString(
       1,
       f
     );
   }
   f = /** @type {string} */ (jspb.Message.getField(message, 2));
   if (f != null) {
     writer.writeString(
       2,
       f
     );
   }
 };
 
 
 /**
  * optional string username = 1;
  * @return {string}
  */
 proto.identity.unauth.FindUserIDRequest.prototype.getUsername = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.FindUserIDRequest} returns this
  */
 proto.identity.unauth.FindUserIDRequest.prototype.setUsername = function(value) {
   return jspb.Message.setOneofField(this, 1, proto.identity.unauth.FindUserIDRequest.oneofGroups_[0], value);
 };
 
 
 /**
  * Clears the field making it undefined.
  * @return {!proto.identity.unauth.FindUserIDRequest} returns this
  */
 proto.identity.unauth.FindUserIDRequest.prototype.clearUsername = function() {
   return jspb.Message.setOneofField(this, 1, proto.identity.unauth.FindUserIDRequest.oneofGroups_[0], undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.unauth.FindUserIDRequest.prototype.hasUsername = function() {
   return jspb.Message.getField(this, 1) != null;
 };
 
 
 /**
  * optional string wallet_address = 2;
  * @return {string}
  */
 proto.identity.unauth.FindUserIDRequest.prototype.getWalletAddress = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.FindUserIDRequest} returns this
  */
 proto.identity.unauth.FindUserIDRequest.prototype.setWalletAddress = function(value) {
   return jspb.Message.setOneofField(this, 2, proto.identity.unauth.FindUserIDRequest.oneofGroups_[0], value);
 };
 
 
 /**
  * Clears the field making it undefined.
  * @return {!proto.identity.unauth.FindUserIDRequest} returns this
  */
 proto.identity.unauth.FindUserIDRequest.prototype.clearWalletAddress = function() {
   return jspb.Message.setOneofField(this, 2, proto.identity.unauth.FindUserIDRequest.oneofGroups_[0], undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.unauth.FindUserIDRequest.prototype.hasWalletAddress = function() {
   return jspb.Message.getField(this, 2) != null;
 };
 
 
 
 
 
 if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
  * Creates an object representation of this proto.
  * Field names that are reserved in JavaScript and will be renamed to pb_name.
  * Optional fields that are not set will be set to undefined.
  * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  * For the list of reserved names please see:
  *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  *     JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
 proto.identity.unauth.FindUserIDResponse.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.unauth.FindUserIDResponse.toObject(opt_includeInstance, this);
 };
 
 
 /**
  * Static version of the {@see toObject} method.
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
  * @param {!proto.identity.unauth.FindUserIDResponse} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.FindUserIDResponse.toObject = function(includeInstance, msg) {
   var f, obj = {
     userId: jspb.Message.getFieldWithDefault(msg, 1, ""),
     isReserved: jspb.Message.getBooleanFieldWithDefault(msg, 2, false)
   };
 
   if (includeInstance) {
     obj.$jspbMessageInstance = msg;
   }
   return obj;
 };
 }
 
 
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
  * @return {!proto.identity.unauth.FindUserIDResponse}
  */
 proto.identity.unauth.FindUserIDResponse.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.unauth.FindUserIDResponse;
   return proto.identity.unauth.FindUserIDResponse.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.unauth.FindUserIDResponse} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.unauth.FindUserIDResponse}
  */
 proto.identity.unauth.FindUserIDResponse.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
     }
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
       var value = /** @type {string} */ (reader.readString());
       msg.setUserId(value);
       break;
     case 2:
       var value = /** @type {boolean} */ (reader.readBool());
       msg.setIsReserved(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.unauth.FindUserIDResponse.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.unauth.FindUserIDResponse.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
  * @param {!proto.identity.unauth.FindUserIDResponse} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.FindUserIDResponse.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = /** @type {string} */ (jspb.Message.getField(message, 1));
   if (f != null) {
     writer.writeString(
       1,
       f
     );
   }
   f = message.getIsReserved();
   if (f) {
     writer.writeBool(
       2,
       f
     );
   }
 };
 
 
 /**
  * optional string user_id = 1;
  * @return {string}
  */
 proto.identity.unauth.FindUserIDResponse.prototype.getUserId = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.FindUserIDResponse} returns this
  */
 proto.identity.unauth.FindUserIDResponse.prototype.setUserId = function(value) {
   return jspb.Message.setField(this, 1, value);
 };
 
 
 /**
  * Clears the field making it undefined.
  * @return {!proto.identity.unauth.FindUserIDResponse} returns this
  */
 proto.identity.unauth.FindUserIDResponse.prototype.clearUserId = function() {
   return jspb.Message.setField(this, 1, undefined);
 };
 
 
 /**
  * Returns whether this field is set.
  * @return {boolean}
  */
 proto.identity.unauth.FindUserIDResponse.prototype.hasUserId = function() {
   return jspb.Message.getField(this, 1) != null;
 };
 
 
 /**
  * optional bool is_reserved = 2;
  * @return {boolean}
  */
 proto.identity.unauth.FindUserIDResponse.prototype.getIsReserved = function() {
   return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 2, false));
 };
 
 
 /**
  * @param {boolean} value
  * @return {!proto.identity.unauth.FindUserIDResponse} returns this
  */
 proto.identity.unauth.FindUserIDResponse.prototype.setIsReserved = function(value) {
   return jspb.Message.setProto3BooleanField(this, 2, value);
 };
 
 
+
+/**
+ * List of repeated fields within this message type.
+ * @private {!Array<number>}
+ * @const
+ */
+proto.identity.unauth.GetFarcasterUsersRequest.repeatedFields_ = [1];
+
+
+
+if (jspb.Message.GENERATE_TO_OBJECT) {
+/**
+ * Creates an object representation of this proto.
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
+ * Optional fields that are not set will be set to undefined.
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
+ * For the list of reserved names please see:
+ *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
+ *     JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @return {!Object}
+ */
+proto.identity.unauth.GetFarcasterUsersRequest.prototype.toObject = function(opt_includeInstance) {
+  return proto.identity.unauth.GetFarcasterUsersRequest.toObject(opt_includeInstance, this);
+};
+
+
+/**
+ * Static version of the {@see toObject} method.
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
+ *     the JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @param {!proto.identity.unauth.GetFarcasterUsersRequest} msg The msg instance to transform.
+ * @return {!Object}
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.identity.unauth.GetFarcasterUsersRequest.toObject = function(includeInstance, msg) {
+  var f, obj = {
+    farcasterIdsList: (f = jspb.Message.getRepeatedField(msg, 1)) == null ? undefined : f
+  };
+
+  if (includeInstance) {
+    obj.$jspbMessageInstance = msg;
+  }
+  return obj;
+};
+}
+
+
+/**
+ * Deserializes binary data (in protobuf wire format).
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
+ * @return {!proto.identity.unauth.GetFarcasterUsersRequest}
+ */
+proto.identity.unauth.GetFarcasterUsersRequest.deserializeBinary = function(bytes) {
+  var reader = new jspb.BinaryReader(bytes);
+  var msg = new proto.identity.unauth.GetFarcasterUsersRequest;
+  return proto.identity.unauth.GetFarcasterUsersRequest.deserializeBinaryFromReader(msg, reader);
+};
+
+
+/**
+ * Deserializes binary data (in protobuf wire format) from the
+ * given reader into the given message object.
+ * @param {!proto.identity.unauth.GetFarcasterUsersRequest} msg The message object to deserialize into.
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
+ * @return {!proto.identity.unauth.GetFarcasterUsersRequest}
+ */
+proto.identity.unauth.GetFarcasterUsersRequest.deserializeBinaryFromReader = function(msg, reader) {
+  while (reader.nextField()) {
+    if (reader.isEndGroup()) {
+      break;
+    }
+    var field = reader.getFieldNumber();
+    switch (field) {
+    case 1:
+      var value = /** @type {string} */ (reader.readString());
+      msg.addFarcasterIds(value);
+      break;
+    default:
+      reader.skipField();
+      break;
+    }
+  }
+  return msg;
+};
+
+
+/**
+ * Serializes the message to binary data (in protobuf wire format).
+ * @return {!Uint8Array}
+ */
+proto.identity.unauth.GetFarcasterUsersRequest.prototype.serializeBinary = function() {
+  var writer = new jspb.BinaryWriter();
+  proto.identity.unauth.GetFarcasterUsersRequest.serializeBinaryToWriter(this, writer);
+  return writer.getResultBuffer();
+};
+
+
+/**
+ * Serializes the given message to binary data (in protobuf wire
+ * format), writing to the given BinaryWriter.
+ * @param {!proto.identity.unauth.GetFarcasterUsersRequest} message
+ * @param {!jspb.BinaryWriter} writer
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.identity.unauth.GetFarcasterUsersRequest.serializeBinaryToWriter = function(message, writer) {
+  var f = undefined;
+  f = message.getFarcasterIdsList();
+  if (f.length > 0) {
+    writer.writeRepeatedString(
+      1,
+      f
+    );
+  }
+};
+
+
+/**
+ * repeated string farcaster_ids = 1;
+ * @return {!Array<string>}
+ */
+proto.identity.unauth.GetFarcasterUsersRequest.prototype.getFarcasterIdsList = function() {
+  return /** @type {!Array<string>} */ (jspb.Message.getRepeatedField(this, 1));
+};
+
+
+/**
+ * @param {!Array<string>} value
+ * @return {!proto.identity.unauth.GetFarcasterUsersRequest} returns this
+ */
+proto.identity.unauth.GetFarcasterUsersRequest.prototype.setFarcasterIdsList = function(value) {
+  return jspb.Message.setField(this, 1, value || []);
+};
+
+
+/**
+ * @param {string} value
+ * @param {number=} opt_index
+ * @return {!proto.identity.unauth.GetFarcasterUsersRequest} returns this
+ */
+proto.identity.unauth.GetFarcasterUsersRequest.prototype.addFarcasterIds = function(value, opt_index) {
+  return jspb.Message.addToRepeatedField(this, 1, value, opt_index);
+};
+
+
+/**
+ * Clears the list making it empty but non-null.
+ * @return {!proto.identity.unauth.GetFarcasterUsersRequest} returns this
+ */
+proto.identity.unauth.GetFarcasterUsersRequest.prototype.clearFarcasterIdsList = function() {
+  return this.setFarcasterIdsList([]);
+};
+
+
+
+/**
+ * List of repeated fields within this message type.
+ * @private {!Array<number>}
+ * @const
+ */
+proto.identity.unauth.GetFarcasterUsersResponse.repeatedFields_ = [1];
+
+
+
+if (jspb.Message.GENERATE_TO_OBJECT) {
+/**
+ * Creates an object representation of this proto.
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
+ * Optional fields that are not set will be set to undefined.
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
+ * For the list of reserved names please see:
+ *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
+ *     JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @return {!Object}
+ */
+proto.identity.unauth.GetFarcasterUsersResponse.prototype.toObject = function(opt_includeInstance) {
+  return proto.identity.unauth.GetFarcasterUsersResponse.toObject(opt_includeInstance, this);
+};
+
+
+/**
+ * Static version of the {@see toObject} method.
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
+ *     the JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @param {!proto.identity.unauth.GetFarcasterUsersResponse} msg The msg instance to transform.
+ * @return {!Object}
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.identity.unauth.GetFarcasterUsersResponse.toObject = function(includeInstance, msg) {
+  var f, obj = {
+    farcasterUsersList: jspb.Message.toObjectList(msg.getFarcasterUsersList(),
+    proto.identity.unauth.FarcasterUser.toObject, includeInstance)
+  };
+
+  if (includeInstance) {
+    obj.$jspbMessageInstance = msg;
+  }
+  return obj;
+};
+}
+
+
+/**
+ * Deserializes binary data (in protobuf wire format).
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
+ * @return {!proto.identity.unauth.GetFarcasterUsersResponse}
+ */
+proto.identity.unauth.GetFarcasterUsersResponse.deserializeBinary = function(bytes) {
+  var reader = new jspb.BinaryReader(bytes);
+  var msg = new proto.identity.unauth.GetFarcasterUsersResponse;
+  return proto.identity.unauth.GetFarcasterUsersResponse.deserializeBinaryFromReader(msg, reader);
+};
+
+
+/**
+ * Deserializes binary data (in protobuf wire format) from the
+ * given reader into the given message object.
+ * @param {!proto.identity.unauth.GetFarcasterUsersResponse} msg The message object to deserialize into.
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
+ * @return {!proto.identity.unauth.GetFarcasterUsersResponse}
+ */
+proto.identity.unauth.GetFarcasterUsersResponse.deserializeBinaryFromReader = function(msg, reader) {
+  while (reader.nextField()) {
+    if (reader.isEndGroup()) {
+      break;
+    }
+    var field = reader.getFieldNumber();
+    switch (field) {
+    case 1:
+      var value = new proto.identity.unauth.FarcasterUser;
+      reader.readMessage(value,proto.identity.unauth.FarcasterUser.deserializeBinaryFromReader);
+      msg.addFarcasterUsers(value);
+      break;
+    default:
+      reader.skipField();
+      break;
+    }
+  }
+  return msg;
+};
+
+
+/**
+ * Serializes the message to binary data (in protobuf wire format).
+ * @return {!Uint8Array}
+ */
+proto.identity.unauth.GetFarcasterUsersResponse.prototype.serializeBinary = function() {
+  var writer = new jspb.BinaryWriter();
+  proto.identity.unauth.GetFarcasterUsersResponse.serializeBinaryToWriter(this, writer);
+  return writer.getResultBuffer();
+};
+
+
+/**
+ * Serializes the given message to binary data (in protobuf wire
+ * format), writing to the given BinaryWriter.
+ * @param {!proto.identity.unauth.GetFarcasterUsersResponse} message
+ * @param {!jspb.BinaryWriter} writer
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.identity.unauth.GetFarcasterUsersResponse.serializeBinaryToWriter = function(message, writer) {
+  var f = undefined;
+  f = message.getFarcasterUsersList();
+  if (f.length > 0) {
+    writer.writeRepeatedMessage(
+      1,
+      f,
+      proto.identity.unauth.FarcasterUser.serializeBinaryToWriter
+    );
+  }
+};
+
+
+/**
+ * repeated FarcasterUser farcaster_users = 1;
+ * @return {!Array<!proto.identity.unauth.FarcasterUser>}
+ */
+proto.identity.unauth.GetFarcasterUsersResponse.prototype.getFarcasterUsersList = function() {
+  return /** @type{!Array<!proto.identity.unauth.FarcasterUser>} */ (
+    jspb.Message.getRepeatedWrapperField(this, proto.identity.unauth.FarcasterUser, 1));
+};
+
+
+/**
+ * @param {!Array<!proto.identity.unauth.FarcasterUser>} value
+ * @return {!proto.identity.unauth.GetFarcasterUsersResponse} returns this
+*/
+proto.identity.unauth.GetFarcasterUsersResponse.prototype.setFarcasterUsersList = function(value) {
+  return jspb.Message.setRepeatedWrapperField(this, 1, value);
+};
+
+
+/**
+ * @param {!proto.identity.unauth.FarcasterUser=} opt_value
+ * @param {number=} opt_index
+ * @return {!proto.identity.unauth.FarcasterUser}
+ */
+proto.identity.unauth.GetFarcasterUsersResponse.prototype.addFarcasterUsers = function(opt_value, opt_index) {
+  return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.identity.unauth.FarcasterUser, opt_index);
+};
+
+
+/**
+ * Clears the list making it empty but non-null.
+ * @return {!proto.identity.unauth.GetFarcasterUsersResponse} returns this
+ */
+proto.identity.unauth.GetFarcasterUsersResponse.prototype.clearFarcasterUsersList = function() {
+  return this.setFarcasterUsersList([]);
+};
+
+
+
+
+
+if (jspb.Message.GENERATE_TO_OBJECT) {
+/**
+ * Creates an object representation of this proto.
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
+ * Optional fields that are not set will be set to undefined.
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
+ * For the list of reserved names please see:
+ *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
+ *     JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @return {!Object}
+ */
+proto.identity.unauth.FarcasterUser.prototype.toObject = function(opt_includeInstance) {
+  return proto.identity.unauth.FarcasterUser.toObject(opt_includeInstance, this);
+};
+
+
+/**
+ * Static version of the {@see toObject} method.
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
+ *     the JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @param {!proto.identity.unauth.FarcasterUser} msg The msg instance to transform.
+ * @return {!Object}
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.identity.unauth.FarcasterUser.toObject = function(includeInstance, msg) {
+  var f, obj = {
+    userId: jspb.Message.getFieldWithDefault(msg, 1, ""),
+    farcasterId: jspb.Message.getFieldWithDefault(msg, 2, ""),
+    username: jspb.Message.getFieldWithDefault(msg, 3, "")
+  };
+
+  if (includeInstance) {
+    obj.$jspbMessageInstance = msg;
+  }
+  return obj;
+};
+}
+
+
+/**
+ * Deserializes binary data (in protobuf wire format).
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
+ * @return {!proto.identity.unauth.FarcasterUser}
+ */
+proto.identity.unauth.FarcasterUser.deserializeBinary = function(bytes) {
+  var reader = new jspb.BinaryReader(bytes);
+  var msg = new proto.identity.unauth.FarcasterUser;
+  return proto.identity.unauth.FarcasterUser.deserializeBinaryFromReader(msg, reader);
+};
+
+
+/**
+ * Deserializes binary data (in protobuf wire format) from the
+ * given reader into the given message object.
+ * @param {!proto.identity.unauth.FarcasterUser} msg The message object to deserialize into.
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
+ * @return {!proto.identity.unauth.FarcasterUser}
+ */
+proto.identity.unauth.FarcasterUser.deserializeBinaryFromReader = function(msg, reader) {
+  while (reader.nextField()) {
+    if (reader.isEndGroup()) {
+      break;
+    }
+    var field = reader.getFieldNumber();
+    switch (field) {
+    case 1:
+      var value = /** @type {string} */ (reader.readString());
+      msg.setUserId(value);
+      break;
+    case 2:
+      var value = /** @type {string} */ (reader.readString());
+      msg.setFarcasterId(value);
+      break;
+    case 3:
+      var value = /** @type {string} */ (reader.readString());
+      msg.setUsername(value);
+      break;
+    default:
+      reader.skipField();
+      break;
+    }
+  }
+  return msg;
+};
+
+
+/**
+ * Serializes the message to binary data (in protobuf wire format).
+ * @return {!Uint8Array}
+ */
+proto.identity.unauth.FarcasterUser.prototype.serializeBinary = function() {
+  var writer = new jspb.BinaryWriter();
+  proto.identity.unauth.FarcasterUser.serializeBinaryToWriter(this, writer);
+  return writer.getResultBuffer();
+};
+
+
+/**
+ * Serializes the given message to binary data (in protobuf wire
+ * format), writing to the given BinaryWriter.
+ * @param {!proto.identity.unauth.FarcasterUser} message
+ * @param {!jspb.BinaryWriter} writer
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.identity.unauth.FarcasterUser.serializeBinaryToWriter = function(message, writer) {
+  var f = undefined;
+  f = message.getUserId();
+  if (f.length > 0) {
+    writer.writeString(
+      1,
+      f
+    );
+  }
+  f = message.getFarcasterId();
+  if (f.length > 0) {
+    writer.writeString(
+      2,
+      f
+    );
+  }
+  f = message.getUsername();
+  if (f.length > 0) {
+    writer.writeString(
+      3,
+      f
+    );
+  }
+};
+
+
+/**
+ * optional string user_id = 1;
+ * @return {string}
+ */
+proto.identity.unauth.FarcasterUser.prototype.getUserId = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
+};
+
+
+/**
+ * @param {string} value
+ * @return {!proto.identity.unauth.FarcasterUser} returns this
+ */
+proto.identity.unauth.FarcasterUser.prototype.setUserId = function(value) {
+  return jspb.Message.setProto3StringField(this, 1, value);
+};
+
+
+/**
+ * optional string farcaster_id = 2;
+ * @return {string}
+ */
+proto.identity.unauth.FarcasterUser.prototype.getFarcasterId = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
+};
+
+
+/**
+ * @param {string} value
+ * @return {!proto.identity.unauth.FarcasterUser} returns this
+ */
+proto.identity.unauth.FarcasterUser.prototype.setFarcasterId = function(value) {
+  return jspb.Message.setProto3StringField(this, 2, value);
+};
+
+
+/**
+ * optional string username = 3;
+ * @return {string}
+ */
+proto.identity.unauth.FarcasterUser.prototype.getUsername = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, ""));
+};
+
+
+/**
+ * @param {string} value
+ * @return {!proto.identity.unauth.FarcasterUser} returns this
+ */
+proto.identity.unauth.FarcasterUser.prototype.setUsername = function(value) {
+  return jspb.Message.setProto3StringField(this, 3, value);
+};
+
+
 /**
  * @enum {number}
  */
 proto.identity.unauth.DeviceType = {
   KEYSERVER: 0,
   WEB: 1,
   IOS: 2,
   ANDROID: 3,
   WINDOWS: 4,
   MAC_OS: 5
 };
 
 goog.object.extend(exports, proto.identity.unauth);
diff --git a/web/protobufs/identity-unauth-structs.cjs.flow b/web/protobufs/identity-unauth-structs.cjs.flow
index a8f27ce74..70dde0c64 100644
--- a/web/protobufs/identity-unauth-structs.cjs.flow
+++ b/web/protobufs/identity-unauth-structs.cjs.flow
@@ -1,556 +1,616 @@
 // @flow
 
 import {
   Message,
   BinaryWriter,
   BinaryReader,
   Map as ProtoMap,
 } from 'google-protobuf';
 
 declare export class Empty extends Message {
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): {};
   static toObject(includeInstance: boolean, msg: Empty): {};
   static serializeBinaryToWriter(message: Empty, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): Empty;
   static deserializeBinaryFromReader(message: Empty, reader: BinaryReader): Empty;
 }
 
 export type PrekeyObject = {
   prekey: string,
   prekeySignature: string,
 }
 
 declare export class Prekey extends Message {
   getPrekey(): string;
   setPrekey(value: string): Prekey;
 
   getPrekeySignature(): string;
   setPrekeySignature(value: string): Prekey;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): PrekeyObject;
   static toObject(includeInstance: boolean, msg: Prekey): PrekeyObject;
   static serializeBinaryToWriter(message: Prekey, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): Prekey;
   static deserializeBinaryFromReader(message: Prekey, reader: BinaryReader): Prekey;
 }
 
 export type IdentityKeyInfoObject = {
   payload: string,
   payloadSignature: string,
   socialProof?: string,
 };
 
 declare export class IdentityKeyInfo extends Message {
   getPayload(): string;
   setPayload(value: string): IdentityKeyInfo;
 
   getPayloadSignature(): string;
   setPayloadSignature(value: string): IdentityKeyInfo;
 
   getSocialProof(): string;
   setSocialProof(value: string): IdentityKeyInfo;
   hasSocialProof(): boolean;
   clearSocialProof(): IdentityKeyInfo;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): IdentityKeyInfoObject;
   static toObject(includeInstance: boolean, msg: IdentityKeyInfo): IdentityKeyInfoObject;
   static serializeBinaryToWriter(message: IdentityKeyInfo, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): IdentityKeyInfo;
   static deserializeBinaryFromReader(message: IdentityKeyInfo, reader: BinaryReader): IdentityKeyInfo;
 }
 
 declare export class DeviceKeyUpload extends Message {
   getDeviceKeyInfo(): IdentityKeyInfo | void;
   setDeviceKeyInfo(value?: IdentityKeyInfo): DeviceKeyUpload;
   hasDeviceKeyInfo(): boolean;
   clearDeviceKeyInfo(): DeviceKeyUpload;
 
   getContentUpload(): Prekey | void;
   setContentUpload(value?: Prekey): DeviceKeyUpload;
   hasContentUpload(): boolean;
   clearContentUpload(): DeviceKeyUpload;
 
   getNotifUpload(): Prekey | void;
   setNotifUpload(value?: Prekey): DeviceKeyUpload;
   hasNotifUpload(): boolean;
   clearNotifUpload(): DeviceKeyUpload;
 
   getOneTimeContentPrekeysList(): Array<string>;
   setOneTimeContentPrekeysList(value: Array<string>): DeviceKeyUpload;
   clearOneTimeContentPrekeysList(): DeviceKeyUpload;
   addOneTimeContentPrekeys(value: string, index?: number): DeviceKeyUpload;
 
   getOneTimeNotifPrekeysList(): Array<string>;
   setOneTimeNotifPrekeysList(value: Array<string>): DeviceKeyUpload;
   clearOneTimeNotifPrekeysList(): DeviceKeyUpload;
   addOneTimeNotifPrekeys(value: string, index?: number): DeviceKeyUpload;
 
   getDeviceType(): DeviceType;
   setDeviceType(value: DeviceType): DeviceKeyUpload;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): DeviceKeyUploadObject;
   static toObject(includeInstance: boolean, msg: DeviceKeyUpload): DeviceKeyUploadObject;
   static serializeBinaryToWriter(message: DeviceKeyUpload, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): DeviceKeyUpload;
   static deserializeBinaryFromReader(message: DeviceKeyUpload, reader: BinaryReader): DeviceKeyUpload;
 }
 
 export type DeviceKeyUploadObject = {
   deviceKeyInfo?: IdentityKeyInfoObject,
   contentUpload?: PrekeyObject,
   notifUpload?: PrekeyObject,
   oneTimeContentPrekeysList: Array<string>,
   oneTimeNotifPrekeysList: Array<string>,
   deviceType: DeviceType,
 };
 
 declare export class RegistrationStartRequest extends Message {
   getOpaqueRegistrationRequest(): Uint8Array | string;
   getOpaqueRegistrationRequest_asU8(): Uint8Array;
   getOpaqueRegistrationRequest_asB64(): string;
   setOpaqueRegistrationRequest(value: Uint8Array | string): RegistrationStartRequest;
 
   getUsername(): string;
   setUsername(value: string): RegistrationStartRequest;
 
   getDeviceKeyUpload(): DeviceKeyUpload | void;
   setDeviceKeyUpload(value?: DeviceKeyUpload): RegistrationStartRequest;
   hasDeviceKeyUpload(): boolean;
   clearDeviceKeyUpload(): RegistrationStartRequest;
 
   getFarcasterId(): string;
   setFarcasterId(value: string): RegistrationStartRequest;
   hasFarcasterId(): boolean;
   clearFarcasterId(): RegistrationStartRequest;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): RegistrationStartRequestObject;
   static toObject(includeInstance: boolean, msg: RegistrationStartRequest): RegistrationStartRequestObject;
   static serializeBinaryToWriter(message: RegistrationStartRequest, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): RegistrationStartRequest;
   static deserializeBinaryFromReader(message: RegistrationStartRequest, reader: BinaryReader): RegistrationStartRequest;
 }
 
 export type RegistrationStartRequestObject = {
   opaqueRegistrationRequest: Uint8Array | string,
   username: string,
   deviceKeyUpload?: DeviceKeyUploadObject,
   farcasterId?: string,
 };
 
 declare export class ReservedRegistrationStartRequest extends Message {
   getOpaqueRegistrationRequest(): Uint8Array | string;
   getOpaqueRegistrationRequest_asU8(): Uint8Array;
   getOpaqueRegistrationRequest_asB64(): string;
   setOpaqueRegistrationRequest(value: Uint8Array | string): ReservedRegistrationStartRequest;
 
   getUsername(): string;
   setUsername(value: string): ReservedRegistrationStartRequest;
 
   getDeviceKeyUpload(): DeviceKeyUpload | void;
   setDeviceKeyUpload(value?: DeviceKeyUpload): ReservedRegistrationStartRequest;
   hasDeviceKeyUpload(): boolean;
   clearDeviceKeyUpload(): ReservedRegistrationStartRequest;
 
   getKeyserverMessage(): string;
   setKeyserverMessage(value: string): ReservedRegistrationStartRequest;
 
   getKeyserverSignature(): string;
   setKeyserverSignature(value: string): ReservedRegistrationStartRequest;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): ReservedRegistrationStartRequestObject;
   static toObject(includeInstance: boolean, msg: ReservedRegistrationStartRequest): ReservedRegistrationStartRequestObject;
   static serializeBinaryToWriter(message: ReservedRegistrationStartRequest, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): ReservedRegistrationStartRequest;
   static deserializeBinaryFromReader(message: ReservedRegistrationStartRequest, reader: BinaryReader): ReservedRegistrationStartRequest;
 }
 
 export type ReservedRegistrationStartRequestObject = {
   opaqueRegistrationRequest: Uint8Array | string,
   username: string,
   deviceKeyUpload?: DeviceKeyUploadObject,
   keyserverMessage: string,
   keyserverSignature: string,
 };
 
 declare export class RegistrationFinishRequest extends Message {
   getSessionid(): string;
   setSessionid(value: string): RegistrationFinishRequest;
 
   getOpaqueregistrationupload(): Uint8Array | string;
   getOpaqueregistrationupload_asU8(): Uint8Array;
   getOpaqueregistrationupload_asB64(): string;
   setOpaqueregistrationupload(value: Uint8Array | string): RegistrationFinishRequest;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): RegistrationFinishRequestObject;
   static toObject(includeInstance: boolean, msg: RegistrationFinishRequest): RegistrationFinishRequestObject;
   static serializeBinaryToWriter(message: RegistrationFinishRequest, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): RegistrationFinishRequest;
   static deserializeBinaryFromReader(message: RegistrationFinishRequest, reader: BinaryReader): RegistrationFinishRequest;
 }
 
 export type RegistrationFinishRequestObject = {
   sessionid: string,
   opaqueregistrationupload: Uint8Array | string,
 };
 
 declare export class RegistrationStartResponse extends Message {
   getSessionId(): string;
   setSessionId(value: string): RegistrationStartResponse;
 
   getOpaqueRegistrationResponse(): Uint8Array | string;
   getOpaqueRegistrationResponse_asU8(): Uint8Array;
   getOpaqueRegistrationResponse_asB64(): string;
   setOpaqueRegistrationResponse(value: Uint8Array | string): RegistrationStartResponse;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): RegistrationStartResponseObject;
   static toObject(includeInstance: boolean, msg: RegistrationStartResponse): RegistrationStartResponseObject;
   static serializeBinaryToWriter(message: RegistrationStartResponse, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): RegistrationStartResponse;
   static deserializeBinaryFromReader(message: RegistrationStartResponse, reader: BinaryReader): RegistrationStartResponse;
 }
 
 export type RegistrationStartResponseObject = {
   sessionId: string,
   opaqueRegistrationResponse: Uint8Array | string,
 };
 
 declare export class AuthResponse extends Message {
   getUserId(): string;
   setUserId(value: string): AuthResponse;
 
   getAccessToken(): string;
   setAccessToken(value: string): AuthResponse;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): AuthResponseObject;
   static toObject(includeInstance: boolean, msg: AuthResponse): AuthResponseObject;
   static serializeBinaryToWriter(message: AuthResponse, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): AuthResponse;
   static deserializeBinaryFromReader(message: AuthResponse, reader: BinaryReader): AuthResponse;
 }
 
 export type AuthResponseObject = {
   userId: string,
   accessToken: string,
 };
 
 declare export class OpaqueLoginStartRequest extends Message {
   getUsername(): string;
   setUsername(value: string): OpaqueLoginStartRequest;
 
   getOpaqueLoginRequest(): Uint8Array | string;
   getOpaqueLoginRequest_asU8(): Uint8Array;
   getOpaqueLoginRequest_asB64(): string;
   setOpaqueLoginRequest(value: Uint8Array | string): OpaqueLoginStartRequest;
 
   getDeviceKeyUpload(): DeviceKeyUpload | void;
   setDeviceKeyUpload(value?: DeviceKeyUpload): OpaqueLoginStartRequest;
   hasDeviceKeyUpload(): boolean;
   clearDeviceKeyUpload(): OpaqueLoginStartRequest;
 
   getForce(): boolean;
   setForce(value: boolean): OpaqueLoginStartRequest;
   hasForce(): boolean;
   clearForce(): OpaqueLoginStartRequest;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): OpaqueLoginStartRequestObject;
   static toObject(includeInstance: boolean, msg: OpaqueLoginStartRequest): OpaqueLoginStartRequestObject;
   static serializeBinaryToWriter(message: OpaqueLoginStartRequest, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): OpaqueLoginStartRequest;
   static deserializeBinaryFromReader(message: OpaqueLoginStartRequest, reader: BinaryReader): OpaqueLoginStartRequest;
 }
 
 export type OpaqueLoginStartRequestObject = {
   username: string,
   opaqueLoginRequest: Uint8Array | string,
   deviceKeyUpload?: DeviceKeyUploadObject,
   force?: boolean,
 };
 
 declare export class OpaqueLoginFinishRequest extends Message {
   getSessionId(): string;
   setSessionId(value: string): OpaqueLoginFinishRequest;
 
   getOpaqueLoginUpload(): Uint8Array | string;
   getOpaqueLoginUpload_asU8(): Uint8Array;
   getOpaqueLoginUpload_asB64(): string;
   setOpaqueLoginUpload(value: Uint8Array | string): OpaqueLoginFinishRequest;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): OpaqueLoginFinishRequestObject;
   static toObject(includeInstance: boolean, msg: OpaqueLoginFinishRequest): OpaqueLoginFinishRequestObject;
   static serializeBinaryToWriter(message: OpaqueLoginFinishRequest, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): OpaqueLoginFinishRequest;
   static deserializeBinaryFromReader(message: OpaqueLoginFinishRequest, reader: BinaryReader): OpaqueLoginFinishRequest;
 }
 
 export type OpaqueLoginFinishRequestObject = {
   sessionId: string,
   opaqueLoginUpload: Uint8Array | string,
 };
 
 declare export class OpaqueLoginStartResponse extends Message {
   getSessionId(): string;
   setSessionId(value: string): OpaqueLoginStartResponse;
 
   getOpaqueLoginResponse(): Uint8Array | string;
   getOpaqueLoginResponse_asU8(): Uint8Array;
   getOpaqueLoginResponse_asB64(): string;
   setOpaqueLoginResponse(value: Uint8Array | string): OpaqueLoginStartResponse;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): OpaqueLoginStartResponseObject;
   static toObject(includeInstance: boolean, msg: OpaqueLoginStartResponse): OpaqueLoginStartResponseObject;
   static serializeBinaryToWriter(message: OpaqueLoginStartResponse, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): OpaqueLoginStartResponse;
   static deserializeBinaryFromReader(message: OpaqueLoginStartResponse, reader: BinaryReader): OpaqueLoginStartResponse;
 }
 
 export type OpaqueLoginStartResponseObject = {
   sessionId: string,
   opaqueLoginResponse: Uint8Array | string,
 };
 
 declare export class WalletAuthRequest extends Message {
   getSiweMessage(): string;
   setSiweMessage(value: string): WalletAuthRequest;
 
   getSiweSignature(): string;
   setSiweSignature(value: string): WalletAuthRequest;
 
   getDeviceKeyUpload(): DeviceKeyUpload | void;
   setDeviceKeyUpload(value?: DeviceKeyUpload): WalletAuthRequest;
   hasDeviceKeyUpload(): boolean;
   clearDeviceKeyUpload(): WalletAuthRequest;
 
   getFarcasterId(): string;
   setFarcasterId(value: string): WalletAuthRequest;
   hasFarcasterId(): boolean;
   clearFarcasterId(): WalletAuthRequest;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): WalletAuthRequestObject;
   static toObject(includeInstance: boolean, msg: WalletAuthRequest): WalletAuthRequestObject;
   static serializeBinaryToWriter(message: WalletAuthRequest, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): WalletAuthRequest;
   static deserializeBinaryFromReader(message: WalletAuthRequest, reader: BinaryReader): WalletAuthRequest;
 }
 
 export type WalletAuthRequestObject = {
   siweMessage: string,
   siweSignature: string,
   deviceKeyUpload?: DeviceKeyUploadObject,
   farcasterId?: string,
 };
 
 declare export class ReservedWalletRegistrationRequest extends Message {
   getSiweMessage(): string;
   setSiweMessage(value: string): ReservedWalletRegistrationRequest;
 
   getSiweSignature(): string;
   setSiweSignature(value: string): ReservedWalletRegistrationRequest;
 
   getDeviceKeyUpload(): DeviceKeyUpload | void;
   setDeviceKeyUpload(value?: DeviceKeyUpload): ReservedWalletRegistrationRequest;
   hasDeviceKeyUpload(): boolean;
   clearDeviceKeyUpload(): ReservedWalletRegistrationRequest;
 
   getKeyserverMessage(): string;
   setKeyserverMessage(value: string): ReservedWalletRegistrationRequest;
 
   getKeyserverSignature(): string;
   setKeyserverSignature(value: string): ReservedWalletRegistrationRequest;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): ReservedWalletRegistrationRequestObject;
   static toObject(includeInstance: boolean, msg: ReservedWalletRegistrationRequest): ReservedWalletRegistrationRequestObject;
   static serializeBinaryToWriter(message: ReservedWalletRegistrationRequest, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): ReservedWalletRegistrationRequest;
   static deserializeBinaryFromReader(message: ReservedWalletRegistrationRequest, reader: BinaryReader): ReservedWalletRegistrationRequest;
 }
 
 export type ReservedWalletRegistrationRequestObject = {
   siweMessage: string,
   siweSignature: string,
   deviceKeyUpload?: DeviceKeyUploadObject,
   keyserverMessage: string,
   keyserverSignature: string,
 };
 
 declare export class SecondaryDeviceKeysUploadRequest extends Message {
   getUserId(): string;
   setUserId(value: string): SecondaryDeviceKeysUploadRequest;
 
   getChallengeResponse(): string;
   setChallengeResponse(value: string): SecondaryDeviceKeysUploadRequest;
 
   getDeviceKeyUpload(): DeviceKeyUpload | void;
   setDeviceKeyUpload(value?: DeviceKeyUpload): SecondaryDeviceKeysUploadRequest;
   hasDeviceKeyUpload(): boolean;
   clearDeviceKeyUpload(): SecondaryDeviceKeysUploadRequest;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): SecondaryDeviceKeysUploadRequestObject;
   static toObject(includeInstance: boolean, msg: SecondaryDeviceKeysUploadRequest): SecondaryDeviceKeysUploadRequestObject;
   static serializeBinaryToWriter(message: SecondaryDeviceKeysUploadRequest, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): SecondaryDeviceKeysUploadRequest;
   static deserializeBinaryFromReader(message: SecondaryDeviceKeysUploadRequest, reader: BinaryReader): SecondaryDeviceKeysUploadRequest;
 }
 
 export type SecondaryDeviceKeysUploadRequestObject = {
   userId: string,
   deviceKeyUpload?: DeviceKeyUploadObject,
 }
 
 declare export class GenerateNonceResponse extends Message {
   getNonce(): string;
   setNonce(value: string): GenerateNonceResponse;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): GenerateNonceResponseObject;
   static toObject(includeInstance: boolean, msg: GenerateNonceResponse): GenerateNonceResponseObject;
   static serializeBinaryToWriter(message: GenerateNonceResponse, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): GenerateNonceResponse;
   static deserializeBinaryFromReader(message: GenerateNonceResponse, reader: BinaryReader): GenerateNonceResponse;
 }
 
 export type GenerateNonceResponseObject = {
   nonce: string,
 };
 
 declare export class VerifyUserAccessTokenRequest extends Message {
   getUserId(): string;
   setUserId(value: string): VerifyUserAccessTokenRequest;
 
   getDeviceId(): string;
   setDeviceId(value: string): VerifyUserAccessTokenRequest;
 
   getAccessToken(): string;
   setAccessToken(value: string): VerifyUserAccessTokenRequest;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): VerifyUserAccessTokenRequestObject;
   static toObject(includeInstance: boolean, msg: VerifyUserAccessTokenRequest): VerifyUserAccessTokenRequestObject;
   static serializeBinaryToWriter(message: VerifyUserAccessTokenRequest, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): VerifyUserAccessTokenRequest;
   static deserializeBinaryFromReader(message: VerifyUserAccessTokenRequest, reader: BinaryReader): VerifyUserAccessTokenRequest;
 }
 
 export type VerifyUserAccessTokenRequestObject = {
   userId: string,
   deviceId: string,
   accessToken: string,
 };
 
 declare export class VerifyUserAccessTokenResponse extends Message {
   getTokenValid(): boolean;
   setTokenValid(value: boolean): VerifyUserAccessTokenResponse;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): VerifyUserAccessTokenResponseObject;
   static toObject(includeInstance: boolean, msg: VerifyUserAccessTokenResponse): VerifyUserAccessTokenResponseObject;
   static serializeBinaryToWriter(message: VerifyUserAccessTokenResponse, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): VerifyUserAccessTokenResponse;
   static deserializeBinaryFromReader(message: VerifyUserAccessTokenResponse, reader: BinaryReader): VerifyUserAccessTokenResponse;
 }
 
 export type VerifyUserAccessTokenResponseObject = {
   tokenValid: boolean,
 };
 
 declare export class AddReservedUsernamesRequest extends Message {
   getMessage(): string;
   setMessage(value: string): AddReservedUsernamesRequest;
 
   getSignature(): string;
   setSignature(value: string): AddReservedUsernamesRequest;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): AddReservedUsernamesRequestObject;
   static toObject(includeInstance: boolean, msg: AddReservedUsernamesRequest): AddReservedUsernamesRequestObject;
   static serializeBinaryToWriter(message: AddReservedUsernamesRequest, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): AddReservedUsernamesRequest;
   static deserializeBinaryFromReader(message: AddReservedUsernamesRequest, reader: BinaryReader): AddReservedUsernamesRequest;
 }
 
 export type AddReservedUsernamesRequestObject = {
   message: string,
   signature: string,
 };
 
 declare export class RemoveReservedUsernameRequest extends Message {
   getMessage(): string;
   setMessage(value: string): RemoveReservedUsernameRequest;
 
   getSignature(): string;
   setSignature(value: string): RemoveReservedUsernameRequest;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): RemoveReservedUsernameRequestObject;
   static toObject(includeInstance: boolean, msg: RemoveReservedUsernameRequest): RemoveReservedUsernameRequestObject;
   static serializeBinaryToWriter(message: RemoveReservedUsernameRequest, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): RemoveReservedUsernameRequest;
   static deserializeBinaryFromReader(message: RemoveReservedUsernameRequest, reader: BinaryReader): RemoveReservedUsernameRequest;
 }
 
 export type RemoveReservedUsernameRequestObject = {
   message: string,
   signature: string,
 };
 
 export type IdentifierCase = 0 | 1 | 2;
 
 declare export class FindUserIDRequest extends Message {
   getUsername(): string;
   setUsername(value: string): FindUserIDRequest;
 
   getWalletAddress(): string;
   setWalletAddress(value: string): FindUserIDRequest;
 
   getIdentifierCase(): IdentifierCase;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): FindUserIDRequestObject;
   static toObject(includeInstance: boolean, msg: FindUserIDRequest): FindUserIDRequestObject;
   static serializeBinaryToWriter(message: FindUserIDRequest, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): FindUserIDRequest;
   static deserializeBinaryFromReader(message: FindUserIDRequest, reader: BinaryReader): FindUserIDRequest;
 }
 
 export type FindUserIDRequestObject = {
   username: string,
   walletAddress: string,
 }
 
 declare export class FindUserIDResponse extends Message {
   getUserId(): string;
   setUserId(value: string): FindUserIDResponse;
   hasUserId(): boolean;
   clearUserId(): FindUserIDResponse;
 
   getIsReserved(): boolean;
   setIsReserved(value: boolean): FindUserIDResponse;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): FindUserIDResponseObject;
   static toObject(includeInstance: boolean, msg: FindUserIDResponse): FindUserIDResponseObject;
   static serializeBinaryToWriter(message: FindUserIDResponse, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): FindUserIDResponse;
   static deserializeBinaryFromReader(message: FindUserIDResponse, reader: BinaryReader): FindUserIDResponse;
 }
 
 export type FindUserIDResponseObject = {
   userId?: string,
   isReserved: boolean,
 }
 
+declare export class GetFarcasterUsersRequest extends Message {
+  getFarcasterIdsList(): Array<string>;
+  setFarcasterIdsList(value: Array<string>): GetFarcasterUsersRequest;
+  clearFarcasterIdsList(): GetFarcasterUsersRequest;
+  addFarcasterIds(value: string, index?: number): GetFarcasterUsersRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GetFarcasterUsersRequestObject;
+  static toObject(includeInstance: boolean, msg: GetFarcasterUsersRequest): GetFarcasterUsersRequestObject;
+  static serializeBinaryToWriter(message: GetFarcasterUsersRequest, writer: BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetFarcasterUsersRequest;
+  static deserializeBinaryFromReader(message: GetFarcasterUsersRequest, reader: BinaryReader): GetFarcasterUsersRequest;
+}
+
+export type GetFarcasterUsersRequestObject = {
+  farcasterIdsList: Array<string>,
+}
+
+declare export class GetFarcasterUsersResponse extends Message {
+  getFarcasterUsersList(): Array<FarcasterUser>;
+  setFarcasterUsersList(value: Array<FarcasterUser>): GetFarcasterUsersResponse;
+  clearFarcasterUsersList(): GetFarcasterUsersResponse;
+  addFarcasterUsers(value?: FarcasterUser, index?: number): FarcasterUser;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GetFarcasterUsersResponseObject;
+  static toObject(includeInstance: boolean, msg: GetFarcasterUsersResponse): GetFarcasterUsersResponseObject;
+  static serializeBinaryToWriter(message: GetFarcasterUsersResponse, writer: BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetFarcasterUsersResponse;
+  static deserializeBinaryFromReader(message: GetFarcasterUsersResponse, reader: BinaryReader): GetFarcasterUsersResponse;
+}
+
+export type GetFarcasterUsersResponseObject = {
+  farcasterUsersList: Array<FarcasterUserObject>,
+}
+
+declare export class FarcasterUser extends Message {
+  getUserId(): string;
+  setUserId(value: string): FarcasterUser;
+
+  getFarcasterId(): string;
+  setFarcasterId(value: string): FarcasterUser;
+
+  getUsername(): string;
+  setUsername(value: string): FarcasterUser;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): FarcasterUserObject;
+  static toObject(includeInstance: boolean, msg: FarcasterUser): FarcasterUserObject;
+  static serializeBinaryToWriter(message: FarcasterUser, writer: BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): FarcasterUser;
+  static deserializeBinaryFromReader(message: FarcasterUser, reader: BinaryReader): FarcasterUser;
+}
+
+export type FarcasterUserObject = {
+  userId: string,
+  farcasterId: string,
+  username: string,
+}
+
 export type DeviceType = 0 | 1 | 2 | 3 | 4 | 5;
diff --git a/web/protobufs/identity-unauth.cjs b/web/protobufs/identity-unauth.cjs
index 79ca4ef26..03fa469f1 100644
--- a/web/protobufs/identity-unauth.cjs
+++ b/web/protobufs/identity-unauth.cjs
@@ -1,995 +1,1055 @@
 /**
  * @fileoverview gRPC-Web generated client stub for identity.unauth
  * @enhanceable
  * @public
  * @generated
  */
 
 // Code generated by protoc-gen-grpc-web. DO NOT EDIT.
 // versions:
 // 	protoc-gen-grpc-web v1.4.2
 // 	protoc              v3.21.12
 // source: identity_unauth.proto
 
 
 /* eslint-disable */
 // @ts-nocheck
 
 
 
 const grpc = {};
 grpc.web = require('grpc-web');
 
 const proto = {};
 proto.identity = {};
 proto.identity.unauth = require('./identity-unauth-structs.cjs');
 
 /**
  * @param {string} hostname
  * @param {?Object} credentials
  * @param {?grpc.web.ClientOptions} options
  * @constructor
  * @struct
  * @final
  */
 proto.identity.unauth.IdentityClientServiceClient =
     function(hostname, credentials, options) {
   if (!options) options = {};
   options.format = 'text';
 
   /**
    * @private @const {!grpc.web.GrpcWebClientBase} The client
    */
   this.client_ = new grpc.web.GrpcWebClientBase(options);
 
   /**
    * @private @const {string} The hostname
    */
   this.hostname_ = hostname.replace(/\/+$/, '');
 
 };
 
 
 /**
  * @param {string} hostname
  * @param {?Object} credentials
  * @param {?grpc.web.ClientOptions} options
  * @constructor
  * @struct
  * @final
  */
 proto.identity.unauth.IdentityClientServicePromiseClient =
     function(hostname, credentials, options) {
   if (!options) options = {};
   options.format = 'text';
 
   /**
    * @private @const {!grpc.web.GrpcWebClientBase} The client
    */
   this.client_ = new grpc.web.GrpcWebClientBase(options);
 
   /**
    * @private @const {string} The hostname
    */
   this.hostname_ = hostname.replace(/\/+$/, '');
 
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.unauth.RegistrationStartRequest,
  *   !proto.identity.unauth.RegistrationStartResponse>}
  */
 const methodDescriptor_IdentityClientService_RegisterPasswordUserStart = new grpc.web.MethodDescriptor(
   '/identity.unauth.IdentityClientService/RegisterPasswordUserStart',
   grpc.web.MethodType.UNARY,
   proto.identity.unauth.RegistrationStartRequest,
   proto.identity.unauth.RegistrationStartResponse,
   /**
    * @param {!proto.identity.unauth.RegistrationStartRequest} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   proto.identity.unauth.RegistrationStartResponse.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.unauth.RegistrationStartRequest} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.unauth.RegistrationStartResponse)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.unauth.RegistrationStartResponse>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.unauth.IdentityClientServiceClient.prototype.registerPasswordUserStart =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/RegisterPasswordUserStart',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_RegisterPasswordUserStart,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.unauth.RegistrationStartRequest} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.unauth.RegistrationStartResponse>}
  *     Promise that resolves to the response
  */
 proto.identity.unauth.IdentityClientServicePromiseClient.prototype.registerPasswordUserStart =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/RegisterPasswordUserStart',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_RegisterPasswordUserStart);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.unauth.ReservedRegistrationStartRequest,
  *   !proto.identity.unauth.RegistrationStartResponse>}
  */
 const methodDescriptor_IdentityClientService_RegisterReservedPasswordUserStart = new grpc.web.MethodDescriptor(
   '/identity.unauth.IdentityClientService/RegisterReservedPasswordUserStart',
   grpc.web.MethodType.UNARY,
   proto.identity.unauth.ReservedRegistrationStartRequest,
   proto.identity.unauth.RegistrationStartResponse,
   /**
    * @param {!proto.identity.unauth.ReservedRegistrationStartRequest} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   proto.identity.unauth.RegistrationStartResponse.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.unauth.ReservedRegistrationStartRequest} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.unauth.RegistrationStartResponse)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.unauth.RegistrationStartResponse>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.unauth.IdentityClientServiceClient.prototype.registerReservedPasswordUserStart =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/RegisterReservedPasswordUserStart',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_RegisterReservedPasswordUserStart,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.unauth.ReservedRegistrationStartRequest} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.unauth.RegistrationStartResponse>}
  *     Promise that resolves to the response
  */
 proto.identity.unauth.IdentityClientServicePromiseClient.prototype.registerReservedPasswordUserStart =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/RegisterReservedPasswordUserStart',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_RegisterReservedPasswordUserStart);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.unauth.RegistrationFinishRequest,
  *   !proto.identity.unauth.AuthResponse>}
  */
 const methodDescriptor_IdentityClientService_RegisterPasswordUserFinish = new grpc.web.MethodDescriptor(
   '/identity.unauth.IdentityClientService/RegisterPasswordUserFinish',
   grpc.web.MethodType.UNARY,
   proto.identity.unauth.RegistrationFinishRequest,
   proto.identity.unauth.AuthResponse,
   /**
    * @param {!proto.identity.unauth.RegistrationFinishRequest} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   proto.identity.unauth.AuthResponse.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.unauth.RegistrationFinishRequest} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.unauth.AuthResponse)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.unauth.AuthResponse>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.unauth.IdentityClientServiceClient.prototype.registerPasswordUserFinish =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/RegisterPasswordUserFinish',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_RegisterPasswordUserFinish,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.unauth.RegistrationFinishRequest} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.unauth.AuthResponse>}
  *     Promise that resolves to the response
  */
 proto.identity.unauth.IdentityClientServicePromiseClient.prototype.registerPasswordUserFinish =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/RegisterPasswordUserFinish',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_RegisterPasswordUserFinish);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.unauth.OpaqueLoginStartRequest,
  *   !proto.identity.unauth.OpaqueLoginStartResponse>}
  */
 const methodDescriptor_IdentityClientService_LogInPasswordUserStart = new grpc.web.MethodDescriptor(
   '/identity.unauth.IdentityClientService/LogInPasswordUserStart',
   grpc.web.MethodType.UNARY,
   proto.identity.unauth.OpaqueLoginStartRequest,
   proto.identity.unauth.OpaqueLoginStartResponse,
   /**
    * @param {!proto.identity.unauth.OpaqueLoginStartRequest} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   proto.identity.unauth.OpaqueLoginStartResponse.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.unauth.OpaqueLoginStartRequest} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.unauth.OpaqueLoginStartResponse)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.unauth.OpaqueLoginStartResponse>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.unauth.IdentityClientServiceClient.prototype.logInPasswordUserStart =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/LogInPasswordUserStart',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_LogInPasswordUserStart,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.unauth.OpaqueLoginStartRequest} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.unauth.OpaqueLoginStartResponse>}
  *     Promise that resolves to the response
  */
 proto.identity.unauth.IdentityClientServicePromiseClient.prototype.logInPasswordUserStart =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/LogInPasswordUserStart',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_LogInPasswordUserStart);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.unauth.OpaqueLoginFinishRequest,
  *   !proto.identity.unauth.AuthResponse>}
  */
 const methodDescriptor_IdentityClientService_LogInPasswordUserFinish = new grpc.web.MethodDescriptor(
   '/identity.unauth.IdentityClientService/LogInPasswordUserFinish',
   grpc.web.MethodType.UNARY,
   proto.identity.unauth.OpaqueLoginFinishRequest,
   proto.identity.unauth.AuthResponse,
   /**
    * @param {!proto.identity.unauth.OpaqueLoginFinishRequest} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   proto.identity.unauth.AuthResponse.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.unauth.OpaqueLoginFinishRequest} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.unauth.AuthResponse)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.unauth.AuthResponse>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.unauth.IdentityClientServiceClient.prototype.logInPasswordUserFinish =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/LogInPasswordUserFinish',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_LogInPasswordUserFinish,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.unauth.OpaqueLoginFinishRequest} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.unauth.AuthResponse>}
  *     Promise that resolves to the response
  */
 proto.identity.unauth.IdentityClientServicePromiseClient.prototype.logInPasswordUserFinish =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/LogInPasswordUserFinish',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_LogInPasswordUserFinish);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.unauth.WalletAuthRequest,
  *   !proto.identity.unauth.AuthResponse>}
  */
 const methodDescriptor_IdentityClientService_LogInWalletUser = new grpc.web.MethodDescriptor(
   '/identity.unauth.IdentityClientService/LogInWalletUser',
   grpc.web.MethodType.UNARY,
   proto.identity.unauth.WalletAuthRequest,
   proto.identity.unauth.AuthResponse,
   /**
    * @param {!proto.identity.unauth.WalletAuthRequest} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   proto.identity.unauth.AuthResponse.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.unauth.WalletAuthRequest} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.unauth.AuthResponse)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.unauth.AuthResponse>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.unauth.IdentityClientServiceClient.prototype.logInWalletUser =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/LogInWalletUser',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_LogInWalletUser,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.unauth.WalletAuthRequest} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.unauth.AuthResponse>}
  *     Promise that resolves to the response
  */
 proto.identity.unauth.IdentityClientServicePromiseClient.prototype.logInWalletUser =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/LogInWalletUser',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_LogInWalletUser);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.unauth.WalletAuthRequest,
  *   !proto.identity.unauth.AuthResponse>}
  */
 const methodDescriptor_IdentityClientService_RegisterWalletUser = new grpc.web.MethodDescriptor(
   '/identity.unauth.IdentityClientService/RegisterWalletUser',
   grpc.web.MethodType.UNARY,
   proto.identity.unauth.WalletAuthRequest,
   proto.identity.unauth.AuthResponse,
   /**
    * @param {!proto.identity.unauth.WalletAuthRequest} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   proto.identity.unauth.AuthResponse.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.unauth.WalletAuthRequest} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.unauth.AuthResponse)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.unauth.AuthResponse>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.unauth.IdentityClientServiceClient.prototype.registerWalletUser =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/RegisterWalletUser',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_RegisterWalletUser,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.unauth.WalletAuthRequest} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.unauth.AuthResponse>}
  *     Promise that resolves to the response
  */
 proto.identity.unauth.IdentityClientServicePromiseClient.prototype.registerWalletUser =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/RegisterWalletUser',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_RegisterWalletUser);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.unauth.ReservedWalletRegistrationRequest,
  *   !proto.identity.unauth.AuthResponse>}
  */
 const methodDescriptor_IdentityClientService_RegisterReservedWalletUser = new grpc.web.MethodDescriptor(
   '/identity.unauth.IdentityClientService/RegisterReservedWalletUser',
   grpc.web.MethodType.UNARY,
   proto.identity.unauth.ReservedWalletRegistrationRequest,
   proto.identity.unauth.AuthResponse,
   /**
    * @param {!proto.identity.unauth.ReservedWalletRegistrationRequest} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   proto.identity.unauth.AuthResponse.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.unauth.ReservedWalletRegistrationRequest} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.unauth.AuthResponse)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.unauth.AuthResponse>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.unauth.IdentityClientServiceClient.prototype.registerReservedWalletUser =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/RegisterReservedWalletUser',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_RegisterReservedWalletUser,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.unauth.ReservedWalletRegistrationRequest} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.unauth.AuthResponse>}
  *     Promise that resolves to the response
  */
 proto.identity.unauth.IdentityClientServicePromiseClient.prototype.registerReservedWalletUser =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/RegisterReservedWalletUser',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_RegisterReservedWalletUser);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.unauth.SecondaryDeviceKeysUploadRequest,
  *   !proto.identity.unauth.AuthResponse>}
  */
 const methodDescriptor_IdentityClientService_UploadKeysForRegisteredDeviceAndLogIn = new grpc.web.MethodDescriptor(
   '/identity.unauth.IdentityClientService/UploadKeysForRegisteredDeviceAndLogIn',
   grpc.web.MethodType.UNARY,
   proto.identity.unauth.SecondaryDeviceKeysUploadRequest,
   proto.identity.unauth.AuthResponse,
   /**
    * @param {!proto.identity.unauth.SecondaryDeviceKeysUploadRequest} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   proto.identity.unauth.AuthResponse.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.unauth.SecondaryDeviceKeysUploadRequest} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.unauth.AuthResponse)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.unauth.AuthResponse>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.unauth.IdentityClientServiceClient.prototype.uploadKeysForRegisteredDeviceAndLogIn =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/UploadKeysForRegisteredDeviceAndLogIn',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_UploadKeysForRegisteredDeviceAndLogIn,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.unauth.SecondaryDeviceKeysUploadRequest} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.unauth.AuthResponse>}
  *     Promise that resolves to the response
  */
 proto.identity.unauth.IdentityClientServicePromiseClient.prototype.uploadKeysForRegisteredDeviceAndLogIn =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/UploadKeysForRegisteredDeviceAndLogIn',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_UploadKeysForRegisteredDeviceAndLogIn);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.unauth.Empty,
  *   !proto.identity.unauth.GenerateNonceResponse>}
  */
 const methodDescriptor_IdentityClientService_GenerateNonce = new grpc.web.MethodDescriptor(
   '/identity.unauth.IdentityClientService/GenerateNonce',
   grpc.web.MethodType.UNARY,
   proto.identity.unauth.Empty,
   proto.identity.unauth.GenerateNonceResponse,
   /**
    * @param {!proto.identity.unauth.Empty} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   proto.identity.unauth.GenerateNonceResponse.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.unauth.Empty} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.unauth.GenerateNonceResponse)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.unauth.GenerateNonceResponse>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.unauth.IdentityClientServiceClient.prototype.generateNonce =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/GenerateNonce',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_GenerateNonce,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.unauth.Empty} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.unauth.GenerateNonceResponse>}
  *     Promise that resolves to the response
  */
 proto.identity.unauth.IdentityClientServicePromiseClient.prototype.generateNonce =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/GenerateNonce',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_GenerateNonce);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.unauth.VerifyUserAccessTokenRequest,
  *   !proto.identity.unauth.VerifyUserAccessTokenResponse>}
  */
 const methodDescriptor_IdentityClientService_VerifyUserAccessToken = new grpc.web.MethodDescriptor(
   '/identity.unauth.IdentityClientService/VerifyUserAccessToken',
   grpc.web.MethodType.UNARY,
   proto.identity.unauth.VerifyUserAccessTokenRequest,
   proto.identity.unauth.VerifyUserAccessTokenResponse,
   /**
    * @param {!proto.identity.unauth.VerifyUserAccessTokenRequest} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   proto.identity.unauth.VerifyUserAccessTokenResponse.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.unauth.VerifyUserAccessTokenRequest} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.unauth.VerifyUserAccessTokenResponse)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.unauth.VerifyUserAccessTokenResponse>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.unauth.IdentityClientServiceClient.prototype.verifyUserAccessToken =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/VerifyUserAccessToken',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_VerifyUserAccessToken,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.unauth.VerifyUserAccessTokenRequest} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.unauth.VerifyUserAccessTokenResponse>}
  *     Promise that resolves to the response
  */
 proto.identity.unauth.IdentityClientServicePromiseClient.prototype.verifyUserAccessToken =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/VerifyUserAccessToken',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_VerifyUserAccessToken);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.unauth.AddReservedUsernamesRequest,
  *   !proto.identity.unauth.Empty>}
  */
 const methodDescriptor_IdentityClientService_AddReservedUsernames = new grpc.web.MethodDescriptor(
   '/identity.unauth.IdentityClientService/AddReservedUsernames',
   grpc.web.MethodType.UNARY,
   proto.identity.unauth.AddReservedUsernamesRequest,
   proto.identity.unauth.Empty,
   /**
    * @param {!proto.identity.unauth.AddReservedUsernamesRequest} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   proto.identity.unauth.Empty.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.unauth.AddReservedUsernamesRequest} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.unauth.Empty)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.unauth.Empty>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.unauth.IdentityClientServiceClient.prototype.addReservedUsernames =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/AddReservedUsernames',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_AddReservedUsernames,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.unauth.AddReservedUsernamesRequest} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.unauth.Empty>}
  *     Promise that resolves to the response
  */
 proto.identity.unauth.IdentityClientServicePromiseClient.prototype.addReservedUsernames =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/AddReservedUsernames',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_AddReservedUsernames);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.unauth.RemoveReservedUsernameRequest,
  *   !proto.identity.unauth.Empty>}
  */
 const methodDescriptor_IdentityClientService_RemoveReservedUsername = new grpc.web.MethodDescriptor(
   '/identity.unauth.IdentityClientService/RemoveReservedUsername',
   grpc.web.MethodType.UNARY,
   proto.identity.unauth.RemoveReservedUsernameRequest,
   proto.identity.unauth.Empty,
   /**
    * @param {!proto.identity.unauth.RemoveReservedUsernameRequest} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   proto.identity.unauth.Empty.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.unauth.RemoveReservedUsernameRequest} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.unauth.Empty)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.unauth.Empty>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.unauth.IdentityClientServiceClient.prototype.removeReservedUsername =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/RemoveReservedUsername',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_RemoveReservedUsername,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.unauth.RemoveReservedUsernameRequest} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.unauth.Empty>}
  *     Promise that resolves to the response
  */
 proto.identity.unauth.IdentityClientServicePromiseClient.prototype.removeReservedUsername =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/RemoveReservedUsername',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_RemoveReservedUsername);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.unauth.Empty,
  *   !proto.identity.unauth.Empty>}
  */
 const methodDescriptor_IdentityClientService_Ping = new grpc.web.MethodDescriptor(
   '/identity.unauth.IdentityClientService/Ping',
   grpc.web.MethodType.UNARY,
   proto.identity.unauth.Empty,
   proto.identity.unauth.Empty,
   /**
    * @param {!proto.identity.unauth.Empty} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   proto.identity.unauth.Empty.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.unauth.Empty} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.unauth.Empty)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.unauth.Empty>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.unauth.IdentityClientServiceClient.prototype.ping =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/Ping',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_Ping,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.unauth.Empty} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.unauth.Empty>}
  *     Promise that resolves to the response
  */
 proto.identity.unauth.IdentityClientServicePromiseClient.prototype.ping =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/Ping',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_Ping);
 };
 
 
 /**
  * @const
  * @type {!grpc.web.MethodDescriptor<
  *   !proto.identity.unauth.FindUserIDRequest,
  *   !proto.identity.unauth.FindUserIDResponse>}
  */
 const methodDescriptor_IdentityClientService_FindUserID = new grpc.web.MethodDescriptor(
   '/identity.unauth.IdentityClientService/FindUserID',
   grpc.web.MethodType.UNARY,
   proto.identity.unauth.FindUserIDRequest,
   proto.identity.unauth.FindUserIDResponse,
   /**
    * @param {!proto.identity.unauth.FindUserIDRequest} request
    * @return {!Uint8Array}
    */
   function(request) {
     return request.serializeBinary();
   },
   proto.identity.unauth.FindUserIDResponse.deserializeBinary
 );
 
 
 /**
  * @param {!proto.identity.unauth.FindUserIDRequest} request The
  *     request proto
  * @param {?Object<string, string>} metadata User defined
  *     call metadata
  * @param {function(?grpc.web.RpcError, ?proto.identity.unauth.FindUserIDResponse)}
  *     callback The callback function(error, response)
  * @return {!grpc.web.ClientReadableStream<!proto.identity.unauth.FindUserIDResponse>|undefined}
  *     The XHR Node Readable Stream
  */
 proto.identity.unauth.IdentityClientServiceClient.prototype.findUserID =
     function(request, metadata, callback) {
   return this.client_.rpcCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/FindUserID',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_FindUserID,
       callback);
 };
 
 
 /**
  * @param {!proto.identity.unauth.FindUserIDRequest} request The
  *     request proto
  * @param {?Object<string, string>=} metadata User defined
  *     call metadata
  * @return {!Promise<!proto.identity.unauth.FindUserIDResponse>}
  *     Promise that resolves to the response
  */
 proto.identity.unauth.IdentityClientServicePromiseClient.prototype.findUserID =
     function(request, metadata) {
   return this.client_.unaryCall(this.hostname_ +
       '/identity.unauth.IdentityClientService/FindUserID',
       request,
       metadata || {},
       methodDescriptor_IdentityClientService_FindUserID);
 };
 
 
-module.exports = proto.identity.unauth;
+/**
+ * @const
+ * @type {!grpc.web.MethodDescriptor<
+ *   !proto.identity.unauth.GetFarcasterUsersRequest,
+ *   !proto.identity.unauth.GetFarcasterUsersResponse>}
+ */
+const methodDescriptor_IdentityClientService_GetFarcasterUsers = new grpc.web.MethodDescriptor(
+  '/identity.unauth.IdentityClientService/GetFarcasterUsers',
+  grpc.web.MethodType.UNARY,
+  proto.identity.unauth.GetFarcasterUsersRequest,
+  proto.identity.unauth.GetFarcasterUsersResponse,
+  /**
+   * @param {!proto.identity.unauth.GetFarcasterUsersRequest} request
+   * @return {!Uint8Array}
+   */
+  function(request) {
+    return request.serializeBinary();
+  },
+  proto.identity.unauth.GetFarcasterUsersResponse.deserializeBinary
+);
+
 
+/**
+ * @param {!proto.identity.unauth.GetFarcasterUsersRequest} request The
+ *     request proto
+ * @param {?Object<string, string>} metadata User defined
+ *     call metadata
+ * @param {function(?grpc.web.RpcError, ?proto.identity.unauth.GetFarcasterUsersResponse)}
+ *     callback The callback function(error, response)
+ * @return {!grpc.web.ClientReadableStream<!proto.identity.unauth.GetFarcasterUsersResponse>|undefined}
+ *     The XHR Node Readable Stream
+ */
+proto.identity.unauth.IdentityClientServiceClient.prototype.getFarcasterUsers =
+    function(request, metadata, callback) {
+  return this.client_.rpcCall(this.hostname_ +
+      '/identity.unauth.IdentityClientService/GetFarcasterUsers',
+      request,
+      metadata || {},
+      methodDescriptor_IdentityClientService_GetFarcasterUsers,
+      callback);
+};
+
+
+/**
+ * @param {!proto.identity.unauth.GetFarcasterUsersRequest} request The
+ *     request proto
+ * @param {?Object<string, string>=} metadata User defined
+ *     call metadata
+ * @return {!Promise<!proto.identity.unauth.GetFarcasterUsersResponse>}
+ *     Promise that resolves to the response
+ */
+proto.identity.unauth.IdentityClientServicePromiseClient.prototype.getFarcasterUsers =
+    function(request, metadata) {
+  return this.client_.unaryCall(this.hostname_ +
+      '/identity.unauth.IdentityClientService/GetFarcasterUsers',
+      request,
+      metadata || {},
+      methodDescriptor_IdentityClientService_GetFarcasterUsers);
+};
+
+
+module.exports = proto.identity.unauth;
diff --git a/web/protobufs/identity-unauth.cjs.flow b/web/protobufs/identity-unauth.cjs.flow
index f211951af..6b369aeee 100644
--- a/web/protobufs/identity-unauth.cjs.flow
+++ b/web/protobufs/identity-unauth.cjs.flow
@@ -1,198 +1,210 @@
 // @flow
 
 import * as grpcWeb from 'grpc-web';
 
 import * as identityStructs from './identity-unauth-structs.cjs';
 
 declare export class IdentityClientServiceClient {
   constructor (hostname: string,
                credentials?: null | { +[index: string]: string },
                options?: null | { +[index: string]: any }): void;
 
   registerPasswordUserStart(
     request: identityStructs.RegistrationStartRequest,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityStructs.RegistrationStartResponse) => void
   ): grpcWeb.ClientReadableStream<identityStructs.RegistrationStartResponse>;
 
   registerReservedPasswordUserStart(
     request: identityStructs.ReservedRegistrationStartRequest,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityStructs.RegistrationStartResponse) => void
   ): grpcWeb.ClientReadableStream<identityStructs.RegistrationStartResponse>;
 
   registerPasswordUserFinish(
     request: identityStructs.RegistrationFinishRequest,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityStructs.AuthResponse) => void
   ): grpcWeb.ClientReadableStream<identityStructs.AuthResponse>;
 
   logInPasswordUserStart(
     request: identityStructs.OpaqueLoginStartRequest,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityStructs.OpaqueLoginStartResponse) => void
   ): grpcWeb.ClientReadableStream<identityStructs.OpaqueLoginStartResponse>;
 
   logInPasswordUserFinish(
     request: identityStructs.OpaqueLoginFinishRequest,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityStructs.AuthResponse) => void
   ): grpcWeb.ClientReadableStream<identityStructs.AuthResponse>;
 
   logInWalletUser(
     request: identityStructs.WalletAuthRequest,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityStructs.AuthResponse) => void
   ): grpcWeb.ClientReadableStream<identityStructs.AuthResponse>;
 
   registerWalletUser(
     request: identityStructs.WalletAuthRequest,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityStructs.AuthResponse) => void
   ): grpcWeb.ClientReadableStream<identityStructs.AuthResponse>;
 
   registerReservedWalletUser(
     request: identityStructs.ReservedWalletRegistrationRequest,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityStructs.AuthResponse) => void
   ): grpcWeb.ClientReadableStream<identityStructs.AuthResponse>;
 
   uploadKeysForRegisteredDeviceAndLogIn(
     request: identityStructs.SecondaryDeviceKeysUploadRequest,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityStructs.AuthResponse) => void
   ): grpcWeb.ClientReadableStream<identityStructs.AuthResponse>;
 
   generateNonce(
     request: identityStructs.Empty,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityStructs.GenerateNonceResponse) => void
   ): grpcWeb.ClientReadableStream<identityStructs.GenerateNonceResponse>;
 
   verifyUserAccessToken(
     request: identityStructs.VerifyUserAccessTokenRequest,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityStructs.VerifyUserAccessTokenResponse) => void
   ): grpcWeb.ClientReadableStream<identityStructs.VerifyUserAccessTokenResponse>;
 
   addReservedUsernames(
     request: identityStructs.AddReservedUsernamesRequest,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityStructs.Empty) => void
   ): grpcWeb.ClientReadableStream<identityStructs.Empty>;
 
   removeReservedUsername(
     request: identityStructs.RemoveReservedUsernameRequest,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityStructs.Empty) => void
   ): grpcWeb.ClientReadableStream<identityStructs.Empty>;
 
   ping(
     request: identityStructs.Empty,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityStructs.Empty) => void
   ): grpcWeb.ClientReadableStream<identityStructs.Empty>;
 
   findUserID(
     request: identityStructs.FindUserIDRequest,
     metadata: grpcWeb.Metadata | void,
     callback: (err: grpcWeb.RpcError,
                response: identityStructs.FindUserIDResponse) => void
   ): grpcWeb.ClientReadableStream<identityStructs.FindUserIDResponse>;
 
+  getFarcasterUsers(
+    request: identityStructs.GetFarcasterUsersRequest,
+    metadata: grpcWeb.Metadata | void,
+    callback: (err: grpcWeb.RpcError,
+               response: identityStructs.GetFarcasterUsersResponse) => void
+  ): grpcWeb.ClientReadableStream<identityStructs.GetFarcasterUsersResponse>;
+
 }
 
 declare export class IdentityClientServicePromiseClient {
   constructor (hostname: string,
                credentials?: null | { +[index: string]: string },
                options?: null | { +[index: string]: any }): void;
 
   registerPasswordUserStart(
     request: identityStructs.RegistrationStartRequest,
     metadata?: grpcWeb.Metadata
   ): Promise<identityStructs.RegistrationStartResponse>;
 
   registerReservedPasswordUserStart(
     request: identityStructs.ReservedRegistrationStartRequest,
     metadata?: grpcWeb.Metadata
   ): Promise<identityStructs.RegistrationStartResponse>;
 registerPasswordUserFinish(
     request: identityStructs.RegistrationFinishRequest,
     metadata?: grpcWeb.Metadata
   ): Promise<identityStructs.AuthResponse>;
 
   logInPasswordUserStart(
     request: identityStructs.OpaqueLoginStartRequest,
     metadata?: grpcWeb.Metadata
   ): Promise<identityStructs.OpaqueLoginStartResponse>;
 
   logInPasswordUserFinish(
     request: identityStructs.OpaqueLoginFinishRequest,
     metadata?: grpcWeb.Metadata
   ): Promise<identityStructs.AuthResponse>;
 
   logInWalletUser(
     request: identityStructs.WalletAuthRequest,
     metadata?: grpcWeb.Metadata
   ): Promise<identityStructs.AuthResponse>;
 
   registerWalletUser(
     request: identityStructs.WalletAuthRequest,
     metadata?: grpcWeb.Metadata
   ): Promise<identityStructs.AuthResponse>;
 
   registerReservedWalletUser(
     request: identityStructs.ReservedWalletRegistrationRequest,
     metadata?: grpcWeb.Metadata
   ): Promise<identityStructs.AuthResponse>;
 
   uploadKeysForRegisteredDeviceAndLogIn(
     request: identityStructs.SecondaryDeviceKeysUploadRequest,
     metadata?: grpcWeb.Metadata
   ): Promise<identityStructs.AuthResponse>;
 
   generateNonce(
     request: identityStructs.Empty,
     metadata?: grpcWeb.Metadata
   ): Promise<identityStructs.GenerateNonceResponse>;
 
   verifyUserAccessToken(
     request: identityStructs.VerifyUserAccessTokenRequest,
     metadata?: grpcWeb.Metadata
   ): Promise<identityStructs.VerifyUserAccessTokenResponse>;
 
   addReservedUsernames(
     request: identityStructs.AddReservedUsernamesRequest,
     metadata?: grpcWeb.Metadata
   ): Promise<identityStructs.Empty>;
 
   removeReservedUsername(
     request: identityStructs.RemoveReservedUsernameRequest,
     metadata?: grpcWeb.Metadata
   ): Promise<identityStructs.Empty>;
 
   ping(
     request: identityStructs.Empty,
     metadata?: grpcWeb.Metadata
   ): Promise<identityStructs.Empty>;
 
   findUserID(
     request: identityStructs.FindUserIDRequest,
     metadata?: grpcWeb.Metadata
   ): Promise<identityStructs.FindUserIDResponse>;
 
+  getFarcasterUsers(
+    request: identityStructs.GetFarcasterUsersRequest,
+    metadata?: grpcWeb.Metadata
+  ): Promise<identityStructs.GetFarcasterUsersResponse>;
+
 }