internal: incomplete vault systems behind feature flag (#2340)

packages/encryption/src/Domain/Keys/ItemsKey/ItemsKey.ts

@@ -7,11 +7,10 @@ import {
   HistoryEntryInterface,
   ItemsKeyContent,
   ItemsKeyInterface,
-  RootKeyInterface,
 } from '@standardnotes/models'
 
-export function isItemsKey(x: ItemsKeyInterface | RootKeyInterface): x is ItemsKeyInterface {
-  return x.content_type === ContentType.ItemsKey
+export function isItemsKey(x: unknown): x is ItemsKeyInterface {
+  return (x as ItemsKeyInterface).content_type === ContentType.ItemsKey
 }
 
 /**

packages/encryption/src/Domain/Keys/KeySystemItemsKey/KeySystemItemsKey.ts

@@ -0,0 +1,41 @@
+import { ContentType, ProtocolVersion } from '@standardnotes/common'
+import {
+  ConflictStrategy,
+  DecryptedItem,
+  DecryptedItemInterface,
+  DecryptedPayloadInterface,
+  HistoryEntryInterface,
+  KeySystemItemsKeyContent,
+  KeySystemItemsKeyInterface,
+} from '@standardnotes/models'
+
+export function isKeySystemItemsKey(x: unknown): x is KeySystemItemsKeyInterface {
+  return (x as KeySystemItemsKeyInterface).content_type === ContentType.KeySystemItemsKey
+}
+
+/**
+ * A key used to encrypt other items. Items keys are synced and persisted.
+ */
+export class KeySystemItemsKey extends DecryptedItem<KeySystemItemsKeyContent> implements KeySystemItemsKeyInterface {
+  creationTimestamp: number
+  keyVersion: ProtocolVersion
+  itemsKey: string
+  rootKeyToken: string
+
+  constructor(payload: DecryptedPayloadInterface<KeySystemItemsKeyContent>) {
+    super(payload)
+
+    this.creationTimestamp = payload.content.creationTimestamp
+    this.keyVersion = payload.content.version
+    this.itemsKey = this.payload.content.itemsKey
+    this.rootKeyToken = this.payload.content.rootKeyToken
+  }
+
+  /** Do not duplicate vault items keys. Always keep original */
+  override strategyWhenConflictingWithItem(
+    _item: DecryptedItemInterface,
+    _previousRevision?: HistoryEntryInterface,
+  ): ConflictStrategy {
+    return ConflictStrategy.KeepBase
+  }
+}

packages/encryption/src/Domain/Keys/KeySystemItemsKey/KeySystemItemsKeyMutator.ts

@@ -0,0 +1,3 @@
+import { DecryptedItemMutator, KeySystemItemsKeyContent } from '@standardnotes/models'
+
+export class KeySystemItemsKeyMutator extends DecryptedItemMutator<KeySystemItemsKeyContent> {}

packages/encryption/src/Domain/Keys/KeySystemItemsKey/Registration.ts

@@ -0,0 +1,10 @@
+import { ContentType } from '@standardnotes/common'
+import { DecryptedItemMutator, KeySystemItemsKeyContent, RegisterItemClass } from '@standardnotes/models'
+import { KeySystemItemsKey } from './KeySystemItemsKey'
+import { KeySystemItemsKeyMutator } from './KeySystemItemsKeyMutator'
+
+RegisterItemClass(
+  ContentType.KeySystemItemsKey,
+  KeySystemItemsKey,
+  KeySystemItemsKeyMutator as unknown as DecryptedItemMutator<KeySystemItemsKeyContent>,
+)

packages/encryption/src/Domain/Keys/RootKey/Functions.ts

@@ -5,11 +5,12 @@ import {
   PayloadTimestampDefaults,
   RootKeyContent,
   RootKeyContentSpecialized,
+  RootKeyInterface,
 } from '@standardnotes/models'
 import { UuidGenerator } from '@standardnotes/utils'
 import { SNRootKey } from './RootKey'
 
-export function CreateNewRootKey(content: RootKeyContentSpecialized): SNRootKey {
+export function CreateNewRootKey<K extends RootKeyInterface>(content: RootKeyContentSpecialized): K {
   const uuid = UuidGenerator.GenerateUuid()
 
   const payload = new DecryptedPayload<RootKeyContent>({
@@ -19,7 +20,7 @@ export function CreateNewRootKey(content: RootKeyContentSpecialized): SNRootKey
     ...PayloadTimestampDefaults(),
   })
 
-  return new SNRootKey(payload)
+  return new SNRootKey(payload) as K
 }
 
 export function FillRootKeyContent(content: Partial<RootKeyContentSpecialized>): RootKeyContent {
@@ -37,15 +38,3 @@ export function FillRootKeyContent(content: Partial<RootKeyContentSpecialized>):
 
   return FillItemContentSpecialized(content)
 }
-
-export function ContentTypeUsesRootKeyEncryption(contentType: ContentType): boolean {
-  return (
-    contentType === ContentType.RootKey ||
-    contentType === ContentType.ItemsKey ||
-    contentType === ContentType.EncryptedStorage
-  )
-}
-
-export function ItemContentTypeUsesRootKeyEncryption(contentType: ContentType): boolean {
-  return contentType === ContentType.ItemsKey
-}

packages/encryption/src/Domain/Keys/RootKey/RootKey.ts

@@ -7,7 +7,7 @@ import {
   RootKeyContentInStorage,
   RootKeyInterface,
 } from '@standardnotes/models'
-import { timingSafeEqual } from '@standardnotes/sncrypto-common'
+import { PkcKeyPair, timingSafeEqual } from '@standardnotes/sncrypto-common'
 import { SNRootKeyParams } from './RootKeyParams'
 
 /**
@@ -47,6 +47,14 @@ export class SNRootKey extends DecryptedItem<RootKeyContent> implements RootKeyI
     return this.content.serverPassword
   }
 
+  get encryptionKeyPair(): PkcKeyPair | undefined {
+    return this.content.encryptionKeyPair
+  }
+
+  get signingKeyPair(): PkcKeyPair | undefined {
+    return this.content.signingKeyPair
+  }
+
   /** 003 and below only. */
   public get dataAuthenticationKey(): string | undefined {
     return this.content.dataAuthenticationKey
@@ -84,6 +92,8 @@ export class SNRootKey extends DecryptedItem<RootKeyContent> implements RootKeyI
     const values: NamespacedRootKeyInKeychain = {
       version: this.keyVersion,
       masterKey: this.masterKey,
+      encryptionKeyPair: this.encryptionKeyPair,
+      signingKeyPair: this.signingKeyPair,
     }
 
     if (this.dataAuthenticationKey) {