@icure/api 6.3.1 → 7.0.0-beta.0

package/dist/icc-x-api/crypto/ShamirKeysManager.d.ts

@@ -0,0 +1,43 @@
+import { DataOwner, DataOwnerWithType, IccDataOwnerXApi } from '../icc-data-owner-x-api';
+import { KeyManager } from './KeyManager';
+import { ExchangeKeysManager } from './ExchangeKeysManager';
+import { CryptoPrimitives } from './CryptoPrimitives';
+/**
+ * Allows to create or update shamir split keys.
+ */
+export declare class ShamirKeysManager {
+    private readonly primitives;
+    private readonly dataOwnerApi;
+    private readonly keyManager;
+    private readonly exchangeKeysManager;
+    constructor(primitives: CryptoPrimitives, dataOwnerApi: IccDataOwnerXApi, keyManager: KeyManager, exchangeKeysManager: ExchangeKeysManager);
+    /**
+     * Get information on existing private keys splits for the provided data owner. For each private key of the provided data owner which has been
+     * split using the Shamir sharing algorithm gives the list of the notaries (other data owners) which hold a copy of the key part.
+     * @param dataOwner a data owner
+     * @return the existing splits for the current data owner as a publicKeyFingerprint -> notariesIds object
+     */
+    getExistingSplitsInfo(dataOwner: DataOwner): {
+        [keyPairFingerprint: string]: string[];
+    };
+    /**
+     * Creates, updates or deletes shamir splits for keys of the current data owner. Any request to update the splits for a specific key will completely
+     * replace any existing data on that split (all previous notaries will be ignored).
+     * Note: currently you can only split the legacy key pair.
+     * @param keySplitsToUpdate the fingerprints of key pairs which will have updated/new splits and the details on how to create the updated splits.
+     * @param keySplitsToDelete the fingerprints or hex-encoded spki public keys which will not be shared anymore.
+     * @throws if the parameters refer to non-existing or unavailable keys, have split creation details, or if they request to delete a non-existing
+     * split.
+     */
+    updateSelfSplits(keySplitsToUpdate: {
+        [publicKeyHexOrFp: string]: {
+            notariesIds: string[];
+            minShares: number;
+        };
+    }, keySplitsToDelete: string[]): Promise<DataOwnerWithType>;
+    private validateShamirParams;
+    private deleteKeySplit;
+    private updateKeySplit;
+    private createPartitionsFor;
+    private encryptShares;
+}

package/dist/icc-x-api/crypto/ShamirKeysManager.js

@@ -0,0 +1,150 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShamirKeysManager = void 0;
+const utils_1 = require("../utils");
+/**
+ * Allows to create or update shamir split keys.
+ */
+class ShamirKeysManager {
+    constructor(primitives, dataOwnerApi, keyManager, exchangeKeysManager) {
+        this.primitives = primitives;
+        this.dataOwnerApi = dataOwnerApi;
+        this.keyManager = keyManager;
+        this.exchangeKeysManager = exchangeKeysManager;
+    }
+    /**
+     * Get information on existing private keys splits for the provided data owner. For each private key of the provided data owner which has been
+     * split using the Shamir sharing algorithm gives the list of the notaries (other data owners) which hold a copy of the key part.
+     * @param dataOwner a data owner
+     * @return the existing splits for the current data owner as a publicKeyFingerprint -> notariesIds object
+     */
+    getExistingSplitsInfo(dataOwner) {
+        var _a, _b;
+        const legacyPartitionDelegates = Object.keys((_a = dataOwner.privateKeyShamirPartitions) !== null && _a !== void 0 ? _a : {});
+        if (legacyPartitionDelegates.length > 0) {
+            const fp = (_b = dataOwner.publicKey) === null || _b === void 0 ? void 0 : _b.slice(-32);
+            if (!fp) {
+                console.error('Invalid data owner: the owner has legacy key partitions but no legacy key.');
+            }
+            else
+                return { [fp]: legacyPartitionDelegates };
+        }
+        return {};
+    }
+    /**
+     * Creates, updates or deletes shamir splits for keys of the current data owner. Any request to update the splits for a specific key will completely
+     * replace any existing data on that split (all previous notaries will be ignored).
+     * Note: currently you can only split the legacy key pair.
+     * @param keySplitsToUpdate the fingerprints of key pairs which will have updated/new splits and the details on how to create the updated splits.
+     * @param keySplitsToDelete the fingerprints or hex-encoded spki public keys which will not be shared anymore.
+     * @throws if the parameters refer to non-existing or unavailable keys, have split creation details, or if they request to delete a non-existing
+     * split.
+     */
+    updateSelfSplits(keySplitsToUpdate, keySplitsToDelete) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const self = yield this.dataOwnerApi.getCurrentDataOwner();
+            const toUpdateSet = new Set(Object.keys(keySplitsToUpdate).map((x) => x.slice(-32)));
+            const toDeleteSet = new Set(keySplitsToDelete.slice(-32));
+            const intersection = Array.from(toDeleteSet).filter((x) => toUpdateSet.has(x));
+            const existingSplits = new Set(Object.keys(this.getExistingSplitsInfo(self.dataOwner)));
+            const allKeys = this.keyManager.getDecryptionKeys();
+            if (toDeleteSet.size !== keySplitsToDelete.length || toUpdateSet.size !== Object.keys(keySplitsToUpdate).length || intersection.length > 0)
+                throw new Error(`Duplicate keys in input:\nkeySplitsToUpdate: ${keySplitsToUpdate}\nkeySplitsToDelete: ${keySplitsToDelete}`);
+            Object.entries(keySplitsToUpdate).forEach(([key, params]) => this.validateShamirParams(key, params));
+            if (!Array.from(existingSplits).every((x) => existingSplits.has(x))) {
+                throw new Error(`Requested to delete non-existing split.\nexistingSplits: ${Array.from(existingSplits)}\ntoDelete:${Array.from(toDeleteSet)}`);
+            }
+            if (Array.from(toUpdateSet).some((x) => !allKeys[x])) {
+                throw new Error(`Private key is not available for some of the requested key split updates. ${keySplitsToUpdate}`);
+            }
+            const delegatesKeys = {};
+            let updatedSelf = self;
+            for (const delegateId of new Set(Object.values(keySplitsToUpdate).flatMap((x) => x.notariesIds))) {
+                const res = yield this.exchangeKeysManager.getOrCreateEncryptionExchangeKeysTo(delegateId);
+                delegatesKeys[delegateId] = res.keys[0];
+                if (res.updatedDelegator) {
+                    updatedSelf = res.updatedDelegator;
+                }
+            }
+            for (const [key, params] of Object.entries(keySplitsToUpdate)) {
+                updatedSelf = yield this.updateKeySplit(updatedSelf, key.slice(-32), params.notariesIds, params.minShares, delegatesKeys, allKeys);
+            }
+            for (const keyFp of toDeleteSet) {
+                updatedSelf = this.deleteKeySplit(updatedSelf, keyFp);
+            }
+            return yield this.dataOwnerApi.updateDataOwner(updatedSelf);
+        });
+    }
+    /*TODO
+     * Get suggested recovery keys: analyse transfer keys and shamir to get keys which should be shared with shamir for optimal recovery.
+     */
+    validateShamirParams(key, params) {
+        if (params.notariesIds.length > 0) {
+            if (params.minShares > params.notariesIds.length) {
+                throw new Error(`Invalid parameters for key ${key}: min shares can't be greater than the number of delegates. ${params}`);
+            }
+        }
+        else
+            throw new Error(`Invalid parameters for key ${key}: must have at least one delegate. ${params}`);
+    }
+    deleteKeySplit(dataOwner, keyFp) {
+        var _a;
+        if (keyFp !== ((_a = dataOwner.dataOwner.publicKey) === null || _a === void 0 ? void 0 : _a.slice(-32))) {
+            throw new Error('Currently it is possible to use shamir splits only for the legacy public key');
+        }
+        return {
+            type: dataOwner.type,
+            dataOwner: Object.assign(Object.assign({}, dataOwner.dataOwner), { privateKeyShamirPartitions: {} }),
+        };
+    }
+    updateKeySplit(dataOwner, keyFp, delegateIds, minShares, delegatesKeys, allKeys) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (keyFp !== ((_a = dataOwner.dataOwner.publicKey) === null || _a === void 0 ? void 0 : _a.slice(-32))) {
+                throw new Error('Currently it is possible to use shamir splits only for the legacy public key');
+            }
+            return {
+                type: dataOwner.type,
+                dataOwner: Object.assign(Object.assign({}, dataOwner.dataOwner), { privateKeyShamirPartitions: yield this.createPartitionsFor(allKeys[keyFp], delegateIds, minShares, delegatesKeys) }),
+            };
+        });
+    }
+    createPartitionsFor(keyPair, delegateIds, minShares, delegatesKeys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exportedKey = yield this.primitives.RSA.exportKey(keyPair.privateKey, 'pkcs8');
+            if (delegateIds.length == 1) {
+                return yield this.encryptShares([exportedKey], delegateIds, delegatesKeys);
+            }
+            else {
+                const exportedKeysHex = (0, utils_1.ua2hex)(exportedKey);
+                const stringShares = this.primitives.shamir.share(exportedKeysHex, delegateIds.length, minShares);
+                const paddedStringShares = stringShares.map((x) => `f${x}`); // Shares are uneven length, apart from that they are perfect hexes
+                for (const share of paddedStringShares) {
+                    if (!/^(?:[0-9a-f][0-9a-f])+$/g.test(share))
+                        throw new Error('Unexpected result of shamir split: padded shares should be a valid hex value');
+                    if (share !== (0, utils_1.ua2hex)((0, utils_1.hex2ua)(share)))
+                        throw new Error('Unexpected result with encoding-decoding share');
+                }
+                return yield this.encryptShares(paddedStringShares.map((x) => (0, utils_1.hex2ua)(x)), delegateIds, delegatesKeys);
+            }
+        });
+    }
+    encryptShares(shares, delegateIds, delegatesKeys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return delegateIds.reduce((acc, delegateId, index) => __awaiter(this, void 0, void 0, function* () {
+                return (Object.assign(Object.assign({}, (yield acc)), { [delegateId]: (0, utils_1.ua2hex)(yield this.primitives.AES.encrypt(delegatesKeys[delegateId], shares[index])) }));
+            }), Promise.resolve({}));
+        });
+    }
+}
+exports.ShamirKeysManager = ShamirKeysManager;
+//# sourceMappingURL=ShamirKeysManager.js.map

package/dist/icc-x-api/crypto/ShamirKeysManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShamirKeysManager.js","sourceRoot":"","sources":["../../../icc-x-api/crypto/ShamirKeysManager.ts"],"names":[],"mappings":"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","sourcesContent":["import { DataOwner, DataOwnerWithType, IccDataOwnerXApi } from '../icc-data-owner-x-api'\nimport { KeyManager } from './KeyManager'\nimport { ExchangeKeysManager } from './ExchangeKeysManager'\nimport { CryptoPrimitives } from './CryptoPrimitives'\nimport { KeyPair } from './RSA'\nimport { hex2ua, ua2hex } from '../utils'\n\n/**\n * Allows to create or update shamir split keys.\n */\nexport class ShamirKeysManager {\n  private readonly primitives: CryptoPrimitives\n  private readonly dataOwnerApi: IccDataOwnerXApi\n  private readonly keyManager: KeyManager\n  private readonly exchangeKeysManager: ExchangeKeysManager\n\n  constructor(primitives: CryptoPrimitives, dataOwnerApi: IccDataOwnerXApi, keyManager: KeyManager, exchangeKeysManager: ExchangeKeysManager) {\n    this.primitives = primitives\n    this.dataOwnerApi = dataOwnerApi\n    this.keyManager = keyManager\n    this.exchangeKeysManager = exchangeKeysManager\n  }\n\n  /**\n   * Get information on existing private keys splits for the provided data owner. For each private key of the provided data owner which has been\n   * split using the Shamir sharing algorithm gives the list of the notaries (other data owners) which hold a copy of the key part.\n   * @param dataOwner a data owner\n   * @return the existing splits for the current data owner as a publicKeyFingerprint -> notariesIds object\n   */\n  getExistingSplitsInfo(dataOwner: DataOwner): { [keyPairFingerprint: string]: string[] } {\n    const legacyPartitionDelegates = Object.keys(dataOwner.privateKeyShamirPartitions ?? {})\n    if (legacyPartitionDelegates.length > 0) {\n      const fp = dataOwner.publicKey?.slice(-32)\n      if (!fp) {\n        console.error('Invalid data owner: the owner has legacy key partitions but no legacy key.')\n      } else return { [fp]: legacyPartitionDelegates }\n    }\n    return {}\n  }\n\n  /**\n   * Creates, updates or deletes shamir splits for keys of the current data owner. Any request to update the splits for a specific key will completely\n   * replace any existing data on that split (all previous notaries will be ignored).\n   * Note: currently you can only split the legacy key pair.\n   * @param keySplitsToUpdate the fingerprints of key pairs which will have updated/new splits and the details on how to create the updated splits.\n   * @param keySplitsToDelete the fingerprints or hex-encoded spki public keys which will not be shared anymore.\n   * @throws if the parameters refer to non-existing or unavailable keys, have split creation details, or if they request to delete a non-existing\n   * split.\n   */\n  async updateSelfSplits(\n    keySplitsToUpdate: { [publicKeyHexOrFp: string]: { notariesIds: string[]; minShares: number } },\n    keySplitsToDelete: string[]\n  ): Promise<DataOwnerWithType> {\n    const self = await this.dataOwnerApi.getCurrentDataOwner()\n    const toUpdateSet = new Set(Object.keys(keySplitsToUpdate).map((x) => x.slice(-32)))\n    const toDeleteSet = new Set(keySplitsToDelete.slice(-32))\n    const intersection = Array.from(toDeleteSet).filter((x) => toUpdateSet.has(x))\n    const existingSplits = new Set(Object.keys(this.getExistingSplitsInfo(self.dataOwner)))\n    const allKeys = this.keyManager.getDecryptionKeys()\n    if (toDeleteSet.size !== keySplitsToDelete.length || toUpdateSet.size !== Object.keys(keySplitsToUpdate).length || intersection.length > 0)\n      throw new Error(`Duplicate keys in input:\\nkeySplitsToUpdate: ${keySplitsToUpdate}\\nkeySplitsToDelete: ${keySplitsToDelete}`)\n    Object.entries(keySplitsToUpdate).forEach(([key, params]) => this.validateShamirParams(key, params))\n    if (!Array.from(existingSplits).every((x) => existingSplits.has(x))) {\n      throw new Error(`Requested to delete non-existing split.\\nexistingSplits: ${Array.from(existingSplits)}\\ntoDelete:${Array.from(toDeleteSet)}`)\n    }\n    if (Array.from(toUpdateSet).some((x) => !allKeys[x])) {\n      throw new Error(`Private key is not available for some of the requested key split updates. ${keySplitsToUpdate}`)\n    }\n    const delegatesKeys: { [delegateId: string]: CryptoKey } = {}\n    let updatedSelf = self\n    for (const delegateId of new Set(Object.values(keySplitsToUpdate).flatMap((x) => x.notariesIds))) {\n      const res = await this.exchangeKeysManager.getOrCreateEncryptionExchangeKeysTo(delegateId)\n      delegatesKeys[delegateId] = res.keys[0]\n      if (res.updatedDelegator) {\n        updatedSelf = res.updatedDelegator\n      }\n    }\n    for (const [key, params] of Object.entries(keySplitsToUpdate)) {\n      updatedSelf = await this.updateKeySplit(updatedSelf, key.slice(-32), params.notariesIds, params.minShares, delegatesKeys, allKeys)\n    }\n    for (const keyFp of toDeleteSet) {\n      updatedSelf = this.deleteKeySplit(updatedSelf, keyFp)\n    }\n    return await this.dataOwnerApi.updateDataOwner(updatedSelf)\n  }\n\n  /*TODO\n   * Get suggested recovery keys: analyse transfer keys and shamir to get keys which should be shared with shamir for optimal recovery.\n   */\n\n  private validateShamirParams(key: string, params: { notariesIds: string[]; minShares: number }) {\n    if (params.notariesIds.length > 0) {\n      if (params.minShares > params.notariesIds.length) {\n        throw new Error(`Invalid parameters for key ${key}: min shares can't be greater than the number of delegates. ${params}`)\n      }\n    } else throw new Error(`Invalid parameters for key ${key}: must have at least one delegate. ${params}`)\n  }\n\n  private deleteKeySplit(dataOwner: DataOwnerWithType, keyFp: string): DataOwnerWithType {\n    if (keyFp !== dataOwner.dataOwner.publicKey?.slice(-32)) {\n      throw new Error('Currently it is possible to use shamir splits only for the legacy public key')\n    }\n    return {\n      type: dataOwner.type,\n      dataOwner: {\n        ...dataOwner.dataOwner,\n        privateKeyShamirPartitions: {},\n      },\n    }\n  }\n\n  private async updateKeySplit(\n    dataOwner: DataOwnerWithType,\n    keyFp: string,\n    delegateIds: string[],\n    minShares: number,\n    delegatesKeys: { [p: string]: CryptoKey },\n    allKeys: { [p: string]: KeyPair<CryptoKey> }\n  ): Promise<DataOwnerWithType> {\n    if (keyFp !== dataOwner.dataOwner.publicKey?.slice(-32)) {\n      throw new Error('Currently it is possible to use shamir splits only for the legacy public key')\n    }\n    return {\n      type: dataOwner.type,\n      dataOwner: {\n        ...dataOwner.dataOwner,\n        privateKeyShamirPartitions: await this.createPartitionsFor(allKeys[keyFp], delegateIds, minShares, delegatesKeys),\n      },\n    }\n  }\n\n  private async createPartitionsFor(\n    keyPair: KeyPair<CryptoKey>,\n    delegateIds: string[],\n    minShares: number,\n    delegatesKeys: { [p: string]: CryptoKey }\n  ): Promise<{ [delegateId: string]: string }> {\n    const exportedKey = await this.primitives.RSA.exportKey(keyPair.privateKey, 'pkcs8')\n    if (delegateIds.length == 1) {\n      return await this.encryptShares([exportedKey], delegateIds, delegatesKeys)\n    } else {\n      const exportedKeysHex = ua2hex(exportedKey)\n      const stringShares = this.primitives.shamir.share(exportedKeysHex, delegateIds.length, minShares)\n      const paddedStringShares = stringShares.map((x) => `f${x}`) // Shares are uneven length, apart from that they are perfect hexes\n      for (const share of paddedStringShares) {\n        if (!/^(?:[0-9a-f][0-9a-f])+$/g.test(share)) throw new Error('Unexpected result of shamir split: padded shares should be a valid hex value')\n        if (share !== ua2hex(hex2ua(share))) throw new Error('Unexpected result with encoding-decoding share')\n      }\n      return await this.encryptShares(\n        paddedStringShares.map((x) => hex2ua(x)),\n        delegateIds,\n        delegatesKeys\n      )\n    }\n  }\n\n  private async encryptShares(\n    shares: ArrayBuffer[],\n    delegateIds: string[],\n    delegatesKeys: { [p: string]: CryptoKey }\n  ): Promise<{ [delegateId: string]: string }> {\n    return delegateIds.reduce(\n      async (acc, delegateId, index) => ({\n        ...(await acc),\n        [delegateId]: ua2hex(await this.primitives.AES.encrypt(delegatesKeys[delegateId], shares[index])),\n      }),\n      Promise.resolve({} as { [delegateId: string]: string })\n    )\n  }\n}\n"]}

package/dist/icc-x-api/crypto/ShareMetadataBehaviour.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Specifies a behaviour for the sharing of encryption keys or owning entity ids in the extended apis 'share' methods.
+ */
+export declare enum ShareMetadataBehaviour {
+    /**
+     * The method must share the metadata with the delegate. If this is not possible, because for example the current user has no access to this kind of
+     * metadata, the method will throw an error.
+     */
+    REQUIRED = "REQUIRED",
+    /**
+     * The method must share the metadata with the delegate if available. If this is not possible, because for example the current user has no access to
+     * this kind of metadata, the method will simply not share this metadata.
+     */
+    IF_AVAILABLE = "IF_AVAILABLE",
+    /**
+     * The method must not share the metadata with the delegate, even if the current data owner can access it.
+     */
+    NEVER = "NEVER"
+}

package/dist/icc-x-api/crypto/ShareMetadataBehaviour.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShareMetadataBehaviour = void 0;
+/**
+ * Specifies a behaviour for the sharing of encryption keys or owning entity ids in the extended apis 'share' methods.
+ */
+var ShareMetadataBehaviour;
+(function (ShareMetadataBehaviour) {
+    /**
+     * The method must share the metadata with the delegate. If this is not possible, because for example the current user has no access to this kind of
+     * metadata, the method will throw an error.
+     */
+    ShareMetadataBehaviour["REQUIRED"] = "REQUIRED";
+    /**
+     * The method must share the metadata with the delegate if available. If this is not possible, because for example the current user has no access to
+     * this kind of metadata, the method will simply not share this metadata.
+     */
+    ShareMetadataBehaviour["IF_AVAILABLE"] = "IF_AVAILABLE";
+    /**
+     * The method must not share the metadata with the delegate, even if the current data owner can access it.
+     */
+    ShareMetadataBehaviour["NEVER"] = "NEVER";
+})(ShareMetadataBehaviour = exports.ShareMetadataBehaviour || (exports.ShareMetadataBehaviour = {}));
+//# sourceMappingURL=ShareMetadataBehaviour.js.map

package/dist/icc-x-api/crypto/ShareMetadataBehaviour.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShareMetadataBehaviour.js","sourceRoot":"","sources":["../../../icc-x-api/crypto/ShareMetadataBehaviour.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACH,IAAY,sBAeX;AAfD,WAAY,sBAAsB;IAChC;;;OAGG;IACH,+CAAqB,CAAA;IACrB;;;OAGG;IACH,uDAA6B,CAAA;IAC7B;;OAEG;IACH,yCAAe,CAAA;AACjB,CAAC,EAfW,sBAAsB,GAAtB,8BAAsB,KAAtB,8BAAsB,QAejC","sourcesContent":["/**\n * Specifies a behaviour for the sharing of encryption keys or owning entity ids in the extended apis 'share' methods.\n */\nexport enum ShareMetadataBehaviour {\n  /**\n   * The method must share the metadata with the delegate. If this is not possible, because for example the current user has no access to this kind of\n   * metadata, the method will throw an error.\n   */\n  REQUIRED = 'REQUIRED',\n  /**\n   * The method must share the metadata with the delegate if available. If this is not possible, because for example the current user has no access to\n   * this kind of metadata, the method will simply not share this metadata.\n   */\n  IF_AVAILABLE = 'IF_AVAILABLE',\n  /**\n   * The method must not share the metadata with the delegate, even if the current data owner can access it.\n   */\n  NEVER = 'NEVER',\n}\n"]}

package/dist/icc-x-api/crypto/TransferKeysManager.d.ts

@@ -0,0 +1,29 @@
+import { BaseExchangeKeysManager } from './BaseExchangeKeysManager';
+import { DataOwnerWithType, IccDataOwnerXApi } from '../icc-data-owner-x-api';
+import { KeyManager } from './KeyManager';
+import { CryptoPrimitives } from './CryptoPrimitives';
+import { IcureStorageFacade } from '../storage/IcureStorageFacade';
+/**
+ * @internal this class is intended only for internal use and may be changed without notice.
+ * Allows to create new transfer keys.
+ */
+export declare class TransferKeysManager {
+    private readonly primitives;
+    private readonly baseExchangeKeysManager;
+    private readonly dataOwnerApi;
+    private readonly keyManager;
+    private readonly icureStorage;
+    constructor(primitives: CryptoPrimitives, baseExchangeKeysManager: BaseExchangeKeysManager, dataOwnerApi: IccDataOwnerXApi, keyManager: KeyManager, icureStorage: IcureStorageFacade);
+    /**
+     * Analyses the transfer keys graph and creates new transfer keys which allow to improve data accessibility from other devices.
+     * For security reasons transfer keys will only be created between keys verified by the user, but this will be done ignoring any existing edges from
+     * unverified keys to verified keys.
+     * @param self the current data owner.
+     * @return the updated data owner.
+     */
+    updateTransferKeys(self: DataOwnerWithType): Promise<void>;
+    private encryptTransferKey;
+    private transferKeysCandidatesFp;
+    private transferTargetVerifiedKey;
+    private getNewVerifiedTransferKeysEdges;
+}

package/dist/icc-x-api/crypto/TransferKeysManager.js

@@ -0,0 +1,121 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransferKeysManager = void 0;
+const utils_1 = require("../utils");
+const graph_utils_1 = require("../utils/graph-utils");
+const utils_2 = require("./utils");
+/**
+ * @internal this class is intended only for internal use and may be changed without notice.
+ * Allows to create new transfer keys.
+ */
+class TransferKeysManager {
+    constructor(primitives, baseExchangeKeysManager, dataOwnerApi, keyManager, icureStorage) {
+        this.primitives = primitives;
+        this.baseExchangeKeysManager = baseExchangeKeysManager;
+        this.dataOwnerApi = dataOwnerApi;
+        this.keyManager = keyManager;
+        this.icureStorage = icureStorage;
+    }
+    /**
+     * Analyses the transfer keys graph and creates new transfer keys which allow to improve data accessibility from other devices.
+     * For security reasons transfer keys will only be created between keys verified by the user, but this will be done ignoring any existing edges from
+     * unverified keys to verified keys.
+     * @param self the current data owner.
+     * @return the updated data owner.
+     */
+    updateTransferKeys(self) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const newEdges = yield this.getNewVerifiedTransferKeysEdges(self);
+            if (!newEdges)
+                return;
+            const selfId = yield this.dataOwnerApi.getCurrentDataOwnerId();
+            const fpToPublicKey = (0, utils_2.fingerprintToPublicKeysMapOf)(self.dataOwner);
+            const newExchangeKeyPublicKeys = newEdges.sources.map((fp) => fpToPublicKey[fp]);
+            const { key: exchangeKey, updatedDelegator: updatedSelf } = yield this.baseExchangeKeysManager.createOrUpdateEncryptedExchangeKeyTo(selfId, newEdges.target, yield (0, utils_2.loadPublicKeys)(this.primitives.RSA, newExchangeKeyPublicKeys));
+            // note: createEncryptedExchangeKeyFor may update self
+            const encryptedTransferKey = yield this.encryptTransferKey(newEdges.target, exchangeKey);
+            const newTransferKeys = newEdges.sources.reduce((acc, candidateFp) => {
+                var _a;
+                const existingKeys = Object.assign({}, ((_a = acc[candidateFp]) !== null && _a !== void 0 ? _a : {}));
+                existingKeys[newEdges.targetFp] = encryptedTransferKey;
+                acc[candidateFp] = existingKeys;
+                return acc;
+            }, Object.assign({}, ((_a = updatedSelf.dataOwner.transferKeys) !== null && _a !== void 0 ? _a : {})));
+            yield this.dataOwnerApi.updateDataOwner({
+                type: updatedSelf.type,
+                dataOwner: Object.assign(Object.assign({}, updatedSelf.dataOwner), { transferKeys: newTransferKeys }),
+            });
+        });
+    }
+    // encrypts a transfer key in pkcs8 format using an exchange key, returns the hex representation
+    encryptTransferKey(transferKey, exchangeKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exportedKey = yield this.primitives.RSA.exportKey(transferKey.privateKey, 'pkcs8');
+            return (0, utils_1.ua2hex)(yield this.primitives.AES.encrypt(exchangeKey, exportedKey));
+        });
+    }
+    // all public keys would go to the stored keys -> no need for specifying the key.
+    // Result only includes the acyclic label, not the full group
+    transferKeysCandidatesFp(keyToFp, graph) {
+        return Object.entries((0, graph_utils_1.reachSetsAcyclic)(graph.acyclicGraph))
+            .filter(([from, reachable]) => from != keyToFp && !reachable.has(keyToFp))
+            .map((x) => x[0]);
+    }
+    transferTargetVerifiedKey(keyManager) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return keyManager.getSelfVerifiedKeys()[0];
+        });
+    }
+    // Decides the best edges considering the verified public keys.
+    getNewVerifiedTransferKeysEdges(self) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const verifiedKeysFpSet = new Set(this.keyManager.getSelfVerifiedKeys().map((x) => x.fingerprint));
+            Object.entries(yield this.icureStorage.loadSelfVerifiedKeys(self.dataOwner.id)).forEach(([key, verified]) => {
+                if (verified)
+                    verifiedKeysFpSet.add(key.slice(-32));
+            });
+            if (verifiedKeysFpSet.size == 0)
+                return undefined;
+            const graph = (0, utils_2.transferKeysFpGraphOf)(self.dataOwner);
+            // 1. Choose a key available in this device which should be reachable from all other verified keys
+            const { fingerprint: targetKeyFp, pair: targetKey } = yield this.transferTargetVerifiedKey(this.keyManager);
+            // 2. Find groups which can't reach the existing target keys
+            const candidatesFp = this.transferKeysCandidatesFp(targetKeyFp, graph);
+            // 3. Keep only groups which contain at least a verified candidate
+            const verifiedGroupCandidates = candidatesFp.filter((candidate) => graph.acyclicLabelToGroup[candidate].some((candidateGroupMember) => verifiedKeysFpSet.has(candidateGroupMember)));
+            const verifiedCandidatesSet = new Set(verifiedGroupCandidates);
+            if (verifiedCandidatesSet.size == 0)
+                return undefined;
+            // 4. Drop all candidates which can already reach another candidate group: it is sufficient to create a transfer key from that group.
+            const reachSets = (0, graph_utils_1.reachSetsAcyclic)(graph.acyclicGraph);
+            const optimizedCandidates = verifiedGroupCandidates.filter((candidate) => Array.from(reachSets[candidate]).every((reachableNode) => !verifiedCandidatesSet.has(reachableNode)));
+            if (optimizedCandidates.length == 0)
+                throw new Error('Check failed: at least one candidate should survive optimization');
+            // 5. Transfer keys could also be faked: to make sure we are not giving access to unauthorised people we remap the candidates to a verified public
+            // keys
+            const verifiedOptimizedCandidates = optimizedCandidates.map((candidate) => {
+                const res = graph.acyclicLabelToGroup[candidate].find((groupMemberFp) => verifiedKeysFpSet.has(groupMemberFp));
+                if (!res)
+                    throw new Error('Check failed: optimized candidates groups should have at least a verified member');
+                return res;
+            });
+            return {
+                sources: verifiedOptimizedCandidates,
+                target: targetKey,
+                targetFp: targetKeyFp,
+            };
+        });
+    }
+}
+exports.TransferKeysManager = TransferKeysManager;
+//# sourceMappingURL=TransferKeysManager.js.map

package/dist/icc-x-api/crypto/TransferKeysManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransferKeysManager.js","sourceRoot":"","sources":["../../../icc-x-api/crypto/TransferKeysManager.ts"],"names":[],"mappings":"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","sourcesContent":["import { KeyPair } from './RSA'\nimport { BaseExchangeKeysManager } from './BaseExchangeKeysManager'\nimport { DataOwnerWithType, IccDataOwnerXApi } from '../icc-data-owner-x-api'\nimport { ua2hex } from '../utils'\nimport { KeyManager } from './KeyManager'\nimport { reachSetsAcyclic, StronglyConnectedGraph } from '../utils/graph-utils'\nimport { fingerprintToPublicKeysMapOf, loadPublicKeys, transferKeysFpGraphOf } from './utils'\nimport { CryptoPrimitives } from './CryptoPrimitives'\nimport { IcureStorageFacade } from '../storage/IcureStorageFacade'\n\n/**\n * @internal this class is intended only for internal use and may be changed without notice.\n * Allows to create new transfer keys.\n */\nexport class TransferKeysManager {\n  private readonly primitives: CryptoPrimitives\n  private readonly baseExchangeKeysManager: BaseExchangeKeysManager\n  private readonly dataOwnerApi: IccDataOwnerXApi\n  private readonly keyManager: KeyManager\n  private readonly icureStorage: IcureStorageFacade\n\n  constructor(\n    primitives: CryptoPrimitives,\n    baseExchangeKeysManager: BaseExchangeKeysManager,\n    dataOwnerApi: IccDataOwnerXApi,\n    keyManager: KeyManager,\n    icureStorage: IcureStorageFacade\n  ) {\n    this.primitives = primitives\n    this.baseExchangeKeysManager = baseExchangeKeysManager\n    this.dataOwnerApi = dataOwnerApi\n    this.keyManager = keyManager\n    this.icureStorage = icureStorage\n  }\n\n  /**\n   * Analyses the transfer keys graph and creates new transfer keys which allow to improve data accessibility from other devices.\n   * For security reasons transfer keys will only be created between keys verified by the user, but this will be done ignoring any existing edges from\n   * unverified keys to verified keys.\n   * @param self the current data owner.\n   * @return the updated data owner.\n   */\n  async updateTransferKeys(self: DataOwnerWithType): Promise<void> {\n    const newEdges = await this.getNewVerifiedTransferKeysEdges(self)\n    if (!newEdges) return\n    const selfId = await this.dataOwnerApi.getCurrentDataOwnerId()\n    const fpToPublicKey = fingerprintToPublicKeysMapOf(self.dataOwner)\n    const newExchangeKeyPublicKeys = newEdges.sources.map((fp) => fpToPublicKey[fp])\n    const { key: exchangeKey, updatedDelegator: updatedSelf } = await this.baseExchangeKeysManager.createOrUpdateEncryptedExchangeKeyTo(\n      selfId,\n      newEdges.target,\n      await loadPublicKeys(this.primitives.RSA, newExchangeKeyPublicKeys)\n    )\n    // note: createEncryptedExchangeKeyFor may update self\n    const encryptedTransferKey = await this.encryptTransferKey(newEdges.target, exchangeKey)\n    const newTransferKeys = newEdges.sources.reduce(\n      (acc, candidateFp) => {\n        const existingKeys = { ...(acc[candidateFp] ?? {}) }\n        existingKeys[newEdges.targetFp] = encryptedTransferKey\n        acc[candidateFp] = existingKeys\n        return acc\n      },\n      { ...(updatedSelf.dataOwner.transferKeys ?? {}) }\n    )\n    await this.dataOwnerApi.updateDataOwner({\n      type: updatedSelf.type,\n      dataOwner: {\n        ...updatedSelf.dataOwner,\n        transferKeys: newTransferKeys,\n      },\n    })\n  }\n\n  // encrypts a transfer key in pkcs8 format using an exchange key, returns the hex representation\n  private async encryptTransferKey(transferKey: KeyPair<CryptoKey>, exchangeKey: CryptoKey): Promise<string> {\n    const exportedKey = await this.primitives.RSA.exportKey(transferKey.privateKey, 'pkcs8')\n    return ua2hex(await this.primitives.AES.encrypt(exchangeKey, exportedKey))\n  }\n\n  // all public keys would go to the stored keys -> no need for specifying the key.\n  // Result only includes the acyclic label, not the full group\n  private transferKeysCandidatesFp(keyToFp: string, graph: StronglyConnectedGraph): string[] {\n    return Object.entries(reachSetsAcyclic(graph.acyclicGraph))\n      .filter(([from, reachable]) => from != keyToFp && !reachable.has(keyToFp))\n      .map((x) => x[0])\n  }\n\n  private async transferTargetVerifiedKey(keyManager: KeyManager): Promise<{ fingerprint: string; pair: KeyPair<CryptoKey> }> {\n    return keyManager.getSelfVerifiedKeys()[0]\n  }\n\n  // Decides the best edges considering the verified public keys.\n  private async getNewVerifiedTransferKeysEdges(self: DataOwnerWithType): Promise<\n    | undefined\n    | {\n        sources: string[]\n        target: KeyPair<CryptoKey>\n        targetFp: string\n      }\n  > {\n    const verifiedKeysFpSet = new Set(this.keyManager.getSelfVerifiedKeys().map((x) => x.fingerprint))\n    Object.entries(await this.icureStorage.loadSelfVerifiedKeys(self.dataOwner.id!)).forEach(([key, verified]) => {\n      if (verified) verifiedKeysFpSet.add(key.slice(-32))\n    })\n    if (verifiedKeysFpSet.size == 0) return undefined\n    const graph = transferKeysFpGraphOf(self.dataOwner)\n    // 1. Choose a key available in this device which should be reachable from all other verified keys\n    const { fingerprint: targetKeyFp, pair: targetKey } = await this.transferTargetVerifiedKey(this.keyManager)\n    // 2. Find groups which can't reach the existing target keys\n    const candidatesFp = this.transferKeysCandidatesFp(targetKeyFp, graph)\n    // 3. Keep only groups which contain at least a verified candidate\n    const verifiedGroupCandidates = candidatesFp.filter((candidate) =>\n      graph.acyclicLabelToGroup[candidate].some((candidateGroupMember) => verifiedKeysFpSet.has(candidateGroupMember))\n    )\n    const verifiedCandidatesSet = new Set(verifiedGroupCandidates)\n    if (verifiedCandidatesSet.size == 0) return undefined\n    // 4. Drop all candidates which can already reach another candidate group: it is sufficient to create a transfer key from that group.\n    const reachSets = reachSetsAcyclic(graph.acyclicGraph)\n    const optimizedCandidates = verifiedGroupCandidates.filter((candidate) =>\n      Array.from(reachSets[candidate]).every((reachableNode) => !verifiedCandidatesSet.has(reachableNode))\n    )\n    if (optimizedCandidates.length == 0) throw new Error('Check failed: at least one candidate should survive optimization')\n    // 5. Transfer keys could also be faked: to make sure we are not giving access to unauthorised people we remap the candidates to a verified public\n    // keys\n    const verifiedOptimizedCandidates = optimizedCandidates.map((candidate) => {\n      const res = graph.acyclicLabelToGroup[candidate].find((groupMemberFp) => verifiedKeysFpSet.has(groupMemberFp))\n      if (!res) throw new Error('Check failed: optimized candidates groups should have at least a verified member')\n      return res\n    })\n    return {\n      sources: verifiedOptimizedCandidates,\n      target: targetKey,\n      targetFp: targetKeyFp,\n    }\n  }\n}\n"]}

package/dist/icc-x-api/crypto/utils.d.ts

@@ -0,0 +1,46 @@
+import { StronglyConnectedGraph } from '../utils/graph-utils';
+import { DataOwner, DataOwnerWithType, IccDataOwnerXApi } from '../icc-data-owner-x-api';
+import { RSAUtils } from './RSA';
+import { EntitiesEncryption } from './EntitiesEncryption';
+import { CryptoPrimitives } from './CryptoPrimitives';
+import { EncryptedEntityStub } from '../../icc-api/model/models';
+/**
+ * @internal this function is meant only for internal use and may be changed without notice.
+ * Get the public keys of a data owner, same as {@link dataOwnerApi.getHexPublicKeysOf}.
+ * @param dataOwner
+ */
+export declare function hexPublicKeysOf(dataOwner: DataOwner): Set<string>;
+/**
+ * @internal this function is meant only for internal use and may be changed without notice.
+ * Get the transfer key graph for a data owner. Node names are the public key fingerprints of the data owner's keys, and an edge represents a key
+ * which can be retrieved from another key using the transfer keys.
+ * @param dataOwner a data owner.
+ * @return a graph representing the possible key recovery paths using transfer keys for hte provided data owner.
+ */
+export declare function transferKeysFpGraphOf(dataOwner: DataOwner): StronglyConnectedGraph;
+/**
+ * @internal this function is meant only for internal use and may be changed without notice.
+ * Get a map for converting public keys fingerprint to full public keys for the provided data owner.
+ * @param dataOwner a data owner.
+ * @return a map to convert fingerprints of the data owner into full public keys.
+ */
+export declare function fingerprintToPublicKeysMapOf(dataOwner: DataOwner): {
+    [fp: string]: string;
+};
+/**
+ * @internal this function is meant only for internal use and may be changed without notice.
+ * Load many public keys in spki format.
+ * @param rsa the rsa service
+ * @param publicKeysSpkiHex public keys in spki format, hex encoded.
+ * @return public keys as crypto keys by their fingerprint.
+ */
+export declare function loadPublicKeys(rsa: RSAUtils, publicKeysSpkiHex: string[]): Promise<{
+    [publicKeyFingerprint: string]: CryptoKey;
+}>;
+/**
+ * @internal This method is intended only for internal use and may be changed without notice.
+ * Creates a delegation for the current data owner if the data owner is an encrypted entity and there is no delegation to himself.
+ * @return the updated self.
+ */
+export declare function ensureDelegationForSelf(dataOwnerApi: IccDataOwnerXApi, entitiesEncryption: EntitiesEncryption, cryptoPrimitives: CryptoPrimitives): Promise<DataOwnerWithType>;
+export declare function encryptedStubEquals(a: EncryptedEntityStub, b: EncryptedEntityStub): boolean;

package/dist/icc-x-api/crypto/utils.js

@@ -0,0 +1,130 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encryptedStubEquals = exports.ensureDelegationForSelf = exports.loadPublicKeys = exports.fingerprintToPublicKeysMapOf = exports.transferKeysFpGraphOf = exports.hexPublicKeysOf = void 0;
+// Uses fp as node names
+const graph_utils_1 = require("../utils/graph-utils");
+const icc_data_owner_x_api_1 = require("../icc-data-owner-x-api");
+const utils_1 = require("../utils");
+const collection_utils_1 = require("../utils/collection-utils");
+/**
+ * @internal this function is meant only for internal use and may be changed without notice.
+ * Get the public keys of a data owner, same as {@link dataOwnerApi.getHexPublicKeysOf}.
+ * @param dataOwner
+ */
+function hexPublicKeysOf(dataOwner) {
+    var _a;
+    return new Set([dataOwner.publicKey, ...Object.keys((_a = dataOwner.aesExchangeKeys) !== null && _a !== void 0 ? _a : {})].filter((pubKey) => !!pubKey));
+}
+exports.hexPublicKeysOf = hexPublicKeysOf;
+/**
+ * @internal this function is meant only for internal use and may be changed without notice.
+ * Get the transfer key graph for a data owner. Node names are the public key fingerprints of the data owner's keys, and an edge represents a key
+ * which can be retrieved from another key using the transfer keys.
+ * @param dataOwner a data owner.
+ * @return a graph representing the possible key recovery paths using transfer keys for hte provided data owner.
+ */
+function transferKeysFpGraphOf(dataOwner) {
+    var _a;
+    const publicKeys = Array.from(hexPublicKeysOf(dataOwner));
+    const edges = [];
+    Object.entries((_a = dataOwner.transferKeys) !== null && _a !== void 0 ? _a : {}).forEach(([from, tos]) => {
+        Object.keys(tos).forEach((to) => {
+            edges.push([from.slice(-32), to.slice(-32)]);
+        });
+    });
+    return (0, graph_utils_1.acyclic)((0, graph_utils_1.graphFromEdges)(edges, publicKeys.map((x) => x.slice(-32))));
+}
+exports.transferKeysFpGraphOf = transferKeysFpGraphOf;
+/**
+ * @internal this function is meant only for internal use and may be changed without notice.
+ * Get a map for converting public keys fingerprint to full public keys for the provided data owner.
+ * @param dataOwner a data owner.
+ * @return a map to convert fingerprints of the data owner into full public keys.
+ */
+function fingerprintToPublicKeysMapOf(dataOwner) {
+    const publicKeys = Array.from(hexPublicKeysOf(dataOwner));
+    const res = {};
+    publicKeys.forEach((pk) => {
+        res[pk.slice(-32)] = pk;
+    });
+    return res;
+}
+exports.fingerprintToPublicKeysMapOf = fingerprintToPublicKeysMapOf;
+/**
+ * @internal this function is meant only for internal use and may be changed without notice.
+ * Load many public keys in spki format.
+ * @param rsa the rsa service
+ * @param publicKeysSpkiHex public keys in spki format, hex encoded.
+ * @return public keys as crypto keys by their fingerprint.
+ */
+function loadPublicKeys(rsa, publicKeysSpkiHex) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return Object.fromEntries(yield Promise.all(publicKeysSpkiHex.map((x) => __awaiter(this, void 0, void 0, function* () { return [x.slice(-32), yield rsa.importKey('spki', (0, utils_1.hex2ua)(x), ['encrypt'])]; }))));
+    });
+}
+exports.loadPublicKeys = loadPublicKeys;
+/**
+ * @internal This method is intended only for internal use and may be changed without notice.
+ * Creates a delegation for the current data owner if the data owner is an encrypted entity and there is no delegation to himself.
+ * @return the updated self.
+ */
+function ensureDelegationForSelf(dataOwnerApi, entitiesEncryption, cryptoPrimitives) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        const self = yield dataOwnerApi.getCurrentDataOwner();
+        if (self.type === icc_data_owner_x_api_1.DataOwnerTypeEnum.Patient) {
+            const patient = self.dataOwner;
+            const availableSecretIds = yield entitiesEncryption.secretIdsOf(patient);
+            if (availableSecretIds.length) {
+                return self;
+            }
+            else {
+                const updatedPatient = Object.entries((_a = patient.encryptionKeys) !== null && _a !== void 0 ? _a : {}).length || Object.entries((_b = patient.delegations) !== null && _b !== void 0 ? _b : {}).length
+                    ? yield entitiesEncryption.entityWithExtendedEncryptedMetadata(
+                    // If there is already something initialise only a new delegation to self
+                    patient, patient.id, [cryptoPrimitives.randomUuid()], [], []) // else initialise also encryption keys
+                    : yield entitiesEncryption.entityWithInitialisedEncryptedMetadata(patient, undefined, undefined, true).then((x) => x.updatedEntity);
+                return yield dataOwnerApi.updateDataOwner({
+                    dataOwner: updatedPatient,
+                    type: icc_data_owner_x_api_1.DataOwnerTypeEnum.Patient,
+                });
+            }
+        }
+        else {
+            return self;
+        }
+    });
+}
+exports.ensureDelegationForSelf = ensureDelegationForSelf;
+function encryptedStubEquals(a, b) {
+    if (!delegationLikeEquality(a.delegations, b.delegations))
+        return false;
+    if (!delegationLikeEquality(a.encryptionKeys, b.encryptionKeys))
+        return false;
+    if (!delegationLikeEquality(a.cryptedForeignKeys, b.cryptedForeignKeys))
+        return false;
+    if (!(0, collection_utils_1.setEquals)(new Set(a.secretForeignKeys), new Set(b.secretForeignKeys)))
+        return false;
+    return a.encryptedSelf === b.encryptedSelf;
+}
+exports.encryptedStubEquals = encryptedStubEquals;
+function delegationLikeEquality(a, b) {
+    if (!(0, collection_utils_1.setEquals)(new Set(Object.keys(a !== null && a !== void 0 ? a : {})), new Set(Object.keys(b !== null && b !== void 0 ? b : {}))))
+        return false;
+    for (const [k, aDelegations] of Object.entries(a !== null && a !== void 0 ? a : {})) {
+        const bDelegations = (b !== null && b !== void 0 ? b : {})[k];
+        if (!aDelegations.every((da) => !!bDelegations.find((db) => da.key === db.key && da.delegatedTo === db.delegatedTo && da.owner === db.owner && (0, collection_utils_1.setEquals)(new Set(da.tags), new Set(db.tags)))))
+            return false;
+    }
+    return true;
+}
+//# sourceMappingURL=utils.js.map