refactor: application dependency management (#2363)

2023-07-23 15:54:31 -05:00
parent e698b1c990
commit a77535456c
299 changed files with 7415 additions and 4890 deletions
--- a/packages/services/src/Domain/SharedVaults/SharedVaultService.ts
+++ b/packages/services/src/Domain/SharedVaults/SharedVaultService.ts
@@ -1,6 +1,5 @@
-import { MutatorClientInterface } from './../Mutator/MutatorClientInterface'
-import { StorageServiceInterface } from './../Storage/StorageServiceInterface'
-import { InviteContactToSharedVaultUseCase } from './UseCase/InviteContactToSharedVault'
+import { UserKeyPairChangedEventData } from './../Session/UserKeyPairChangedEventData'
+import { InviteToVault } from './UseCase/InviteToVault'
 import {
  ClientDisplayableError,
  SharedVaultInviteServerHash,
@@ -10,17 +9,7 @@ import {
  SharedVaultPermission,
  UserEventType,
 } from '@standardnotes/responses'
-import {
-  HttpServiceInterface,
-  SharedVaultServerInterface,
-  SharedVaultUsersServerInterface,
-  SharedVaultInvitesServerInterface,
-  SharedVaultUsersServer,
-  SharedVaultInvitesServer,
-  SharedVaultServer,
-  AsymmetricMessageServerInterface,
-  AsymmetricMessageServer,
-} from '@standardnotes/api'
+import { SharedVaultInvitesServer } from '@standardnotes/api'
 import {
  DecryptedItemInterface,
  PayloadEmitSource,
@@ -32,61 +21,72 @@ import {
 } from '@standardnotes/models'
 import { SharedVaultServiceInterface } from './SharedVaultServiceInterface'
 import { SharedVaultServiceEvent, SharedVaultServiceEventPayload } from './SharedVaultServiceEvent'
-import { EncryptionProviderInterface } from '@standardnotes/encryption'
-import { GetSharedVaultUsersUseCase } from './UseCase/GetSharedVaultUsers'
-import { RemoveVaultMemberUseCase } from './UseCase/RemoveSharedVaultMember'
+import { GetVaultUsers } from './UseCase/GetVaultUsers'
+import { RemoveVaultMember } from './UseCase/RemoveSharedVaultMember'
 import { AbstractService } from '../Service/AbstractService'
 import { InternalEventHandlerInterface } from '../Internal/InternalEventHandlerInterface'
 import { SyncServiceInterface } from '../Sync/SyncServiceInterface'
 import { ItemManagerInterface } from '../Item/ItemManagerInterface'
 import { SessionsClientInterface } from '../Session/SessionsClientInterface'
-import { ContactServiceInterface } from '../Contacts/ContactServiceInterface'
 import { InternalEventBusInterface } from '../Internal/InternalEventBusInterface'
 import { SyncEvent, SyncEventReceivedSharedVaultInvitesData } from '../Event/SyncEvent'
 import { SessionEvent } from '../Session/SessionEvent'
 import { InternalEventInterface } from '../Internal/InternalEventInterface'
-import { FilesClientInterface } from '@standardnotes/files'
-import { LeaveVaultUseCase } from './UseCase/LeaveSharedVault'
+import { LeaveVault } from './UseCase/LeaveSharedVault'
 import { VaultServiceInterface } from '../Vaults/VaultServiceInterface'
 import { UserEventServiceEvent, UserEventServiceEventPayload } from '../UserEvent/UserEventServiceEvent'
-import { DeleteExternalSharedVaultUseCase } from './UseCase/DeleteExternalSharedVault'
-import { DeleteSharedVaultUseCase } from './UseCase/DeleteSharedVault'
+import { DeleteThirdPartyVault } from './UseCase/DeleteExternalSharedVault'
+import { DeleteSharedVault } from './UseCase/DeleteSharedVault'
 import { VaultServiceEvent, VaultServiceEventPayload } from '../Vaults/VaultServiceEvent'
-import { AcceptTrustedSharedVaultInvite } from './UseCase/AcceptTrustedSharedVaultInvite'
-import { GetAsymmetricMessageTrustedPayload } from '../AsymmetricMessage/UseCase/GetAsymmetricMessageTrustedPayload'
+import { AcceptVaultInvite } from './UseCase/AcceptVaultInvite'
+import { GetTrustedPayload } from '../AsymmetricMessage/UseCase/GetTrustedPayload'
 import { PendingSharedVaultInviteRecord } from './PendingSharedVaultInviteRecord'
-import { GetAsymmetricMessageUntrustedPayload } from '../AsymmetricMessage/UseCase/GetAsymmetricMessageUntrustedPayload'
-import { ShareContactWithAllMembersOfSharedVaultUseCase } from './UseCase/ShareContactWithAllMembersOfSharedVault'
-import { GetSharedVaultTrustedContacts } from './UseCase/GetSharedVaultTrustedContacts'
-import { NotifySharedVaultUsersOfRootKeyRotationUseCase } from './UseCase/NotifySharedVaultUsersOfRootKeyRotation'
-import { CreateSharedVaultUseCase } from './UseCase/CreateSharedVault'
-import { SendSharedVaultMetadataChangedMessageToAll } from './UseCase/SendSharedVaultMetadataChangedMessageToAll'
-import { ConvertToSharedVaultUseCase } from './UseCase/ConvertToSharedVault'
-import { GetVaultUseCase } from '../Vaults/UseCase/GetVault'
-import { ContentType } from '@standardnotes/domain-core'
+import { GetUntrustedPayload } from '../AsymmetricMessage/UseCase/GetUntrustedPayload'
+import { ShareContactWithVault } from './UseCase/ShareContactWithVault'
+import { GetVaultContacts } from './UseCase/GetVaultContacts'
+import { NotifyVaultUsersOfKeyRotation } from './UseCase/NotifyVaultUsersOfKeyRotation'
+import { CreateSharedVault } from './UseCase/CreateSharedVault'
+import { SendVaultDataChangedMessage } from './UseCase/SendVaultDataChangedMessage'
+import { ConvertToSharedVault } from './UseCase/ConvertToSharedVault'
+import { GetVault } from '../Vaults/UseCase/GetVault'
+import { ContentType, Result } from '@standardnotes/domain-core'
+import { HandleKeyPairChange } from '../Contacts/UseCase/HandleKeyPairChange'
+import { FindContact } from '../Contacts/UseCase/FindContact'
+import { GetAllContacts } from '../Contacts/UseCase/GetAllContacts'
+import { EncryptionProviderInterface } from '../Encryption/EncryptionProviderInterface'

 export class SharedVaultService
  extends AbstractService<SharedVaultServiceEvent, SharedVaultServiceEventPayload>
  implements SharedVaultServiceInterface, InternalEventHandlerInterface
 {
-  private server: SharedVaultServerInterface
-  private usersServer: SharedVaultUsersServerInterface
-  private invitesServer: SharedVaultInvitesServerInterface
-  private messageServer: AsymmetricMessageServerInterface
-
  private pendingInvites: Record<string, PendingSharedVaultInviteRecord> = {}

  constructor(
-    http: HttpServiceInterface,
    private sync: SyncServiceInterface,
    private items: ItemManagerInterface,
-    private mutator: MutatorClientInterface,
    private encryption: EncryptionProviderInterface,
    private session: SessionsClientInterface,
-    private contacts: ContactServiceInterface,
-    private files: FilesClientInterface,
    private vaults: VaultServiceInterface,
-    private storage: StorageServiceInterface,
+    private invitesServer: SharedVaultInvitesServer,
+    private getVault: GetVault,
+    private createSharedVaultUseCase: CreateSharedVault,
+    private handleKeyPairChange: HandleKeyPairChange,
+    private notifyVaultUsersOfKeyRotation: NotifyVaultUsersOfKeyRotation,
+    private sendVaultDataChangeMessage: SendVaultDataChangedMessage,
+    private getTrustedPayload: GetTrustedPayload,
+    private getUntrustedPayload: GetUntrustedPayload,
+    private findContact: FindContact,
+    private getAllContacts: GetAllContacts,
+    private getVaultContacts: GetVaultContacts,
+    private acceptVaultInvite: AcceptVaultInvite,
+    private inviteToVault: InviteToVault,
+    private leaveVault: LeaveVault,
+    private deleteThirdPartyVault: DeleteThirdPartyVault,
+    private shareContactWithVault: ShareContactWithVault,
+    private convertToSharedVault: ConvertToSharedVault,
+    private deleteSharedVaultUseCase: DeleteSharedVault,
+    private removeVaultMember: RemoveVaultMember,
+    private getSharedVaultUsersUseCase: GetVaultUsers,
    eventBus: InternalEventBusInterface,
  ) {
    super(eventBus)
@@ -95,21 +95,6 @@ export class SharedVaultService
    eventBus.addEventHandler(this, UserEventServiceEvent.UserEventReceived)
    eventBus.addEventHandler(this, VaultServiceEvent.VaultRootKeyRotated)

-    this.server = new SharedVaultServer(http)
-    this.usersServer = new SharedVaultUsersServer(http)
-    this.invitesServer = new SharedVaultInvitesServer(http)
-    this.messageServer = new AsymmetricMessageServer(http)
-
-    this.eventDisposers.push(
-      sync.addEventObserver(async (event, data) => {
-        if (event === SyncEvent.ReceivedSharedVaultInvites) {
-          void this.processInboundInvites(data as SyncEventReceivedSharedVaultInvitesData)
-        } else if (event === SyncEvent.ReceivedRemoteSharedVaults) {
-          void this.notifyCollaborationStatusChanged()
-        }
-      }),
-    )
-
    this.eventDisposers.push(
      items.addObserver<TrustedContactInterface>(
        ContentType.TYPES.TrustedContact,
@@ -138,26 +123,32 @@ export class SharedVaultService
  async handleEvent(event: InternalEventInterface): Promise<void> {
    if (event.type === SessionEvent.UserKeyPairChanged) {
      void this.invitesServer.deleteAllInboundInvites()
+
+      const eventData = event.payload as UserKeyPairChangedEventData
+
+      void this.handleKeyPairChange.execute({
+        newKeys: eventData.current,
+        previousKeys: eventData.previous,
+      })
    } else if (event.type === UserEventServiceEvent.UserEventReceived) {
      await this.handleUserEvent(event.payload as UserEventServiceEventPayload)
    } else if (event.type === VaultServiceEvent.VaultRootKeyRotated) {
      const payload = event.payload as VaultServiceEventPayload[VaultServiceEvent.VaultRootKeyRotated]
      await this.handleVaultRootKeyRotatedEvent(payload.vault)
+    } else if (event.type === SyncEvent.ReceivedSharedVaultInvites) {
+      await this.processInboundInvites(event.payload as SyncEventReceivedSharedVaultInvitesData)
+    } else if (event.type === SyncEvent.ReceivedRemoteSharedVaults) {
+      void this.notifyCollaborationStatusChanged()
    }
  }

  private async handleUserEvent(event: UserEventServiceEventPayload): Promise<void> {
    if (event.eventPayload.eventType === UserEventType.RemovedFromSharedVault) {
-      const vault = new GetVaultUseCase(this.items).execute({ sharedVaultUuid: event.eventPayload.sharedVaultUuid })
-      if (vault) {
-        const useCase = new DeleteExternalSharedVaultUseCase(
-          this.items,
-          this.mutator,
-          this.encryption,
-          this.storage,
-          this.sync,
-        )
-        await useCase.execute(vault)
+      const vault = this.getVault.execute<SharedVaultListingInterface>({
+        sharedVaultUuid: event.eventPayload.sharedVaultUuid,
+      })
+      if (!vault.isFailed()) {
+        await this.deleteThirdPartyVault.execute(vault.getValue())
      }
    } else if (event.eventPayload.eventType === UserEventType.SharedVaultItemRemoved) {
      const item = this.items.findItem(event.eventPayload.itemUuid)
@@ -176,15 +167,14 @@ export class SharedVaultService
      return
    }

-    const usecase = new NotifySharedVaultUsersOfRootKeyRotationUseCase(
-      this.usersServer,
-      this.invitesServer,
-      this.messageServer,
-      this.encryption,
-      this.contacts,
-    )
-
-    await usecase.execute({ sharedVault: vault, userUuid: this.session.getSureUser().uuid })
+    await this.notifyVaultUsersOfKeyRotation.execute({
+      sharedVault: vault,
+      senderUuid: this.session.getSureUser().uuid,
+      keys: {
+        encryption: this.encryption.getKeyPair(),
+        signing: this.encryption.getSigningKeyPair(),
+      },
+    })
  }

  async createSharedVault(dto: {
@@ -193,16 +183,7 @@ export class SharedVaultService
    userInputtedPassword: string | undefined
    storagePreference?: KeySystemRootKeyStorageMode
  }): Promise<VaultListingInterface | ClientDisplayableError> {
-    const usecase = new CreateSharedVaultUseCase(
-      this.encryption,
-      this.items,
-      this.mutator,
-      this.sync,
-      this.files,
-      this.server,
-    )
-
-    return usecase.execute({
+    return this.createSharedVaultUseCase.execute({
      vaultName: dto.name,
      vaultDescription: dto.description,
      userInputtedPassword: dto.userInputtedPassword,
@@ -213,9 +194,7 @@ export class SharedVaultService
  async convertVaultToSharedVault(
    vault: VaultListingInterface,
  ): Promise<SharedVaultListingInterface | ClientDisplayableError> {
-    const usecase = new ConvertToSharedVaultUseCase(this.items, this.mutator, this.sync, this.files, this.server)
-
-    return usecase.execute({ vault })
+    return this.convertToSharedVault.execute({ vault })
  }

  public getCachedPendingInviteRecords(): PendingSharedVaultInviteRecord[] {
@@ -228,7 +207,12 @@ export class SharedVaultService
  }

  private findSharedVault(sharedVaultUuid: string): SharedVaultListingInterface | undefined {
-    return this.getAllSharedVaults().find((vault) => vault.sharing.sharedVaultUuid === sharedVaultUuid)
+    const result = this.getVault.execute<SharedVaultListingInterface>({ sharedVaultUuid })
+    if (result.isFailed()) {
+      return undefined
+    }
+
+    return result.getValue()
  }

  public isCurrentUserSharedVaultAdmin(sharedVault: SharedVaultListingInterface): boolean {
@@ -256,7 +240,11 @@ export class SharedVaultService

  private async handleTrustedContactsChange(contacts: TrustedContactInterface[]): Promise<void> {
    for (const contact of contacts) {
-      await this.shareContactWithUserAdministeredSharedVaults(contact)
+      if (contact.isMe) {
+        continue
+      }
+
+      await this.shareContactWithVaults(contact)
    }
  }

@@ -266,18 +254,13 @@ export class SharedVaultService
        continue
      }

-      const usecase = new SendSharedVaultMetadataChangedMessageToAll(
-        this.encryption,
-        this.contacts,
-        this.usersServer,
-        this.messageServer,
-      )
-
-      await usecase.execute({
+      await this.sendVaultDataChangeMessage.execute({
        vault,
        senderUuid: this.session.getSureUser().uuid,
-        senderEncryptionKeyPair: this.encryption.getKeyPair(),
-        senderSigningKeyPair: this.encryption.getSigningKeyPair(),
+        keys: {
+          encryption: this.encryption.getKeyPair(),
+          signing: this.encryption.getSigningKeyPair(),
+        },
      })
    }
  }
@@ -326,8 +309,7 @@ export class SharedVaultService
  }

  public async deleteSharedVault(sharedVault: SharedVaultListingInterface): Promise<ClientDisplayableError | void> {
-    const useCase = new DeleteSharedVaultUseCase(this.server, this.items, this.mutator, this.sync, this.encryption)
-    return useCase.execute({ sharedVault })
+    return this.deleteSharedVaultUseCase.execute({ sharedVault })
  }

  private async reprocessCachedInvitesTrustStatusAfterTrustedContactsChange(): Promise<void> {
@@ -342,39 +324,34 @@ export class SharedVaultService
    }

    for (const invite of invites) {
-      const trustedMessageUseCase = new GetAsymmetricMessageTrustedPayload<AsymmetricMessageSharedVaultInvite>(
-        this.encryption,
-        this.contacts,
-      )
+      const sender = this.findContact.execute({ userUuid: invite.sender_uuid })
+      if (!sender.isFailed()) {
+        const trustedMessage = this.getTrustedPayload.execute<AsymmetricMessageSharedVaultInvite>({
+          message: invite,
+          privateKey: this.encryption.getKeyPair().privateKey,
+          sender: sender.getValue(),
+        })

-      const trustedMessage = trustedMessageUseCase.execute({
-        message: invite,
-        privateKey: this.encryption.getKeyPair().privateKey,
-      })
+        if (!trustedMessage.isFailed()) {
+          this.pendingInvites[invite.uuid] = {
+            invite,
+            message: trustedMessage.getValue(),
+            trusted: true,
+          }

-      if (trustedMessage) {
-        this.pendingInvites[invite.uuid] = {
-          invite,
-          message: trustedMessage,
-          trusted: true,
+          continue
        }
-
-        continue
      }

-      const untrustedMessageUseCase = new GetAsymmetricMessageUntrustedPayload<AsymmetricMessageSharedVaultInvite>(
-        this.encryption,
-      )
-
-      const untrustedMessage = untrustedMessageUseCase.execute({
+      const untrustedMessage = this.getUntrustedPayload.execute<AsymmetricMessageSharedVaultInvite>({
        message: invite,
        privateKey: this.encryption.getKeyPair().privateKey,
      })

-      if (untrustedMessage) {
+      if (!untrustedMessage.isFailed()) {
        this.pendingInvites[invite.uuid] = {
          invite,
-          message: untrustedMessage,
+          message: untrustedMessage.getValue(),
          trusted: false,
        }
      }
@@ -392,8 +369,7 @@ export class SharedVaultService
      throw new Error('Cannot accept untrusted invite')
    }

-    const useCase = new AcceptTrustedSharedVaultInvite(this.invitesServer, this.mutator, this.sync, this.contacts)
-    await useCase.execute({ invite: pendingInvite.invite, message: pendingInvite.message })
+    await this.acceptVaultInvite.execute({ invite: pendingInvite.invite, message: pendingInvite.message })

    delete this.pendingInvites[pendingInvite.invite.uuid]

@@ -416,35 +392,38 @@ export class SharedVaultService
      return []
    }

-    const contacts = this.contacts.getAllContacts()
-    return contacts.filter((contact) => {
+    const contacts = this.getAllContacts.execute()
+    if (contacts.isFailed()) {
+      return []
+    }
+    return contacts.getValue().filter((contact) => {
      const isContactAlreadyInVault = users.some((user) => user.user_uuid === contact.contactUuid)
      return !isContactAlreadyInVault
    })
  }

  private async getSharedVaultContacts(sharedVault: SharedVaultListingInterface): Promise<TrustedContactInterface[]> {
-    const usecase = new GetSharedVaultTrustedContacts(this.contacts, this.usersServer)
-    const contacts = await usecase.execute(sharedVault)
-    if (!contacts) {
+    const contacts = await this.getVaultContacts.execute(sharedVault.sharing.sharedVaultUuid)
+    if (contacts.isFailed()) {
      return []
    }

-    return contacts
+    return contacts.getValue()
  }

  async inviteContactToSharedVault(
    sharedVault: SharedVaultListingInterface,
    contact: TrustedContactInterface,
    permissions: SharedVaultPermission,
-  ): Promise<SharedVaultInviteServerHash | ClientDisplayableError> {
+  ): Promise<Result<SharedVaultInviteServerHash>> {
    const sharedVaultContacts = await this.getSharedVaultContacts(sharedVault)

-    const useCase = new InviteContactToSharedVaultUseCase(this.encryption, this.invitesServer)
-
-    const result = await useCase.execute({
-      senderKeyPair: this.encryption.getKeyPair(),
-      senderSigningKeyPair: this.encryption.getSigningKeyPair(),
+    const result = await this.inviteToVault.execute({
+      keys: {
+        encryption: this.encryption.getKeyPair(),
+        signing: this.encryption.getSigningKeyPair(),
+      },
+      senderUuid: this.session.getSureUser().uuid,
      sharedVault,
      recipient: contact,
      sharedVaultContacts,
@@ -470,8 +449,10 @@ export class SharedVaultService
      throw new Error('Cannot remove user from locked vault')
    }

-    const useCase = new RemoveVaultMemberUseCase(this.usersServer)
-    const result = await useCase.execute({ sharedVaultUuid: sharedVault.sharing.sharedVaultUuid, userUuid })
+    const result = await this.removeVaultMember.execute({
+      sharedVaultUuid: sharedVault.sharing.sharedVaultUuid,
+      userUuid,
+    })
    if (isClientDisplayableError(result)) {
      return result
    }
@@ -482,15 +463,7 @@ export class SharedVaultService
  }

  async leaveSharedVault(sharedVault: SharedVaultListingInterface): Promise<ClientDisplayableError | void> {
-    const useCase = new LeaveVaultUseCase(
-      this.usersServer,
-      this.items,
-      this.mutator,
-      this.encryption,
-      this.storage,
-      this.sync,
-    )
-    const result = await useCase.execute({
+    const result = await this.leaveVault.execute({
      sharedVault: sharedVault,
      userUuid: this.session.getSureUser().uuid,
    })
@@ -505,28 +478,22 @@ export class SharedVaultService
  async getSharedVaultUsers(
    sharedVault: SharedVaultListingInterface,
  ): Promise<SharedVaultUserServerHash[] | undefined> {
-    const useCase = new GetSharedVaultUsersUseCase(this.usersServer)
-    return useCase.execute({ sharedVaultUuid: sharedVault.sharing.sharedVaultUuid })
+    return this.getSharedVaultUsersUseCase.execute({ sharedVaultUuid: sharedVault.sharing.sharedVaultUuid })
  }

-  private async shareContactWithUserAdministeredSharedVaults(contact: TrustedContactInterface): Promise<void> {
-    const sharedVaults = this.getAllSharedVaults()
+  async shareContactWithVaults(contact: TrustedContactInterface): Promise<void> {
+    if (contact.isMe) {
+      throw new Error('Cannot share self contact')
+    }

-    const useCase = new ShareContactWithAllMembersOfSharedVaultUseCase(
-      this.contacts,
-      this.encryption,
-      this.usersServer,
-      this.messageServer,
-    )
+    const ownedVaults = this.getAllSharedVaults().filter(this.isCurrentUserSharedVaultAdmin.bind(this))

-    for (const vault of sharedVaults) {
-      if (!this.isCurrentUserSharedVaultAdmin(vault)) {
-        continue
-      }
-
-      await useCase.execute({
-        senderKeyPair: this.encryption.getKeyPair(),
-        senderSigningKeyPair: this.encryption.getSigningKeyPair(),
+    for (const vault of ownedVaults) {
+      await this.shareContactWithVault.execute({
+        keys: {
+          encryption: this.encryption.getKeyPair(),
+          signing: this.encryption.getSigningKeyPair(),
+        },
        sharedVault: vault,
        contactToShare: contact,
        senderUserUuid: this.session.getSureUser().uuid,
@@ -539,9 +506,9 @@ export class SharedVaultService
      return undefined
    }

-    const contact = this.contacts.findTrustedContact(item.last_edited_by_uuid)
+    const contact = this.findContact.execute({ userUuid: item.last_edited_by_uuid })

-    return contact
+    return contact.isFailed() ? undefined : contact.getValue()
  }

  getItemSharedBy(item: DecryptedItemInterface): TrustedContactInterface | undefined {
@@ -549,23 +516,37 @@ export class SharedVaultService
      return undefined
    }

-    const contact = this.contacts.findTrustedContact(item.user_uuid)
+    const contact = this.findContact.execute({ userUuid: item.user_uuid })

-    return contact
+    return contact.isFailed() ? undefined : contact.getValue()
  }

  override deinit(): void {
    super.deinit()
-    ;(this.contacts as unknown) = undefined
-    ;(this.encryption as unknown) = undefined
-    ;(this.files as unknown) = undefined
-    ;(this.invitesServer as unknown) = undefined
-    ;(this.items as unknown) = undefined
-    ;(this.messageServer as unknown) = undefined
-    ;(this.server as unknown) = undefined
-    ;(this.session as unknown) = undefined
    ;(this.sync as unknown) = undefined
-    ;(this.usersServer as unknown) = undefined
+    ;(this.items as unknown) = undefined
+    ;(this.encryption as unknown) = undefined
+    ;(this.session as unknown) = undefined
    ;(this.vaults as unknown) = undefined
+    ;(this.invitesServer as unknown) = undefined
+    ;(this.getVault as unknown) = undefined
+    ;(this.createSharedVaultUseCase as unknown) = undefined
+    ;(this.handleKeyPairChange as unknown) = undefined
+    ;(this.notifyVaultUsersOfKeyRotation as unknown) = undefined
+    ;(this.sendVaultDataChangeMessage as unknown) = undefined
+    ;(this.getTrustedPayload as unknown) = undefined
+    ;(this.getUntrustedPayload as unknown) = undefined
+    ;(this.findContact as unknown) = undefined
+    ;(this.getAllContacts as unknown) = undefined
+    ;(this.getVaultContacts as unknown) = undefined
+    ;(this.acceptVaultInvite as unknown) = undefined
+    ;(this.inviteToVault as unknown) = undefined
+    ;(this.leaveVault as unknown) = undefined
+    ;(this.deleteThirdPartyVault as unknown) = undefined
+    ;(this.shareContactWithVault as unknown) = undefined
+    ;(this.convertToSharedVault as unknown) = undefined
+    ;(this.deleteSharedVaultUseCase as unknown) = undefined
+    ;(this.removeVaultMember as unknown) = undefined
+    ;(this.getSharedVaultUsersUseCase as unknown) = undefined
  }
 }