diff --git a/lib/types/identity-service-types.js b/lib/types/identity-service-types.js
index 3c60015c5..cf75ac0f9 100644
--- a/lib/types/identity-service-types.js
+++ b/lib/types/identity-service-types.js
@@ -1,245 +1,241 @@
 // @flow
 
 import t, { type TInterface, type TList } from 'tcomb';
 
 import {
   identityKeysBlobValidator,
   type IdentityKeysBlob,
   signedPrekeysValidator,
   type SignedPrekeys,
   type OneTimeKeysResultValues,
 } from './crypto-types.js';
 import {
   type OlmSessionInitializationInfo,
   olmSessionInitializationInfoValidator,
 } from './request-types.js';
 import {
   currentUserInfoValidator,
   type CurrentUserInfo,
 } from './user-types.js';
 import { tShape } from '../utils/validation-utils.js';
 
 export type UserAuthMetadata = {
   +userID: string,
   +accessToken: string,
 };
 
 // This type should not be altered without also updating OutboundKeyInfoResponse
 // in native/native_rust_library/src/identity/x3dh.rs
 export type OutboundKeyInfoResponse = {
   +payload: string,
   +payloadSignature: string,
   +contentPrekey: string,
   +contentPrekeySignature: string,
   +notifPrekey: string,
   +notifPrekeySignature: string,
   +oneTimeContentPrekey: ?string,
   +oneTimeNotifPrekey: ?string,
 };
 
 // This type should not be altered without also updating InboundKeyInfoResponse
 // in native/native_rust_library/src/identity/x3dh.rs
 export type InboundKeyInfoResponse = {
   +payload: string,
   +payloadSignature: string,
   +contentPrekey: string,
   +contentPrekeySignature: string,
   +notifPrekey: string,
   +notifPrekeySignature: string,
   +username?: ?string,
   +walletAddress?: ?string,
 };
 
 export type DeviceOlmOutboundKeys = {
   +identityKeysBlob: IdentityKeysBlob,
   +contentInitializationInfo: OlmSessionInitializationInfo,
   +notifInitializationInfo: OlmSessionInitializationInfo,
   +payloadSignature: string,
 };
 export const deviceOlmOutboundKeysValidator: TInterface<DeviceOlmOutboundKeys> =
   tShape<DeviceOlmOutboundKeys>({
     identityKeysBlob: identityKeysBlobValidator,
     contentInitializationInfo: olmSessionInitializationInfoValidator,
     notifInitializationInfo: olmSessionInitializationInfoValidator,
     payloadSignature: t.String,
   });
 
 export type UserDevicesOlmOutboundKeys = {
   +deviceID: string,
   +keys: ?DeviceOlmOutboundKeys,
 };
 
 export type DeviceOlmInboundKeys = {
   +identityKeysBlob: IdentityKeysBlob,
   +signedPrekeys: SignedPrekeys,
   +payloadSignature: string,
 };
 export const deviceOlmInboundKeysValidator: TInterface<DeviceOlmInboundKeys> =
   tShape<DeviceOlmInboundKeys>({
     identityKeysBlob: identityKeysBlobValidator,
     signedPrekeys: signedPrekeysValidator,
     payloadSignature: t.String,
   });
 
 export type UserDevicesOlmInboundKeys = {
   +keys: {
     +[deviceID: string]: ?DeviceOlmInboundKeys,
   },
   +username?: ?string,
   +walletAddress?: ?string,
 };
 
 // This type should not be altered without also updating FarcasterUser in
 // keyserver/addons/rust-node-addon/src/identity_client/get_farcaster_users.rs
 export type FarcasterUser = {
   +userID: string,
   +username: string,
   +farcasterID: string,
 };
 
 export const farcasterUserValidator: TInterface<FarcasterUser> =
   tShape<FarcasterUser>({
     userID: t.String,
     username: t.String,
     farcasterID: t.String,
   });
 
 export const farcasterUsersValidator: TList<Array<FarcasterUser>> = t.list(
   farcasterUserValidator,
 );
 
 export const userDeviceOlmInboundKeysValidator: TInterface<UserDevicesOlmInboundKeys> =
   tShape<UserDevicesOlmInboundKeys>({
     keys: t.dict(t.String, t.maybe(deviceOlmInboundKeysValidator)),
     username: t.maybe(t.String),
     walletAddress: t.maybe(t.String),
   });
 
 export interface IdentityServiceClient {
   +deleteUser: () => Promise<void>;
   +logOut: () => Promise<void>;
   +getKeyserverKeys: string => Promise<DeviceOlmOutboundKeys>;
   +registerPasswordUser?: (
     username: string,
     password: string,
   ) => Promise<IdentityAuthResult>;
   +logInPasswordUser: (
     username: string,
     password: string,
   ) => Promise<IdentityAuthResult>;
   +getOutboundKeysForUser: (
     userID: string,
   ) => Promise<UserDevicesOlmOutboundKeys[]>;
   +getInboundKeysForUser: (
     userID: string,
   ) => Promise<UserDevicesOlmInboundKeys>;
   +uploadOneTimeKeys: (oneTimeKeys: OneTimeKeysResultValues) => Promise<void>;
   +generateNonce: () => Promise<string>;
   +registerWalletUser?: (
     walletAddress: string,
     siweMessage: string,
     siweSignature: string,
   ) => Promise<IdentityAuthResult>;
   +logInWalletUser: (
     walletAddress: string,
     siweMessage: string,
     siweSignature: string,
   ) => Promise<IdentityAuthResult>;
   // on native, publishing prekeys to Identity is called directly from C++,
   // there is no need to expose it to JS
   +publishWebPrekeys?: (prekeys: SignedPrekeys) => Promise<void>;
   +getDeviceListHistoryForUser: (
     userID: string,
     sinceTimestamp?: number,
   ) => Promise<$ReadOnlyArray<SignedDeviceList>>;
   // updating device list is possible only on Native
   // web cannot be a primary device, so there's no need to expose it to JS
   +updateDeviceList?: (newDeviceList: SignedDeviceList) => Promise<void>;
   +uploadKeysForRegisteredDeviceAndLogIn: (
     userID: string,
-    nonceChallengeResponse: SignedMessage,
+    signedNonce: SignedNonce,
   ) => Promise<IdentityAuthResult>;
   +getFarcasterUsers: (
     farcasterIDs: $ReadOnlyArray<string>,
   ) => Promise<$ReadOnlyArray<FarcasterUser>>;
   +linkFarcasterAccount: (farcasterID: string) => Promise<void>;
   +unlinkFarcasterAccount: () => Promise<void>;
 }
 
 export type IdentityServiceAuthLayer = {
   +userID: string,
   +deviceID: string,
   +commServicesAccessToken: string,
 };
 
 export type IdentityAuthResult = {
   +userID: string,
   +accessToken: string,
   +username: string,
   +preRequestUserState?: ?CurrentUserInfo,
 };
 export const identityAuthResultValidator: TInterface<IdentityAuthResult> =
   tShape<IdentityAuthResult>({
     userID: t.String,
     accessToken: t.String,
     username: t.String,
     preRequestUserState: t.maybe(currentUserInfoValidator),
   });
 
 export type IdentityNewDeviceKeyUpload = {
   +keyPayload: string,
   +keyPayloadSignature: string,
   +contentPrekey: string,
   +contentPrekeySignature: string,
   +notifPrekey: string,
   +notifPrekeySignature: string,
   +contentOneTimeKeys: $ReadOnlyArray<string>,
   +notifOneTimeKeys: $ReadOnlyArray<string>,
 };
 
 export type IdentityExistingDeviceKeyUpload = {
   +keyPayload: string,
   +keyPayloadSignature: string,
   +contentPrekey: string,
   +contentPrekeySignature: string,
   +notifPrekey: string,
   +notifPrekeySignature: string,
 };
 
 // Device list types
 
 export type RawDeviceList = {
   +devices: $ReadOnlyArray<string>,
   +timestamp: number,
 };
 
 export type SignedDeviceList = {
   // JSON-stringified RawDeviceList
   +rawDeviceList: string,
 };
 export const signedDeviceListValidator: TInterface<SignedDeviceList> =
   tShape<SignedDeviceList>({
     rawDeviceList: t.String,
   });
 export const signedDeviceListHistoryValidator: TList<Array<SignedDeviceList>> =
   t.list(signedDeviceListValidator);
 
-export type NonceChallenge = {
+export type SignedNonce = {
   +nonce: string,
-};
-
-export type SignedMessage = {
-  +message: string,
-  +signature: string,
+  +nonceSignature: string,
 };
 
 export const ONE_TIME_KEYS_NUMBER = 10;
 
 export const identityDeviceTypes = Object.freeze({
   KEYSERVER: 0,
   WEB: 1,
   IOS: 2,
   ANDROID: 3,
   WINDOWS: 4,
   MAC_OS: 5,
 });
diff --git a/native/cpp/CommonCpp/NativeModules/CommRustModule.cpp b/native/cpp/CommonCpp/NativeModules/CommRustModule.cpp
index 28f052ca1..9210990b1 100644
--- a/native/cpp/CommonCpp/NativeModules/CommRustModule.cpp
+++ b/native/cpp/CommonCpp/NativeModules/CommRustModule.cpp
@@ -1,747 +1,756 @@
 #include "CommRustModule.h"
 #include "InternalModules/RustPromiseManager.h"
 #include "JSIRust.h"
 #include "lib.rs.h"
 
 #include <ReactCommon/TurboModuleUtils.h>
 
 namespace comm {
 
 using namespace facebook::react;
 
 CommRustModule::CommRustModule(std::shared_ptr<CallInvoker> jsInvoker)
     : CommRustModuleSchemaCxxSpecJSI(jsInvoker) {
 }
 
 jsi::Value CommRustModule::generateNonce(jsi::Runtime &rt) {
   return createPromiseAsJSIValue(
       rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityGenerateNonce(currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::registerPasswordUser(
     jsi::Runtime &rt,
     jsi::String username,
     jsi::String password,
     jsi::String keyPayload,
     jsi::String keyPayloadSignature,
     jsi::String contentPrekey,
     jsi::String contentPrekeySignature,
     jsi::String notifPrekey,
     jsi::String notifPrekeySignature,
     jsi::Array contentOneTimeKeys,
     jsi::Array notifOneTimeKeys,
     jsi::String farcasterID) {
   auto usernameRust = jsiStringToRustString(username, rt);
   auto passwordRust = jsiStringToRustString(password, rt);
   auto keyPayloadRust = jsiStringToRustString(keyPayload, rt);
   auto keyPayloadSignatureRust = jsiStringToRustString(keyPayloadSignature, rt);
   auto contentPrekeyRust = jsiStringToRustString(contentPrekey, rt);
   auto contentPrekeySignatureRust =
       jsiStringToRustString(contentPrekeySignature, rt);
   auto notifPrekeyRust = jsiStringToRustString(notifPrekey, rt);
   auto notifPrekeySignatureRust =
       jsiStringToRustString(notifPrekeySignature, rt);
   auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
   auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
   auto farcasterIDRust = jsiStringToRustString(farcasterID, rt);
 
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityRegisterPasswordUser(
               usernameRust,
               passwordRust,
               keyPayloadRust,
               keyPayloadSignatureRust,
               contentPrekeyRust,
               contentPrekeySignatureRust,
               notifPrekeyRust,
               notifPrekeySignatureRust,
               contentOneTimeKeysRust,
               notifOneTimeKeysRust,
               farcasterIDRust,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::logInPasswordUser(
     jsi::Runtime &rt,
     jsi::String username,
     jsi::String password,
     jsi::String keyPayload,
     jsi::String keyPayloadSignature,
     jsi::String contentPrekey,
     jsi::String contentPrekeySignature,
     jsi::String notifPrekey,
     jsi::String notifPrekeySignature) {
   auto usernameRust = jsiStringToRustString(username, rt);
   auto passwordRust = jsiStringToRustString(password, rt);
   auto keyPayloadRust = jsiStringToRustString(keyPayload, rt);
   auto keyPayloadSignatureRust = jsiStringToRustString(keyPayloadSignature, rt);
   auto contentPrekeyRust = jsiStringToRustString(contentPrekey, rt);
   auto contentPrekeySignatureRust =
       jsiStringToRustString(contentPrekeySignature, rt);
   auto notifPrekeyRust = jsiStringToRustString(notifPrekey, rt);
   auto notifPrekeySignatureRust =
       jsiStringToRustString(notifPrekeySignature, rt);
 
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityLogInPasswordUser(
               usernameRust,
               passwordRust,
               keyPayloadRust,
               keyPayloadSignatureRust,
               contentPrekeyRust,
               contentPrekeySignatureRust,
               notifPrekeyRust,
               notifPrekeySignatureRust,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::registerWalletUser(
     jsi::Runtime &rt,
     jsi::String siweMessage,
     jsi::String siweSignature,
     jsi::String keyPayload,
     jsi::String keyPayloadSignature,
     jsi::String contentPrekey,
     jsi::String contentPrekeySignature,
     jsi::String notifPrekey,
     jsi::String notifPrekeySignature,
     jsi::Array contentOneTimeKeys,
     jsi::Array notifOneTimeKeys,
     jsi::String farcasterID) {
   auto siweMessageRust = jsiStringToRustString(siweMessage, rt);
   auto siweSignatureRust = jsiStringToRustString(siweSignature, rt);
   auto keyPayloadRust = jsiStringToRustString(keyPayload, rt);
   auto keyPayloadSignatureRust = jsiStringToRustString(keyPayloadSignature, rt);
   auto contentPrekeyRust = jsiStringToRustString(contentPrekey, rt);
   auto contentPrekeySignatureRust =
       jsiStringToRustString(contentPrekeySignature, rt);
   auto notifPrekeyRust = jsiStringToRustString(notifPrekey, rt);
   auto notifPrekeySignatureRust =
       jsiStringToRustString(notifPrekeySignature, rt);
   auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
   auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
   auto farcasterIDRust = jsiStringToRustString(farcasterID, rt);
 
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityRegisterWalletUser(
               siweMessageRust,
               siweSignatureRust,
               keyPayloadRust,
               keyPayloadSignatureRust,
               contentPrekeyRust,
               contentPrekeySignatureRust,
               notifPrekeyRust,
               notifPrekeySignatureRust,
               contentOneTimeKeysRust,
               notifOneTimeKeysRust,
               farcasterIDRust,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::logInWalletUser(
     jsi::Runtime &rt,
     jsi::String siweMessage,
     jsi::String siweSignature,
     jsi::String keyPayload,
     jsi::String keyPayloadSignature,
     jsi::String contentPrekey,
     jsi::String contentPrekeySignature,
     jsi::String notifPrekey,
     jsi::String notifPrekeySignature) {
   auto siweMessageRust = jsiStringToRustString(siweMessage, rt);
   auto siweSignatureRust = jsiStringToRustString(siweSignature, rt);
   auto keyPayloadRust = jsiStringToRustString(keyPayload, rt);
   auto keyPayloadSignatureRust = jsiStringToRustString(keyPayloadSignature, rt);
   auto contentPrekeyRust = jsiStringToRustString(contentPrekey, rt);
   auto contentPrekeySignatureRust =
       jsiStringToRustString(contentPrekeySignature, rt);
   auto notifPrekeyRust = jsiStringToRustString(notifPrekey, rt);
   auto notifPrekeySignatureRust =
       jsiStringToRustString(notifPrekeySignature, rt);
 
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityLogInWalletUser(
               siweMessageRust,
               siweSignatureRust,
               keyPayloadRust,
               keyPayloadSignatureRust,
               contentPrekeyRust,
               contentPrekeySignatureRust,
               notifPrekeyRust,
               notifPrekeySignatureRust,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::updatePassword(
     jsi::Runtime &rt,
     jsi::String userID,
     jsi::String deviceID,
     jsi::String accessToken,
     jsi::String password) {
   auto userIDRust = jsiStringToRustString(userID, rt);
   auto deviceIDRust = jsiStringToRustString(deviceID, rt);
   auto accessTokenRust = jsiStringToRustString(accessToken, rt);
   auto passwordRust = jsiStringToRustString(password, rt);
 
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityUpdateUserPassword(
               userIDRust,
               deviceIDRust,
               accessTokenRust,
               passwordRust,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::deleteUser(
     jsi::Runtime &rt,
     jsi::String userID,
     jsi::String deviceID,
     jsi::String accessToken) {
   auto userIDRust = jsiStringToRustString(userID, rt);
   auto deviceIDRust = jsiStringToRustString(deviceID, rt);
   auto accessTokenRust = jsiStringToRustString(accessToken, rt);
 
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityDeleteUser(
               userIDRust, deviceIDRust, accessTokenRust, currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::logOut(
     jsi::Runtime &rt,
     jsi::String userID,
     jsi::String deviceID,
     jsi::String accessToken) {
   auto userIDRust = jsiStringToRustString(userID, rt);
   auto deviceIDRust = jsiStringToRustString(deviceID, rt);
   auto accessTokenRust = jsiStringToRustString(accessToken, rt);
 
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityLogOut(userIDRust, deviceIDRust, accessTokenRust, currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::getOutboundKeysForUser(
     jsi::Runtime &rt,
     jsi::String authUserID,
     jsi::String authDeviceID,
     jsi::String authAccessToken,
     jsi::String userID) {
   auto authUserIDRust = jsiStringToRustString(authUserID, rt);
   auto authDeviceIDRust = jsiStringToRustString(authDeviceID, rt);
   auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
   auto userIDRust = jsiStringToRustString(userID, rt);
 
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityGetOutboundKeysForUser(
               authUserIDRust,
               authDeviceIDRust,
               authAccessTokenRust,
               userIDRust,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::getInboundKeysForUser(
     jsi::Runtime &rt,
     jsi::String authUserID,
     jsi::String authDeviceID,
     jsi::String authAccessToken,
     jsi::String userID) {
   auto authUserIDRust = jsiStringToRustString(authUserID, rt);
   auto authDeviceIDRust = jsiStringToRustString(authDeviceID, rt);
   auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
   auto userIDRust = jsiStringToRustString(userID, rt);
 
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityGetInboundKeysForUser(
               authUserIDRust,
               authDeviceIDRust,
               authAccessTokenRust,
               userIDRust,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::versionSupported(jsi::Runtime &rt) {
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityVersionSupported(currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::uploadOneTimeKeys(
     jsi::Runtime &rt,
     jsi::String authUserID,
     jsi::String authDeviceID,
     jsi::String authAccessToken,
     jsi::Array contentOneTimePreKeys,
     jsi::Array notifOneTimePreKeys) {
   auto authUserIDRust = jsiStringToRustString(authUserID, rt);
   auto authDeviceIDRust = jsiStringToRustString(authDeviceID, rt);
   auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
   auto contentOneTimePreKeysRust =
       jsiStringArrayToRustVec(contentOneTimePreKeys, rt);
   auto notifOneTimePreKeysRust =
       jsiStringArrayToRustVec(notifOneTimePreKeys, rt);
 
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityUploadOneTimeKeys(
               authUserIDRust,
               authDeviceIDRust,
               authAccessTokenRust,
               contentOneTimePreKeysRust,
               notifOneTimePreKeysRust,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::getKeyserverKeys(
     jsi::Runtime &rt,
     jsi::String authUserID,
     jsi::String authDeviceID,
     jsi::String authAccessToken,
     jsi::String keyserverID) {
   auto authUserIDRust = jsiStringToRustString(authUserID, rt);
   auto authDeviceIDRust = jsiStringToRustString(authDeviceID, rt);
   auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
   auto keyserverIDRust = jsiStringToRustString(keyserverID, rt);
 
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityGetKeyserverKeys(
               authUserIDRust,
               authDeviceIDRust,
               authAccessTokenRust,
               keyserverIDRust,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::getDeviceListForUser(
     jsi::Runtime &rt,
     jsi::String authUserID,
     jsi::String authDeviceID,
     jsi::String authAccessToken,
     jsi::String userID,
     std::optional<double> sinceTimestamp) {
   auto authUserIDRust = jsiStringToRustString(authUserID, rt);
   auto authDeviceIDRust = jsiStringToRustString(authDeviceID, rt);
   auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
   auto userIDRust = jsiStringToRustString(userID, rt);
 
   auto timestampI64 = static_cast<int64_t>(sinceTimestamp.value_or(0));
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityGetDeviceListForUser(
               authUserIDRust,
               authDeviceIDRust,
               authAccessTokenRust,
               userIDRust,
               timestampI64,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::updateDeviceList(
     jsi::Runtime &rt,
     jsi::String authUserID,
     jsi::String authDeviceID,
     jsi::String authAccessToken,
     jsi::String updatePayload) {
   auto authUserIDRust = jsiStringToRustString(authUserID, rt);
   auto authDeviceIDRust = jsiStringToRustString(authDeviceID, rt);
   auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
   auto updatePayloadRust = jsiStringToRustString(updatePayload, rt);
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityUpdateDeviceList(
               authUserIDRust,
               authDeviceIDRust,
               authAccessTokenRust,
               updatePayloadRust,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::uploadSecondaryDeviceKeysAndLogIn(
     jsi::Runtime &rt,
     jsi::String userID,
-    jsi::String challengeResponse,
+    jsi::String nonce,
+    jsi::String nonceSignature,
     jsi::String keyPayload,
     jsi::String keyPayloadSignature,
     jsi::String contentPrekey,
     jsi::String contentPrekeySignature,
     jsi::String notifPrekey,
     jsi::String notifPrekeySignature,
     jsi::Array contentOneTimeKeys,
     jsi::Array notifOneTimeKeys) {
   auto userIDRust = jsiStringToRustString(userID, rt);
-  auto challengeResponseRust = jsiStringToRustString(challengeResponse, rt);
+  auto nonceRust = jsiStringToRustString(nonce, rt);
+  auto nonceSignatureRust = jsiStringToRustString(nonceSignature, rt);
   auto keyPayloadRust = jsiStringToRustString(keyPayload, rt);
   auto keyPayloadSignatureRust = jsiStringToRustString(keyPayloadSignature, rt);
   auto contentPrekeyRust = jsiStringToRustString(contentPrekey, rt);
   auto contentPrekeySignatureRust =
       jsiStringToRustString(contentPrekeySignature, rt);
   auto notifPrekeyRust = jsiStringToRustString(notifPrekey, rt);
   auto notifPrekeySignatureRust =
       jsiStringToRustString(notifPrekeySignature, rt);
   auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
   auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityUploadSecondaryDeviceKeysAndLogIn(
               userIDRust,
-              challengeResponseRust,
+              nonceRust,
+              nonceSignatureRust,
               keyPayloadRust,
               keyPayloadSignatureRust,
               contentPrekeyRust,
               contentPrekeySignatureRust,
               notifPrekeyRust,
               notifPrekeySignatureRust,
               contentOneTimeKeysRust,
               notifOneTimeKeysRust,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::logInExistingDevice(
     jsi::Runtime &rt,
     jsi::String userID,
     jsi::String deviceID,
-    jsi::String challengeResponse) {
+    jsi::String nonce,
+    jsi::String nonceSignature) {
   auto userIDRust = jsiStringToRustString(userID, rt);
   auto deviceIDRust = jsiStringToRustString(deviceID, rt);
-  auto challengeResponseRust = jsiStringToRustString(challengeResponse, rt);
+  auto nonceRust = jsiStringToRustString(nonce, rt);
+  auto nonceSignatureRust = jsiStringToRustString(nonceSignature, rt);
 
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityLogInExistingDevice(
-              userIDRust, deviceIDRust, challengeResponseRust, currentID);
+              userIDRust,
+              deviceIDRust,
+              nonceRust,
+              nonceSignatureRust,
+              currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::findUserIDForWalletAddress(
     jsi::Runtime &rt,
     jsi::String walletAddress) {
   auto walletAddressRust = jsiStringToRustString(walletAddress, rt);
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityFindUserIDForWalletAddress(walletAddressRust, currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value
 CommRustModule::findUserIDForUsername(jsi::Runtime &rt, jsi::String username) {
   auto usernameRust = jsiStringToRustString(username, rt);
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityFindUserIDForUsername(usernameRust, currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value
 CommRustModule::getFarcasterUsers(jsi::Runtime &rt, jsi::Array farcasterIDs) {
   auto farcasterIDsRust = jsiStringArrayToRustVec(farcasterIDs, rt);
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityGetFarcasterUsers(farcasterIDsRust, currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::linkFarcasterAccount(
     jsi::Runtime &rt,
     jsi::String userID,
     jsi::String deviceID,
     jsi::String accessToken,
     jsi::String farcasterID) {
   auto userIDRust = jsiStringToRustString(userID, rt);
   auto deviceIDRust = jsiStringToRustString(deviceID, rt);
   auto accessTokenRust = jsiStringToRustString(accessToken, rt);
   auto farcasterIDRust = jsiStringToRustString(farcasterID, rt);
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityLinkFarcasterAccount(
               userIDRust,
               deviceIDRust,
               accessTokenRust,
               farcasterIDRust,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::unlinkFarcasterAccount(
     jsi::Runtime &rt,
     jsi::String userID,
     jsi::String deviceID,
     jsi::String accessToken) {
   auto userIDRust = jsiStringToRustString(userID, rt);
   auto deviceIDRust = jsiStringToRustString(deviceID, rt);
   auto accessTokenRust = jsiStringToRustString(accessToken, rt);
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityUnlinkFarcasterAccount(
               userIDRust, deviceIDRust, accessTokenRust, currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 } // namespace comm
diff --git a/native/cpp/CommonCpp/NativeModules/CommRustModule.h b/native/cpp/CommonCpp/NativeModules/CommRustModule.h
index 5f3171816..4d42db8d5 100644
--- a/native/cpp/CommonCpp/NativeModules/CommRustModule.h
+++ b/native/cpp/CommonCpp/NativeModules/CommRustModule.h
@@ -1,156 +1,158 @@
 #pragma once
 
 #include "../_generated/rustJSI.h"
 
 #include <ReactCommon/TurboModuleUtils.h>
 #include <jsi/jsi.h>
 #include <memory>
 
 namespace comm {
 
 namespace jsi = facebook::jsi;
 
 class CommRustModule : public facebook::react::CommRustModuleSchemaCxxSpecJSI {
   virtual jsi::Value generateNonce(jsi::Runtime &rt) override;
   virtual jsi::Value registerPasswordUser(
       jsi::Runtime &rt,
       jsi::String username,
       jsi::String password,
       jsi::String keyPayload,
       jsi::String keyPayloadSignature,
       jsi::String contentPrekey,
       jsi::String contentPrekeySignature,
       jsi::String notifPrekey,
       jsi::String notifPrekeySignature,
       jsi::Array contentOneTimeKeys,
       jsi::Array notifOneTimeKeys,
       jsi::String farcasterID) override;
   virtual jsi::Value logInPasswordUser(
       jsi::Runtime &rt,
       jsi::String username,
       jsi::String password,
       jsi::String keyPayload,
       jsi::String keyPayloadSignature,
       jsi::String contentPrekey,
       jsi::String contentPrekeySignature,
       jsi::String notifPrekey,
       jsi::String notifPrekeySignature) override;
   virtual jsi::Value registerWalletUser(
       jsi::Runtime &rt,
       jsi::String siweMessage,
       jsi::String siweSignature,
       jsi::String keyPayload,
       jsi::String keyPayloadSignature,
       jsi::String contentPrekey,
       jsi::String contentPrekeySignature,
       jsi::String notifPrekey,
       jsi::String notifPrekeySignature,
       jsi::Array contentOneTimeKeys,
       jsi::Array notifOneTimeKeys,
       jsi::String farcasterID) override;
   virtual jsi::Value logInWalletUser(
       jsi::Runtime &rt,
       jsi::String siweMessage,
       jsi::String siweSignature,
       jsi::String keyPayload,
       jsi::String keyPayloadSignature,
       jsi::String contentPrekey,
       jsi::String contentPrekeySignature,
       jsi::String notifPrekey,
       jsi::String notifPrekeySignature) override;
   virtual jsi::Value updatePassword(
       jsi::Runtime &rt,
       jsi::String userID,
       jsi::String deviceID,
       jsi::String accessToken,
       jsi::String password) override;
   virtual jsi::Value deleteUser(
       jsi::Runtime &rt,
       jsi::String userID,
       jsi::String deviceID,
       jsi::String accessToken) override;
   virtual jsi::Value logOut(
       jsi::Runtime &rt,
       jsi::String userID,
       jsi::String deviceID,
       jsi::String accessToken) override;
   virtual jsi::Value getOutboundKeysForUser(
       jsi::Runtime &rt,
       jsi::String authUserID,
       jsi::String authDeviceID,
       jsi::String authAccessToken,
       jsi::String userID) override;
   virtual jsi::Value getInboundKeysForUser(
       jsi::Runtime &rt,
       jsi::String authUserID,
       jsi::String authDeviceID,
       jsi::String authAccessToken,
       jsi::String userID) override;
   virtual jsi::Value versionSupported(jsi::Runtime &rt) override;
   virtual jsi::Value uploadOneTimeKeys(
       jsi::Runtime &rt,
       jsi::String authUserID,
       jsi::String authDeviceID,
       jsi::String authAccessToken,
       jsi::Array contentOneTimePreKeys,
       jsi::Array notifOneTimePreKeys) override;
   virtual jsi::Value getKeyserverKeys(
       jsi::Runtime &rt,
       jsi::String authUserID,
       jsi::String authDeviceID,
       jsi::String authAccessToken,
       jsi::String keyserverID) override;
   virtual jsi::Value getDeviceListForUser(
       jsi::Runtime &rt,
       jsi::String authUserID,
       jsi::String authDeviceID,
       jsi::String authAccessToken,
       jsi::String userID,
       std::optional<double> sinceTimestamp) override;
   virtual jsi::Value updateDeviceList(
       jsi::Runtime &rt,
       jsi::String authUserID,
       jsi::String authDeviceID,
       jsi::String authAccessToken,
       jsi::String updatePayload) override;
   virtual jsi::Value uploadSecondaryDeviceKeysAndLogIn(
       jsi::Runtime &rt,
       jsi::String userID,
-      jsi::String challengeResponse,
+      jsi::String nonce,
+      jsi::String nonceSignature,
       jsi::String keyPayload,
       jsi::String keyPayloadSignature,
       jsi::String contentPrekey,
       jsi::String contentPrekeySignature,
       jsi::String notifPrekey,
       jsi::String notifPrekeySignature,
       jsi::Array contentOneTimeKeys,
       jsi::Array notifOneTimeKeys) override;
   virtual jsi::Value logInExistingDevice(
       jsi::Runtime &rt,
       jsi::String userID,
       jsi::String deviceID,
-      jsi::String challengeResponse) override;
+      jsi::String nonce,
+      jsi::String nonceSignature) override;
   virtual jsi::Value findUserIDForWalletAddress(
       jsi::Runtime &rt,
       jsi::String walletAddress) override;
   virtual jsi::Value
   findUserIDForUsername(jsi::Runtime &rt, jsi::String username) override;
   virtual jsi::Value
   getFarcasterUsers(jsi::Runtime &rt, jsi::Array farcasterIDs) override;
   virtual jsi::Value linkFarcasterAccount(
       jsi::Runtime &rt,
       jsi::String userID,
       jsi::String deviceID,
       jsi::String accessToken,
       jsi::String farcasterID) override;
   virtual jsi::Value unlinkFarcasterAccount(
       jsi::Runtime &rt,
       jsi::String userID,
       jsi::String deviceID,
       jsi::String accessToken) override;
 
 public:
   CommRustModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker);
 };
 
 } // namespace comm
diff --git a/native/cpp/CommonCpp/_generated/rustJSI-generated.cpp b/native/cpp/CommonCpp/_generated/rustJSI-generated.cpp
index 8f402431c..3e2c4d6d2 100644
--- a/native/cpp/CommonCpp/_generated/rustJSI-generated.cpp
+++ b/native/cpp/CommonCpp/_generated/rustJSI-generated.cpp
@@ -1,110 +1,110 @@
 /**
  * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
  *
  * Do not edit this file as changes may cause incorrect behavior and will be lost
  * once the code is regenerated.
  *
  * @generated by codegen project: GenerateModuleH.js
  */
 
 #include "rustJSI.h"
 
 namespace facebook {
 namespace react {
 
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_generateNonce(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->generateNonce(rt);
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_registerPasswordUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->registerPasswordUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt), args[4].asString(rt), args[5].asString(rt), args[6].asString(rt), args[7].asString(rt), args[8].asObject(rt).asArray(rt), args[9].asObject(rt).asArray(rt), args[10].asString(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_logInPasswordUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->logInPasswordUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt), args[4].asString(rt), args[5].asString(rt), args[6].asString(rt), args[7].asString(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_registerWalletUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->registerWalletUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt), args[4].asString(rt), args[5].asString(rt), args[6].asString(rt), args[7].asString(rt), args[8].asObject(rt).asArray(rt), args[9].asObject(rt).asArray(rt), args[10].asString(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_logInWalletUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->logInWalletUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt), args[4].asString(rt), args[5].asString(rt), args[6].asString(rt), args[7].asString(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_updatePassword(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->updatePassword(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_deleteUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->deleteUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_logOut(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->logOut(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_getOutboundKeysForUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->getOutboundKeysForUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_getInboundKeysForUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->getInboundKeysForUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_versionSupported(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->versionSupported(rt);
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_uploadOneTimeKeys(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->uploadOneTimeKeys(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asObject(rt).asArray(rt), args[4].asObject(rt).asArray(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_getKeyserverKeys(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->getKeyserverKeys(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_getDeviceListForUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->getDeviceListForUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt), args[4].isNull() || args[4].isUndefined() ? std::nullopt : std::make_optional(args[4].asNumber()));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_updateDeviceList(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->updateDeviceList(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_uploadSecondaryDeviceKeysAndLogIn(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
-  return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->uploadSecondaryDeviceKeysAndLogIn(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt), args[4].asString(rt), args[5].asString(rt), args[6].asString(rt), args[7].asString(rt), args[8].asObject(rt).asArray(rt), args[9].asObject(rt).asArray(rt));
+  return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->uploadSecondaryDeviceKeysAndLogIn(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt), args[4].asString(rt), args[5].asString(rt), args[6].asString(rt), args[7].asString(rt), args[8].asString(rt), args[9].asObject(rt).asArray(rt), args[10].asObject(rt).asArray(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_logInExistingDevice(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
-  return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->logInExistingDevice(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt));
+  return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->logInExistingDevice(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_findUserIDForWalletAddress(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->findUserIDForWalletAddress(rt, args[0].asString(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_findUserIDForUsername(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->findUserIDForUsername(rt, args[0].asString(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_getFarcasterUsers(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->getFarcasterUsers(rt, args[0].asObject(rt).asArray(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_linkFarcasterAccount(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->linkFarcasterAccount(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_unlinkFarcasterAccount(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->unlinkFarcasterAccount(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt));
 }
 
 CommRustModuleSchemaCxxSpecJSI::CommRustModuleSchemaCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker)
   : TurboModule("CommRustTurboModule", jsInvoker) {
   methodMap_["generateNonce"] = MethodMetadata {0, __hostFunction_CommRustModuleSchemaCxxSpecJSI_generateNonce};
   methodMap_["registerPasswordUser"] = MethodMetadata {11, __hostFunction_CommRustModuleSchemaCxxSpecJSI_registerPasswordUser};
   methodMap_["logInPasswordUser"] = MethodMetadata {8, __hostFunction_CommRustModuleSchemaCxxSpecJSI_logInPasswordUser};
   methodMap_["registerWalletUser"] = MethodMetadata {11, __hostFunction_CommRustModuleSchemaCxxSpecJSI_registerWalletUser};
   methodMap_["logInWalletUser"] = MethodMetadata {8, __hostFunction_CommRustModuleSchemaCxxSpecJSI_logInWalletUser};
   methodMap_["updatePassword"] = MethodMetadata {4, __hostFunction_CommRustModuleSchemaCxxSpecJSI_updatePassword};
   methodMap_["deleteUser"] = MethodMetadata {3, __hostFunction_CommRustModuleSchemaCxxSpecJSI_deleteUser};
   methodMap_["logOut"] = MethodMetadata {3, __hostFunction_CommRustModuleSchemaCxxSpecJSI_logOut};
   methodMap_["getOutboundKeysForUser"] = MethodMetadata {4, __hostFunction_CommRustModuleSchemaCxxSpecJSI_getOutboundKeysForUser};
   methodMap_["getInboundKeysForUser"] = MethodMetadata {4, __hostFunction_CommRustModuleSchemaCxxSpecJSI_getInboundKeysForUser};
   methodMap_["versionSupported"] = MethodMetadata {0, __hostFunction_CommRustModuleSchemaCxxSpecJSI_versionSupported};
   methodMap_["uploadOneTimeKeys"] = MethodMetadata {5, __hostFunction_CommRustModuleSchemaCxxSpecJSI_uploadOneTimeKeys};
   methodMap_["getKeyserverKeys"] = MethodMetadata {4, __hostFunction_CommRustModuleSchemaCxxSpecJSI_getKeyserverKeys};
   methodMap_["getDeviceListForUser"] = MethodMetadata {5, __hostFunction_CommRustModuleSchemaCxxSpecJSI_getDeviceListForUser};
   methodMap_["updateDeviceList"] = MethodMetadata {4, __hostFunction_CommRustModuleSchemaCxxSpecJSI_updateDeviceList};
-  methodMap_["uploadSecondaryDeviceKeysAndLogIn"] = MethodMetadata {10, __hostFunction_CommRustModuleSchemaCxxSpecJSI_uploadSecondaryDeviceKeysAndLogIn};
-  methodMap_["logInExistingDevice"] = MethodMetadata {3, __hostFunction_CommRustModuleSchemaCxxSpecJSI_logInExistingDevice};
+  methodMap_["uploadSecondaryDeviceKeysAndLogIn"] = MethodMetadata {11, __hostFunction_CommRustModuleSchemaCxxSpecJSI_uploadSecondaryDeviceKeysAndLogIn};
+  methodMap_["logInExistingDevice"] = MethodMetadata {4, __hostFunction_CommRustModuleSchemaCxxSpecJSI_logInExistingDevice};
   methodMap_["findUserIDForWalletAddress"] = MethodMetadata {1, __hostFunction_CommRustModuleSchemaCxxSpecJSI_findUserIDForWalletAddress};
   methodMap_["findUserIDForUsername"] = MethodMetadata {1, __hostFunction_CommRustModuleSchemaCxxSpecJSI_findUserIDForUsername};
   methodMap_["getFarcasterUsers"] = MethodMetadata {1, __hostFunction_CommRustModuleSchemaCxxSpecJSI_getFarcasterUsers};
   methodMap_["linkFarcasterAccount"] = MethodMetadata {4, __hostFunction_CommRustModuleSchemaCxxSpecJSI_linkFarcasterAccount};
   methodMap_["unlinkFarcasterAccount"] = MethodMetadata {3, __hostFunction_CommRustModuleSchemaCxxSpecJSI_unlinkFarcasterAccount};
 }
 
 
 } // namespace react
 } // namespace facebook
diff --git a/native/cpp/CommonCpp/_generated/rustJSI.h b/native/cpp/CommonCpp/_generated/rustJSI.h
index 5d9c97c66..bc46240df 100644
--- a/native/cpp/CommonCpp/_generated/rustJSI.h
+++ b/native/cpp/CommonCpp/_generated/rustJSI.h
@@ -1,251 +1,251 @@
 /**
  * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
  *
  * Do not edit this file as changes may cause incorrect behavior and will be lost
  * once the code is regenerated.
  *
  * @generated by codegen project: GenerateModuleH.js
  */
 
 #pragma once
 
 #include <ReactCommon/TurboModule.h>
 #include <react/bridging/Bridging.h>
 
 namespace facebook {
 namespace react {
 
 class JSI_EXPORT CommRustModuleSchemaCxxSpecJSI : public TurboModule {
 protected:
   CommRustModuleSchemaCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker);
 
 public:
   virtual jsi::Value generateNonce(jsi::Runtime &rt) = 0;
   virtual jsi::Value registerPasswordUser(jsi::Runtime &rt, jsi::String username, jsi::String password, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys, jsi::String farcasterID) = 0;
   virtual jsi::Value logInPasswordUser(jsi::Runtime &rt, jsi::String username, jsi::String password, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature) = 0;
   virtual jsi::Value registerWalletUser(jsi::Runtime &rt, jsi::String siweMessage, jsi::String siweSignature, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys, jsi::String farcasterID) = 0;
   virtual jsi::Value logInWalletUser(jsi::Runtime &rt, jsi::String siweMessage, jsi::String siweSignature, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature) = 0;
   virtual jsi::Value updatePassword(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken, jsi::String password) = 0;
   virtual jsi::Value deleteUser(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken) = 0;
   virtual jsi::Value logOut(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken) = 0;
   virtual jsi::Value getOutboundKeysForUser(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String userID) = 0;
   virtual jsi::Value getInboundKeysForUser(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String userID) = 0;
   virtual jsi::Value versionSupported(jsi::Runtime &rt) = 0;
   virtual jsi::Value uploadOneTimeKeys(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::Array contentOneTimePreKeys, jsi::Array notifOneTimePreKeys) = 0;
   virtual jsi::Value getKeyserverKeys(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String keyserverID) = 0;
   virtual jsi::Value getDeviceListForUser(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String userID, std::optional<double> sinceTimestamp) = 0;
   virtual jsi::Value updateDeviceList(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String updatePayload) = 0;
-  virtual jsi::Value uploadSecondaryDeviceKeysAndLogIn(jsi::Runtime &rt, jsi::String userID, jsi::String challengeResponse, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys) = 0;
-  virtual jsi::Value logInExistingDevice(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String challengeResponse) = 0;
+  virtual jsi::Value uploadSecondaryDeviceKeysAndLogIn(jsi::Runtime &rt, jsi::String userID, jsi::String nonce, jsi::String nonceSignature, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys) = 0;
+  virtual jsi::Value logInExistingDevice(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String nonce, jsi::String nonceSignature) = 0;
   virtual jsi::Value findUserIDForWalletAddress(jsi::Runtime &rt, jsi::String walletAddress) = 0;
   virtual jsi::Value findUserIDForUsername(jsi::Runtime &rt, jsi::String username) = 0;
   virtual jsi::Value getFarcasterUsers(jsi::Runtime &rt, jsi::Array farcasterIDs) = 0;
   virtual jsi::Value linkFarcasterAccount(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken, jsi::String farcasterID) = 0;
   virtual jsi::Value unlinkFarcasterAccount(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken) = 0;
 
 };
 
 template <typename T>
 class JSI_EXPORT CommRustModuleSchemaCxxSpec : public TurboModule {
 public:
   jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propName) override {
     return delegate_.get(rt, propName);
   }
 
 protected:
   CommRustModuleSchemaCxxSpec(std::shared_ptr<CallInvoker> jsInvoker)
     : TurboModule("CommRustTurboModule", jsInvoker),
       delegate_(static_cast<T*>(this), jsInvoker) {}
 
 private:
   class Delegate : public CommRustModuleSchemaCxxSpecJSI {
   public:
     Delegate(T *instance, std::shared_ptr<CallInvoker> jsInvoker) :
       CommRustModuleSchemaCxxSpecJSI(std::move(jsInvoker)), instance_(instance) {}
 
     jsi::Value generateNonce(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::generateNonce) == 1,
           "Expected generateNonce(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::generateNonce, jsInvoker_, instance_);
     }
     jsi::Value registerPasswordUser(jsi::Runtime &rt, jsi::String username, jsi::String password, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys, jsi::String farcasterID) override {
       static_assert(
           bridging::getParameterCount(&T::registerPasswordUser) == 12,
           "Expected registerPasswordUser(...) to have 12 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::registerPasswordUser, jsInvoker_, instance_, std::move(username), std::move(password), std::move(keyPayload), std::move(keyPayloadSignature), std::move(contentPrekey), std::move(contentPrekeySignature), std::move(notifPrekey), std::move(notifPrekeySignature), std::move(contentOneTimeKeys), std::move(notifOneTimeKeys), std::move(farcasterID));
     }
     jsi::Value logInPasswordUser(jsi::Runtime &rt, jsi::String username, jsi::String password, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature) override {
       static_assert(
           bridging::getParameterCount(&T::logInPasswordUser) == 9,
           "Expected logInPasswordUser(...) to have 9 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::logInPasswordUser, jsInvoker_, instance_, std::move(username), std::move(password), std::move(keyPayload), std::move(keyPayloadSignature), std::move(contentPrekey), std::move(contentPrekeySignature), std::move(notifPrekey), std::move(notifPrekeySignature));
     }
     jsi::Value registerWalletUser(jsi::Runtime &rt, jsi::String siweMessage, jsi::String siweSignature, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys, jsi::String farcasterID) override {
       static_assert(
           bridging::getParameterCount(&T::registerWalletUser) == 12,
           "Expected registerWalletUser(...) to have 12 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::registerWalletUser, jsInvoker_, instance_, std::move(siweMessage), std::move(siweSignature), std::move(keyPayload), std::move(keyPayloadSignature), std::move(contentPrekey), std::move(contentPrekeySignature), std::move(notifPrekey), std::move(notifPrekeySignature), std::move(contentOneTimeKeys), std::move(notifOneTimeKeys), std::move(farcasterID));
     }
     jsi::Value logInWalletUser(jsi::Runtime &rt, jsi::String siweMessage, jsi::String siweSignature, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature) override {
       static_assert(
           bridging::getParameterCount(&T::logInWalletUser) == 9,
           "Expected logInWalletUser(...) to have 9 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::logInWalletUser, jsInvoker_, instance_, std::move(siweMessage), std::move(siweSignature), std::move(keyPayload), std::move(keyPayloadSignature), std::move(contentPrekey), std::move(contentPrekeySignature), std::move(notifPrekey), std::move(notifPrekeySignature));
     }
     jsi::Value updatePassword(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken, jsi::String password) override {
       static_assert(
           bridging::getParameterCount(&T::updatePassword) == 5,
           "Expected updatePassword(...) to have 5 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::updatePassword, jsInvoker_, instance_, std::move(userID), std::move(deviceID), std::move(accessToken), std::move(password));
     }
     jsi::Value deleteUser(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken) override {
       static_assert(
           bridging::getParameterCount(&T::deleteUser) == 4,
           "Expected deleteUser(...) to have 4 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::deleteUser, jsInvoker_, instance_, std::move(userID), std::move(deviceID), std::move(accessToken));
     }
     jsi::Value logOut(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken) override {
       static_assert(
           bridging::getParameterCount(&T::logOut) == 4,
           "Expected logOut(...) to have 4 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::logOut, jsInvoker_, instance_, std::move(userID), std::move(deviceID), std::move(accessToken));
     }
     jsi::Value getOutboundKeysForUser(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String userID) override {
       static_assert(
           bridging::getParameterCount(&T::getOutboundKeysForUser) == 5,
           "Expected getOutboundKeysForUser(...) to have 5 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getOutboundKeysForUser, jsInvoker_, instance_, std::move(authUserID), std::move(authDeviceID), std::move(authAccessToken), std::move(userID));
     }
     jsi::Value getInboundKeysForUser(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String userID) override {
       static_assert(
           bridging::getParameterCount(&T::getInboundKeysForUser) == 5,
           "Expected getInboundKeysForUser(...) to have 5 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getInboundKeysForUser, jsInvoker_, instance_, std::move(authUserID), std::move(authDeviceID), std::move(authAccessToken), std::move(userID));
     }
     jsi::Value versionSupported(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::versionSupported) == 1,
           "Expected versionSupported(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::versionSupported, jsInvoker_, instance_);
     }
     jsi::Value uploadOneTimeKeys(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::Array contentOneTimePreKeys, jsi::Array notifOneTimePreKeys) override {
       static_assert(
           bridging::getParameterCount(&T::uploadOneTimeKeys) == 6,
           "Expected uploadOneTimeKeys(...) to have 6 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::uploadOneTimeKeys, jsInvoker_, instance_, std::move(authUserID), std::move(authDeviceID), std::move(authAccessToken), std::move(contentOneTimePreKeys), std::move(notifOneTimePreKeys));
     }
     jsi::Value getKeyserverKeys(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String keyserverID) override {
       static_assert(
           bridging::getParameterCount(&T::getKeyserverKeys) == 5,
           "Expected getKeyserverKeys(...) to have 5 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getKeyserverKeys, jsInvoker_, instance_, std::move(authUserID), std::move(authDeviceID), std::move(authAccessToken), std::move(keyserverID));
     }
     jsi::Value getDeviceListForUser(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String userID, std::optional<double> sinceTimestamp) override {
       static_assert(
           bridging::getParameterCount(&T::getDeviceListForUser) == 6,
           "Expected getDeviceListForUser(...) to have 6 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getDeviceListForUser, jsInvoker_, instance_, std::move(authUserID), std::move(authDeviceID), std::move(authAccessToken), std::move(userID), std::move(sinceTimestamp));
     }
     jsi::Value updateDeviceList(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String updatePayload) override {
       static_assert(
           bridging::getParameterCount(&T::updateDeviceList) == 5,
           "Expected updateDeviceList(...) to have 5 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::updateDeviceList, jsInvoker_, instance_, std::move(authUserID), std::move(authDeviceID), std::move(authAccessToken), std::move(updatePayload));
     }
-    jsi::Value uploadSecondaryDeviceKeysAndLogIn(jsi::Runtime &rt, jsi::String userID, jsi::String challengeResponse, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys) override {
+    jsi::Value uploadSecondaryDeviceKeysAndLogIn(jsi::Runtime &rt, jsi::String userID, jsi::String nonce, jsi::String nonceSignature, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys) override {
       static_assert(
-          bridging::getParameterCount(&T::uploadSecondaryDeviceKeysAndLogIn) == 11,
-          "Expected uploadSecondaryDeviceKeysAndLogIn(...) to have 11 parameters");
+          bridging::getParameterCount(&T::uploadSecondaryDeviceKeysAndLogIn) == 12,
+          "Expected uploadSecondaryDeviceKeysAndLogIn(...) to have 12 parameters");
 
       return bridging::callFromJs<jsi::Value>(
-          rt, &T::uploadSecondaryDeviceKeysAndLogIn, jsInvoker_, instance_, std::move(userID), std::move(challengeResponse), std::move(keyPayload), std::move(keyPayloadSignature), std::move(contentPrekey), std::move(contentPrekeySignature), std::move(notifPrekey), std::move(notifPrekeySignature), std::move(contentOneTimeKeys), std::move(notifOneTimeKeys));
+          rt, &T::uploadSecondaryDeviceKeysAndLogIn, jsInvoker_, instance_, std::move(userID), std::move(nonce), std::move(nonceSignature), std::move(keyPayload), std::move(keyPayloadSignature), std::move(contentPrekey), std::move(contentPrekeySignature), std::move(notifPrekey), std::move(notifPrekeySignature), std::move(contentOneTimeKeys), std::move(notifOneTimeKeys));
     }
-    jsi::Value logInExistingDevice(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String challengeResponse) override {
+    jsi::Value logInExistingDevice(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String nonce, jsi::String nonceSignature) override {
       static_assert(
-          bridging::getParameterCount(&T::logInExistingDevice) == 4,
-          "Expected logInExistingDevice(...) to have 4 parameters");
+          bridging::getParameterCount(&T::logInExistingDevice) == 5,
+          "Expected logInExistingDevice(...) to have 5 parameters");
 
       return bridging::callFromJs<jsi::Value>(
-          rt, &T::logInExistingDevice, jsInvoker_, instance_, std::move(userID), std::move(deviceID), std::move(challengeResponse));
+          rt, &T::logInExistingDevice, jsInvoker_, instance_, std::move(userID), std::move(deviceID), std::move(nonce), std::move(nonceSignature));
     }
     jsi::Value findUserIDForWalletAddress(jsi::Runtime &rt, jsi::String walletAddress) override {
       static_assert(
           bridging::getParameterCount(&T::findUserIDForWalletAddress) == 2,
           "Expected findUserIDForWalletAddress(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::findUserIDForWalletAddress, jsInvoker_, instance_, std::move(walletAddress));
     }
     jsi::Value findUserIDForUsername(jsi::Runtime &rt, jsi::String username) override {
       static_assert(
           bridging::getParameterCount(&T::findUserIDForUsername) == 2,
           "Expected findUserIDForUsername(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::findUserIDForUsername, jsInvoker_, instance_, std::move(username));
     }
     jsi::Value getFarcasterUsers(jsi::Runtime &rt, jsi::Array farcasterIDs) override {
       static_assert(
           bridging::getParameterCount(&T::getFarcasterUsers) == 2,
           "Expected getFarcasterUsers(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getFarcasterUsers, jsInvoker_, instance_, std::move(farcasterIDs));
     }
     jsi::Value linkFarcasterAccount(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken, jsi::String farcasterID) override {
       static_assert(
           bridging::getParameterCount(&T::linkFarcasterAccount) == 5,
           "Expected linkFarcasterAccount(...) to have 5 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::linkFarcasterAccount, jsInvoker_, instance_, std::move(userID), std::move(deviceID), std::move(accessToken), std::move(farcasterID));
     }
     jsi::Value unlinkFarcasterAccount(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken) override {
       static_assert(
           bridging::getParameterCount(&T::unlinkFarcasterAccount) == 4,
           "Expected unlinkFarcasterAccount(...) to have 4 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::unlinkFarcasterAccount, jsInvoker_, instance_, std::move(userID), std::move(deviceID), std::move(accessToken));
     }
 
   private:
     T *instance_;
   };
 
   Delegate delegate_;
 };
 
 } // namespace react
 } // namespace facebook
diff --git a/native/identity-service/identity-service-context-provider.react.js b/native/identity-service/identity-service-context-provider.react.js
index 1d8a4ea15..5027ce6b9 100644
--- a/native/identity-service/identity-service-context-provider.react.js
+++ b/native/identity-service/identity-service-context-provider.react.js
@@ -1,596 +1,597 @@
 // @flow
 
 import * as React from 'react';
 
 import { getOneTimeKeyValues } from 'lib/shared/crypto-utils.js';
 import { IdentityClientContext } from 'lib/shared/identity-client-context.js';
 import {
   type IdentityKeysBlob,
   identityKeysBlobValidator,
   type OneTimeKeysResultValues,
 } from 'lib/types/crypto-types.js';
 import {
   type SignedDeviceList,
   signedDeviceListHistoryValidator,
-  type SignedMessage,
+  type SignedNonce,
   type DeviceOlmOutboundKeys,
   deviceOlmOutboundKeysValidator,
   type IdentityServiceClient,
   type UserDevicesOlmOutboundKeys,
   type UserAuthMetadata,
   ONE_TIME_KEYS_NUMBER,
   identityAuthResultValidator,
   type DeviceOlmInboundKeys,
   type UserDevicesOlmInboundKeys,
   deviceOlmInboundKeysValidator,
   userDeviceOlmInboundKeysValidator,
   farcasterUsersValidator,
 } from 'lib/types/identity-service-types.js';
 import { getContentSigningKey } from 'lib/utils/crypto-utils.js';
 import { assertWithValidator } from 'lib/utils/validation-utils.js';
 
 import { getCommServicesAuthMetadataEmitter } from '../event-emitters/csa-auth-metadata-emitter.js';
 import { commCoreModule, commRustModule } from '../native-modules.js';
 import { useSelector } from '../redux/redux-utils.js';
 
 type Props = {
   +children: React.Node,
 };
 function IdentityServiceContextProvider(props: Props): React.Node {
   const { children } = props;
 
   const userIDPromiseRef = React.useRef<?Promise<?string>>();
   if (!userIDPromiseRef.current) {
     userIDPromiseRef.current = (async () => {
       const { userID } = await commCoreModule.getCommServicesAuthMetadata();
       return userID;
     })();
   }
 
   React.useEffect(() => {
     const metadataEmitter = getCommServicesAuthMetadataEmitter();
     const subscription = metadataEmitter.addListener(
       'commServicesAuthMetadata',
       (authMetadata: UserAuthMetadata) => {
         userIDPromiseRef.current = Promise.resolve(authMetadata.userID);
       },
     );
     return () => subscription.remove();
   }, []);
 
   const accessToken = useSelector(state => state.commServicesAccessToken);
 
   const getAuthMetadata = React.useCallback<
     () => Promise<{
       +deviceID: string,
       +userID: string,
       +accessToken: string,
     }>,
   >(async () => {
     const deviceID = await getContentSigningKey();
     const userID = await userIDPromiseRef.current;
     if (!deviceID || !userID || !accessToken) {
       throw new Error('Identity service client is not initialized');
     }
     return { deviceID, userID, accessToken };
   }, [accessToken]);
 
   const client = React.useMemo<IdentityServiceClient>(
     () => ({
       deleteUser: async () => {
         const {
           deviceID,
           userID,
           accessToken: token,
         } = await getAuthMetadata();
         return commRustModule.deleteUser(userID, deviceID, token);
       },
       logOut: async () => {
         const {
           deviceID,
           userID,
           accessToken: token,
         } = await getAuthMetadata();
         return commRustModule.logOut(userID, deviceID, token);
       },
       getKeyserverKeys: async (
         keyserverID: string,
       ): Promise<DeviceOlmOutboundKeys> => {
         const {
           deviceID,
           userID,
           accessToken: token,
         } = await getAuthMetadata();
         const result = await commRustModule.getKeyserverKeys(
           userID,
           deviceID,
           token,
           keyserverID,
         );
         const resultObject = JSON.parse(result);
         const payload = resultObject?.payload;
 
         const keyserverKeys = {
           identityKeysBlob: payload ? JSON.parse(payload) : null,
           contentInitializationInfo: {
             prekey: resultObject?.contentPrekey,
             prekeySignature: resultObject?.contentPrekeySignature,
             oneTimeKey: resultObject?.oneTimeContentPrekey,
           },
           notifInitializationInfo: {
             prekey: resultObject?.notifPrekey,
             prekeySignature: resultObject?.notifPrekeySignature,
             oneTimeKey: resultObject?.oneTimeNotifPrekey,
           },
           payloadSignature: resultObject?.payloadSignature,
           socialProof: resultObject?.socialProof,
         };
 
         if (!keyserverKeys.contentInitializationInfo.oneTimeKey) {
           throw new Error('Missing content one time key');
         }
         if (!keyserverKeys.notifInitializationInfo.oneTimeKey) {
           throw new Error('Missing notif one time key');
         }
 
         return assertWithValidator(
           keyserverKeys,
           deviceOlmOutboundKeysValidator,
         );
       },
       getOutboundKeysForUser: async (
         targetUserID: string,
       ): Promise<UserDevicesOlmOutboundKeys[]> => {
         const {
           deviceID: authDeviceID,
           userID,
           accessToken: token,
         } = await getAuthMetadata();
         const result = await commRustModule.getOutboundKeysForUser(
           userID,
           authDeviceID,
           token,
           targetUserID,
         );
         const resultArray = JSON.parse(result);
 
         return resultArray
           .map(outboundKeysInfo => {
             try {
               const payload = outboundKeysInfo?.payload;
               const identityKeysBlob: IdentityKeysBlob = assertWithValidator(
                 payload ? JSON.parse(payload) : null,
                 identityKeysBlobValidator,
               );
               const deviceID =
                 identityKeysBlob.primaryIdentityPublicKeys.ed25519;
 
               if (
                 !outboundKeysInfo.oneTimeContentPrekey ||
                 !outboundKeysInfo.oneTimeNotifPrekey
               ) {
                 console.log(`Missing one time key for device ${deviceID}`);
                 return {
                   deviceID,
                   keys: null,
                 };
               }
 
               const deviceKeys = {
                 identityKeysBlob,
                 contentInitializationInfo: {
                   prekey: outboundKeysInfo?.contentPrekey,
                   prekeySignature: outboundKeysInfo?.contentPrekeySignature,
                   oneTimeKey: outboundKeysInfo?.oneTimeContentPrekey,
                 },
                 notifInitializationInfo: {
                   prekey: outboundKeysInfo?.notifPrekey,
                   prekeySignature: outboundKeysInfo?.notifPrekeySignature,
                   oneTimeKey: outboundKeysInfo?.oneTimeNotifPrekey,
                 },
                 payloadSignature: outboundKeysInfo?.payloadSignature,
                 socialProof: outboundKeysInfo?.socialProof,
               };
 
               try {
                 const validatedKeys = assertWithValidator(
                   deviceKeys,
                   deviceOlmOutboundKeysValidator,
                 );
                 return {
                   deviceID,
                   keys: validatedKeys,
                 };
               } catch (e) {
                 console.log(e);
                 return {
                   deviceID,
                   keys: null,
                 };
               }
             } catch (e) {
               console.log(e);
               return null;
             }
           })
           .filter(Boolean);
       },
       getInboundKeysForUser: async (
         targetUserID: string,
       ): Promise<UserDevicesOlmInboundKeys> => {
         const {
           deviceID: authDeviceID,
           userID,
           accessToken: token,
         } = await getAuthMetadata();
         const result = await commRustModule.getInboundKeysForUser(
           userID,
           authDeviceID,
           token,
           targetUserID,
         );
         const resultArray = JSON.parse(result);
 
         const devicesKeys: {
           [deviceID: string]: ?DeviceOlmInboundKeys,
         } = {};
 
         resultArray.forEach(inboundKeysInfo => {
           try {
             const payload = inboundKeysInfo?.payload;
             const identityKeysBlob: IdentityKeysBlob = assertWithValidator(
               payload ? JSON.parse(payload) : null,
               identityKeysBlobValidator,
             );
             const deviceID = identityKeysBlob.primaryIdentityPublicKeys.ed25519;
 
             const deviceKeys = {
               identityKeysBlob,
               signedPrekeys: {
                 contentPrekey: inboundKeysInfo?.contentPrekey,
                 contentPrekeySignature: inboundKeysInfo?.contentPrekeySignature,
                 notifPrekey: inboundKeysInfo?.notifPrekey,
                 notifPrekeySignature: inboundKeysInfo?.notifPrekeySignature,
               },
               payloadSignature: inboundKeysInfo?.payloadSignature,
             };
 
             try {
               devicesKeys[deviceID] = assertWithValidator(
                 deviceKeys,
                 deviceOlmInboundKeysValidator,
               );
             } catch (e) {
               console.log(e);
               devicesKeys[deviceID] = null;
             }
           } catch (e) {
             console.log(e);
           }
         });
         const device = resultArray?.[0];
 
         const inboundUserKeys = {
           keys: devicesKeys,
           username: device?.username,
           walletAddress: device?.walletAddress,
         };
 
         return assertWithValidator(
           inboundUserKeys,
           userDeviceOlmInboundKeysValidator,
         );
       },
       uploadOneTimeKeys: async (oneTimeKeys: OneTimeKeysResultValues) => {
         const {
           deviceID: authDeviceID,
           userID,
           accessToken: token,
         } = await getAuthMetadata();
 
         await commRustModule.uploadOneTimeKeys(
           userID,
           authDeviceID,
           token,
           oneTimeKeys.contentOneTimeKeys,
           oneTimeKeys.notificationsOneTimeKeys,
         );
       },
       registerPasswordUser: async (
         username: string,
         password: string,
         fid: ?string,
       ) => {
         await commCoreModule.initializeCryptoAccount();
         const [
           { blobPayload, signature, primaryIdentityPublicKeys },
           { contentOneTimeKeys, notificationsOneTimeKeys },
           prekeys,
         ] = await Promise.all([
           commCoreModule.getUserPublicKey(),
           commCoreModule.getOneTimeKeys(ONE_TIME_KEYS_NUMBER),
           commCoreModule.validateAndGetPrekeys(),
         ]);
         const registrationResult = await commRustModule.registerPasswordUser(
           username,
           password,
           blobPayload,
           signature,
           prekeys.contentPrekey,
           prekeys.contentPrekeySignature,
           prekeys.notifPrekey,
           prekeys.notifPrekeySignature,
           getOneTimeKeyValues(contentOneTimeKeys),
           getOneTimeKeyValues(notificationsOneTimeKeys),
           fid ?? '',
         );
         const { userID, accessToken: token } = JSON.parse(registrationResult);
         const identityAuthResult = { accessToken: token, userID, username };
 
         const validatedResult = assertWithValidator(
           identityAuthResult,
           identityAuthResultValidator,
         );
 
         await commCoreModule.setCommServicesAuthMetadata(
           validatedResult.userID,
           primaryIdentityPublicKeys.ed25519,
           validatedResult.accessToken,
         );
 
         return validatedResult;
       },
       logInPasswordUser: async (username: string, password: string) => {
         await commCoreModule.initializeCryptoAccount();
         const [{ blobPayload, signature, primaryIdentityPublicKeys }, prekeys] =
           await Promise.all([
             commCoreModule.getUserPublicKey(),
             commCoreModule.validateAndGetPrekeys(),
           ]);
         const loginResult = await commRustModule.logInPasswordUser(
           username,
           password,
           blobPayload,
           signature,
           prekeys.contentPrekey,
           prekeys.contentPrekeySignature,
           prekeys.notifPrekey,
           prekeys.notifPrekeySignature,
         );
         const { userID, accessToken: token } = JSON.parse(loginResult);
         const identityAuthResult = { accessToken: token, userID, username };
 
         const validatedResult = assertWithValidator(
           identityAuthResult,
           identityAuthResultValidator,
         );
 
         await commCoreModule.setCommServicesAuthMetadata(
           validatedResult.userID,
           primaryIdentityPublicKeys.ed25519,
           validatedResult.accessToken,
         );
 
         return validatedResult;
       },
       registerWalletUser: async (
         walletAddress: string,
         siweMessage: string,
         siweSignature: string,
         fid: ?string,
       ) => {
         await commCoreModule.initializeCryptoAccount();
         const [
           { blobPayload, signature, primaryIdentityPublicKeys },
           { contentOneTimeKeys, notificationsOneTimeKeys },
           prekeys,
         ] = await Promise.all([
           commCoreModule.getUserPublicKey(),
           commCoreModule.getOneTimeKeys(ONE_TIME_KEYS_NUMBER),
           commCoreModule.validateAndGetPrekeys(),
         ]);
         const registrationResult = await commRustModule.registerWalletUser(
           siweMessage,
           siweSignature,
           blobPayload,
           signature,
           prekeys.contentPrekey,
           prekeys.contentPrekeySignature,
           prekeys.notifPrekey,
           prekeys.notifPrekeySignature,
           getOneTimeKeyValues(contentOneTimeKeys),
           getOneTimeKeyValues(notificationsOneTimeKeys),
           fid ?? '',
         );
         const { userID, accessToken: token } = JSON.parse(registrationResult);
         const identityAuthResult = {
           accessToken: token,
           userID,
           username: walletAddress,
         };
 
         const validatedResult = assertWithValidator(
           identityAuthResult,
           identityAuthResultValidator,
         );
 
         await commCoreModule.setCommServicesAuthMetadata(
           validatedResult.userID,
           primaryIdentityPublicKeys.ed25519,
           validatedResult.accessToken,
         );
 
         return validatedResult;
       },
       logInWalletUser: async (
         walletAddress: string,
         siweMessage: string,
         siweSignature: string,
       ) => {
         await commCoreModule.initializeCryptoAccount();
         const [{ blobPayload, signature, primaryIdentityPublicKeys }, prekeys] =
           await Promise.all([
             commCoreModule.getUserPublicKey(),
             commCoreModule.validateAndGetPrekeys(),
           ]);
         const loginResult = await commRustModule.logInWalletUser(
           siweMessage,
           siweSignature,
           blobPayload,
           signature,
           prekeys.contentPrekey,
           prekeys.contentPrekeySignature,
           prekeys.notifPrekey,
           prekeys.notifPrekeySignature,
         );
         const { userID, accessToken: token } = JSON.parse(loginResult);
         const identityAuthResult = {
           accessToken: token,
           userID,
           username: walletAddress,
         };
 
         const validatedResult = assertWithValidator(
           identityAuthResult,
           identityAuthResultValidator,
         );
 
         await commCoreModule.setCommServicesAuthMetadata(
           validatedResult.userID,
           primaryIdentityPublicKeys.ed25519,
           validatedResult.accessToken,
         );
 
         return validatedResult;
       },
       uploadKeysForRegisteredDeviceAndLogIn: async (
         userID: string,
-        nonceChallengeResponse: SignedMessage,
+        nonceChallengeResponse: SignedNonce,
       ) => {
         await commCoreModule.initializeCryptoAccount();
         const [
           { blobPayload, signature, primaryIdentityPublicKeys },
           { contentOneTimeKeys, notificationsOneTimeKeys },
           prekeys,
         ] = await Promise.all([
           commCoreModule.getUserPublicKey(),
           commCoreModule.getOneTimeKeys(ONE_TIME_KEYS_NUMBER),
           commCoreModule.validateAndGetPrekeys(),
         ]);
-        const challengeResponse = JSON.stringify(nonceChallengeResponse);
+        const { nonce, nonceSignature } = nonceChallengeResponse;
         const registrationResult =
           await commRustModule.uploadSecondaryDeviceKeysAndLogIn(
             userID,
-            challengeResponse,
+            nonce,
+            nonceSignature,
             blobPayload,
             signature,
             prekeys.contentPrekey,
             prekeys.contentPrekeySignature,
             prekeys.notifPrekey,
             prekeys.notifPrekeySignature,
             getOneTimeKeyValues(contentOneTimeKeys),
             getOneTimeKeyValues(notificationsOneTimeKeys),
           );
         const { accessToken: token } = JSON.parse(registrationResult);
 
         const identityAuthResult = { accessToken: token, userID, username: '' };
         const validatedResult = assertWithValidator(
           identityAuthResult,
           identityAuthResultValidator,
         );
 
         await commCoreModule.setCommServicesAuthMetadata(
           validatedResult.userID,
           primaryIdentityPublicKeys.ed25519,
           validatedResult.accessToken,
         );
 
         return validatedResult;
       },
       generateNonce: commRustModule.generateNonce,
       getDeviceListHistoryForUser: async (
         userID: string,
         sinceTimestamp?: number,
       ) => {
         const {
           deviceID: authDeviceID,
           userID: authUserID,
           accessToken: token,
         } = await getAuthMetadata();
         const result = await commRustModule.getDeviceListForUser(
           authUserID,
           authDeviceID,
           token,
           userID,
           sinceTimestamp,
         );
         const rawPayloads: string[] = JSON.parse(result);
         const deviceLists: SignedDeviceList[] = rawPayloads.map(payload =>
           JSON.parse(payload),
         );
         return assertWithValidator(
           deviceLists,
           signedDeviceListHistoryValidator,
         );
       },
       updateDeviceList: async (newDeviceList: SignedDeviceList) => {
         const {
           deviceID: authDeviceID,
           userID,
           accessToken: authAccessToken,
         } = await getAuthMetadata();
         const payload = JSON.stringify(newDeviceList);
         await commRustModule.updateDeviceList(
           userID,
           authDeviceID,
           authAccessToken,
           payload,
         );
       },
       getFarcasterUsers: async (farcasterIDs: $ReadOnlyArray<string>) => {
         const farcasterUsersJSONString =
           await commRustModule.getFarcasterUsers(farcasterIDs);
         const farcasterUsers = JSON.parse(farcasterUsersJSONString);
         return assertWithValidator(farcasterUsers, farcasterUsersValidator);
       },
       linkFarcasterAccount: async (farcasterID: string) => {
         const {
           deviceID,
           userID,
           accessToken: token,
         } = await getAuthMetadata();
         return commRustModule.linkFarcasterAccount(
           userID,
           deviceID,
           token,
           farcasterID,
         );
       },
       unlinkFarcasterAccount: async () => {
         const {
           deviceID,
           userID,
           accessToken: token,
         } = await getAuthMetadata();
         return commRustModule.unlinkFarcasterAccount(userID, deviceID, token);
       },
     }),
     [getAuthMetadata],
   );
 
   const value = React.useMemo(
     () => ({
       identityClient: client,
       getAuthMetadata,
     }),
     [client, getAuthMetadata],
   );
 
   return (
     <IdentityClientContext.Provider value={value}>
       {children}
     </IdentityClientContext.Provider>
   );
 }
 
 export default IdentityServiceContextProvider;
diff --git a/native/native_rust_library/src/identity/login.rs b/native/native_rust_library/src/identity/login.rs
index 418fc1b10..01c6da506 100644
--- a/native/native_rust_library/src/identity/login.rs
+++ b/native/native_rust_library/src/identity/login.rs
@@ -1,295 +1,306 @@
 use comm_opaque2::client::Login;
 use grpc_clients::identity::{
   get_unauthenticated_client,
   protos::unauth::{
     DeviceKeyUpload, ExistingDeviceLoginRequest, IdentityKeyInfo,
     OpaqueLoginFinishRequest, OpaqueLoginStartRequest, Prekey,
     SecondaryDeviceKeysUploadRequest, WalletAuthRequest,
   },
 };
 use tracing::instrument;
 
 use super::{PasswordUserInfo, UserIDAndDeviceAccessToken, WalletUserInfo};
 use crate::utils::jsi_callbacks::handle_string_result_as_callback;
 use crate::{Error, CODE_VERSION, DEVICE_TYPE, IDENTITY_SOCKET_ADDR, RUNTIME};
 
 pub mod ffi {
   use super::*;
 
   #[instrument]
   pub fn log_in_password_user(
     username: String,
     password: String,
     key_payload: String,
     key_payload_signature: String,
     content_prekey: String,
     content_prekey_signature: String,
     notif_prekey: String,
     notif_prekey_signature: String,
     promise_id: u32,
   ) {
     RUNTIME.spawn(async move {
       let password_user_info = PasswordUserInfo {
         username,
         password,
         key_payload,
         key_payload_signature,
         content_prekey,
         content_prekey_signature,
         notif_prekey,
         notif_prekey_signature,
         content_one_time_keys: Vec::new(),
         notif_one_time_keys: Vec::new(),
         farcaster_id: None,
       };
       let result = log_in_password_user_helper(password_user_info).await;
       handle_string_result_as_callback(result, promise_id);
     });
   }
 
   #[instrument]
   pub fn log_in_wallet_user(
     siwe_message: String,
     siwe_signature: String,
     key_payload: String,
     key_payload_signature: String,
     content_prekey: String,
     content_prekey_signature: String,
     notif_prekey: String,
     notif_prekey_signature: String,
     promise_id: u32,
   ) {
     RUNTIME.spawn(async move {
       let wallet_user_info = WalletUserInfo {
         siwe_message,
         siwe_signature,
         key_payload,
         key_payload_signature,
         content_prekey,
         content_prekey_signature,
         notif_prekey,
         notif_prekey_signature,
         content_one_time_keys: Vec::new(),
         notif_one_time_keys: Vec::new(),
         farcaster_id: None,
       };
       let result = log_in_wallet_user_helper(wallet_user_info).await;
       handle_string_result_as_callback(result, promise_id);
     });
   }
 
   // QR code device log in
   pub fn upload_secondary_device_keys_and_log_in(
     user_id: String,
-    challenge_response: String,
+    nonce: String,
+    nonce_signature: String,
     key_payload: String,
     key_payload_signature: String,
     content_prekey: String,
     content_prekey_signature: String,
     notif_prekey: String,
     notif_prekey_signature: String,
     content_one_time_keys: Vec<String>,
     notif_one_time_keys: Vec<String>,
     promise_id: u32,
   ) {
     RUNTIME.spawn(async move {
       let device_key_upload = DeviceKeyUpload {
         device_key_info: Some(IdentityKeyInfo {
           payload: key_payload,
           payload_signature: key_payload_signature,
         }),
         content_upload: Some(Prekey {
           prekey: content_prekey,
           prekey_signature: content_prekey_signature,
         }),
         notif_upload: Some(Prekey {
           prekey: notif_prekey,
           prekey_signature: notif_prekey_signature,
         }),
         one_time_content_prekeys: content_one_time_keys,
         one_time_notif_prekeys: notif_one_time_keys,
         device_type: DEVICE_TYPE.into(),
       };
 
       let result = upload_secondary_device_keys_and_log_in_helper(
         user_id,
-        challenge_response,
+        nonce,
+        nonce_signature,
         device_key_upload,
       )
       .await;
       handle_string_result_as_callback(result, promise_id);
     });
   }
 
   pub fn log_in_existing_device(
     user_id: String,
     device_id: String,
-    challenge_response: String,
+    nonce: String,
+    nonce_signature: String,
     promise_id: u32,
   ) {
     RUNTIME.spawn(async move {
-      let result =
-        log_in_existing_device_helper(user_id, device_id, challenge_response)
-          .await;
+      let result = log_in_existing_device_helper(
+        user_id,
+        device_id,
+        nonce,
+        nonce_signature,
+      )
+      .await;
       handle_string_result_as_callback(result, promise_id);
     });
   }
 }
 
 async fn log_in_password_user_helper(
   password_user_info: PasswordUserInfo,
 ) -> Result<String, Error> {
   let mut client_login = Login::new();
   let opaque_login_request = client_login
     .start(&password_user_info.password)
     .map_err(crate::handle_error)?;
   let login_start_request = OpaqueLoginStartRequest {
     opaque_login_request,
     username: password_user_info.username,
     device_key_upload: Some(DeviceKeyUpload {
       device_key_info: Some(IdentityKeyInfo {
         payload: password_user_info.key_payload,
         payload_signature: password_user_info.key_payload_signature,
       }),
       content_upload: Some(Prekey {
         prekey: password_user_info.content_prekey,
         prekey_signature: password_user_info.content_prekey_signature,
       }),
       notif_upload: Some(Prekey {
         prekey: password_user_info.notif_prekey,
         prekey_signature: password_user_info.notif_prekey_signature,
       }),
       one_time_content_prekeys: password_user_info.content_one_time_keys,
       one_time_notif_prekeys: password_user_info.notif_one_time_keys,
       device_type: DEVICE_TYPE.into(),
     }),
     force: None,
   };
 
   let mut identity_client = get_unauthenticated_client(
     IDENTITY_SOCKET_ADDR,
     CODE_VERSION,
     DEVICE_TYPE.as_str_name().to_lowercase(),
   )
   .await?;
 
   let response = identity_client
     .log_in_password_user_start(login_start_request)
     .await?;
 
   let login_start_response = response.into_inner();
 
   let opaque_login_upload = client_login
     .finish(&login_start_response.opaque_login_response)
     .map_err(crate::handle_error)?;
 
   let login_finish_request = OpaqueLoginFinishRequest {
     session_id: login_start_response.session_id,
     opaque_login_upload,
   };
 
   let login_finish_response = identity_client
     .log_in_password_user_finish(login_finish_request)
     .await?
     .into_inner();
   let user_id_and_access_token =
     UserIDAndDeviceAccessToken::from(login_finish_response);
   Ok(serde_json::to_string(&user_id_and_access_token)?)
 }
 
 async fn log_in_wallet_user_helper(
   wallet_user_info: WalletUserInfo,
 ) -> Result<String, Error> {
   let login_request = WalletAuthRequest {
     siwe_message: wallet_user_info.siwe_message,
     siwe_signature: wallet_user_info.siwe_signature,
     device_key_upload: Some(DeviceKeyUpload {
       device_key_info: Some(IdentityKeyInfo {
         payload: wallet_user_info.key_payload,
         payload_signature: wallet_user_info.key_payload_signature,
       }),
       content_upload: Some(Prekey {
         prekey: wallet_user_info.content_prekey,
         prekey_signature: wallet_user_info.content_prekey_signature,
       }),
       notif_upload: Some(Prekey {
         prekey: wallet_user_info.notif_prekey,
         prekey_signature: wallet_user_info.notif_prekey_signature,
       }),
       one_time_content_prekeys: wallet_user_info.content_one_time_keys,
       one_time_notif_prekeys: wallet_user_info.notif_one_time_keys,
       device_type: DEVICE_TYPE.into(),
     }),
     farcaster_id: None,
   };
 
   let mut identity_client = get_unauthenticated_client(
     IDENTITY_SOCKET_ADDR,
     CODE_VERSION,
     DEVICE_TYPE.as_str_name().to_lowercase(),
   )
   .await?;
 
   let login_response = identity_client
     .log_in_wallet_user(login_request)
     .await?
     .into_inner();
 
   let user_id_and_access_token =
     UserIDAndDeviceAccessToken::from(login_response);
   Ok(serde_json::to_string(&user_id_and_access_token)?)
 }
 
 async fn upload_secondary_device_keys_and_log_in_helper(
   user_id: String,
-  challenge_response: String,
+  nonce: String,
+  nonce_signature: String,
   device_key_upload: DeviceKeyUpload,
 ) -> Result<String, Error> {
   let mut identity_client = get_unauthenticated_client(
     IDENTITY_SOCKET_ADDR,
     CODE_VERSION,
     DEVICE_TYPE.as_str_name().to_lowercase(),
   )
   .await?;
 
   let request = SecondaryDeviceKeysUploadRequest {
     user_id,
-    challenge_response,
+    nonce,
+    nonce_signature,
     device_key_upload: Some(device_key_upload),
   };
 
   let response = identity_client
     .upload_keys_for_registered_device_and_log_in(request)
     .await?
     .into_inner();
 
   let user_id_and_access_token = UserIDAndDeviceAccessToken::from(response);
   Ok(serde_json::to_string(&user_id_and_access_token)?)
 }
 
 async fn log_in_existing_device_helper(
   user_id: String,
   device_id: String,
-  challenge_response: String,
+  nonce: String,
+  nonce_signature: String,
 ) -> Result<String, Error> {
   let mut identity_client = get_unauthenticated_client(
     IDENTITY_SOCKET_ADDR,
     CODE_VERSION,
     DEVICE_TYPE.as_str_name().to_lowercase(),
   )
   .await?;
 
   let request = ExistingDeviceLoginRequest {
     user_id,
     device_id,
-    challenge_response,
+    nonce,
+    nonce_signature,
   };
 
   let response = identity_client
     .log_in_existing_device(request)
     .await?
     .into_inner();
 
   let user_id_and_access_token = UserIDAndDeviceAccessToken::from(response);
   Ok(serde_json::to_string(&user_id_and_access_token)?)
 }
diff --git a/native/native_rust_library/src/lib.rs b/native/native_rust_library/src/lib.rs
index 3dff23a97..af5153657 100644
--- a/native/native_rust_library/src/lib.rs
+++ b/native/native_rust_library/src/lib.rs
@@ -1,446 +1,448 @@
 use comm_opaque2::grpc::opaque_error_to_grpc_status as handle_error;
 use grpc_clients::identity::protos::unauth::DeviceType;
 use lazy_static::lazy_static;
 use std::sync::Arc;
 use tokio::runtime::{Builder, Runtime};
 use tonic::Status;
 
 mod argon2_tools;
 mod backup;
 mod constants;
 mod identity;
 mod utils;
 
 use crate::argon2_tools::compute_backup_key_str;
 use crate::utils::jsi_callbacks::{
   handle_string_result_as_callback, handle_void_result_as_callback,
 };
 
 mod generated {
   // We get the CODE_VERSION from this generated file
   include!(concat!(env!("OUT_DIR"), "/version.rs"));
   // We get the IDENTITY_SOCKET_ADDR from this generated file
   include!(concat!(env!("OUT_DIR"), "/socket_config.rs"));
 }
 
 pub use generated::CODE_VERSION;
 pub use generated::{BACKUP_SOCKET_ADDR, IDENTITY_SOCKET_ADDR};
 
 #[cfg(not(target_os = "android"))]
 pub const DEVICE_TYPE: DeviceType = DeviceType::Ios;
 #[cfg(target_os = "android")]
 pub const DEVICE_TYPE: DeviceType = DeviceType::Android;
 
 lazy_static! {
   static ref RUNTIME: Arc<Runtime> =
     Arc::new(Builder::new_multi_thread().enable_all().build().unwrap());
 }
 
 // ffi uses
 use backup::ffi::*;
 use identity::ffi::*;
 use utils::future_manager::ffi::*;
 
 #[cxx::bridge]
 mod ffi {
 
   // Identity Service APIs
   extern "Rust" {
     #[cxx_name = "identityRegisterPasswordUser"]
     fn register_password_user(
       username: String,
       password: String,
       key_payload: String,
       key_payload_signature: String,
       content_prekey: String,
       content_prekey_signature: String,
       notif_prekey: String,
       notif_prekey_signature: String,
       content_one_time_keys: Vec<String>,
       notif_one_time_keys: Vec<String>,
       farcaster_id: String,
       promise_id: u32,
     );
 
     #[cxx_name = "identityLogInPasswordUser"]
     fn log_in_password_user(
       username: String,
       password: String,
       key_payload: String,
       key_payload_signature: String,
       content_prekey: String,
       content_prekey_signature: String,
       notif_prekey: String,
       notif_prekey_signature: String,
       promise_id: u32,
     );
 
     #[cxx_name = "identityRegisterWalletUser"]
     fn register_wallet_user(
       siwe_message: String,
       siwe_signature: String,
       key_payload: String,
       key_payload_signature: String,
       content_prekey: String,
       content_prekey_signature: String,
       notif_prekey: String,
       notif_prekey_signature: String,
       content_one_time_keys: Vec<String>,
       notif_one_time_keys: Vec<String>,
       farcaster_id: String,
       promise_id: u32,
     );
 
     #[cxx_name = "identityLogInWalletUser"]
     fn log_in_wallet_user(
       siwe_message: String,
       siwe_signature: String,
       key_payload: String,
       key_payload_signature: String,
       content_prekey: String,
       content_prekey_signature: String,
       notif_prekey: String,
       notif_prekey_signature: String,
       promise_id: u32,
     );
 
     #[cxx_name = "identityUpdateUserPassword"]
     fn update_user_password(
       user_id: String,
       device_id: String,
       access_token: String,
       password: String,
       promise_id: u32,
     );
 
     #[cxx_name = "identityDeleteUser"]
     fn delete_user(
       user_id: String,
       device_id: String,
       access_token: String,
       promise_id: u32,
     );
 
     #[cxx_name = "identityLogOut"]
     fn log_out(
       user_id: String,
       device_id: String,
       access_token: String,
       promise_id: u32,
     );
 
     #[cxx_name = "identityGetOutboundKeysForUser"]
     fn get_outbound_keys_for_user(
       auth_user_id: String,
       auth_device_id: String,
       auth_access_token: String,
       user_id: String,
       promise_id: u32,
     );
 
     #[cxx_name = "identityGetInboundKeysForUser"]
     fn get_inbound_keys_for_user(
       auth_user_id: String,
       auth_device_id: String,
       auth_access_token: String,
       user_id: String,
       promise_id: u32,
     );
 
     #[cxx_name = "identityRefreshUserPrekeys"]
     fn refresh_user_prekeys(
       auth_user_id: String,
       auth_device_id: String,
       auth_access_token: String,
       content_prekey: String,
       content_prekey_signature: String,
       notif_prekey: String,
       notif_prekey_signature: String,
       promise_id: u32,
     );
 
     #[cxx_name = "identityGenerateNonce"]
     fn generate_nonce(promise_id: u32);
 
     #[cxx_name = "identityVersionSupported"]
     fn version_supported(promise_id: u32);
 
     #[cxx_name = "identityUploadOneTimeKeys"]
     fn upload_one_time_keys(
       auth_user_id: String,
       auth_device_id: String,
       auth_access_token: String,
       content_one_time_keys: Vec<String>,
       notif_one_time_keys: Vec<String>,
       promise_id: u32,
     );
 
     #[cxx_name = "identityGetKeyserverKeys"]
     fn get_keyserver_keys(
       user_id: String,
       device_id: String,
       access_token: String,
       keyserver_id: String,
       promise_id: u32,
     );
 
     #[cxx_name = "identityGetDeviceListForUser"]
     fn get_device_list_for_user(
       auth_user_id: String,
       auth_device_id: String,
       auth_access_token: String,
       user_id: String,
       since_timestamp: i64,
       promise_id: u32,
     );
 
     #[cxx_name = "identityUpdateDeviceList"]
     fn update_device_list(
       auth_user_id: String,
       auth_device_id: String,
       auth_access_token: String,
       update_payload: String,
       promise_id: u32,
     );
 
     #[cxx_name = "identityUploadSecondaryDeviceKeysAndLogIn"]
     fn upload_secondary_device_keys_and_log_in(
       user_id: String,
-      challenge_response: String,
+      nonce: String,
+      nonce_signature: String,
       key_payload: String,
       key_payload_signature: String,
       content_prekey: String,
       content_prekey_signature: String,
       notif_prekey: String,
       notif_prekey_signature: String,
       content_one_time_keys: Vec<String>,
       notif_one_time_keys: Vec<String>,
       promise_id: u32,
     );
 
     #[cxx_name = "identityLogInExistingDevice"]
     fn log_in_existing_device(
       user_id: String,
       device_id: String,
-      challenge_response: String,
+      nonce: String,
+      nonce_signature: String,
       promise_id: u32,
     );
 
     #[cxx_name = "identityFindUserIDForWalletAddress"]
     fn find_user_id_for_wallet_address(wallet_address: String, promise_id: u32);
 
     #[cxx_name = "identityFindUserIDForUsername"]
     fn find_user_id_for_username(username: String, promise_id: u32);
 
     // Farcaster
     #[cxx_name = "identityGetFarcasterUsers"]
     fn get_farcaster_users(farcaster_ids: Vec<String>, promise_id: u32);
 
     #[cxx_name = "identityLinkFarcasterAccount"]
     fn link_farcaster_account(
       user_id: String,
       device_id: String,
       access_token: String,
       farcaster_id: String,
       promise_id: u32,
     );
 
     #[cxx_name = "identityUnlinkFarcasterAccount"]
     fn unlink_farcaster_account(
       user_id: String,
       device_id: String,
       access_token: String,
       promise_id: u32,
     );
 
     // Argon2
     #[cxx_name = "compute_backup_key"]
     fn compute_backup_key_str(
       password: &str,
       backup_id: &str,
     ) -> Result<[u8; 32]>;
   }
 
   unsafe extern "C++" {
     include!("RustCallback.h");
     #[namespace = "comm"]
     #[cxx_name = "stringCallback"]
     fn string_callback(error: String, promise_id: u32, ret: String);
 
     #[namespace = "comm"]
     #[cxx_name = "voidCallback"]
     fn void_callback(error: String, promise_id: u32);
 
     #[namespace = "comm"]
     #[cxx_name = "boolCallback"]
     fn bool_callback(error: String, promise_id: u32, ret: bool);
   }
 
   // AES cryptography
   #[namespace = "comm"]
   unsafe extern "C++" {
     include!("RustAESCrypto.h");
 
     #[allow(unused)]
     #[cxx_name = "aesGenerateKey"]
     fn generate_key(buffer: &mut [u8]) -> Result<()>;
 
     /// The first two argument aren't mutated but creation of Java ByteBuffer
     /// requires the underlying bytes to be mutable.
     #[allow(unused)]
     #[cxx_name = "aesEncrypt"]
     fn encrypt(
       key: &mut [u8],
       plaintext: &mut [u8],
       sealed_data: &mut [u8],
     ) -> Result<()>;
 
     /// The first two argument aren't mutated but creation of Java ByteBuffer
     /// requires the underlying bytes to be mutable.
     #[allow(unused)]
     #[cxx_name = "aesDecrypt"]
     fn decrypt(
       key: &mut [u8],
       sealed_data: &mut [u8],
       plaintext: &mut [u8],
     ) -> Result<()>;
   }
 
   // Comm Services Auth Metadata Emission
   #[namespace = "comm"]
   unsafe extern "C++" {
     include!("RustCSAMetadataEmitter.h");
 
     #[allow(unused)]
     #[cxx_name = "sendAuthMetadataToJS"]
     fn send_auth_metadata_to_js(
       access_token: String,
       user_id: String,
     ) -> Result<()>;
   }
 
   // Backup
   extern "Rust" {
     #[cxx_name = "startBackupHandler"]
     fn start_backup_handler() -> Result<()>;
     #[cxx_name = "stopBackupHandler"]
     fn stop_backup_handler() -> Result<()>;
 
     #[cxx_name = "triggerBackupFileUpload"]
     fn trigger_backup_file_upload();
 
     #[cxx_name = "createBackup"]
     fn create_backup(
       backup_id: String,
       backup_secret: String,
       pickle_key: String,
       pickled_account: String,
       promise_id: u32,
     );
 
     #[cxx_name = "restoreBackup"]
     fn restore_backup(backup_secret: String, promise_id: u32);
 
     #[cxx_name = "restoreBackupData"]
     fn restore_backup_data(
       backup_id: String,
       backup_data_key: String,
       backup_log_data_key: String,
       promise_id: u32,
     );
 
     #[cxx_name = "retrieveBackupKeys"]
     fn retrieve_backup_keys(backup_secret: String, promise_id: u32);
   }
 
   // Secure store
   #[namespace = "comm"]
   unsafe extern "C++" {
     include!("RustSecureStore.h");
 
     #[allow(unused)]
     #[cxx_name = "secureStoreSet"]
     fn secure_store_set(key: &str, value: String) -> Result<()>;
 
     #[cxx_name = "secureStoreGet"]
     fn secure_store_get(key: &str) -> Result<String>;
   }
 
   // C++ Backup creation
   #[namespace = "comm"]
   unsafe extern "C++" {
     include!("RustBackupExecutor.h");
 
     #[cxx_name = "getBackupDirectoryPath"]
     fn get_backup_directory_path() -> Result<String>;
 
     #[cxx_name = "getBackupFilePath"]
     fn get_backup_file_path(
       backup_id: &str,
       is_attachments: bool,
     ) -> Result<String>;
 
     #[cxx_name = "getBackupLogFilePath"]
     fn get_backup_log_file_path(
       backup_id: &str,
       log_id: &str,
       is_attachments: bool,
     ) -> Result<String>;
 
     #[cxx_name = "getBackupUserKeysFilePath"]
     fn get_backup_user_keys_file_path(backup_id: &str) -> Result<String>;
 
     #[cxx_name = "createMainCompaction"]
     fn create_main_compaction(backup_id: &str, future_id: usize);
 
     #[cxx_name = "restoreFromMainCompaction"]
     fn restore_from_main_compaction(
       main_compaction_path: &str,
       main_compaction_encryption_key: &str,
       future_id: usize,
     );
 
     #[cxx_name = "restoreFromBackupLog"]
     fn restore_from_backup_log(backup_log: Vec<u8>, future_id: usize);
   }
 
   // Future handling from C++
   extern "Rust" {
     #[cxx_name = "resolveUnitFuture"]
     fn resolve_unit_future(future_id: usize);
 
     #[cxx_name = "rejectFuture"]
     fn reject_future(future_id: usize, error: String);
   }
 }
 
 #[derive(
   Debug, derive_more::Display, derive_more::From, derive_more::Error,
 )]
 pub enum Error {
   #[display(fmt = "{}", "_0.message()")]
   TonicGRPC(Status),
   #[display(fmt = "{}", "_0")]
   SerdeJson(serde_json::Error),
   #[display(fmt = "Missing response data")]
   MissingResponseData,
   #[display(fmt = "{}", "_0")]
   GRPClient(grpc_clients::error::Error),
 }
 
 #[cfg(test)]
 #[allow(clippy::assertions_on_constants)]
 mod tests {
   use super::{BACKUP_SOCKET_ADDR, CODE_VERSION, IDENTITY_SOCKET_ADDR};
 
   #[test]
   fn test_code_version_exists() {
     assert!(CODE_VERSION > 0);
   }
 
   #[test]
   fn test_identity_socket_addr_exists() {
     assert!(!IDENTITY_SOCKET_ADDR.is_empty());
     assert!(!BACKUP_SOCKET_ADDR.is_empty());
   }
 }
diff --git a/native/qr-code/qr-code-screen.react.js b/native/qr-code/qr-code-screen.react.js
index 1c6d64ab2..ded5027f1 100644
--- a/native/qr-code/qr-code-screen.react.js
+++ b/native/qr-code/qr-code-screen.react.js
@@ -1,182 +1,177 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { View, Text } from 'react-native';
 import QRCode from 'react-native-qrcode-svg';
 
 import { QRAuthHandler } from 'lib/components/qr-auth-handler.react.js';
 import { qrCodeLinkURL } from 'lib/facts/links.js';
 import { uintArrayToHexString } from 'lib/media/data-utils.js';
 import { IdentityClientContext } from 'lib/shared/identity-client-context.js';
 import { useTunnelbroker } from 'lib/tunnelbroker/tunnelbroker-context.js';
 import type { BackupKeys } from 'lib/types/backup-types.js';
-import type {
-  NonceChallenge,
-  SignedMessage,
-} from 'lib/types/identity-service-types.js';
+import type { SignedNonce } from 'lib/types/identity-service-types.js';
 import { getContentSigningKey } from 'lib/utils/crypto-utils.js';
 
 import type { QRCodeSignInNavigationProp } from './qr-code-sign-in-navigator.react.js';
 import {
   composeTunnelbrokerQRAuthMessage,
   parseTunnelbrokerQRAuthMessage,
 } from './qr-code-utils.js';
 import { olmAPI } from '../crypto/olm-api.js';
 import { commCoreModule } from '../native-modules.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 import { useStyles } from '../themes/colors.js';
 import * as AES from '../utils/aes-crypto-module.js';
 import Alert from '../utils/alert.js';
 
 type QRCodeScreenProps = {
   +navigation: QRCodeSignInNavigationProp<'QRCodeScreen'>,
   +route: NavigationRoute<'QRCodeScreen'>,
 };
 
 function performBackupRestore(backupKeys: BackupKeys): Promise<void> {
   const { backupID, backupDataKey, backupLogDataKey } = backupKeys;
   return commCoreModule.restoreBackupData(
     backupID,
     backupDataKey,
     backupLogDataKey,
   );
 }
 
 // eslint-disable-next-line no-unused-vars
 function QRCodeScreen(props: QRCodeScreenProps): React.Node {
   const [qrCodeValue, setQrCodeValue] = React.useState<?string>();
   const [qrData, setQRData] =
     React.useState<?{ +deviceID: string, +aesKey: string }>();
   const { setUnauthorizedDeviceID } = useTunnelbroker();
 
   const identityContext = React.useContext(IdentityClientContext);
   const identityClient = identityContext?.identityClient;
 
   const performRegistration = React.useCallback(
     async (userID: string) => {
       invariant(identityClient, 'identity context not set');
       try {
         const nonce = await identityClient.generateNonce();
-        const nonceChallenge: NonceChallenge = { nonce };
-        const nonceMessage = JSON.stringify(nonceChallenge);
-        const signature = await olmAPI.signMessage(nonceMessage);
-        const challengeResponse: SignedMessage = {
-          message: nonceMessage,
-          signature,
+        const nonceSignature = await olmAPI.signMessage(nonce);
+        const challengeResponse: SignedNonce = {
+          nonce,
+          nonceSignature,
         };
 
         await identityClient.uploadKeysForRegisteredDeviceAndLogIn(
           userID,
           challengeResponse,
         );
         setUnauthorizedDeviceID(null);
       } catch (err) {
         console.error('Secondary device registration error:', err);
         Alert.alert('Registration failed', 'Failed to upload device keys', [
           { text: 'OK' },
         ]);
       }
     },
     [setUnauthorizedDeviceID, identityClient],
   );
 
   const generateQRCode = React.useCallback(async () => {
     try {
       const rawAESKey: Uint8Array = await AES.generateKey();
       const aesKeyAsHexString: string = uintArrayToHexString(rawAESKey);
 
       const ed25519Key: string = await getContentSigningKey();
 
       const url = qrCodeLinkURL(aesKeyAsHexString, ed25519Key);
       setUnauthorizedDeviceID(ed25519Key);
       setQrCodeValue(url);
       setQRData({ deviceID: ed25519Key, aesKey: aesKeyAsHexString });
     } catch (err) {
       console.error('Failed to generate QR Code:', err);
     }
   }, [setUnauthorizedDeviceID]);
 
   React.useEffect(() => {
     void generateQRCode();
   }, [generateQRCode]);
 
   const styles = useStyles(unboundStyles);
   return (
     <>
       <QRAuthHandler
         secondaryDeviceID={qrData?.deviceID}
         aesKey={qrData?.aesKey}
         performSecondaryDeviceRegistration={performRegistration}
         composeMessage={composeTunnelbrokerQRAuthMessage}
         processMessage={parseTunnelbrokerQRAuthMessage}
         performBackupRestore={performBackupRestore}
       />
       <View style={styles.container}>
         <Text style={styles.heading}>Log in to Comm</Text>
         <Text style={styles.headingSubtext}>
           Open the Comm app on your phone and scan the QR code below
         </Text>
         <QRCode value={qrCodeValue} size={200} />
         <View style={styles.instructionsBox}>
           <Text style={styles.instructionsTitle}>How to find the scanner:</Text>
           <Text style={styles.instructionsStep}>
             <Text>Go to </Text>
             <Text style={styles.instructionsBold}>Profile</Text>
           </Text>
           <Text style={styles.instructionsStep}>
             <Text>Select </Text>
             <Text style={styles.instructionsBold}>Linked devices </Text>
           </Text>
           <Text style={styles.instructionsStep}>
             <Text>Click </Text>
             <Text style={styles.instructionsBold}>Add </Text>
             <Text>on the top right</Text>
           </Text>
         </View>
       </View>
     </>
   );
 }
 
 const unboundStyles = {
   container: {
     flex: 1,
     alignItems: 'center',
     marginTop: 125,
   },
   heading: {
     fontSize: 24,
     color: 'panelForegroundLabel',
     paddingBottom: 12,
   },
   headingSubtext: {
     fontSize: 12,
     color: 'panelForegroundLabel',
     paddingBottom: 30,
   },
   instructionsBox: {
     alignItems: 'center',
     width: 300,
     marginTop: 40,
     padding: 15,
     borderColor: 'panelForegroundLabel',
     borderWidth: 2,
     borderRadius: 8,
   },
   instructionsTitle: {
     fontSize: 12,
     color: 'panelForegroundLabel',
     paddingBottom: 15,
   },
   instructionsStep: {
     fontSize: 12,
     padding: 1,
     color: 'panelForegroundLabel',
   },
   instructionsBold: {
     fontWeight: 'bold',
   },
 };
 
 export default QRCodeScreen;
diff --git a/native/schema/CommRustModuleSchema.js b/native/schema/CommRustModuleSchema.js
index 288d941c2..04b0036a4 100644
--- a/native/schema/CommRustModuleSchema.js
+++ b/native/schema/CommRustModuleSchema.js
@@ -1,146 +1,148 @@
 // @flow
 
 'use strict';
 
 import { TurboModuleRegistry } from 'react-native';
 import type { TurboModule } from 'react-native/Libraries/TurboModule/RCTExport.js';
 
 export interface Spec extends TurboModule {
   +generateNonce: () => Promise<string>;
   +registerPasswordUser: (
     username: string,
     password: string,
     keyPayload: string,
     keyPayloadSignature: string,
     contentPrekey: string,
     contentPrekeySignature: string,
     notifPrekey: string,
     notifPrekeySignature: string,
     contentOneTimeKeys: $ReadOnlyArray<string>,
     notifOneTimeKeys: $ReadOnlyArray<string>,
     farcasterID: string,
   ) => Promise<string>;
   +logInPasswordUser: (
     username: string,
     password: string,
     keyPayload: string,
     keyPayloadSignature: string,
     contentPrekey: string,
     contentPrekeySignature: string,
     notifPrekey: string,
     notifPrekeySignature: string,
   ) => Promise<string>;
   +registerWalletUser: (
     siweMessage: string,
     siweSignature: string,
     keyPayload: string,
     keyPayloadSignature: string,
     contentPrekey: string,
     contentPrekeySignature: string,
     notifPrekey: string,
     notifPrekeySignature: string,
     contentOneTimeKeys: $ReadOnlyArray<string>,
     notifOneTimeKeys: $ReadOnlyArray<string>,
     farcasterID: string,
   ) => Promise<string>;
   +logInWalletUser: (
     siweMessage: string,
     siweSignature: string,
     keyPayload: string,
     keyPayloadSignature: string,
     contentPrekey: string,
     contentPrekeySignature: string,
     notifPrekey: string,
     notifPrekeySignature: string,
   ) => Promise<string>;
   +updatePassword: (
     userID: string,
     deviceID: string,
     accessToken: string,
     password: string,
   ) => Promise<void>;
   +deleteUser: (
     userID: string,
     deviceID: string,
     accessToken: string,
   ) => Promise<void>;
   +logOut: (
     userID: string,
     deviceID: string,
     accessToken: string,
   ) => Promise<void>;
   +getOutboundKeysForUser: (
     authUserID: string,
     authDeviceID: string,
     authAccessToken: string,
     userID: string,
   ) => Promise<string>;
   +getInboundKeysForUser: (
     authUserID: string,
     authDeviceID: string,
     authAccessToken: string,
     userID: string,
   ) => Promise<string>;
   +versionSupported: () => Promise<boolean>;
   +uploadOneTimeKeys: (
     authUserID: string,
     authDeviceID: string,
     authAccessToken: string,
     contentOneTimePreKeys: $ReadOnlyArray<string>,
     notifOneTimePreKeys: $ReadOnlyArray<string>,
   ) => Promise<void>;
   +getKeyserverKeys: (
     authUserID: string,
     authDeviceID: string,
     authAccessToken: string,
     keyserverID: string,
   ) => Promise<string>;
   +getDeviceListForUser: (
     authUserID: string,
     authDeviceID: string,
     authAccessToken: string,
     userID: string,
     sinceTimestamp: ?number,
   ) => Promise<string>;
   +updateDeviceList: (
     authUserID: string,
     authDeviceID: string,
     authAccessToken: string,
     updatePayload: string,
   ) => Promise<void>;
   +uploadSecondaryDeviceKeysAndLogIn: (
     userID: string,
-    challengeResponse: string,
+    nonce: string,
+    nonceSignature: string,
     keyPayload: string,
     keyPayloadSignature: string,
     contentPrekey: string,
     contentPrekeySignature: string,
     notifPrekey: string,
     notifPrekeySignature: string,
     contentOneTimeKeys: $ReadOnlyArray<string>,
     notifOneTimeKeys: $ReadOnlyArray<string>,
   ) => Promise<string>;
   +logInExistingDevice: (
     userID: string,
     deviceID: string,
-    challengeResponse: string,
+    nonce: string,
+    nonceSignature: string,
   ) => Promise<string>;
   +findUserIDForWalletAddress: (walletAddress: string) => Promise<string>;
   +findUserIDForUsername: (username: string) => Promise<string>;
   +getFarcasterUsers: (farcasterIDs: $ReadOnlyArray<string>) => Promise<string>;
   +linkFarcasterAccount: (
     userID: string,
     deviceID: string,
     accessToken: string,
     farcasterID: string,
   ) => Promise<void>;
   +unlinkFarcasterAccount: (
     userID: string,
     deviceID: string,
     accessToken: string,
   ) => Promise<void>;
 }
 
 export default (TurboModuleRegistry.getEnforcing<Spec>(
   'CommRustTurboModule',
 ): Spec);
diff --git a/services/commtest/src/identity/mod.rs b/services/commtest/src/identity/mod.rs
index 47a45bb1a..0cdcba510 100644
--- a/services/commtest/src/identity/mod.rs
+++ b/services/commtest/src/identity/mod.rs
@@ -1,68 +1,51 @@
 use base64::Engine;
 use ed25519_dalek::{ed25519::signature::SignerMut, Keypair, Signature};
 use rand::rngs::OsRng;
-use serde_json::json;
 
 use self::olm_account_infos::{
   ClientPublicKeys, IdentityPublicKeys, DEFAULT_CLIENT_KEYS,
 };
 
 pub mod device;
 pub mod olm_account_infos;
 
 pub struct SigningCapableAccount {
   signing_key: Keypair,
 }
 
 impl SigningCapableAccount {
   pub fn new() -> Self {
     let mut rng = OsRng {};
     let signing_key = Keypair::generate(&mut rng);
     Self { signing_key }
   }
 
   /// returns device public keys, required for device key upload
   pub fn public_keys(&self) -> ClientPublicKeys {
     let default = DEFAULT_CLIENT_KEYS.clone();
     let signing_public_key = self.signing_key.public.to_bytes();
     let ed25519 = base64::engine::general_purpose::STANDARD_NO_PAD
       .encode(signing_public_key);
 
     ClientPublicKeys {
       primary_identity_public_keys: IdentityPublicKeys {
         ed25519,
         ..default.primary_identity_public_keys
       },
       ..default
     }
   }
 
   /// signs message, returns signature
   pub fn sign_message(&mut self, message: &str) -> String {
     let signature: Signature = self.signing_key.sign(message.as_bytes());
     base64::engine::general_purpose::STANDARD_NO_PAD
       .encode(signature.to_bytes())
   }
-
-  /// returns value for challenge_response gRPC field
-  pub fn sign_nonce(&mut self, nonce: String) -> String {
-    let message = json!({
-      "nonce": nonce
-    });
-    let message_str =
-      serde_json::to_string(&message).expect("message stringify failed");
-    let message_signature = self.sign_message(&message_str);
-
-    let response = json!({
-      "message": message_str,
-      "signature": message_signature,
-    });
-    serde_json::to_string(&response).expect("response stringify failed")
-  }
 }
 
 impl Default for SigningCapableAccount {
   fn default() -> Self {
     Self::new()
   }
 }
diff --git a/services/commtest/tests/identity_access_tokens_tests.rs b/services/commtest/tests/identity_access_tokens_tests.rs
index bf7d988b4..45f155515 100644
--- a/services/commtest/tests/identity_access_tokens_tests.rs
+++ b/services/commtest/tests/identity_access_tokens_tests.rs
@@ -1,88 +1,89 @@
 use commtest::identity::device::{
   register_user_device, DEVICE_TYPE, PLACEHOLDER_CODE_VERSION,
 };
 use commtest::identity::SigningCapableAccount;
 use commtest::service_addr;
 use grpc_clients::identity::protos::unauth::{
   Empty, ExistingDeviceLoginRequest,
 };
 use grpc_clients::identity::{
   get_unauthenticated_client, protos::unauth::VerifyUserAccessTokenRequest,
 };
 
 #[tokio::test]
 async fn verify_access_token() {
   let identity_grpc_endpoint = service_addr::IDENTITY_GRPC.to_string();
   let device_info = register_user_device(None, None).await;
 
   let mut identity_client = get_unauthenticated_client(
     &identity_grpc_endpoint,
     PLACEHOLDER_CODE_VERSION,
     DEVICE_TYPE.to_string(),
   )
   .await
   .expect("Couldn't connect to identity service");
 
   let verify_request = VerifyUserAccessTokenRequest::from(&device_info);
   let response = identity_client
     .verify_user_access_token(verify_request)
     .await
     .unwrap();
 
   assert!(response.into_inner().token_valid);
 }
 
 #[tokio::test]
 async fn refresh_token_test() {
   let identity_grpc_endpoint = service_addr::IDENTITY_GRPC.to_string();
   let mut client = get_unauthenticated_client(
     &identity_grpc_endpoint,
     PLACEHOLDER_CODE_VERSION,
     DEVICE_TYPE.to_string(),
   )
   .await
   .expect("Couldn't connect to identity service");
 
   let mut account = SigningCapableAccount::new();
   let client_keys = account.public_keys();
   let user = register_user_device(Some(&client_keys), None).await;
 
   // refresh session
   let nonce = client
     .generate_nonce(Empty {})
     .await
     .expect("failed to generate nonce")
     .into_inner()
     .nonce;
-  let challenge_response = account.sign_nonce(nonce);
+  let nonce_signature = account.sign_message(&nonce);
   let new_credentials = client
     .log_in_existing_device(ExistingDeviceLoginRequest {
       user_id: user.user_id.clone(),
       device_id: user.device_id.clone(),
-      challenge_response,
+      nonce,
+      nonce_signature,
     })
     .await
     .expect("LogInExistingDevice call failed")
     .into_inner();
 
   // old token should now be invalid
   let old_token_result = client
     .verify_user_access_token(VerifyUserAccessTokenRequest::from(&user))
     .await
     .expect("failed to verify token")
     .into_inner();
   assert!(!old_token_result.token_valid);
 
   // new token should be valid
   let new_token_result = client
     .verify_user_access_token(VerifyUserAccessTokenRequest {
       user_id: new_credentials.user_id,
       access_token: new_credentials.access_token,
       device_id: user.device_id,
     })
     .await
     .expect("failed to verify token")
     .into_inner();
 
   assert!(new_token_result.token_valid);
 }
diff --git a/services/identity/src/client_service.rs b/services/identity/src/client_service.rs
index e0fb8ebae..617768b70 100644
--- a/services/identity/src/client_service.rs
+++ b/services/identity/src/client_service.rs
@@ -1,1154 +1,1151 @@
 // 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,
   ExistingDeviceLoginRequest, FindUserIdRequest, FindUserIdResponse,
   GenerateNonceResponse, OpaqueLoginFinishRequest, OpaqueLoginStartRequest,
   OpaqueLoginStartResponse, RegistrationFinishRequest, RegistrationStartRequest,
   RegistrationStartResponse, RemoveReservedUsernameRequest,
   ReservedRegistrationStartRequest, ReservedWalletRegistrationRequest,
   SecondaryDeviceKeysUploadRequest, VerifyUserAccessTokenRequest,
   VerifyUserAccessTokenResponse, WalletAuthRequest, GetFarcasterUsersRequest,
   GetFarcasterUsersResponse
 };
 use crate::grpc_services::shared::get_value;
 use crate::grpc_utils::{
-  ChallengeResponse, DeviceKeyUploadActions, NonceChallenge,
+  SignedNonce, DeviceKeyUploadActions,
 };
 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"));
     }
 
     if let Some(fid) = &message.farcaster_id {
       self.check_farcaster_id_taken(fid).await?;
     }
 
     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",
       ));
     }
 
     if let Some(fid) = &message.farcaster_id {
       self.check_farcaster_id_taken(fid).await?;
     }
 
     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 user_id = self
       .client
       .add_wallet_user_to_users_table(
         flattened_device_key_upload.clone(),
         wallet_address,
         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 login_time = chrono::Utc::now();
     self
       .client
       .add_wallet_user_to_users_table(
         flattened_device_key_upload.clone(),
         wallet_address,
         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 challenge_response = SignedNonce::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)?;
-
+    let nonce = challenge_response.verify_and_get_nonce(&device_id)?;
     self.verify_and_remove_nonce(&nonce).await?;
 
     let user_identifier = self
       .client
       .get_user_identifier(&user_id)
       .await
       .map_err(handle_db_error)?
       .ok_or_else(|| tonic::Status::not_found("user not found"))?;
 
     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 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 log_in_existing_device(
     &self,
     request: tonic::Request<ExistingDeviceLoginRequest>,
   ) -> std::result::Result<tonic::Response<AuthResponse>, tonic::Status> {
     let message = request.into_inner();
-    let challenge_response = ChallengeResponse::try_from(&message)?;
+    let challenge_response = SignedNonce::try_from(&message)?;
     let ExistingDeviceLoginRequest {
       user_id, device_id, ..
     } = message;
 
-    let NonceChallenge { nonce } =
-      challenge_response.verify_and_get_message(&device_id)?;
+    let nonce = challenge_response.verify_and_get_nonce(&device_id)?;
     self.verify_and_remove_nonce(&nonce).await?;
 
     let (identifier_response, device_list_response) = tokio::join!(
       self.client.get_user_identifier(&user_id),
       self.client.get_current_device_list(&user_id)
     );
     let user_identifier = identifier_response
       .map_err(handle_db_error)?
       .ok_or_else(|| tonic::Status::not_found("user not found"))?;
 
     let device_list = device_list_response
       .map_err(handle_db_error)?
       .ok_or_else(|| {
         warn!("User {} does not have a valid device list.", user_id);
         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 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)?;
 
     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> {
     let message = request.into_inner();
 
     let farcaster_users = self
       .client
       .get_farcaster_users(message.farcaster_ids)
       .await
       .map_err(handle_db_error)?
       .into_iter()
       .map(|d| d.0)
       .collect();
 
     Ok(Response::new(GetFarcasterUsersResponse { farcaster_users }))
   }
 }
 
 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 check_farcaster_id_taken(
     &self,
     farcaster_id: &str,
   ) -> Result<(), tonic::Status> {
     let fid_already_registered = !self
       .client
       .get_farcaster_users(vec![farcaster_id.to_string()])
       .await
       .map_err(handle_db_error)?
       .is_empty();
     if fid_already_registered {
       return Err(tonic::Status::already_exists(
         "farcaster ID already associated with different user",
       ));
     }
     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_utils.rs b/services/identity/src/grpc_utils.rs
index 607798ce1..25426babf 100644
--- a/services/identity/src/grpc_utils.rs
+++ b/services/identity/src/grpc_utils.rs
@@ -1,293 +1,285 @@
 use base64::{engine::general_purpose, Engine as _};
 use ed25519_dalek::{PublicKey, Signature, Verifier};
 use serde::Deserialize;
 use tonic::Status;
-use tracing::error;
 
 use crate::{
   database::DeviceRow,
   ddb_utils::Identifier as DBIdentifier,
   grpc_services::protos::{
     auth::{EthereumIdentity, Identity, InboundKeyInfo, OutboundKeyInfo},
     unauth::{
       DeviceKeyUpload, ExistingDeviceLoginRequest, OpaqueLoginStartRequest,
       RegistrationStartRequest, ReservedRegistrationStartRequest,
       ReservedWalletRegistrationRequest, SecondaryDeviceKeysUploadRequest,
       WalletAuthRequest,
     },
   },
-  siwe::SocialProof,
 };
 
 #[derive(Deserialize)]
-pub struct ChallengeResponse {
-  message: String,
+pub struct SignedNonce {
+  nonce: String,
   signature: String,
 }
 
-#[derive(Deserialize)]
-pub struct NonceChallenge {
-  pub nonce: String,
-}
-
-impl TryFrom<&SecondaryDeviceKeysUploadRequest> for ChallengeResponse {
+impl TryFrom<&SecondaryDeviceKeysUploadRequest> for SignedNonce {
   type Error = Status;
   fn try_from(
     value: &SecondaryDeviceKeysUploadRequest,
   ) -> Result<Self, Self::Error> {
-    serde_json::from_str(&value.challenge_response)
-      .map_err(|_| Status::invalid_argument("message format invalid"))
+    Ok(Self {
+      nonce: value.nonce.to_string(),
+      signature: value.nonce_signature.to_string(),
+    })
   }
 }
 
-impl TryFrom<&ExistingDeviceLoginRequest> for ChallengeResponse {
+impl TryFrom<&ExistingDeviceLoginRequest> for SignedNonce {
   type Error = Status;
   fn try_from(value: &ExistingDeviceLoginRequest) -> Result<Self, Self::Error> {
-    serde_json::from_str(&value.challenge_response)
-      .map_err(|_| Status::invalid_argument("message format invalid"))
+    Ok(Self {
+      nonce: value.nonce.to_string(),
+      signature: value.nonce_signature.to_string(),
+    })
   }
 }
 
-impl ChallengeResponse {
-  pub fn verify_and_get_message<T: serde::de::DeserializeOwned>(
-    &self,
+impl SignedNonce {
+  pub fn verify_and_get_nonce(
+    self,
     signing_public_key: &str,
-  ) -> Result<T, Status> {
+  ) -> Result<String, Status> {
     let signature_bytes = general_purpose::STANDARD_NO_PAD
       .decode(&self.signature)
       .map_err(|_| Status::invalid_argument("signature invalid"))?;
 
     let signature = Signature::from_bytes(&signature_bytes)
       .map_err(|_| Status::invalid_argument("signature invalid"))?;
 
     let public_key_bytes = general_purpose::STANDARD_NO_PAD
       .decode(signing_public_key)
       .map_err(|_| Status::failed_precondition("malformed key"))?;
 
     let public_key: PublicKey = PublicKey::from_bytes(&public_key_bytes)
       .map_err(|_| Status::failed_precondition("malformed key"))?;
 
     public_key
-      .verify(self.message.as_bytes(), &signature)
+      .verify(self.nonce.as_bytes(), &signature)
       .map_err(|_| Status::permission_denied("verification failed"))?;
 
-    serde_json::from_str(&self.message)
-      .map_err(|_| Status::invalid_argument("message format invalid"))
+    Ok(self.nonce)
   }
 }
 
 pub struct DeviceKeysInfo {
   pub device_info: DeviceRow,
   pub content_one_time_key: Option<String>,
   pub notif_one_time_key: Option<String>,
 }
 
 impl From<DeviceRow> for DeviceKeysInfo {
   fn from(device_info: DeviceRow) -> Self {
     Self {
       device_info,
       content_one_time_key: None,
       notif_one_time_key: None,
     }
   }
 }
 
 impl From<DeviceKeysInfo> for InboundKeyInfo {
   fn from(info: DeviceKeysInfo) -> Self {
     let DeviceKeysInfo { device_info, .. } = info;
     InboundKeyInfo {
       identity_info: Some(device_info.device_key_info.into()),
       content_prekey: Some(device_info.content_prekey.into()),
       notif_prekey: Some(device_info.notif_prekey.into()),
     }
   }
 }
 
 impl From<DeviceKeysInfo> for OutboundKeyInfo {
   fn from(info: DeviceKeysInfo) -> Self {
     let DeviceKeysInfo {
       device_info,
       content_one_time_key,
       notif_one_time_key,
     } = info;
     OutboundKeyInfo {
       identity_info: Some(device_info.device_key_info.into()),
       content_prekey: Some(device_info.content_prekey.into()),
       notif_prekey: Some(device_info.notif_prekey.into()),
       one_time_content_prekey: content_one_time_key,
       one_time_notif_prekey: notif_one_time_key,
     }
   }
 }
 
 pub trait DeviceKeyUploadData {
   fn device_key_upload(&self) -> Option<&DeviceKeyUpload>;
 }
 
 impl DeviceKeyUploadData for RegistrationStartRequest {
   fn device_key_upload(&self) -> Option<&DeviceKeyUpload> {
     self.device_key_upload.as_ref()
   }
 }
 
 impl DeviceKeyUploadData for ReservedRegistrationStartRequest {
   fn device_key_upload(&self) -> Option<&DeviceKeyUpload> {
     self.device_key_upload.as_ref()
   }
 }
 
 impl DeviceKeyUploadData for OpaqueLoginStartRequest {
   fn device_key_upload(&self) -> Option<&DeviceKeyUpload> {
     self.device_key_upload.as_ref()
   }
 }
 
 impl DeviceKeyUploadData for WalletAuthRequest {
   fn device_key_upload(&self) -> Option<&DeviceKeyUpload> {
     self.device_key_upload.as_ref()
   }
 }
 
 impl DeviceKeyUploadData for ReservedWalletRegistrationRequest {
   fn device_key_upload(&self) -> Option<&DeviceKeyUpload> {
     self.device_key_upload.as_ref()
   }
 }
 
 impl DeviceKeyUploadData for SecondaryDeviceKeysUploadRequest {
   fn device_key_upload(&self) -> Option<&DeviceKeyUpload> {
     self.device_key_upload.as_ref()
   }
 }
 
 pub trait DeviceKeyUploadActions {
   fn payload(&self) -> Result<String, Status>;
   fn payload_signature(&self) -> Result<String, Status>;
   fn content_prekey(&self) -> Result<String, Status>;
   fn content_prekey_signature(&self) -> Result<String, Status>;
   fn notif_prekey(&self) -> Result<String, Status>;
   fn notif_prekey_signature(&self) -> Result<String, Status>;
   fn one_time_content_prekeys(&self) -> Result<Vec<String>, Status>;
   fn one_time_notif_prekeys(&self) -> Result<Vec<String>, Status>;
   fn device_type(&self) -> Result<i32, Status>;
 }
 
 impl<T: DeviceKeyUploadData> DeviceKeyUploadActions for T {
   fn payload(&self) -> Result<String, Status> {
     self
       .device_key_upload()
       .and_then(|upload| upload.device_key_info.as_ref())
       .map(|info| info.payload.clone())
       .ok_or_else(|| Status::invalid_argument("unexpected message data"))
   }
 
   fn payload_signature(&self) -> Result<String, Status> {
     self
       .device_key_upload()
       .and_then(|upload| upload.device_key_info.as_ref())
       .map(|info| info.payload_signature.clone())
       .ok_or_else(|| Status::invalid_argument("unexpected message data"))
   }
 
   fn content_prekey(&self) -> Result<String, Status> {
     self
       .device_key_upload()
       .and_then(|upload| upload.content_upload.as_ref())
       .map(|prekey| prekey.prekey.clone())
       .ok_or_else(|| Status::invalid_argument("unexpected message data"))
   }
 
   fn content_prekey_signature(&self) -> Result<String, Status> {
     self
       .device_key_upload()
       .and_then(|upload| upload.content_upload.as_ref())
       .map(|prekey| prekey.prekey_signature.clone())
       .ok_or_else(|| Status::invalid_argument("unexpected message data"))
   }
 
   fn notif_prekey(&self) -> Result<String, Status> {
     self
       .device_key_upload()
       .and_then(|upload| upload.notif_upload.as_ref())
       .map(|prekey| prekey.prekey.clone())
       .ok_or_else(|| Status::invalid_argument("unexpected message data"))
   }
 
   fn notif_prekey_signature(&self) -> Result<String, Status> {
     self
       .device_key_upload()
       .and_then(|upload| upload.notif_upload.as_ref())
       .map(|prekey| prekey.prekey_signature.clone())
       .ok_or_else(|| Status::invalid_argument("unexpected message data"))
   }
 
   fn one_time_content_prekeys(&self) -> Result<Vec<String>, Status> {
     self
       .device_key_upload()
       .map(|upload| upload.one_time_content_prekeys.clone())
       .ok_or_else(|| Status::invalid_argument("unexpected message data"))
   }
 
   fn one_time_notif_prekeys(&self) -> Result<Vec<String>, Status> {
     self
       .device_key_upload()
       .map(|upload| upload.one_time_notif_prekeys.clone())
       .ok_or_else(|| Status::invalid_argument("unexpected message data"))
   }
   fn device_type(&self) -> Result<i32, Status> {
     self
       .device_key_upload()
       .map(|upload| upload.device_type)
       .ok_or_else(|| Status::invalid_argument("unexpected message data"))
   }
 }
 
 impl From<DBIdentifier> for Identity {
   fn from(value: DBIdentifier) -> Self {
     match value {
       DBIdentifier::Username(username) => Identity {
         username,
         eth_identity: None,
       },
       DBIdentifier::WalletAddress(eth_identity) => Identity {
         username: eth_identity.wallet_address.clone(),
         eth_identity: Some(EthereumIdentity {
           wallet_address: eth_identity.wallet_address,
           siwe_message: eth_identity.social_proof.message,
           siwe_signature: eth_identity.social_proof.signature,
         }),
       },
     }
   }
 }
 
 #[cfg(test)]
 mod tests {
-  use serde_json::json;
-
   use super::*;
 
   #[test]
   fn test_challenge_response_verification() {
-    let signing_key = "TF6XVmtso2xpCfUWcU1dOTPDnoo+Euls3H4wJhO6T6A";
-    let challenge_response_json = json!({
-      "message": r#"{"nonce":"hello"}"#,
-      "signature": "pXQZc9if5/p926HoomKEtLfe10SNOHdkf3wIXLjax0yg3mOE0z+0JTf+IgsjB7p9RGSisVRfskQQXa30uPupAQ"
-    });
+    let expected_nonce = "hello";
+    let signing_key = "jnBariweGMSdfmJYvuObTu4IGT1fpaJTo/ovbkU0SAY";
+
     let request = SecondaryDeviceKeysUploadRequest {
-      challenge_response: serde_json::to_string(&challenge_response_json)
-        .unwrap(),
+      nonce: expected_nonce.to_string(),
+      nonce_signature: "LWlgCDND3bmgIS8liW/0eKJvuNs4Vcb4iMf43zD038/MnC0cSAYl2l3bO9dFc0fa2w6/2ABsUlPDMVr+isE0Aw".to_string(),
       user_id: "foo".to_string(),
       device_key_upload: None,
     };
 
-    let challenge_response = ChallengeResponse::try_from(&request)
+    let challenge_response = SignedNonce::try_from(&request)
       .expect("failed to parse challenge response");
 
-    let msg: NonceChallenge = challenge_response
-      .verify_and_get_message(signing_key)
+    let retrieved_nonce = challenge_response
+      .verify_and_get_nonce(signing_key)
       .expect("verification failed");
 
-    assert_eq!(msg.nonce, "hello".to_string());
+    assert_eq!(retrieved_nonce, expected_nonce);
   }
 }
diff --git a/shared/protos/identity_unauth.proto b/shared/protos/identity_unauth.proto
index 2b798d843..aea343563 100644
--- a/shared/protos/identity_unauth.proto
+++ b/shared/protos/identity_unauth.proto
@@ -1,303 +1,303 @@
 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) {}
   rpc LogInExistingDevice(ExistingDeviceLoginRequest) returns (AuthResponse) {}
 
   /* Service actions */
 
   // Called by other services to verify a user's access token
   rpc VerifyUserAccessToken(VerifyUserAccessTokenRequest) returns
     (VerifyUserAccessTokenResponse) {}
 
   /* Authoritative keyserver actions */
 
   // Called by authoritative keyserver to add usernames
   // to the Identity service's reserved list
   rpc AddReservedUsernames(AddReservedUsernamesRequest) returns (Empty) {}
   // Called by authoritative 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) {}
 
   // Called by clients to get a nonce for a Sign-In with Ethereum message
   // or RPCs requiring challenge-response actions
   rpc GenerateNonce(Empty) returns (GenerateNonceResponse) {}
 
   /* 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;
 }
 
 // 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 authoritative keyserver attesting that a given user 
   // has ownership of a given username
   string keyserver_message = 4;
   // Above message signed with authoritative 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 authoritative keyserver attesting that a given user
   // has ownership of a given wallet address
   string keyserver_message = 4;
   // Above message signed with authoritative keyserver's signing ed25519 key
   string keyserver_signature = 5;
 }
 
 // UploadKeysForRegisteredDeviceAndLogIn
 
 message SecondaryDeviceKeysUploadRequest {
   string user_id = 1;
-  // Signed nonce message, JSON-stringified
-  string challenge_response = 2;
+  string nonce = 2;
+  string nonce_signature = 3;
   // Information specific to a user's device needed to open a new channel of
   // communication with this user
-  DeviceKeyUpload device_key_upload = 3;
+  DeviceKeyUpload device_key_upload = 4;
 }
 
 // LogInExistingDevice
 
 message ExistingDeviceLoginRequest {
   string user_id = 1;
   string device_id = 2;
-  // Signed nonce message, JSON-stringified
-  string challenge_response = 3;
+  string nonce = 3;
+  string nonce_signature = 4;
 }
 
 // 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 authoritative keyserver containing the username to be added
   string message = 1;
   // Above message signed with authoritative keyserver's signing ed25519 key
   string signature = 2;
 }
 
 // RemoveReservedUsername
 
 message RemoveReservedUsernameRequest {
   // Message from authoritative keyserver containing the username to be removed
   string message = 1;
   // Above message signed with authoritative 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/account/qr-code-login.react.js b/web/account/qr-code-login.react.js
index 91a42005e..cd020bda2 100644
--- a/web/account/qr-code-login.react.js
+++ b/web/account/qr-code-login.react.js
@@ -1,167 +1,162 @@
 // @flow
 
 import invariant from 'invariant';
 import { QRCodeSVG } from 'qrcode.react';
 import * as React from 'react';
 
 import { identityLogInActionTypes } from 'lib/actions/user-actions.js';
 import { QRAuthHandler } from 'lib/components/qr-auth-handler.react.js';
 import { qrCodeLinkURL } from 'lib/facts/links.js';
 import { generateKeyCommon } from 'lib/media/aes-crypto-utils-common.js';
 import * as AES from 'lib/media/aes-crypto-utils-common.js';
 import { hexToUintArray, uintArrayToHexString } from 'lib/media/data-utils.js';
 import { IdentityClientContext } from 'lib/shared/identity-client-context.js';
 import { useTunnelbroker } from 'lib/tunnelbroker/tunnelbroker-context.js';
-import type {
-  NonceChallenge,
-  SignedMessage,
-} from 'lib/types/identity-service-types.js';
+import type { SignedNonce } from 'lib/types/identity-service-types.js';
 import {
   peerToPeerMessageTypes,
   type QRCodeAuthMessage,
 } from 'lib/types/tunnelbroker/peer-to-peer-message-types.js';
 import {
   qrCodeAuthMessagePayloadValidator,
   type QRCodeAuthMessagePayload,
 } from 'lib/types/tunnelbroker/qr-code-auth-message-types.js';
 import { getContentSigningKey } from 'lib/utils/crypto-utils.js';
 import { useDispatchActionPromise } from 'lib/utils/redux-promise-utils.js';
 
 import css from './qr-code-login.css';
 import { olmAPI } from '../crypto/olm-api.js';
 import {
   base64DecodeBuffer,
   base64EncodeBuffer,
 } from '../utils/base64-utils.js';
 import {
   convertBytesToObj,
   convertObjToBytes,
 } from '../utils/conversion-utils.js';
 
 async function composeTunnelbrokerMessage(
   encryptionKey: string,
   obj: QRCodeAuthMessagePayload,
 ): Promise<QRCodeAuthMessage> {
   const objBytes = convertObjToBytes(obj);
   const keyBytes = hexToUintArray(encryptionKey);
   const encryptedBytes = await AES.encryptCommon(crypto, keyBytes, objBytes);
   const encryptedContent = base64EncodeBuffer(encryptedBytes);
   return {
     type: peerToPeerMessageTypes.QR_CODE_AUTH_MESSAGE,
     encryptedContent,
   };
 }
 
 async function parseTunnelbrokerMessage(
   encryptionKey: string,
   message: QRCodeAuthMessage,
 ): Promise<?QRCodeAuthMessagePayload> {
   const encryptedData = base64DecodeBuffer(message.encryptedContent);
   const decryptedData = await AES.decryptCommon(
     crypto,
     hexToUintArray(encryptionKey),
     new Uint8Array(encryptedData),
   );
   const payload = convertBytesToObj<QRCodeAuthMessagePayload>(decryptedData);
   if (!qrCodeAuthMessagePayloadValidator.is(payload)) {
     return null;
   }
 
   return payload;
 }
 
 function QrCodeLogin(): React.Node {
   const [qrCodeValue, setQrCodeValue] = React.useState<?string>();
 
   const [deviceKeys, setDeviceKeys] =
     React.useState<?{ +deviceID: string, +aesKey: string }>();
   const { setUnauthorizedDeviceID } = useTunnelbroker();
 
   const identityContext = React.useContext(IdentityClientContext);
   const identityClient = identityContext?.identityClient;
 
   const dispatchActionPromise = useDispatchActionPromise();
   const performRegistration = React.useCallback(
     async (userID: string) => {
       invariant(identityClient, 'identity context not set');
       try {
         const nonce = await identityClient.generateNonce();
-        const nonceChallenge: NonceChallenge = { nonce };
-        const nonceMessage = JSON.stringify(nonceChallenge);
-        const signature = await olmAPI.signMessage(nonceMessage);
-        const challengeResponse: SignedMessage = {
-          message: nonceMessage,
-          signature,
+        const nonceSignature = await olmAPI.signMessage(nonce);
+        const challengeResponse: SignedNonce = {
+          nonce,
+          nonceSignature,
         };
 
         await dispatchActionPromise(
           identityLogInActionTypes,
           identityClient.uploadKeysForRegisteredDeviceAndLogIn(
             userID,
             challengeResponse,
           ),
         );
         setUnauthorizedDeviceID(null);
       } catch (err) {
         console.error('Secondary device registration error:', err);
       }
     },
     [dispatchActionPromise, identityClient, setUnauthorizedDeviceID],
   );
 
   const generateQRCode = React.useCallback(async () => {
     try {
       const ed25519 = await getContentSigningKey();
       if (!ed25519) {
         return;
       }
 
       const rawAESKey: Uint8Array = await generateKeyCommon(crypto);
       const aesKeyAsHexString: string = uintArrayToHexString(rawAESKey);
 
       const url = qrCodeLinkURL(aesKeyAsHexString, ed25519);
       setUnauthorizedDeviceID(ed25519);
       setQrCodeValue(url);
       setDeviceKeys({ deviceID: ed25519, aesKey: aesKeyAsHexString });
     } catch (err) {
       console.error('Failed to generate QR Code:', err);
     }
   }, [setUnauthorizedDeviceID]);
 
   React.useEffect(() => {
     void generateQRCode();
   }, [generateQRCode]);
 
   return (
     <>
       <QRAuthHandler
         secondaryDeviceID={deviceKeys?.deviceID}
         aesKey={deviceKeys?.aesKey}
         performSecondaryDeviceRegistration={performRegistration}
         composeMessage={composeTunnelbrokerMessage}
         processMessage={parseTunnelbrokerMessage}
       />
       <div className={css.qrContainer}>
         <div className={css.title}>Log in to Comm</div>
         <div className={css.scanInstructions}>
           Open the Comm app on your phone and scan the QR code below
         </div>
         <QRCodeSVG value={qrCodeValue} size={300} marginSize={4} level="L" />
         <div className={css.instructionsContainer}>
           <div className={css.instructionsTitle}>How to find the scanner:</div>
           <div className={css.instructionsStep}>
             Go to <strong>Profile</strong>
           </div>
           <div className={css.instructionsStep}>
             Select <strong>Linked devices</strong>
           </div>
           <div className={css.instructionsStep}>
             Click <strong>Add</strong> on the top right
           </div>
         </div>
       </div>
     </>
   );
 }
 
 export default QrCodeLogin;
diff --git a/web/grpc/identity-service-client-wrapper.js b/web/grpc/identity-service-client-wrapper.js
index aec8e670a..b3d37f279 100644
--- a/web/grpc/identity-service-client-wrapper.js
+++ b/web/grpc/identity-service-client-wrapper.js
@@ -1,687 +1,688 @@
 // @flow
 
 import { Login } from '@commapp/opaque-ke-wasm';
 
 import identityServiceConfig from 'lib/facts/identity-service.js';
 import type {
   OneTimeKeysResultValues,
   SignedPrekeys,
 } from 'lib/types/crypto-types.js';
 import type { PlatformDetails } from 'lib/types/device-types.js';
 import {
   type SignedDeviceList,
   signedDeviceListHistoryValidator,
-  type SignedMessage,
+  type SignedNonce,
   type IdentityServiceAuthLayer,
   type IdentityServiceClient,
   type DeviceOlmOutboundKeys,
   deviceOlmOutboundKeysValidator,
   type UserDevicesOlmOutboundKeys,
   type IdentityAuthResult,
   type IdentityNewDeviceKeyUpload,
   type IdentityExistingDeviceKeyUpload,
   identityDeviceTypes,
   identityAuthResultValidator,
   type UserDevicesOlmInboundKeys,
   type DeviceOlmInboundKeys,
   deviceOlmInboundKeysValidator,
   userDeviceOlmInboundKeysValidator,
   type FarcasterUser,
 } from 'lib/types/identity-service-types.js';
 import { farcasterUsersValidator } from 'lib/types/identity-service-types.js';
 import { getMessageForException } from 'lib/utils/errors.js';
 import { assertWithValidator } from 'lib/utils/validation-utils.js';
 
 import { VersionInterceptor, AuthInterceptor } from './interceptor.js';
 import * as IdentityAuthClient from '../protobufs/identity-auth-client.cjs';
 import * as IdentityAuthStructs from '../protobufs/identity-auth-structs.cjs';
 import {
   DeviceKeyUpload,
   Empty,
   IdentityKeyInfo,
   OpaqueLoginFinishRequest,
   OpaqueLoginStartRequest,
   Prekey,
   WalletAuthRequest,
   SecondaryDeviceKeysUploadRequest,
   GetFarcasterUsersRequest,
 } from '../protobufs/identity-unauth-structs.cjs';
 import * as IdentityUnauthClient from '../protobufs/identity-unauth.cjs';
 import { initOpaque } from '../shared-worker/utils/opaque-utils.js';
 
 class IdentityServiceClientWrapper implements IdentityServiceClient {
   overridedOpaqueFilepath: string;
   authClient: ?IdentityAuthClient.IdentityClientServicePromiseClient;
   unauthClient: IdentityUnauthClient.IdentityClientServicePromiseClient;
   getNewDeviceKeyUpload: () => Promise<IdentityNewDeviceKeyUpload>;
   getExistingDeviceKeyUpload: () => Promise<IdentityExistingDeviceKeyUpload>;
 
   constructor(
     platformDetails: PlatformDetails,
     overridedOpaqueFilepath: string,
     authLayer: ?IdentityServiceAuthLayer,
     getNewDeviceKeyUpload: () => Promise<IdentityNewDeviceKeyUpload>,
     getExistingDeviceKeyUpload: () => Promise<IdentityExistingDeviceKeyUpload>,
   ) {
     this.overridedOpaqueFilepath = overridedOpaqueFilepath;
     if (authLayer) {
       this.authClient = IdentityServiceClientWrapper.createAuthClient(
         platformDetails,
         authLayer,
       );
     }
     this.unauthClient =
       IdentityServiceClientWrapper.createUnauthClient(platformDetails);
     this.getNewDeviceKeyUpload = getNewDeviceKeyUpload;
     this.getExistingDeviceKeyUpload = getExistingDeviceKeyUpload;
   }
 
   static determineSocketAddr(): string {
     return process.env.IDENTITY_SOCKET_ADDR ?? identityServiceConfig.defaultURL;
   }
 
   static createAuthClient(
     platformDetails: PlatformDetails,
     authLayer: IdentityServiceAuthLayer,
   ): IdentityAuthClient.IdentityClientServicePromiseClient {
     const { userID, deviceID, commServicesAccessToken } = authLayer;
 
     const identitySocketAddr =
       IdentityServiceClientWrapper.determineSocketAddr();
 
     const versionInterceptor = new VersionInterceptor<Request, Response>(
       platformDetails,
     );
     const authInterceptor = new AuthInterceptor<Request, Response>(
       userID,
       deviceID,
       commServicesAccessToken,
     );
 
     const authClientOpts = {
       unaryInterceptors: [versionInterceptor, authInterceptor],
     };
 
     return new IdentityAuthClient.IdentityClientServicePromiseClient(
       identitySocketAddr,
       null,
       authClientOpts,
     );
   }
 
   static createUnauthClient(
     platformDetails: PlatformDetails,
   ): IdentityUnauthClient.IdentityClientServicePromiseClient {
     const identitySocketAddr =
       IdentityServiceClientWrapper.determineSocketAddr();
 
     const versionInterceptor = new VersionInterceptor<Request, Response>(
       platformDetails,
     );
 
     const unauthClientOpts = {
       unaryInterceptors: [versionInterceptor],
     };
 
     return new IdentityUnauthClient.IdentityClientServicePromiseClient(
       identitySocketAddr,
       null,
       unauthClientOpts,
     );
   }
 
   deleteUser: () => Promise<void> = async () => {
     if (!this.authClient) {
       throw new Error('Identity service client is not initialized');
     }
     await this.authClient.deleteUser(new Empty());
   };
 
   logOut: () => Promise<void> = async () => {
     if (!this.authClient) {
       throw new Error('Identity service client is not initialized');
     }
     await this.authClient.logOutUser(new Empty());
   };
 
   getKeyserverKeys: (keyserverID: string) => Promise<DeviceOlmOutboundKeys> =
     async (keyserverID: string) => {
       const client = this.authClient;
       if (!client) {
         throw new Error('Identity service client is not initialized');
       }
 
       const request = new IdentityAuthStructs.OutboundKeysForUserRequest();
       request.setUserId(keyserverID);
       const response = await client.getKeyserverKeys(request);
 
       const keyserverInfo = response.getKeyserverInfo();
       const identityInfo = keyserverInfo?.getIdentityInfo();
       const contentPreKey = keyserverInfo?.getContentPrekey();
       const notifPreKey = keyserverInfo?.getNotifPrekey();
       const payload = identityInfo?.getPayload();
 
       const keyserverKeys = {
         identityKeysBlob: payload ? JSON.parse(payload) : null,
         contentInitializationInfo: {
           prekey: contentPreKey?.getPrekey(),
           prekeySignature: contentPreKey?.getPrekeySignature(),
           oneTimeKey: keyserverInfo?.getOneTimeContentPrekey(),
         },
         notifInitializationInfo: {
           prekey: notifPreKey?.getPrekey(),
           prekeySignature: notifPreKey?.getPrekeySignature(),
           oneTimeKey: keyserverInfo?.getOneTimeNotifPrekey(),
         },
         payloadSignature: identityInfo?.getPayloadSignature(),
       };
 
       if (!keyserverKeys.contentInitializationInfo.oneTimeKey) {
         throw new Error('Missing content one time key');
       }
       if (!keyserverKeys.notifInitializationInfo.oneTimeKey) {
         throw new Error('Missing notif one time key');
       }
 
       return assertWithValidator(keyserverKeys, deviceOlmOutboundKeysValidator);
     };
 
   getOutboundKeysForUser: (
     userID: string,
   ) => Promise<UserDevicesOlmOutboundKeys[]> = async (userID: string) => {
     const client = this.authClient;
     if (!client) {
       throw new Error('Identity service client is not initialized');
     }
 
     const request = new IdentityAuthStructs.OutboundKeysForUserRequest();
     request.setUserId(userID);
     const response = await client.getOutboundKeysForUser(request);
     const devicesMap = response.toObject()?.devicesMap;
 
     if (!devicesMap || !Array.isArray(devicesMap)) {
       throw new Error('Invalid devicesMap');
     }
 
     const devicesKeys: (?UserDevicesOlmOutboundKeys)[] = devicesMap.map(
       ([deviceID, outboundKeysInfo]) => {
         const identityInfo = outboundKeysInfo?.identityInfo;
         const payload = identityInfo?.payload;
         const contentPreKey = outboundKeysInfo?.contentPrekey;
         const notifPreKey = outboundKeysInfo?.notifPrekey;
 
         if (typeof deviceID !== 'string') {
           console.log(`Invalid deviceID in devicesMap: ${deviceID}`);
           return null;
         }
 
         if (
           !outboundKeysInfo.oneTimeContentPrekey ||
           !outboundKeysInfo.oneTimeNotifPrekey
         ) {
           console.log(`Missing one time key for device ${deviceID}`);
           return {
             deviceID,
             keys: null,
           };
         }
 
         const deviceKeys = {
           identityKeysBlob: payload ? JSON.parse(payload) : null,
           contentInitializationInfo: {
             prekey: contentPreKey?.prekey,
             prekeySignature: contentPreKey?.prekeySignature,
             oneTimeKey: outboundKeysInfo.oneTimeContentPrekey,
           },
           notifInitializationInfo: {
             prekey: notifPreKey?.prekey,
             prekeySignature: notifPreKey?.prekeySignature,
             oneTimeKey: outboundKeysInfo.oneTimeNotifPrekey,
           },
           payloadSignature: identityInfo?.payloadSignature,
         };
 
         try {
           const validatedKeys = assertWithValidator(
             deviceKeys,
             deviceOlmOutboundKeysValidator,
           );
           return {
             deviceID,
             keys: validatedKeys,
           };
         } catch (e) {
           console.log(e);
           return {
             deviceID,
             keys: null,
           };
         }
       },
     );
 
     return devicesKeys.filter(Boolean);
   };
 
   getInboundKeysForUser: (
     userID: string,
   ) => Promise<UserDevicesOlmInboundKeys> = async (userID: string) => {
     const client = this.authClient;
     if (!client) {
       throw new Error('Identity service client is not initialized');
     }
 
     const request = new IdentityAuthStructs.InboundKeysForUserRequest();
     request.setUserId(userID);
     const response = await client.getInboundKeysForUser(request);
     const devicesMap = response.toObject()?.devicesMap;
 
     if (!devicesMap || !Array.isArray(devicesMap)) {
       throw new Error('Invalid devicesMap');
     }
 
     const devicesKeys: {
       [deviceID: string]: ?DeviceOlmInboundKeys,
     } = {};
 
     devicesMap.forEach(([deviceID, inboundKeys]) => {
       const identityInfo = inboundKeys?.identityInfo;
       const payload = identityInfo?.payload;
       const contentPreKey = inboundKeys?.contentPrekey;
       const notifPreKey = inboundKeys?.notifPrekey;
 
       if (typeof deviceID !== 'string') {
         console.log(`Invalid deviceID in devicesMap: ${deviceID}`);
         return;
       }
 
       const deviceKeys = {
         identityKeysBlob: payload ? JSON.parse(payload) : null,
         signedPrekeys: {
           contentPrekey: contentPreKey?.prekey,
           contentPrekeySignature: contentPreKey?.prekeySignature,
           notifPrekey: notifPreKey?.prekey,
           notifPrekeySignature: notifPreKey?.prekeySignature,
         },
         payloadSignature: identityInfo?.payloadSignature,
       };
 
       try {
         devicesKeys[deviceID] = assertWithValidator(
           deviceKeys,
           deviceOlmInboundKeysValidator,
         );
       } catch (e) {
         console.log(e);
         devicesKeys[deviceID] = null;
       }
     });
 
     const identityInfo = response?.getIdentity();
     const inboundUserKeys = {
       keys: devicesKeys,
       username: identityInfo?.getUsername(),
       walletAddress: identityInfo?.getEthIdentity()?.getWalletAddress(),
     };
 
     return assertWithValidator(
       inboundUserKeys,
       userDeviceOlmInboundKeysValidator,
     );
   };
 
   uploadOneTimeKeys: (oneTimeKeys: OneTimeKeysResultValues) => Promise<void> =
     async (oneTimeKeys: OneTimeKeysResultValues) => {
       const client = this.authClient;
       if (!client) {
         throw new Error('Identity service client is not initialized');
       }
 
       const contentOneTimeKeysArray = [...oneTimeKeys.contentOneTimeKeys];
       const notifOneTimeKeysArray = [...oneTimeKeys.notificationsOneTimeKeys];
 
       const request = new IdentityAuthStructs.UploadOneTimeKeysRequest();
       request.setContentOneTimePrekeysList(contentOneTimeKeysArray);
       request.setNotifOneTimePrekeysList(notifOneTimeKeysArray);
       await client.uploadOneTimeKeys(request);
     };
 
   logInPasswordUser: (
     username: string,
     password: string,
   ) => Promise<IdentityAuthResult> = async (
     username: string,
     password: string,
   ) => {
     const client = this.unauthClient;
     if (!client) {
       throw new Error('Identity service client is not initialized');
     }
 
     const [identityDeviceKeyUpload] = await Promise.all([
       this.getExistingDeviceKeyUpload(),
       initOpaque(this.overridedOpaqueFilepath),
     ]);
 
     const opaqueLogin = new Login();
     const startRequestBytes = opaqueLogin.start(password);
 
     const deviceKeyUpload = authExistingDeviceKeyUpload(
       identityDeviceKeyUpload,
     );
 
     const loginStartRequest = new OpaqueLoginStartRequest();
     loginStartRequest.setUsername(username);
     loginStartRequest.setOpaqueLoginRequest(startRequestBytes);
     loginStartRequest.setDeviceKeyUpload(deviceKeyUpload);
 
     let loginStartResponse;
     try {
       loginStartResponse =
         await client.logInPasswordUserStart(loginStartRequest);
     } catch (e) {
       console.log('Error calling logInPasswordUserStart:', e);
       throw new Error(getMessageForException(e) ?? 'unknown');
     }
     const finishRequestBytes = opaqueLogin.finish(
       loginStartResponse.getOpaqueLoginResponse_asU8(),
     );
 
     const loginFinishRequest = new OpaqueLoginFinishRequest();
     loginFinishRequest.setSessionId(loginStartResponse.getSessionId());
     loginFinishRequest.setOpaqueLoginUpload(finishRequestBytes);
 
     let loginFinishResponse;
     try {
       loginFinishResponse =
         await client.logInPasswordUserFinish(loginFinishRequest);
     } catch (e) {
       console.log('Error calling logInPasswordUserFinish:', e);
       throw new Error(getMessageForException(e) ?? 'unknown');
     }
 
     const userID = loginFinishResponse.getUserId();
     const accessToken = loginFinishResponse.getAccessToken();
     const identityAuthResult = { accessToken, userID, username };
 
     return assertWithValidator(identityAuthResult, identityAuthResultValidator);
   };
 
   logInWalletUser: (
     walletAddress: string,
     siweMessage: string,
     siweSignature: string,
   ) => Promise<IdentityAuthResult> = async (
     walletAddress: string,
     siweMessage: string,
     siweSignature: string,
   ) => {
     const identityDeviceKeyUpload = await this.getExistingDeviceKeyUpload();
     const deviceKeyUpload = authExistingDeviceKeyUpload(
       identityDeviceKeyUpload,
     );
 
     const loginRequest = new WalletAuthRequest();
     loginRequest.setSiweMessage(siweMessage);
     loginRequest.setSiweSignature(siweSignature);
     loginRequest.setDeviceKeyUpload(deviceKeyUpload);
 
     let loginResponse;
     try {
       loginResponse = await this.unauthClient.logInWalletUser(loginRequest);
     } catch (e) {
       console.log('Error calling logInWalletUser:', e);
       throw new Error(getMessageForException(e) ?? 'unknown');
     }
 
     const userID = loginResponse.getUserId();
     const accessToken = loginResponse.getAccessToken();
     const identityAuthResult = { accessToken, userID, username: walletAddress };
 
     return assertWithValidator(identityAuthResult, identityAuthResultValidator);
   };
 
   uploadKeysForRegisteredDeviceAndLogIn: (
     ownerUserID: string,
-    nonceChallengeResponse: SignedMessage,
+    nonceChallengeResponse: SignedNonce,
   ) => Promise<IdentityAuthResult> = async (
     ownerUserID,
     nonceChallengeResponse,
   ) => {
     const identityDeviceKeyUpload = await this.getNewDeviceKeyUpload();
     const deviceKeyUpload = authNewDeviceKeyUpload(identityDeviceKeyUpload);
-    const challengeResponse = JSON.stringify(nonceChallengeResponse);
+    const { nonce, nonceSignature } = nonceChallengeResponse;
 
     const request = new SecondaryDeviceKeysUploadRequest();
     request.setUserId(ownerUserID);
-    request.setChallengeResponse(challengeResponse);
+    request.setNonce(nonce);
+    request.setNonceSignature(nonceSignature);
     request.setDeviceKeyUpload(deviceKeyUpload);
 
     let response;
     try {
       response =
         await this.unauthClient.uploadKeysForRegisteredDeviceAndLogIn(request);
     } catch (e) {
       console.log('Error calling uploadKeysForRegisteredDeviceAndLogIn:', e);
       throw new Error(getMessageForException(e) ?? 'unknown');
     }
 
     const userID = response.getUserId();
     const accessToken = response.getAccessToken();
     const identityAuthResult = { accessToken, userID, username: '' };
 
     return assertWithValidator(identityAuthResult, identityAuthResultValidator);
   };
 
   generateNonce: () => Promise<string> = async () => {
     const result = await this.unauthClient.generateNonce(new Empty());
     return result.getNonce();
   };
 
   publishWebPrekeys: (prekeys: SignedPrekeys) => Promise<void> = async (
     prekeys: SignedPrekeys,
   ) => {
     const client = this.authClient;
     if (!client) {
       throw new Error('Identity service client is not initialized');
     }
 
     const contentPrekeyUpload = new Prekey();
     contentPrekeyUpload.setPrekey(prekeys.contentPrekey);
     contentPrekeyUpload.setPrekeySignature(prekeys.contentPrekeySignature);
 
     const notifPrekeyUpload = new Prekey();
     notifPrekeyUpload.setPrekey(prekeys.notifPrekey);
     notifPrekeyUpload.setPrekeySignature(prekeys.notifPrekeySignature);
 
     const request = new IdentityAuthStructs.RefreshUserPrekeysRequest();
     request.setNewContentPrekeys(contentPrekeyUpload);
     request.setNewNotifPrekeys(notifPrekeyUpload);
     await client.refreshUserPrekeys(request);
   };
 
   getDeviceListHistoryForUser: (
     userID: string,
     sinceTimestamp?: number,
   ) => Promise<$ReadOnlyArray<SignedDeviceList>> = async (
     userID,
     sinceTimestamp,
   ) => {
     const client = this.authClient;
     if (!client) {
       throw new Error('Identity service client is not initialized');
     }
     const request = new IdentityAuthStructs.GetDeviceListRequest();
     request.setUserId(userID);
     if (sinceTimestamp) {
       request.setSinceTimestamp(sinceTimestamp);
     }
     const response = await client.getDeviceListForUser(request);
     const rawPayloads = response.getDeviceListUpdatesList();
     const deviceListUpdates: SignedDeviceList[] = rawPayloads.map(payload =>
       JSON.parse(payload),
     );
     return assertWithValidator(
       deviceListUpdates,
       signedDeviceListHistoryValidator,
     );
   };
 
   getFarcasterUsers: (
     farcasterIDs: $ReadOnlyArray<string>,
   ) => Promise<$ReadOnlyArray<FarcasterUser>> = async farcasterIDs => {
     const getFarcasterUsersRequest = new GetFarcasterUsersRequest();
     getFarcasterUsersRequest.setFarcasterIdsList([...farcasterIDs]);
 
     let getFarcasterUsersResponse;
     try {
       getFarcasterUsersResponse = await this.unauthClient.getFarcasterUsers(
         getFarcasterUsersRequest,
       );
     } catch (e) {
       console.log('Error calling getFarcasterUsers:', e);
       throw new Error(getMessageForException(e) ?? 'unknown');
     }
 
     const farcasterUsersList =
       getFarcasterUsersResponse.getFarcasterUsersList();
 
     const returnList = [];
 
     for (const user of farcasterUsersList) {
       returnList.push({
         userID: user.getUserId(),
         username: user.getUsername(),
         farcasterID: user.getFarcasterId(),
       });
     }
 
     return assertWithValidator(returnList, farcasterUsersValidator);
   };
 
   linkFarcasterAccount: (farcasterID: string) => Promise<void> =
     async farcasterID => {
       const client = this.authClient;
       if (!client) {
         throw new Error('Identity service client is not initialized');
       }
       const linkFarcasterAccountRequest =
         new IdentityAuthStructs.LinkFarcasterAccountRequest();
       linkFarcasterAccountRequest.setFarcasterId(farcasterID);
       await client.linkFarcasterAccount(linkFarcasterAccountRequest);
     };
 
   unlinkFarcasterAccount: () => Promise<void> = async () => {
     const client = this.authClient;
     if (!client) {
       throw new Error('Identity service client is not initialized');
     }
     await client.unlinkFarcasterAccount(new Empty());
   };
 }
 
 function authNewDeviceKeyUpload(
   uploadData: IdentityNewDeviceKeyUpload,
 ): DeviceKeyUpload {
   const {
     keyPayload,
     keyPayloadSignature,
     contentPrekey,
     contentPrekeySignature,
     notifPrekey,
     notifPrekeySignature,
     contentOneTimeKeys,
     notifOneTimeKeys,
   } = uploadData;
 
   const identityKeyInfo = createIdentityKeyInfo(
     keyPayload,
     keyPayloadSignature,
   );
 
   const contentPrekeyUpload = createPrekey(
     contentPrekey,
     contentPrekeySignature,
   );
 
   const notifPrekeyUpload = createPrekey(notifPrekey, notifPrekeySignature);
 
   const deviceKeyUpload = createDeviceKeyUpload(
     identityKeyInfo,
     contentPrekeyUpload,
     notifPrekeyUpload,
     contentOneTimeKeys,
     notifOneTimeKeys,
   );
 
   return deviceKeyUpload;
 }
 
 function authExistingDeviceKeyUpload(
   uploadData: IdentityExistingDeviceKeyUpload,
 ): DeviceKeyUpload {
   const {
     keyPayload,
     keyPayloadSignature,
     contentPrekey,
     contentPrekeySignature,
     notifPrekey,
     notifPrekeySignature,
   } = uploadData;
 
   const identityKeyInfo = createIdentityKeyInfo(
     keyPayload,
     keyPayloadSignature,
   );
 
   const contentPrekeyUpload = createPrekey(
     contentPrekey,
     contentPrekeySignature,
   );
 
   const notifPrekeyUpload = createPrekey(notifPrekey, notifPrekeySignature);
 
   const deviceKeyUpload = createDeviceKeyUpload(
     identityKeyInfo,
     contentPrekeyUpload,
     notifPrekeyUpload,
   );
 
   return deviceKeyUpload;
 }
 
 function createIdentityKeyInfo(
   keyPayload: string,
   keyPayloadSignature: string,
 ): IdentityKeyInfo {
   const identityKeyInfo = new IdentityKeyInfo();
   identityKeyInfo.setPayload(keyPayload);
   identityKeyInfo.setPayloadSignature(keyPayloadSignature);
   return identityKeyInfo;
 }
 
 function createPrekey(prekey: string, prekeySignature: string): Prekey {
   const prekeyUpload = new Prekey();
   prekeyUpload.setPrekey(prekey);
   prekeyUpload.setPrekeySignature(prekeySignature);
   return prekeyUpload;
 }
 
 function createDeviceKeyUpload(
   identityKeyInfo: IdentityKeyInfo,
   contentPrekeyUpload: Prekey,
   notifPrekeyUpload: Prekey,
   contentOneTimeKeys: $ReadOnlyArray<string> = [],
   notifOneTimeKeys: $ReadOnlyArray<string> = [],
 ): DeviceKeyUpload {
   const deviceKeyUpload = new DeviceKeyUpload();
   deviceKeyUpload.setDeviceKeyInfo(identityKeyInfo);
   deviceKeyUpload.setContentUpload(contentPrekeyUpload);
   deviceKeyUpload.setNotifUpload(notifPrekeyUpload);
   deviceKeyUpload.setOneTimeContentPrekeysList([...contentOneTimeKeys]);
   deviceKeyUpload.setOneTimeNotifPrekeysList([...notifOneTimeKeys]);
   deviceKeyUpload.setDeviceType(identityDeviceTypes.WEB);
   return deviceKeyUpload;
 }
 
 export { IdentityServiceClientWrapper };
diff --git a/web/protobufs/identity-unauth-structs.cjs b/web/protobufs/identity-unauth-structs.cjs
index 9545a1b77..d8078ee1b 100644
--- a/web/protobufs/identity-unauth-structs.cjs
+++ b/web/protobufs/identity-unauth-structs.cjs
@@ -1,5784 +1,5844 @@
 // 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.ExistingDeviceLoginRequest', 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.ExistingDeviceLoginRequest = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
 goog.inherits(proto.identity.unauth.ExistingDeviceLoginRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
   proto.identity.unauth.ExistingDeviceLoginRequest.displayName = 'proto.identity.unauth.ExistingDeviceLoginRequest';
 }
 /**
  * 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, "")
   };
 
   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;
     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
     );
   }
 };
 
 
 /**
  * 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);
 };
 
 
 
 /**
  * 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, ""),
+    nonce: jspb.Message.getFieldWithDefault(msg, 2, ""),
+    nonceSignature: jspb.Message.getFieldWithDefault(msg, 3, ""),
     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);
+      msg.setNonce(value);
       break;
     case 3:
+      var value = /** @type {string} */ (reader.readString());
+      msg.setNonceSignature(value);
+      break;
+    case 4:
       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();
+  f = message.getNonce();
   if (f.length > 0) {
     writer.writeString(
       2,
       f
     );
   }
+  f = message.getNonceSignature();
+  if (f.length > 0) {
+    writer.writeString(
+      3,
+      f
+    );
+  }
   f = message.getDeviceKeyUpload();
   if (f != null) {
     writer.writeMessage(
-      3,
+      4,
       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;
+ * optional string nonce = 2;
  * @return {string}
  */
-proto.identity.unauth.SecondaryDeviceKeysUploadRequest.prototype.getChallengeResponse = function() {
+proto.identity.unauth.SecondaryDeviceKeysUploadRequest.prototype.getNonce = 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) {
+proto.identity.unauth.SecondaryDeviceKeysUploadRequest.prototype.setNonce = function(value) {
   return jspb.Message.setProto3StringField(this, 2, value);
 };
 
 
 /**
- * optional DeviceKeyUpload device_key_upload = 3;
+ * optional string nonce_signature = 3;
+ * @return {string}
+ */
+proto.identity.unauth.SecondaryDeviceKeysUploadRequest.prototype.getNonceSignature = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, ""));
+};
+
+
+/**
+ * @param {string} value
+ * @return {!proto.identity.unauth.SecondaryDeviceKeysUploadRequest} returns this
+ */
+proto.identity.unauth.SecondaryDeviceKeysUploadRequest.prototype.setNonceSignature = function(value) {
+  return jspb.Message.setProto3StringField(this, 3, value);
+};
+
+
+/**
+ * optional DeviceKeyUpload device_key_upload = 4;
  * @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));
+    jspb.Message.getWrapperField(this, proto.identity.unauth.DeviceKeyUpload, 4));
 };
 
 
 /**
  * @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);
+  return jspb.Message.setWrapperField(this, 4, 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;
+  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.ExistingDeviceLoginRequest.prototype.toObject = function(opt_includeInstance) {
   return proto.identity.unauth.ExistingDeviceLoginRequest.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.ExistingDeviceLoginRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.ExistingDeviceLoginRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
     userId: jspb.Message.getFieldWithDefault(msg, 1, ""),
     deviceId: jspb.Message.getFieldWithDefault(msg, 2, ""),
-    challengeResponse: jspb.Message.getFieldWithDefault(msg, 3, "")
+    nonce: jspb.Message.getFieldWithDefault(msg, 3, ""),
+    nonceSignature: 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.ExistingDeviceLoginRequest}
  */
 proto.identity.unauth.ExistingDeviceLoginRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
   var msg = new proto.identity.unauth.ExistingDeviceLoginRequest;
   return proto.identity.unauth.ExistingDeviceLoginRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
  * @param {!proto.identity.unauth.ExistingDeviceLoginRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  * @return {!proto.identity.unauth.ExistingDeviceLoginRequest}
  */
 proto.identity.unauth.ExistingDeviceLoginRequest.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.setChallengeResponse(value);
+      msg.setNonce(value);
+      break;
+    case 4:
+      var value = /** @type {string} */ (reader.readString());
+      msg.setNonceSignature(value);
       break;
     default:
       reader.skipField();
       break;
     }
   }
   return msg;
 };
 
 
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.identity.unauth.ExistingDeviceLoginRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
   proto.identity.unauth.ExistingDeviceLoginRequest.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.ExistingDeviceLoginRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.identity.unauth.ExistingDeviceLoginRequest.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.getChallengeResponse();
+  f = message.getNonce();
   if (f.length > 0) {
     writer.writeString(
       3,
       f
     );
   }
+  f = message.getNonceSignature();
+  if (f.length > 0) {
+    writer.writeString(
+      4,
+      f
+    );
+  }
 };
 
 
 /**
  * optional string user_id = 1;
  * @return {string}
  */
 proto.identity.unauth.ExistingDeviceLoginRequest.prototype.getUserId = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.ExistingDeviceLoginRequest} returns this
  */
 proto.identity.unauth.ExistingDeviceLoginRequest.prototype.setUserId = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
 /**
  * optional string device_id = 2;
  * @return {string}
  */
 proto.identity.unauth.ExistingDeviceLoginRequest.prototype.getDeviceId = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.ExistingDeviceLoginRequest} returns this
  */
 proto.identity.unauth.ExistingDeviceLoginRequest.prototype.setDeviceId = function(value) {
   return jspb.Message.setProto3StringField(this, 2, value);
 };
 
 
 /**
- * optional string challenge_response = 3;
+ * optional string nonce = 3;
  * @return {string}
  */
-proto.identity.unauth.ExistingDeviceLoginRequest.prototype.getChallengeResponse = function() {
+proto.identity.unauth.ExistingDeviceLoginRequest.prototype.getNonce = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, ""));
 };
 
 
 /**
  * @param {string} value
  * @return {!proto.identity.unauth.ExistingDeviceLoginRequest} returns this
  */
-proto.identity.unauth.ExistingDeviceLoginRequest.prototype.setChallengeResponse = function(value) {
+proto.identity.unauth.ExistingDeviceLoginRequest.prototype.setNonce = function(value) {
   return jspb.Message.setProto3StringField(this, 3, value);
 };
 
 
+/**
+ * optional string nonce_signature = 4;
+ * @return {string}
+ */
+proto.identity.unauth.ExistingDeviceLoginRequest.prototype.getNonceSignature = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, ""));
+};
+
+
+/**
+ * @param {string} value
+ * @return {!proto.identity.unauth.ExistingDeviceLoginRequest} returns this
+ */
+proto.identity.unauth.ExistingDeviceLoginRequest.prototype.setNonceSignature = function(value) {
+  return jspb.Message.setProto3StringField(this, 4, 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.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 26258aac6..4c7d22d67 100644
--- a/web/protobufs/identity-unauth-structs.cjs.flow
+++ b/web/protobufs/identity-unauth-structs.cjs.flow
@@ -1,634 +1,643 @@
 // @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,
 };
 
 declare export class IdentityKeyInfo extends Message {
   getPayload(): string;
   setPayload(value: string): IdentityKeyInfo;
 
   getPayloadSignature(): string;
   setPayloadSignature(value: string): 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;
+  getNonce(): string;
+  setNonce(value: string): SecondaryDeviceKeysUploadRequest;
+
+  getNonceSignature(): string;
+  setNonceSignature(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,
+  nonce: string,
+  nonceSignature: string,
   deviceKeyUpload?: DeviceKeyUploadObject,
 }
 
 declare export class ExistingDeviceLoginRequest extends Message {
   getUserId(): string;
   setUserId(value: string): ExistingDeviceLoginRequest;
 
   getDeviceId(): string;
   setDeviceId(value: string): ExistingDeviceLoginRequest;
 
-  getChallengeResponse(): string;
-  setChallengeResponse(value: string): ExistingDeviceLoginRequest;
+  getNonce(): string;
+  setNonce(value: string): ExistingDeviceLoginRequest;
+
+  getNonceSignature(): string;
+  setNonceSignature(value: string): ExistingDeviceLoginRequest;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): ExistingDeviceLoginRequestObject;
   static toObject(includeInstance: boolean, msg: ExistingDeviceLoginRequest): ExistingDeviceLoginRequestObject;
   static serializeBinaryToWriter(message: ExistingDeviceLoginRequest, writer: BinaryWriter): void;
   static deserializeBinary(bytes: Uint8Array): ExistingDeviceLoginRequest;
   static deserializeBinaryFromReader(message: ExistingDeviceLoginRequest, reader: BinaryReader): ExistingDeviceLoginRequest;
 }
 
 export type ExistingDeviceLoginRequestObject = {
   userId: string,
   deviceId: string,
-  challengeResponse: string,
+  nonce: string,
+  nonceSignature: string,
 }
 
 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;