diff --git a/lib/types/identity-service-types.js b/lib/types/identity-service-types.js
index ef97e02e3..d6dbf7a9b 100644
--- a/lib/types/identity-service-types.js
+++ b/lib/types/identity-service-types.js
@@ -1,425 +1,432 @@
 // @flow
 
 import invariant from 'invariant';
 import t, { type TInterface, type TList, type TDict, type TEnums } from 'tcomb';
 
 import {
   identityKeysBlobValidator,
   type IdentityKeysBlob,
   signedPrekeysValidator,
   type SignedPrekeys,
   type OneTimeKeysResultValues,
 } from './crypto-types.js';
 import { type Platform } from './device-types.js';
 import {
   type OlmSessionInitializationInfo,
   olmSessionInitializationInfoValidator,
 } from './olm-session-types.js';
 import {
   currentUserInfoValidator,
   type CurrentUserInfo,
 } from './user-types.js';
 import { values } from '../utils/objects.js';
 import { tUserID, 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: tUserID,
     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 {
   // Only a primary device can initiate account deletion, and web cannot be a
   // primary device
   +deleteWalletUser?: () => Promise<void>;
   // Only a primary device can initiate account deletion, and web cannot be a
   // primary device
   +deletePasswordUser?: (password: string) => Promise<void>;
   +logOut: () => Promise<void>;
   // This log out type is specific to primary device, and web cannot be a
   // primary device
   +logOutPrimaryDevice?: () => Promise<void>;
   +logOutSecondaryDevice: () => Promise<void>;
   +getKeyserverKeys: string => Promise<DeviceOlmOutboundKeys>;
   // Users cannot register from web
   +registerPasswordUser?: (
     username: string,
     password: string,
     fid: ?string,
   ) => Promise<IdentityAuthResult>;
   // Users cannot register from web
   +registerReservedPasswordUser?: (
     username: string,
     password: string,
     keyserverMessage: string,
     keyserverSignature: 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>;
   // Users cannot register from web
   +registerWalletUser?: (
     walletAddress: string,
     siweMessage: string,
     siweSignature: string,
     fid: ?string,
   ) => Promise<IdentityAuthResult>;
   +logInWalletUser: (
     walletAddress: string,
     siweMessage: string,
     siweSignature: string,
   ) => Promise<IdentityAuthResult>;
+  // Users cannot restore backup from web
+  +restoreUser?: (
+    userID: string,
+    deviceList: SignedDeviceList,
+    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>>;
   +getDeviceListsForUsers: (
     userIDs: $ReadOnlyArray<string>,
   ) => Promise<PeersDeviceLists>;
   // 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>;
   +syncPlatformDetails: () => Promise<void>;
   +uploadKeysForRegisteredDeviceAndLogIn: (
     userID: string,
     signedNonce: SignedNonce,
   ) => Promise<IdentityAuthResult>;
   +getFarcasterUsers: (
     farcasterIDs: $ReadOnlyArray<string>,
   ) => Promise<$ReadOnlyArray<FarcasterUser>>;
   +linkFarcasterAccount: (farcasterID: string) => Promise<void>;
   +unlinkFarcasterAccount: () => Promise<void>;
   +findUserIdentities: (
     userIDs: $ReadOnlyArray<string>,
   ) => Promise<UserIdentitiesResponse>;
   +versionSupported: () => Promise<boolean>;
   +changePassword: (oldPassword: string, newPassword: string) => 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: tUserID,
     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 const rawDeviceListValidator: TInterface<RawDeviceList> =
   tShape<RawDeviceList>({
     devices: t.list(t.String),
     timestamp: t.Number,
   });
 
 export type UsersRawDeviceLists = {
   +[userID: string]: RawDeviceList,
 };
 
 // User Identity types
 
 export type EthereumIdentity = {
   walletAddress: string,
   siweMessage: string,
   siweSignature: string,
 };
 export type Identity = {
   +username: string,
   +ethIdentity: ?EthereumIdentity,
   +farcasterID: ?string,
 };
 export type Identities = {
   +[userID: string]: Identity,
 };
 export const ethereumIdentityValidator: TInterface<EthereumIdentity> =
   tShape<EthereumIdentity>({
     walletAddress: t.String,
     siweMessage: t.String,
     siweSignature: t.String,
   });
 export const identityValidator: TInterface<Identity> = tShape<Identity>({
   username: t.String,
   ethIdentity: t.maybe(ethereumIdentityValidator),
   farcasterID: t.maybe(t.String),
 });
 export const identitiesValidator: TDict<Identities> = t.dict(
   t.String,
   identityValidator,
 );
 
 export type ReservedUserIdentifiers = {
   +[userID: string]: string,
 };
 export const reservedIdentifiersValidator: TDict<ReservedUserIdentifiers> =
   t.dict(t.String, t.String);
 
 export type UserIdentitiesResponse = {
   +identities: Identities,
   +reservedUserIdentifiers: ReservedUserIdentifiers,
 };
 export const userIdentitiesResponseValidator: TInterface<UserIdentitiesResponse> =
   tShape<UserIdentitiesResponse>({
     identities: identitiesValidator,
     reservedUserIdentifiers: reservedIdentifiersValidator,
   });
 
 export type SignedDeviceList = {
   // JSON-stringified RawDeviceList
   +rawDeviceList: string,
   // Current primary device signature. Absent for Identity Service generated
   // device lists.
   +curPrimarySignature?: string,
   // Previous primary device signature. Present only if primary device
   // has changed since last update.
   +lastPrimarySignature?: string,
 };
 export const signedDeviceListValidator: TInterface<SignedDeviceList> =
   tShape<SignedDeviceList>({
     rawDeviceList: t.String,
     curPrimarySignature: t.maybe(t.String),
     lastPrimarySignature: t.maybe(t.String),
   });
 export const signedDeviceListHistoryValidator: TList<Array<SignedDeviceList>> =
   t.list(signedDeviceListValidator);
 
 export type UsersSignedDeviceLists = {
   +[userID: string]: SignedDeviceList,
 };
 export const usersSignedDeviceListsValidator: TDict<UsersSignedDeviceLists> =
   t.dict(t.String, signedDeviceListValidator);
 
 export type SignedNonce = {
   +nonce: 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,
 });
 
 export type IdentityDeviceType = $Values<typeof identityDeviceTypes>;
 
 function isIdentityDeviceType(deviceType: number): boolean %checks {
   return (
     deviceType === 0 ||
     deviceType === 1 ||
     deviceType === 2 ||
     deviceType === 3 ||
     deviceType === 4 ||
     deviceType === 5
   );
 }
 
 export function assertIdentityDeviceType(
   deviceType: number,
 ): IdentityDeviceType {
   invariant(
     isIdentityDeviceType(deviceType),
     'number is not IdentityDeviceType enum',
   );
   return deviceType;
 }
 
 export const identityDeviceTypeToPlatform: {
   +[identityDeviceType: IdentityDeviceType]: Platform,
 } = Object.freeze({
   [identityDeviceTypes.WEB]: 'web',
   [identityDeviceTypes.ANDROID]: 'android',
   [identityDeviceTypes.IOS]: 'ios',
   [identityDeviceTypes.WINDOWS]: 'windows',
   [identityDeviceTypes.MAC_OS]: 'macos',
 });
 
 export const platformToIdentityDeviceType: {
   +[platform: Platform]: IdentityDeviceType,
 } = Object.freeze({
   web: identityDeviceTypes.WEB,
   android: identityDeviceTypes.ANDROID,
   ios: identityDeviceTypes.IOS,
   windows: identityDeviceTypes.WINDOWS,
   macos: identityDeviceTypes.MAC_OS,
 });
 
 export const identityDeviceTypeValidator: TEnums = t.enums.of(
   values(identityDeviceTypes),
 );
 
 export type IdentityPlatformDetails = {
   +deviceType: IdentityDeviceType,
   +codeVersion: number,
   +stateVersion?: number,
   +majorDesktopVersion?: number,
 };
 export const identityPlatformDetailsValidator: TInterface<IdentityPlatformDetails> =
   tShape<IdentityPlatformDetails>({
     deviceType: identityDeviceTypeValidator,
     codeVersion: t.Number,
     stateVersion: t.maybe(t.Number),
     majorDesktopVersion: t.maybe(t.Number),
   });
 
 export type UserDevicesPlatformDetails = {
   +[deviceID: string]: IdentityPlatformDetails,
 };
 export const userDevicesPlatformDetailsValidator: TDict<UserDevicesPlatformDetails> =
   t.dict(t.String, identityPlatformDetailsValidator);
 
 export type UsersDevicesPlatformDetails = {
   +[userID: string]: UserDevicesPlatformDetails,
 };
 export const usersDevicesPlatformDetailsValidator: TDict<UsersDevicesPlatformDetails> =
   t.dict(t.String, userDevicesPlatformDetailsValidator);
 
 export type PeersDeviceLists = {
   +usersSignedDeviceLists: UsersSignedDeviceLists,
   +usersDevicesPlatformDetails: UsersDevicesPlatformDetails,
 };
 export const peersDeviceListsValidator: TInterface<PeersDeviceLists> = tShape({
   usersSignedDeviceLists: usersSignedDeviceListsValidator,
   usersDevicesPlatformDetails: usersDevicesPlatformDetailsValidator,
 });
diff --git a/native/identity-service/identity-service-context-provider.react.js b/native/identity-service/identity-service-context-provider.react.js
index 599e00c38..6d580cb8e 100644
--- a/native/identity-service/identity-service-context-provider.react.js
+++ b/native/identity-service/identity-service-context-provider.react.js
@@ -1,710 +1,746 @@
 // @flow
 
 import * as React from 'react';
 
 import { getOneTimeKeyValues } from 'lib/shared/crypto-utils.js';
 import { createAndSignSingletonDeviceList } from 'lib/shared/device-list-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 DeviceOlmInboundKeys,
   deviceOlmInboundKeysValidator,
   type DeviceOlmOutboundKeys,
   deviceOlmOutboundKeysValidator,
   farcasterUsersValidator,
   identityAuthResultValidator,
   type IdentityServiceClient,
   ONE_TIME_KEYS_NUMBER,
   type SignedDeviceList,
   signedDeviceListHistoryValidator,
   type SignedNonce,
   type UserAuthMetadata,
   userDeviceOlmInboundKeysValidator,
   type UserDevicesOlmInboundKeys,
   type UserDevicesOlmOutboundKeys,
   type UsersSignedDeviceLists,
   userIdentitiesResponseValidator,
   type UsersDevicesPlatformDetails,
   peersDeviceListsValidator,
 } 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 processAuthResult = async (authResult: string, deviceID: string) => {
     const { userID, accessToken: token, username } = JSON.parse(authResult);
     const identityAuthResult = {
       accessToken: token,
       userID,
       username,
     };
 
     const validatedResult = assertWithValidator(
       identityAuthResult,
       identityAuthResultValidator,
     );
 
     await commCoreModule.setCommServicesAuthMetadata(
       validatedResult.userID,
       deviceID,
       validatedResult.accessToken,
     );
 
     return validatedResult;
   };
 
   const client = React.useMemo<IdentityServiceClient>(
     () => ({
       deleteWalletUser: async () => {
         const {
           deviceID,
           userID,
           accessToken: token,
         } = await getAuthMetadata();
         return commRustModule.deleteWalletUser(userID, deviceID, token);
       },
       deletePasswordUser: async (password: string) => {
         const {
           deviceID,
           userID,
           accessToken: token,
         } = await getAuthMetadata();
         return commRustModule.deletePasswordUser(
           userID,
           deviceID,
           token,
           password,
         );
       },
       logOut: async () => {
         const {
           deviceID,
           userID,
           accessToken: token,
         } = await getAuthMetadata();
         return commRustModule.logOut(userID, deviceID, token);
       },
       logOutPrimaryDevice: async () => {
         const {
           deviceID,
           userID,
           accessToken: token,
         } = await getAuthMetadata();
         const signedDeviceList =
           await createAndSignSingletonDeviceList(deviceID);
         return commRustModule.logOutPrimaryDevice(
           userID,
           deviceID,
           token,
           JSON.stringify(signedDeviceList),
         );
       },
       logOutSecondaryDevice: async () => {
         const {
           deviceID,
           userID,
           accessToken: token,
         } = await getAuthMetadata();
         return commRustModule.logOutSecondaryDevice(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,
         };
 
         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;
 
               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,
               };
 
               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 initialDeviceList = await createAndSignSingletonDeviceList(
           primaryIdentityPublicKeys.ed25519,
         );
         const registrationResult = await commRustModule.registerPasswordUser(
           username,
           password,
           blobPayload,
           signature,
           prekeys.contentPrekey,
           prekeys.contentPrekeySignature,
           prekeys.notifPrekey,
           prekeys.notifPrekeySignature,
           getOneTimeKeyValues(contentOneTimeKeys),
           getOneTimeKeyValues(notificationsOneTimeKeys),
           fid ?? '',
           JSON.stringify(initialDeviceList),
         );
 
         return await processAuthResult(
           registrationResult,
           primaryIdentityPublicKeys.ed25519,
         );
       },
       registerReservedPasswordUser: async (
         username: string,
         password: string,
         keyserverMessage: string,
         keyserverSignature: 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 initialDeviceList = await createAndSignSingletonDeviceList(
           primaryIdentityPublicKeys.ed25519,
         );
         const registrationResult =
           await commRustModule.registerReservedPasswordUser(
             username,
             password,
             blobPayload,
             signature,
             prekeys.contentPrekey,
             prekeys.contentPrekeySignature,
             prekeys.notifPrekey,
             prekeys.notifPrekeySignature,
             getOneTimeKeyValues(contentOneTimeKeys),
             getOneTimeKeyValues(notificationsOneTimeKeys),
             keyserverMessage,
             keyserverSignature,
             JSON.stringify(initialDeviceList),
           );
 
         return await processAuthResult(
           registrationResult,
           primaryIdentityPublicKeys.ed25519,
         );
       },
       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,
         );
 
         return await processAuthResult(
           loginResult,
           primaryIdentityPublicKeys.ed25519,
         );
       },
       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 initialDeviceList = await createAndSignSingletonDeviceList(
           primaryIdentityPublicKeys.ed25519,
         );
         const registrationResult = await commRustModule.registerWalletUser(
           siweMessage,
           siweSignature,
           blobPayload,
           signature,
           prekeys.contentPrekey,
           prekeys.contentPrekeySignature,
           prekeys.notifPrekey,
           prekeys.notifPrekeySignature,
           getOneTimeKeyValues(contentOneTimeKeys),
           getOneTimeKeyValues(notificationsOneTimeKeys),
           fid ?? '',
           JSON.stringify(initialDeviceList),
         );
 
         return await processAuthResult(
           registrationResult,
           primaryIdentityPublicKeys.ed25519,
         );
       },
       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,
         );
 
         return await processAuthResult(
           loginResult,
           primaryIdentityPublicKeys.ed25519,
         );
       },
+      restoreUser: async (
+        userID: string,
+        deviceList: SignedDeviceList,
+        siweMessage?: string,
+        siweSignature?: 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 restoreResult = await commRustModule.restoreUser(
+          userID,
+          siweMessage,
+          siweSignature,
+          blobPayload,
+          signature,
+          prekeys.contentPrekey,
+          prekeys.contentPrekeySignature,
+          prekeys.notifPrekey,
+          prekeys.notifPrekeySignature,
+          getOneTimeKeyValues(contentOneTimeKeys),
+          getOneTimeKeyValues(notificationsOneTimeKeys),
+          JSON.stringify(deviceList),
+        );
+
+        return await processAuthResult(
+          restoreResult,
+          primaryIdentityPublicKeys.ed25519,
+        );
+      },
       uploadKeysForRegisteredDeviceAndLogIn: async (
         userID: string,
         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 { nonce, nonceSignature } = nonceChallengeResponse;
         const registrationResult =
           await commRustModule.uploadSecondaryDeviceKeysAndLogIn(
             userID,
             nonce,
             nonceSignature,
             blobPayload,
             signature,
             prekeys.contentPrekey,
             prekeys.contentPrekeySignature,
             prekeys.notifPrekey,
             prekeys.notifPrekeySignature,
             getOneTimeKeyValues(contentOneTimeKeys),
             getOneTimeKeyValues(notificationsOneTimeKeys),
           );
 
         return await processAuthResult(
           registrationResult,
           primaryIdentityPublicKeys.ed25519,
         );
       },
       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,
         );
       },
       getDeviceListsForUsers: async (userIDs: $ReadOnlyArray<string>) => {
         const {
           deviceID: authDeviceID,
           userID: authUserID,
           accessToken: token,
         } = await getAuthMetadata();
         const result = await commRustModule.getDeviceListsForUsers(
           authUserID,
           authDeviceID,
           token,
           userIDs,
         );
 
         const rawPayloads: {
           +usersDeviceLists: { +[userID: string]: string },
           +usersDevicesPlatformDetails: UsersDevicesPlatformDetails,
         } = JSON.parse(result);
 
         let usersDeviceLists: UsersSignedDeviceLists = {};
         for (const userID in rawPayloads.usersDeviceLists) {
           usersDeviceLists = {
             ...usersDeviceLists,
             [userID]: JSON.parse(rawPayloads.usersDeviceLists[userID]),
           };
         }
 
         const peersDeviceLists = {
           usersSignedDeviceLists: usersDeviceLists,
           usersDevicesPlatformDetails: rawPayloads.usersDevicesPlatformDetails,
         };
 
         return assertWithValidator(peersDeviceLists, peersDeviceListsValidator);
       },
       updateDeviceList: async (newDeviceList: SignedDeviceList) => {
         const {
           deviceID: authDeviceID,
           userID,
           accessToken: authAccessToken,
         } = await getAuthMetadata();
         const payload = JSON.stringify(newDeviceList);
         await commRustModule.updateDeviceList(
           userID,
           authDeviceID,
           authAccessToken,
           payload,
         );
       },
       syncPlatformDetails: async () => {
         const {
           deviceID: authDeviceID,
           userID,
           accessToken: authAccessToken,
         } = await getAuthMetadata();
         await commRustModule.syncPlatformDetails(
           userID,
           authDeviceID,
           authAccessToken,
         );
       },
       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);
       },
       findUserIdentities: async (userIDs: $ReadOnlyArray<string>) => {
         const {
           deviceID,
           userID,
           accessToken: token,
         } = await getAuthMetadata();
         const result = await commRustModule.findUserIdentities(
           userID,
           deviceID,
           token,
           userIDs,
         );
         return assertWithValidator(
           JSON.parse(result),
           userIdentitiesResponseValidator,
         );
       },
       versionSupported: () => {
         return commRustModule.versionSupported();
       },
       changePassword: async (oldPassword: string, newPassword: string) => {
         const {
           deviceID,
           userID,
           accessToken: token,
         } = await getAuthMetadata();
         return commRustModule.updatePassword(
           userID,
           deviceID,
           token,
           oldPassword,
           newPassword,
         );
       },
     }),
     [getAuthMetadata],
   );
 
   const value = React.useMemo(
     () => ({
       identityClient: client,
       getAuthMetadata,
     }),
     [client, getAuthMetadata],
   );
 
   return (
     <IdentityClientContext.Provider value={value}>
       {children}
     </IdentityClientContext.Provider>
   );
 }
 
 export default IdentityServiceContextProvider;