diff --git a/native/backup/use-client-backup.js b/native/backup/use-client-backup.js
index 1145f66bd..d7cbe6cb0 100644
--- a/native/backup/use-client-backup.js
+++ b/native/backup/use-client-backup.js
@@ -1,73 +1,73 @@
 // @flow
 
 import * as React from 'react';
 
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import {
   latestBackupInfoResponseValidator,
   type LatestBackupInfo,
 } from 'lib/types/backup-types.js';
 import { assertWithValidator } from 'lib/utils/validation-utils.js';
 
 import { useGetBackupSecretForLoggedInUser } from './use-get-backup-secret.js';
 import { commCoreModule } from '../native-modules.js';
 import { useSelector } from '../redux/redux-utils.js';
 
 type ClientBackup = {
-  +createFullBackup: () => Promise<void>,
-  +createUserKeysBackup: () => Promise<void>,
+  +createFullBackup: () => Promise<string>,
+  +createUserKeysBackup: () => Promise<string>,
   +retrieveLatestBackupInfo: () => Promise<LatestBackupInfo>,
 };
 
 function useClientBackup(): ClientBackup {
   const currentUserID = useSelector(
     state => state.currentUserInfo && state.currentUserInfo.id,
   );
   const currentUserInfo = useSelector(state => state.currentUserInfo);
   const loggedIn = useSelector(isLoggedIn);
   const getBackupSecret = useGetBackupSecretForLoggedInUser();
 
   const createFullBackup = React.useCallback(async () => {
     if (!loggedIn || !currentUserID) {
       throw new Error('Attempt to upload backup for not logged in user.');
     }
 
     const backupSecret = await getBackupSecret();
-    await commCoreModule.createFullBackup(backupSecret);
+    return commCoreModule.createFullBackup(backupSecret);
   }, [loggedIn, currentUserID, getBackupSecret]);
 
   const createUserKeysBackup = React.useCallback(async () => {
     if (!loggedIn || !currentUserID) {
       throw new Error('Attempt to upload User Keys for not logged in user.');
     }
 
     const backupSecret = await getBackupSecret();
-    await commCoreModule.createUserKeysBackup(backupSecret);
+    return commCoreModule.createUserKeysBackup(backupSecret);
   }, [loggedIn, currentUserID, getBackupSecret]);
 
   const retrieveLatestBackupInfo = React.useCallback(async () => {
     if (!loggedIn || !currentUserID || !currentUserInfo?.username) {
       throw new Error('Attempt to restore backup for not logged in user.');
     }
     const userIdentitifer = currentUserInfo?.username;
 
     const response =
       await commCoreModule.retrieveLatestBackupInfo(userIdentitifer);
 
     return assertWithValidator<LatestBackupInfo>(
       JSON.parse(response),
       latestBackupInfoResponseValidator,
     );
   }, [currentUserID, currentUserInfo, loggedIn]);
 
   return React.useMemo(
     () => ({
       createFullBackup,
       createUserKeysBackup,
       retrieveLatestBackupInfo,
     }),
     [retrieveLatestBackupInfo, createFullBackup, createUserKeysBackup],
   );
 }
 
 export { useClientBackup };
diff --git a/native/native_rust_library/src/backup/compaction_upload_promises.rs b/native/native_rust_library/src/backup/compaction_upload_promises.rs
index 6f84d4855..930103bda 100644
--- a/native/native_rust_library/src/backup/compaction_upload_promises.rs
+++ b/native/native_rust_library/src/backup/compaction_upload_promises.rs
@@ -1,24 +1,28 @@
-use crate::handle_void_result_as_callback;
+use crate::handle_string_result_as_callback;
 use lazy_static::lazy_static;
 use std::{collections::HashMap, sync::Mutex};
 
 lazy_static! {
   static ref COMPACTION_UPLOAD_PROMISES: Mutex<HashMap<String, u32>> =
     Default::default();
 }
 
 pub fn insert(backup_id: String, promise_id: u32) {
   if let Ok(mut backups_to_promises) = COMPACTION_UPLOAD_PROMISES.lock() {
     backups_to_promises.insert(backup_id, promise_id);
   };
 }
 
 pub fn resolve(backup_id: &str, result: Result<(), String>) {
   let Ok(mut backups_to_promises) = COMPACTION_UPLOAD_PROMISES.lock() else {
     return;
   };
   let Some(promise_id) = backups_to_promises.remove(backup_id) else {
     return;
   };
-  handle_void_result_as_callback(result, promise_id);
+
+  let backup_id_result: Result<String, String> =
+    result.map(|_| backup_id.to_string());
+
+  handle_string_result_as_callback(backup_id_result, promise_id);
 }
diff --git a/native/profile/backup-menu.react.js b/native/profile/backup-menu.react.js
index 3a5903b28..86646b720 100644
--- a/native/profile/backup-menu.react.js
+++ b/native/profile/backup-menu.react.js
@@ -1,256 +1,258 @@
 // @flow
 
 import { useNavigation } from '@react-navigation/native';
 import * as React from 'react';
 import { Switch, Text, View } from 'react-native';
 import { ScrollView } from 'react-native-gesture-handler';
 
 import { accountHasPassword } from 'lib/shared/account-utils.js';
 import { getMessageForException } from 'lib/utils/errors.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 
 import type { ProfileNavigationProp } from './profile.react.js';
 import { useClientBackup } from '../backup/use-client-backup.js';
 import { useGetBackupSecretForLoggedInUser } from '../backup/use-get-backup-secret.js';
 import Button from '../components/button.react.js';
 import { commCoreModule } from '../native-modules.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 import { RestoreSIWEBackupRouteName } from '../navigation/route-names.js';
 import { setLocalSettingsActionType } from '../redux/action-types.js';
 import { persistConfig } from '../redux/persist.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { useColors, useStyles } from '../themes/colors.js';
 import Alert from '../utils/alert.js';
 
 type Props = {
   +navigation: ProfileNavigationProp<'BackupMenu'>,
   +route: NavigationRoute<'BackupMenu'>,
 };
 // eslint-disable-next-line no-unused-vars
 function BackupMenu(props: Props): React.Node {
   const styles = useStyles(unboundStyles);
   const dispatch = useDispatch();
   const colors = useColors();
   const currentUserInfo = useSelector(state => state.currentUserInfo);
   const navigation = useNavigation();
   const getBackupSecret = useGetBackupSecretForLoggedInUser();
 
   const isBackupEnabled = useSelector(
     state => state.localSettings.isBackupEnabled,
   );
 
   const { createFullBackup, retrieveLatestBackupInfo, createUserKeysBackup } =
     useClientBackup();
 
   const uploadBackup = React.useCallback(async () => {
-    let message = 'Success';
+    let message;
     try {
-      await createFullBackup();
+      const backupID = await createFullBackup();
+      message = `Success!\n` + `Backup ID: ${backupID}`;
     } catch (e) {
       message = `Backup upload error: ${String(getMessageForException(e))}`;
       console.error(message);
     }
     Alert.alert('Upload protocol result', message);
   }, [createFullBackup]);
 
   const uploadUserKeys = React.useCallback(async () => {
-    let message = 'Success';
+    let message;
     try {
-      await createUserKeysBackup();
+      const backupID = await createUserKeysBackup();
+      message = `Success!\n` + `Backup ID: ${backupID}`;
     } catch (e) {
       message = `User Keys upload error: ${String(getMessageForException(e))}`;
       console.error(message);
     }
     Alert.alert('Upload User Keys result', message);
   }, [createUserKeysBackup]);
 
   const testRestoreForPasswordUser = React.useCallback(async () => {
     let message = 'success';
     try {
       const [latestBackupInfo, backupSecret] = await Promise.all([
         retrieveLatestBackupInfo(),
         getBackupSecret(),
       ]);
       await commCoreModule.restoreBackup(
         backupSecret,
         persistConfig.version.toString(),
         latestBackupInfo.backupID,
       );
       console.info('Backup restored.');
     } catch (e) {
       message = `Backup restore error: ${String(getMessageForException(e))}`;
       console.error(message);
     }
     Alert.alert('Restore protocol result', message);
   }, [getBackupSecret, retrieveLatestBackupInfo]);
 
   const testLatestBackupInfo = React.useCallback(async () => {
     let message;
     try {
       const backupInfo = await retrieveLatestBackupInfo();
       const { backupID, userID } = backupInfo;
       message =
         `Success!\n` +
         `Backup ID: ${backupID},\n` +
         `userID: ${userID},\n` +
         `userID check: ${currentUserInfo?.id === userID ? 'true' : 'false'}`;
     } catch (e) {
       message = `Latest backup info error: ${String(
         getMessageForException(e),
       )}`;
       console.error(message);
     }
     Alert.alert('Latest backup info result', message);
   }, [currentUserInfo?.id, retrieveLatestBackupInfo]);
 
   const testRestoreForSIWEUser = React.useCallback(async () => {
     let message = 'success';
     try {
       const backupInfo = await retrieveLatestBackupInfo();
       const { siweBackupData, backupID } = backupInfo;
 
       if (!siweBackupData) {
         throw new Error('Missing SIWE message for Wallet user backup');
       }
 
       const {
         siweBackupMsgNonce,
         siweBackupMsgIssuedAt,
         siweBackupMsgStatement,
       } = siweBackupData;
 
       navigation.navigate<'RestoreSIWEBackup'>({
         name: RestoreSIWEBackupRouteName,
         params: {
           backupID,
           siweNonce: siweBackupMsgNonce,
           siweStatement: siweBackupMsgStatement,
           siweIssuedAt: siweBackupMsgIssuedAt,
         },
       });
     } catch (e) {
       message = `Backup restore error: ${String(getMessageForException(e))}`;
       console.error(message);
     }
   }, [navigation, retrieveLatestBackupInfo]);
 
   const onBackupToggled = React.useCallback(
     (value: boolean) => {
       dispatch({
         type: setLocalSettingsActionType,
         payload: { isBackupEnabled: value },
       });
     },
     [dispatch],
   );
 
   const onPressRestoreButton = accountHasPassword(currentUserInfo)
     ? testRestoreForPasswordUser
     : testRestoreForSIWEUser;
 
   return (
     <ScrollView
       contentContainerStyle={styles.scrollViewContentContainer}
       style={styles.scrollView}
     >
       <Text style={styles.header}>SETTINGS</Text>
       <View style={styles.section}>
         <View style={styles.submenuButton}>
           <Text style={styles.submenuText}>Toggle automatic backup</Text>
           <Switch value={isBackupEnabled} onValueChange={onBackupToggled} />
         </View>
       </View>
 
       <Text style={styles.header}>ACTIONS</Text>
       <View style={styles.section}>
         <Button
           onPress={uploadBackup}
           style={styles.row}
           iosFormat="highlight"
           iosHighlightUnderlayColor={colors.panelIosHighlightUnderlay}
           iosActiveOpacity={0.85}
         >
           <Text style={styles.submenuText}>Test Full Backup upload</Text>
         </Button>
       </View>
       <View style={styles.section}>
         <Button
           onPress={uploadUserKeys}
           style={styles.row}
           iosFormat="highlight"
           iosHighlightUnderlayColor={colors.panelIosHighlightUnderlay}
           iosActiveOpacity={0.85}
         >
           <Text style={styles.submenuText}>Test User Keys upload</Text>
         </Button>
       </View>
       <View style={styles.section}>
         <Button
           onPress={onPressRestoreButton}
           style={styles.row}
           iosFormat="highlight"
           iosHighlightUnderlayColor={colors.panelIosHighlightUnderlay}
           iosActiveOpacity={0.85}
         >
           <Text style={styles.submenuText}>Test backup restore protocol</Text>
         </Button>
       </View>
       <View style={styles.section}>
         <Button
           onPress={testLatestBackupInfo}
           style={styles.row}
           iosFormat="highlight"
           iosHighlightUnderlayColor={colors.panelIosHighlightUnderlay}
           iosActiveOpacity={0.85}
         >
           <Text style={styles.submenuText}>
             Test retrieving latest backup info
           </Text>
         </Button>
       </View>
     </ScrollView>
   );
 }
 
 const unboundStyles = {
   scrollViewContentContainer: {
     paddingTop: 24,
   },
   scrollView: {
     backgroundColor: 'panelBackground',
   },
   section: {
     backgroundColor: 'panelForeground',
     borderBottomWidth: 1,
     borderColor: 'panelForegroundBorder',
     borderTopWidth: 1,
     marginBottom: 24,
     marginVertical: 2,
   },
   header: {
     color: 'panelBackgroundLabel',
     fontSize: 12,
     fontWeight: '400',
     paddingBottom: 3,
     paddingHorizontal: 24,
   },
   submenuButton: {
     flexDirection: 'row',
     paddingHorizontal: 24,
     paddingVertical: 10,
     alignItems: 'center',
   },
   submenuText: {
     color: 'panelForegroundLabel',
     flex: 1,
     fontSize: 16,
   },
   row: {
     flexDirection: 'row',
     justifyContent: 'space-between',
     paddingHorizontal: 24,
     paddingVertical: 14,
   },
 };
 
 export default BackupMenu;
diff --git a/native/schema/CommCoreModuleSchema.js b/native/schema/CommCoreModuleSchema.js
index 5789a655c..483d1341f 100644
--- a/native/schema/CommCoreModuleSchema.js
+++ b/native/schema/CommCoreModuleSchema.js
@@ -1,247 +1,247 @@
 // @flow
 
 'use strict';
 
 import { TurboModuleRegistry } from 'react-native';
 import type { TurboModule } from 'react-native/Libraries/TurboModule/RCTExport.js';
 
 import type { ClientDBMessageStoreOperation } from 'lib/ops/message-store-ops.js';
 import type { ClientDBReportStoreOperation } from 'lib/ops/report-store-ops.js';
 import type { ClientDBThreadStoreOperation } from 'lib/ops/thread-store-ops.js';
 import type {
   OneTimeKeysResult,
   SignedPrekeys,
   ClientPublicKeys,
   EncryptedData,
   OutboundSessionCreationResult,
 } from 'lib/types/crypto-types.js';
 import type { ClientDBMessageInfo } from 'lib/types/message-types.js';
 import type { SIWEBackupSecrets } from 'lib/types/siwe-types.js';
 import type {
   InboundP2PMessage,
   OutboundP2PMessage,
 } from 'lib/types/sqlite-types.js';
 import type {
   ClientDBStore,
   ClientDBStoreOperations,
 } from 'lib/types/store-ops-types';
 import type { ClientDBThreadInfo } from 'lib/types/thread-types.js';
 
 type CommServicesAuthMetadata = {
   +userID?: ?string,
   +deviceID?: ?string,
   +accessToken?: ?string,
 };
 
 interface Spec extends TurboModule {
   +getDraft: (key: string) => Promise<string>;
   +updateDraft: (key: string, text: string) => Promise<boolean>;
   +moveDraft: (oldKey: string, newKey: string) => Promise<boolean>;
   +getClientDBStore: () => Promise<ClientDBStore>;
   +removeAllDrafts: () => Promise<void>;
   +getInitialMessagesSync: () => $ReadOnlyArray<ClientDBMessageInfo>;
   +processMessageStoreOperationsSync: (
     operations: $ReadOnlyArray<ClientDBMessageStoreOperation>,
   ) => void;
   +getAllThreadsSync: () => $ReadOnlyArray<ClientDBThreadInfo>;
   +processReportStoreOperationsSync: (
     operations: $ReadOnlyArray<ClientDBReportStoreOperation>,
   ) => void;
   +processThreadStoreOperationsSync: (
     operations: $ReadOnlyArray<ClientDBThreadStoreOperation>,
   ) => void;
   +processDBStoreOperations: (operations: Object) => Promise<void>;
   +initializeCryptoAccount: () => Promise<string>;
   +getUserPublicKey: () => Promise<ClientPublicKeys>;
   +getOneTimeKeys: (oneTimeKeysAmount: number) => Promise<OneTimeKeysResult>;
   +validateAndGetPrekeys: () => Promise<SignedPrekeys>;
   +validateAndUploadPrekeys: (
     authUserID: string,
     authDeviceID: string,
     authAccessToken: string,
   ) => Promise<void>;
   +initializeNotificationsSession: (
     identityKeys: string,
     prekey: string,
     prekeySignature: string,
     oneTimeKey: ?string,
     keyserverID: string,
   ) => Promise<string>;
   +isNotificationsSessionInitialized: () => Promise<boolean>;
   +isDeviceNotificationsSessionInitialized: (
     deviceID: string,
   ) => Promise<boolean>;
   +isNotificationsSessionInitializedWithDevices: (
     deviceIDs: $ReadOnlyArray<string>,
   ) => Promise<{ +[deviceID: string]: boolean }>;
   +updateKeyserverDataInNotifStorage: (
     keyserversData: $ReadOnlyArray<{ +id: string, +unreadCount: number }>,
   ) => Promise<void>;
   +removeKeyserverDataFromNotifStorage: (
     keyserverIDsToDelete: $ReadOnlyArray<string>,
   ) => Promise<void>;
   +getKeyserverDataFromNotifStorage: (
     keyserverIDs: $ReadOnlyArray<string>,
   ) => Promise<$ReadOnlyArray<{ +id: string, +unreadCount: number }>>;
   +updateUnreadThickThreadsInNotifsStorage: (
     unreadThickThreadIDs: $ReadOnlyArray<string>,
   ) => Promise<void>;
   +getUnreadThickThreadIDsFromNotifsStorage: () => Promise<
     $ReadOnlyArray<string>,
   >;
   +initializeContentOutboundSession: (
     identityKeys: string,
     prekey: string,
     prekeySignature: string,
     oneTimeKey: ?string,
     deviceID: string,
   ) => Promise<OutboundSessionCreationResult>;
   +initializeContentInboundSession: (
     identityKeys: string,
     encryptedContent: Object,
     deviceID: string,
     sessionVersion: number,
     overwrite: boolean,
   ) => Promise<string>;
   +isContentSessionInitialized: (deviceID: string) => Promise<boolean>;
   +initializeNotificationsOutboundSession: (
     identityKeys: string,
     prekey: string,
     prekeySignature: string,
     oneTimeKey: ?string,
     deviceID: string,
   ) => Promise<EncryptedData>;
   +encrypt: (message: string, deviceID: string) => Promise<EncryptedData>;
   +encryptNotification: (
     payload: string,
     deviceID: string,
   ) => Promise<EncryptedData>;
   +encryptAndPersist: (
     message: string,
     deviceID: string,
     messageID: string,
   ) => Promise<EncryptedData>;
   +decrypt: (encryptedData: Object, deviceID: string) => Promise<string>;
   +decryptAndPersist: (
     encryptedData: Object,
     deviceID: string,
     userID: string,
     messageID: string,
   ) => Promise<string>;
   +signMessage: (message: string) => Promise<string>;
   +verifySignature: (
     publicKey: string,
     message: string,
     signature: string,
   ) => Promise<void>;
   +getCodeVersion: () => number;
   +terminate: () => void;
   +setNotifyToken: (token: string) => Promise<void>;
   +clearNotifyToken: () => Promise<void>;
   +stampSQLiteDBUserID: (userID: string) => Promise<void>;
   +getSQLiteStampedUserID: () => Promise<string>;
   +clearSensitiveData: () => Promise<void>;
   +checkIfDatabaseNeedsDeletion: () => boolean;
   +reportDBOperationsFailure: () => void;
   +computeBackupKey: (password: string, backupID: string) => Promise<Object>;
   +generateRandomString: (size: number) => Promise<string>;
   +setCommServicesAuthMetadata: (
     userID: string,
     deviceID: string,
     accessToken: string,
   ) => Promise<void>;
   +getCommServicesAuthMetadata: () => Promise<CommServicesAuthMetadata>;
   +clearCommServicesAuthMetadata: () => Promise<void>;
   +setCommServicesAccessToken: (accessToken: string) => Promise<void>;
   +clearCommServicesAccessToken: () => Promise<void>;
   +startBackupHandler: () => void;
   +stopBackupHandler: () => void;
-  +createUserKeysBackup: (backupSecret: string) => Promise<void>;
-  +createFullBackup: (backupSecret: string) => Promise<void>;
+  +createUserKeysBackup: (backupSecret: string) => Promise<string>;
+  +createFullBackup: (backupSecret: string) => Promise<string>;
   +restoreBackup: (
     backupSecret: string,
     maxVersion: string,
     backupID: string,
   ) => Promise<string>;
   +restoreBackupData: (
     backupID: string,
     backupDataKey: string,
     backupLogDataKey: string,
     maxVersion: string,
   ) => Promise<void>;
   +retrieveBackupKeys: (
     backupSecret: string,
     backupID: string,
   ) => Promise<string>;
   +retrieveLatestBackupInfo: (userIdentifier: string) => Promise<string>;
   +setSIWEBackupSecrets: (siweBackupSecrets: Object) => Promise<void>;
   +getSIWEBackupSecrets: () => Promise<?Object>;
   +getAllInboundP2PMessages: () => Promise<Array<InboundP2PMessage>>;
   +removeInboundP2PMessages: (ids: $ReadOnlyArray<string>) => Promise<void>;
   +getInboundP2PMessagesByID: (
     ids: $ReadOnlyArray<string>,
   ) => Promise<Array<InboundP2PMessage>>;
   +getOutboundP2PMessagesByID: (
     ids: $ReadOnlyArray<string>,
   ) => Promise<Array<OutboundP2PMessage>>;
   +getUnsentOutboundP2PMessages: () => Promise<Array<OutboundP2PMessage>>;
   +markOutboundP2PMessageAsSent: (
     messageID: string,
     deviceID: string,
   ) => Promise<void>;
   +removeOutboundP2PMessage: (
     messageID: string,
     deviceID: string,
   ) => Promise<void>;
   +resetOutboundP2PMessagesForDevice: (
     deviceID: string,
   ) => Promise<Array<string>>;
   +getSyncedDatabaseVersion: () => Promise<string>;
   +markPrekeysAsPublished: () => Promise<void>;
   +getRelatedMessages: (
     messageID: string,
   ) => Promise<Array<ClientDBMessageInfo>>;
   +searchMessages: (
     query: string,
     threadID: string,
     timestampCursor: ?string,
     messageIDCursor: ?string,
   ) => Promise<Array<ClientDBMessageInfo>>;
   +fetchMessages: (
     threadID: string,
     limit: number,
     offset: number,
   ) => Promise<Array<ClientDBMessageInfo>>;
 }
 
 export interface CoreModuleSpec extends Spec {
   +computeBackupKey: (
     password: string,
     backupID: string,
   ) => Promise<ArrayBuffer>;
   +decrypt: (encryptedData: EncryptedData, deviceID: string) => Promise<string>;
   +decryptAndPersist: (
     encryptedData: EncryptedData,
     deviceID: string,
     userID: string,
     messageID: string,
   ) => Promise<string>;
   +initializeContentInboundSession: (
     identityKeys: string,
     encryptedContent: EncryptedData,
     deviceID: string,
     sessionVersion: number,
     overwrite: boolean,
   ) => Promise<string>;
   +setSIWEBackupSecrets: (
     siweBackupSecrets: SIWEBackupSecrets,
   ) => Promise<void>;
   +getSIWEBackupSecrets: () => Promise<?SIWEBackupSecrets>;
   +processDBStoreOperations: (
     operations: ClientDBStoreOperations,
   ) => Promise<void>;
 }
 
 export default (TurboModuleRegistry.getEnforcing<Spec>(
   'CommTurboModule',
 ): Spec);