@icure/api 7.1.5 → 7.1.6

package/icc-x-api/maintenance/KeyPairUpdateRequest.ts

@@ -0,0 +1,62 @@
+/**
+ * Represents a request to update aes exchange keys following the creation of a new key pair for a data owner.
+ */
+import { MaintenanceTask } from '../../icc-api/model/MaintenanceTask'
+import { PropertyStub } from '../../icc-api/model/PropertyStub'
+
+export interface KeyPairUpdateRequest {
+  /**
+   * New public key of the data owner, in hex-encoded spki format.
+   */
+  readonly newPublicKey: string
+
+  /**
+   * Id of the data owner which created a new key pair and wants to regain access to his exchange keys.
+   */
+  readonly concernedDataOwnerId: string
+
+  /**
+   * @internal this field is intended for internal use only and may be changed in future without notice
+   */
+  readonly originalTask?: MaintenanceTask
+}
+
+export namespace KeyPairUpdateRequest {
+  /**
+   * Create a key pair update request from a maintenance task.
+   */
+  export function fromMaintenanceTask(task: MaintenanceTask): KeyPairUpdateRequest {
+    if (task.taskType !== KeyPairUpdateRequest.TASK_TYPE)
+      throw new Error(`Key pair update tasks should have task type ${KeyPairUpdateRequest.TASK_TYPE}, but got task with type ${task.taskType}`)
+
+    function findStringProp(propId: string): string {
+      const prop: PropertyStub | undefined = task.properties?.find((x) => x.id === propId)
+      if (!prop) throw new Error(`Task is missing required string property ${propId} for KeyPairUpdateRequest. ${JSON.stringify(task)}`)
+      const propValue = prop.typedValue?.stringValue
+      if (!propValue)
+        throw new Error(`Invalid value ${prop.typedValue?.stringValue} for property ${propId} for KeyPairUpdateRequest. ${JSON.stringify(task)}`)
+      return propValue
+    }
+
+    return {
+      concernedDataOwnerId: findStringProp(KeyPairUpdateRequest.OWNER_ID_PROP_ID),
+      newPublicKey: findStringProp(KeyPairUpdateRequest.OWNER_PUB_PROP_ID),
+      originalTask: task,
+    }
+  }
+}
+
+export namespace KeyPairUpdateRequest {
+  /**
+   * @internal this field is intended for internal use only and may be changed in future without notice
+   */
+  export const OWNER_ID_PROP_ID = 'dataOwnerConcernedId'
+  /**
+   * @internal this field is intended for internal use only and may be changed in future without notice
+   */
+  export const OWNER_PUB_PROP_ID = 'dataOwnerConcernedPubKey'
+  /**
+   * @internal this field is intended for internal use only and may be changed in future without notice
+   */
+  export const TASK_TYPE = MaintenanceTask.TaskTypeEnum.KeyPairUpdate
+}

package/icc-x-api/rsrc/codelng.ts

@@ -0,0 +1,8 @@
+export default {
+  'BE-THESAURUS': ['fr', 'nl'],
+  'CD-ATC': ['fr', 'nl'],
+  'CD-DRUG-CNK': ['fr', 'nl'],
+  'CD-INNCLUSTER': ['fr', 'nl'],
+  ICPC: ['fr', 'nl'],
+  ICD: ['fr', 'nl'],
+}

package/icc-x-api/rsrc/contact.i18n.ts

@@ -0,0 +1,110 @@
+export default {
+  fr: {
+    package: 'boîte',
+    packages: 'boîtes',
+    packageOf: 'boîte de',
+    packagesOf: 'boîtes de',
+    during: 'pendant',
+    take_s_: 'prise(s)',
+    weekly: '/semaine',
+    monthly: '/mois',
+    daily: '/jour',
+    the: 'le',
+    onDay: 'le jour',
+    on: 'le',
+    afterwakingup: 'Au lever',
+    afterbreakfast: 'Après ptit déj.',
+    afterdinner: 'Après rep. soir',
+    afterlunch: 'Après rep. midi',
+    afternoon: 'Après-midi',
+    beforebreakfast: 'Avant ptit déj.',
+    beforedinner: 'Avant rep. soir',
+    beforelunch: 'Avant rep. midi',
+    duringbreakfast: 'Pdt ptit déj.',
+    duringdinner: 'Pdt rep. soir',
+    duringlunch: 'Pdt rep. midi',
+    betweenbreakfastandlunch: 'Entre ptit déj et rep. midi',
+    betweenlunchanddinner: 'Entre rep. midi et rep. soir',
+    betweendinnerandsleep: 'Entre rep. soir et couch.',
+    evening: 'Soir',
+    knownuse: 'Usage connu',
+    morning: 'Matin',
+    night: 'Avt couch.',
+    midday: 'Midi',
+    noon: 'Midi',
+    at: 'à',
+    thehourofsleep: 'Au coucher',
+  },
+  en: {
+    package: 'package',
+    packages: 'packages',
+    packageOf: 'package of',
+    packagesOf: 'packages of',
+    during: 'during',
+    take_s_: 'take(s)',
+    weekly: 'weekly',
+    monthly: 'monthly',
+    daily: 'daily',
+    the: 'the',
+    onDay: 'on day',
+    on: 'on',
+    afterwakingup: 'After Waking Up',
+    afterbreakfast: 'After Breakfast',
+    afterdinner: 'After Dinner',
+    afterlunch: 'After Lunch',
+    afternoon: 'Afternoon',
+    beforebreakfast: 'Before Breakfast',
+    beforedinner: 'Before Dinner',
+    beforelunch: 'Before Lunch',
+    duringbreakfast: 'During Breakfast',
+    duringdinner: 'During Dinner',
+    duringlunch: 'During Lunch',
+    betweenbreakfastandlunch: 'Between Breakfast and Lunch',
+    betweenlunchanddinner: 'Between Lunch and Dinner',
+    betweendinnerandsleep: 'Between Dinner and Sleep',
+    evening: 'Evening',
+    knownuse: 'Known Usage',
+    morning: 'Morning',
+    night: 'Night',
+    midday: 'Midday',
+    noon: 'Noon',
+    at: 'at',
+    thehourofsleep: 'At Bedtime',
+  },
+  nl: {
+    package: 'verpakking',
+    packages: 'verpakkingen',
+    packageOf: 'verpakking van',
+    packagesOf: 'verpakkingen van',
+    during: 'gedurende',
+    take_s_: 'inname(s)',
+    weekly: 'wekelijks',
+    monthly: 'maandelijks',
+    daily: 'dagelijks',
+    the: 'de',
+    onDay: 'op dag',
+    on: 'op',
+    afterwakingup: 'Bij het opstaan',
+    afterbreakfast: 'Na ontbijt',
+    afterdinner: 'Na avondeten',
+    afterlunch: 'Na middageten',
+    afternoon: 'Namiddag',
+    beforebreakfast: 'Voor ontbijt',
+    beforedinner: 'Voor avondeten',
+    beforelunch: 'Voor middageten',
+    duringbreakfast: 'Tijdens ontbijt',
+    duringdinner: 'Tijdens avondeten',
+    duringlunch: 'Tijdens middageten',
+    betweenbreakfastandlunch: 'Tussen ontbijt en middageten',
+    betweenlunchanddinner: 'Tussen middag- en avondeten',
+    betweendinnerandsleep: 'Tussen avondmaal en slapeneten',
+    evening: 'Avond',
+    knownuse: 'Gekend gebruik',
+    morning: "'s Morgens",
+    night: 'Vóór slapengaan',
+    midday: 'Middag',
+    noon: 'Middag',
+    at: 'om',
+    thehourofsleep: 'Voor het slapen',
+  },
+}

package/icc-x-api/rsrc/icd10.ts

@@ -0,0 +1,113 @@
+export default {
+  'A00-B99': {
+    en: 'Infectious and parasitic',
+    fr: 'Infections & parasites',
+    colour: 'ICD-10--IV',
+  },
+  'C00-D48': {
+    en: 'Neoplasms',
+    fr: 'Tumeurs',
+    colour: 'ICD-10--IV',
+  },
+  'D49-D89': {
+    en: 'Blood & immunity',
+    fr: 'Sang & immunité',
+    colour: 'ICD-10--IV',
+  },
+  'E00-E99': {
+    en: 'Endocrine, nutritional & metabolic',
+    fr: 'Endocrino, nutrition et métabolisme',
+    colour: 'ICD-10--IV',
+  },
+  'F00-F99': {
+    en: 'Mental and behavioural disorders',
+    fr: 'Troubles mentaux et du comportement',
+    colour: 'ICD-10--V',
+  },
+  'G00-G99': {
+    en: 'Nervous system',
+    fr: 'Système nerveux',
+    colour: 'ICD-10--VI',
+  },
+  'H00-H59': {
+    en: 'Eye and adnexa',
+    fr: 'Œil et de ses annexes',
+    colour: 'ICD-10--VII',
+  },
+  'H60-H99': {
+    en: 'Ear and mastoid process',
+    fr: "Oreille et de l'apophyse mastoïde",
+    colour: 'ICD-10--VII',
+  },
+  'I00-I99': {
+    en: 'Circulatory system',
+    fr: 'Appareil circulatoire',
+    colour: 'ICD-10--VIII',
+  },
+  'J00-J99': {
+    en: 'Respiratory system',
+    fr: 'Appareil respiratoire',
+    colour: 'ICD-10--IX',
+  },
+  'K00-K99': {
+    en: 'Digestive system',
+    fr: 'Appareil digestif',
+    colour: 'ICD-10--X',
+  },
+  'L00-L99': {
+    en: 'Skin and subcutaneous tissue',
+    fr: 'Peau et Tissu cellulaire sous-cutané',
+    colour: 'ICD-10--XI',
+  },
+  'M00-M99': {
+    en: 'Musculoskeletal system and connective tissue',
+    fr: 'Système ostéo-articulaire, des muscles et du tissu conjonctif',
+    colour: 'ICD-10--XII',
+  },
+  'N00-N99': {
+    en: 'Genitourinary system',
+    fr: 'Appareil génito-urinaire',
+    colour: 'ICD-10--XIII',
+  },
+  'O00-O99': {
+    en: 'Pregnancy, childbirth and the puerperium',
+    fr: 'Grossesse, accouchement et puerpéralité',
+    colour: 'ICD-10--XIV',
+  },
+  'P00-P99': {
+    en: 'Perinatal period conditions',
+    fr: 'Affections périnatale',
+    colour: 'ICD-10--XV',
+  },
+  'Q00-Q99': {
+    en: 'Congenital malformations, deformations and chromosomal abnormalities',
+    fr: 'Malformations congénitales et anomalies chromosomiques',
+    colour: 'ICD-10--XVI',
+  },
+  'R00-R69': {
+    en: 'Symptoms and signs',
+    fr: 'Symptômes et signes',
+    colour: 'ICD-10--other',
+  },
+  'R70-R94': {
+    en: 'Abnormal clinical and laboratory findings',
+    fr: 'Examens cliniques et laboratoires anormaux',
+    colour: 'ICD-10--other',
+  },
+  'R95-R99': {
+    en: 'Ill-defined and unknown causes of mortality',
+    fr: 'Cause de décès mal-définie ou inconnue',
+    colour: 'ICD-10--other',
+  },
+  'S00-T99': {
+    en: 'Injuries & poisoning',
+    fr: 'Traumato & toxicologie',
+    colour: 'ICD-10--other',
+  },
+  'U00-Y99': { en: 'Unsorted', fr: 'Non-classé', colour: 'ICD-10--other' },
+  'Z00-Z99': {
+    en: 'General health status',
+    fr: 'Etat général',
+    colour: 'ICD-10--other',
+  },
+}

package/icc-x-api/rsrc/icpc2.ts

@@ -0,0 +1,22 @@
+export default {
+  A: { en: 'General and unspecified', colour: 'ICPC-2--A' },
+  B: {
+    en: 'Blood, blood forming organs, lymphatics, spleen',
+    colour: 'ICPC-2--B',
+  },
+  D: { en: 'Digestive', colour: 'ICPC-2--D' },
+  F: { en: 'Eye', colour: 'ICPC-2--F' },
+  H: { en: 'Ear', colour: 'ICPC-2--H' },
+  K: { en: 'Circulatory', colour: 'ICPC-2--K' },
+  L: { en: 'Musculoskeletal', colour: 'ICPC-2--L' },
+  N: { en: 'Neurological', colour: 'ICPC-2--N' },
+  P: { en: 'Psychological', colour: 'ICPC-2--P' },
+  R: { en: 'Respiratory', colour: 'ICPC-2--R' },
+  S: { en: 'Skin', colour: 'ICPC-2--S' },
+  T: { en: 'Endocrine, metabolic and nutritional', colour: 'ICPC-2--T' },
+  U: { en: 'Urology', colour: 'ICPC-2--U' },
+  W: { en: 'Pregnancy, childbirth, family planning', colour: 'ICPC-2--W' },
+  X: { en: 'Female genital system and breast', colour: 'ICPC-2--X' },
+  Y: { en: 'Male genital system', colour: 'ICPC-2--Y' },
+  Z: { en: 'Social problems', colour: 'ICPC-2--Z' },
+}

package/icc-x-api/storage/DefaultStorageEntryKeysFactory.ts

@@ -0,0 +1,20 @@
+import { StorageEntryKeysFactory } from './StorageEntryKeysFactory'
+
+/**
+ * Default implementation for {@link StorageEntryKeysFactory}, compatible with legacy local storage keys.
+ */
+export class DefaultStorageEntryKeysFactory implements StorageEntryKeysFactory {
+  cachedRecoveredKeypairOfDataOwner(dataOwnerId: string, publicKeyFingerprint: string): string {
+    if (publicKeyFingerprint.length != 32) throw new Error(`Invalid key fingerprint: ${publicKeyFingerprint}`)
+    return `org.taktik.icure.rsa.recovered.${dataOwnerId}.${publicKeyFingerprint}`
+  }
+
+  deviceKeypairOfDataOwner(dataOwnerId: string, publicKeyFingerprint: string): string {
+    if (publicKeyFingerprint.length != 32) throw new Error(`Invalid key fingerprint: ${publicKeyFingerprint}`)
+    return `org.taktik.icure.rsa.device.${dataOwnerId}.${publicKeyFingerprint}`
+  }
+
+  selfPublicKeysVerificationCacheForDataOwner(dataOwnerId: string): string {
+    return `org.taktik.icure.rsa.${dataOwnerId}.verification.self`
+  }
+}

package/icc-x-api/storage/IcureStorageFacade.ts

@@ -0,0 +1,93 @@
+import { KeyStorageFacade } from './KeyStorageFacade'
+import { StorageFacade } from './StorageFacade'
+import { StorageEntryKeysFactory } from './StorageEntryKeysFactory'
+import { KeyPair } from '../crypto/RSA'
+
+/**
+ * @internal This class is meant for internal use only and may be changed without notice.
+ * Simplifies access to the storage facades for iCure-specific data storage.
+ */
+export class IcureStorageFacade {
+  private readonly keys: KeyStorageFacade
+  private readonly data: StorageFacade<string>
+  private readonly entryFor: StorageEntryKeysFactory
+
+  constructor(keyStorage: KeyStorageFacade, storage: StorageFacade<string>, entryKeysFactory: StorageEntryKeysFactory) {
+    this.keys = keyStorage
+    this.data = storage
+    this.entryFor = entryKeysFactory
+  }
+
+  /**
+   * Saves a key pair for the data owner.
+   * @param dataOwnerId id of the data owner with the key.
+   * @param publicKeyFingerprint fingerprint of the public key of the pair.
+   * @param keyPair a key pair of the data owner.
+   * @param isDevice true if the key was generated on this device.
+   */
+  async saveKey(dataOwnerId: string, publicKeyFingerprint: string, keyPair: KeyPair<JsonWebKey>, isDevice: boolean): Promise<void> {
+    const key = isDevice
+      ? this.entryFor.deviceKeypairOfDataOwner(dataOwnerId, publicKeyFingerprint)
+      : this.entryFor.cachedRecoveredKeypairOfDataOwner(dataOwnerId, publicKeyFingerprint)
+    await this.keys.storeKeyPair(key, keyPair)
+  }
+
+  /**
+   * Get an existing key pair for the data owner.
+   * @param dataOwnerId id of the data owner with the key.
+   * @param publicKeyFingerprint fingerprint of a public key of the data owner.
+   * @param legacyPublicKey the legacy public key of the data owner, if present
+   * @return the keypair and if the key was generated on this device or undefined if the key pair could not be found.
+   */
+  async loadKey(
+    dataOwnerId: string,
+    publicKeyFingerprint: string,
+    legacyPublicKey: string | undefined
+  ): Promise<{ pair: KeyPair<JsonWebKey>; isDevice: boolean } | undefined> {
+    const deviceKey =
+      (await this.keys.getKeypair(this.entryFor.deviceKeypairOfDataOwner(dataOwnerId, publicKeyFingerprint))) ??
+      (await this.keys.getKeypair(`org.taktik.icure.rsa.${dataOwnerId}.${publicKeyFingerprint}`)) ??
+      (legacyPublicKey?.slice(-32) === publicKeyFingerprint ? await this.keys.getKeypair(`org.taktik.icure.rsa.${dataOwnerId}`) : undefined)
+    if (deviceKey) return { pair: deviceKey, isDevice: true }
+    const cachedKey = await this.keys.getKeypair(this.entryFor.cachedRecoveredKeypairOfDataOwner(dataOwnerId, publicKeyFingerprint))
+    if (cachedKey) return { pair: cachedKey, isDevice: false }
+    return undefined
+  }
+
+  /**
+   * Save the results of public key verification. If there were already results stored the entries will be merged. In case of conflicts the new
+   * {@link verificationDetails} take priority over the stored data.
+   * @param dataOwnerId id of a data owner.
+   * @param verificationDetails results of verification, associates key fingerprints to true if they were verified by the user or false otherwise.
+   * @return the udpated keys
+   */
+  async saveSelfVerifiedKeys(
+    dataOwnerId: string,
+    verificationDetails: { [keyFingerprint: string]: boolean }
+  ): Promise<{ [keyFingerprint: string]: boolean }> {
+    const updated = {
+      ...(await this.loadSelfVerifiedKeys(dataOwnerId)),
+      ...verificationDetails,
+    }
+    await this.data.setItem(this.entryFor.selfPublicKeysVerificationCacheForDataOwner(dataOwnerId), JSON.stringify(updated))
+    return updated
+  }
+
+  /**
+   * Get the last saved results of public key verification.
+   * @param dataOwnerId id of a data owner.
+   * @return saved results of verification, associates key fingerprints to true if they were verified by the user or false otherwise. If no results
+   * were saved returns an empty object instead.
+   * @throws if the stored results are not in a valid format.
+   */
+  async loadSelfVerifiedKeys(dataOwnerId: string): Promise<{ [keyFingerprint: string]: boolean }> {
+    const dataString = await this.data.getItem(this.entryFor.selfPublicKeysVerificationCacheForDataOwner(dataOwnerId))
+    if (dataString) {
+      const parsed = JSON.parse(dataString)
+      Object.entries(parsed).forEach(([k, v]) => {
+        if (v !== true && v !== false) throw new Error(`Unexpected entry ${k}:${v}`)
+      })
+      return parsed
+    } else return {}
+  }
+}

package/icc-x-api/storage/KeyStorageFacade.ts

@@ -0,0 +1,35 @@
+export interface KeyStorageFacade {
+  /**
+   * Returns the publicKey of the provided key from the storage
+   * @param key Key of the value to retrieve
+   * @return The publicKey associated to the provided key or undefined if not found.
+   */
+  getPublicKey(key: string): Promise<JsonWebKey | undefined>
+
+  /**
+   * Returns the privateKey of the provided key from the storage
+   * @param key Key of the value to retrieve
+   * @return The privateKey associated to the provided key or undefined if not found.
+   */
+  getPrivateKey(key: string): Promise<JsonWebKey | undefined>
+
+  /**
+   * Get the keyPair associated to the provided key
+   * @param key Key of the value to retrieve
+   * @return The keyPair associated to the provided key or undefined if not found.
+   */
+  getKeypair(key: string): Promise<{ publicKey: JsonWebKey; privateKey: JsonWebKey } | undefined>
+
+  /**
+   * Delete the keyPair associated to the provided key
+   * @param key Key of the value to delete
+   */
+  deleteKeypair(key: string): Promise<void>
+
+  /**
+   * Stores the given keyPair under the given key in the storage.
+   * @param key The id of the entry in storage
+   * @param keyPair should be JWK
+   */
+  storeKeyPair(key: string, keyPair: { publicKey: JsonWebKey; privateKey: JsonWebKey }): Promise<void>
+}

package/icc-x-api/storage/KeyStorageImpl.ts

@@ -0,0 +1,36 @@
+import { StorageFacade } from './StorageFacade'
+import { KeyStorageFacade } from './KeyStorageFacade'
+
+export class KeyStorageImpl implements KeyStorageFacade {
+  private readonly _storage: StorageFacade<string>
+
+  constructor(storage: StorageFacade<string>) {
+    this._storage = storage
+  }
+
+  async deleteKeypair(key: string): Promise<void> {
+    return await this._storage.removeItem(key)
+  }
+
+  async getKeypair(key: string): Promise<{ publicKey: JsonWebKey; privateKey: JsonWebKey } | undefined> {
+    const keyPair = JSON.parse((await this._storage.getItem(key)) ?? '{}')
+    return keyPair.hasOwnProperty('publicKey') && keyPair.hasOwnProperty('privateKey')
+      ? {
+          publicKey: keyPair.publicKey as JsonWebKey,
+          privateKey: keyPair.privateKey as JsonWebKey,
+        }
+      : undefined
+  }
+
+  async getPrivateKey(key: string): Promise<JsonWebKey | undefined> {
+    return (await this.getKeypair(key))?.privateKey
+  }
+
+  async getPublicKey(key: string): Promise<JsonWebKey | undefined> {
+    return (await this.getKeypair(key))?.publicKey
+  }
+
+  async storeKeyPair(key: string, keyPair: { publicKey: JsonWebKey; privateKey: JsonWebKey }): Promise<void> {
+    return await this._storage.setItem(key, JSON.stringify(keyPair))
+  }
+}

package/icc-x-api/storage/LocalStorageImpl.ts

@@ -0,0 +1,27 @@
+import { StorageFacade } from './StorageFacade'
+
+export class LocalStorageImpl implements StorageFacade<string> {
+  async getItem(key: string): Promise<string | undefined> {
+    if (typeof Storage === 'undefined') {
+      console.error('Your browser does not support HTML5 Browser Local Storage !')
+      throw new Error('Your browser does not support HTML5 Browser Local Storage !')
+    }
+    return localStorage.getItem(key) ?? undefined
+  }
+
+  async removeItem(key: string): Promise<void> {
+    if (typeof Storage === 'undefined') {
+      console.error('Your browser does not support HTML5 Browser Local Storage !')
+      throw new Error('Your browser does not support HTML5 Browser Local Storage !')
+    }
+    return localStorage.removeItem(key)
+  }
+
+  async setItem(key: string, valueToStore: string): Promise<void> {
+    if (typeof Storage === 'undefined') {
+      console.error('Your browser does not support HTML5 Browser Local Storage !')
+      throw new Error('Your browser does not support HTML5 Browser Local Storage !')
+    }
+    return localStorage.setItem(key, valueToStore)
+  }
+}

package/icc-x-api/storage/StorageEntryKeysFactory.ts

@@ -0,0 +1,39 @@
+/**
+ * Specifies the entry keys to use for storage of data needed by iCure.
+ */
+export interface StorageEntryKeysFactory {
+  /**
+   * Get the entry key for the storage of a key pair of a data owner which was created on this device. All keys created on this device will be
+   * considered as verified and safe.
+   * This entry key will be used in a {@link KeyStorageFacade}.
+   * @param dataOwnerId Id of a data owner.
+   * @param publicKeyFingerprint Fingerprint of the public key in a keypair of the data owner.
+   * @return entry key for the keypair.
+   */
+  deviceKeypairOfDataOwner(dataOwnerId: string, publicKeyFingerprint: string): string
+
+  /**
+   * Get the entry key for the storage of a key pair of a data owner which was recovered from transfer keys or shamir.
+   * These keys are going to be considered as UNSAFE for encryption unless their public key has been verified by the human user and has been stored in
+   * {@link selfPublicKeysVerificationCacheForDataOwner}.
+   * This entry key will be used in a {@link KeyStorageFacade}.
+   * @param dataOwnerId Id of a data owner.
+   * @param publicKeyFingerprint Fingerprint of the public key in a keypair of the data owner.
+   * @return entry key for the keypair.
+   */
+  cachedRecoveredKeypairOfDataOwner(dataOwnerId: string, publicKeyFingerprint: string): string
+
+  /**
+   * Get the entry key for the storage of answers to own public key verification (from {@link CryptoStrategies.verifyOwnPublicKeys}).
+   * This entry key will be used in a {@link StorageFacade}.
+   * @param dataOwnerId Id of a data owner.
+   * @return entry key for verified public keys of the data owner.
+   */
+  selfPublicKeysVerificationCacheForDataOwner(dataOwnerId: string): string
+
+  /*
+   * There is no need to store verified public keys for other data owners: we verify only when we want to create a new exchange key, and we need to
+   * create an exchange key to each user only once unless we lose our key. But we can lose our key only if we delete our data, which means we would
+   * also used the verified keys for other data owners...
+   */
+}

package/icc-x-api/storage/StorageFacade.ts

@@ -0,0 +1,21 @@
+export interface StorageFacade<T> {
+  /**
+   * Returns the value of the provided key from the storage
+   * @param key Key of the value to retrieve
+   * @return The value associated to the provided key or undefined if not found.
+   */
+  getItem(key: string): Promise<T | undefined>
+
+  /**
+   * Set an item in the storage for the given key
+   * @param key Key of the value to set
+   * @param valueToStore
+   */
+  setItem(key: string, valueToStore: T): Promise<void>
+
+  /**
+   * Removes the item with the given key from the storage.
+   * @param key The key of the item to remove.
+   */
+  removeItem(key: string): Promise<void>
+}