fix: move wrapped storage to unwrapped if not encrypted (#1603)

packages/snjs/lib/Services/Protection/ProtectionService.ts

@@ -257,36 +257,36 @@ export class SNProtectionService extends AbstractService<ProtectionEvent> implem
     ]
   }
 
-  private async getBiometricsTiming(): Promise<MobileUnlockTiming | undefined> {
-    return this.storageService.getValue<Promise<MobileUnlockTiming | undefined>>(
+  private getBiometricsTiming(): MobileUnlockTiming | undefined {
+    return this.storageService.getValue<MobileUnlockTiming | undefined>(
       StorageKey.MobileBiometricsTiming,
       StorageValueModes.Nonwrapped,
     )
   }
 
-  private async getPasscodeTiming(): Promise<MobileUnlockTiming | undefined> {
-    return this.storageService.getValue<Promise<MobileUnlockTiming | undefined>>(
+  private getPasscodeTiming(): MobileUnlockTiming | undefined {
+    return this.storageService.getValue<MobileUnlockTiming | undefined>(
       StorageKey.MobilePasscodeTiming,
       StorageValueModes.Nonwrapped,
     )
   }
 
   async setBiometricsTiming(timing: MobileUnlockTiming) {
-    await this.storageService.setValue(StorageKey.MobileBiometricsTiming, timing, StorageValueModes.Nonwrapped)
+    this.storageService.setValue(StorageKey.MobileBiometricsTiming, timing, StorageValueModes.Nonwrapped)
     this.mobileBiometricsTiming = timing
   }
 
-  async setMobileScreenshotPrivacyEnabled(isEnabled: boolean) {
+  setMobileScreenshotPrivacyEnabled(isEnabled: boolean) {
     return this.storageService.setValue(StorageKey.MobileScreenshotPrivacyEnabled, isEnabled, StorageValueModes.Default)
   }
 
-  async getMobileScreenshotPrivacyEnabled(): Promise<boolean | undefined> {
-    return this.storageService.getValue(StorageKey.MobileScreenshotPrivacyEnabled, StorageValueModes.Default)
+  getMobileScreenshotPrivacyEnabled(): boolean {
+    return this.storageService.getValue(StorageKey.MobileScreenshotPrivacyEnabled, StorageValueModes.Default, false)
   }
 
-  async loadMobileUnlockTiming() {
-    this.mobilePasscodeTiming = await this.getPasscodeTiming()
-    this.mobileBiometricsTiming = await this.getBiometricsTiming()
+  loadMobileUnlockTiming(): void {
+    this.mobilePasscodeTiming = this.getPasscodeTiming()
+    this.mobileBiometricsTiming = this.getBiometricsTiming()
   }
 
   private async validateOrRenewSession(

packages/snjs/lib/Services/Storage/DiskStorageService.spec.ts

@@ -0,0 +1,33 @@
+import { DiskStorageService } from './DiskStorageService'
+
+import { InternalEventBus, DeviceInterface, InternalEventBusInterface } from '@standardnotes/services'
+import { Environment } from '@standardnotes/models'
+
+describe('diskStorageService', () => {
+  let storageService: DiskStorageService
+  let internalEventBus: InternalEventBusInterface
+  let device: DeviceInterface
+
+  beforeEach(() => {
+    internalEventBus = {} as jest.Mocked<InternalEventBus>
+    device = {} as jest.Mocked<DeviceInterface>
+
+    storageService = new DiskStorageService(device, 'test', Environment.Desktop, internalEventBus)
+  })
+
+  it('setInitialValues should set unwrapped values as wrapped value if wrapped value is not encrypted', async () => {
+    storageService.isStorageWrapped = jest.fn().mockReturnValue(false)
+
+    await storageService['setInitialValues']({
+      wrapped: { content: { foo: 'bar' } } as never,
+      nonwrapped: {},
+      unwrapped: { bar: 'zoo' },
+    })
+
+    expect(storageService['values']).toEqual({
+      wrapped: { content: { foo: 'bar' } } as never,
+      nonwrapped: {},
+      unwrapped: { bar: 'zoo', foo: 'bar' },
+    })
+  })
+})

packages/snjs/lib/Services/Storage/DiskStorageService.ts

@@ -112,14 +112,10 @@ export class DiskStorageService extends Services.AbstractService implements Serv
     const value = await this.deviceInterface.getRawStorageValue(this.getPersistenceKey())
     const values = value ? JSON.parse(value as string) : undefined
 
-    this.setInitialValues(values)
+    await this.setInitialValues(values)
   }
 
-  /**
-   * Called by platforms with the value they load from disk,
-   * after they handle initializeFromDisk
-   */
-  private setInitialValues(values?: Services.StorageValuesObject) {
+  private async setInitialValues(values?: Services.StorageValuesObject) {
     const sureValues = values || this.defaultValuesObject()
 
     if (!sureValues[Services.ValueModesKeys.Unwrapped]) {
@@ -127,6 +123,13 @@ export class DiskStorageService extends Services.AbstractService implements Serv
     }
 
     this.values = sureValues
+
+    if (!this.isStorageWrapped()) {
+      this.values[Services.ValueModesKeys.Unwrapped] = {
+        ...(this.values[Services.ValueModesKeys.Wrapped].content as object),
+        ...this.values[Services.ValueModesKeys.Unwrapped],
+      }
+    }
   }
 
   public isStorageWrapped(): boolean {
@@ -370,7 +373,7 @@ export class DiskStorageService extends Services.AbstractService implements Serv
    * Clears simple values from storage only. Does not affect payloads.
    */
   async clearValues() {
-    this.setInitialValues()
+    await this.setInitialValues()
     await this.immediatelyPersistValuesToDisk()
   }