@lifeready/core 0.6.0-beta.1

package/esm2015/lib/scenario/approvals/scenario-approver.service.js

@@ -0,0 +1,300 @@
+import { __awaiter, __rest } from "tslib";
+import { Injectable } from '@angular/core';
+import { LrApolloService } from '../../api/lr-apollo.service';
+import { EncryptionService } from '../../cryptography/encryption.service';
+import { KeyFactoryService } from '../../cryptography/key-factory.service';
+import { KeyGraphService } from '../../cryptography/key-graph.service';
+import { KeyMetaService } from '../../cryptography/key-meta.service';
+import * as slip from '../../cryptography/slip39.service';
+import { TrustedPartyService } from '../../trusted-parties/trusted-party.service';
+import { CreateScenarioApproverAssemblyMutation, DeleteScenarioApproverAssemblyMutation, GetScenarioApproverQuery, UpdateScenarioApproverAssemblyMutation, UpdateScenarioApproverMutation, } from './scenario-approval.gql';
+import * as i0 from "@angular/core";
+import * as i1 from "../../api/lr-apollo.service";
+import * as i2 from "../../cryptography/key-factory.service";
+import * as i3 from "../../cryptography/key-meta.service";
+import * as i4 from "../../cryptography/key-graph.service";
+import * as i5 from "../../cryptography/slip39.service";
+import * as i6 from "../../cryptography/encryption.service";
+import * as i7 from "../../trusted-parties/trusted-party.service";
+export class ScenarioApproverService {
+    constructor(lrApollo, keyFactory, keyMetaService, keyGraph, slip39Service, encryptionService, trustedPartyService) {
+        this.lrApollo = lrApollo;
+        this.keyFactory = keyFactory;
+        this.keyMetaService = keyMetaService;
+        this.keyGraph = keyGraph;
+        this.slip39Service = slip39Service;
+        this.encryptionService = encryptionService;
+        this.trustedPartyService = trustedPartyService;
+    }
+    getApprover(approverId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { scenarioApprover } = yield this.lrApollo.query({
+                query: GetScenarioApproverQuery,
+                variables: {
+                    id: approverId,
+                },
+            });
+            return this.mapApprover(scenarioApprover);
+        });
+    }
+    mapApproverGroup(group) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { name } = yield this.keyGraph.decryptFromString(group.assemblyKey.id, group.subAssemblyCipherData);
+            return {
+                id: group.id,
+                keyId: group.assemblyKey.id,
+                name,
+                quorum: group.quorum,
+                singleReject: group.singleReject,
+                approvers: yield Promise.all(group.approvers.edges.map((x) => this.mapApprover(x.node))),
+            };
+        });
+    }
+    mapApprover(approver) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { message } = yield this.keyGraph.decryptFromString(approver.sharedKey.id, approver.sharedCipherData);
+            return {
+                id: approver.id,
+                keyId: approver.sharedKey.id,
+                trustedParty: yield this.trustedPartyService.mapTrustedParty(approver.tp),
+                message,
+            };
+        });
+    }
+    updateApprover(approver) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sharedCipherData = yield this.keyGraph.encryptToString(approver.keyId, approver.plainSharedCipherData);
+            yield this.lrApollo.mutate({
+                mutation: UpdateScenarioApproverMutation,
+                variables: {
+                    input: {
+                        approverId: approver.approverId,
+                        sharedKeyId: approver.keyId,
+                        sharedCipherData,
+                        sharedCipherApprovalData: '',
+                    },
+                },
+            });
+        });
+    }
+    createScenarioApproverAssembly(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const assemblyKey = yield this.keyFactory.createKey();
+            const subjectKeyWrappedAssemblyKey = yield this.keyGraph.encryptToString(input.keyId, assemblyKey.toJSON(true));
+            const assemblyCipherData = input.plainAssemblyCipherData
+                ? yield this.keyGraph.encryptToString(assemblyKey, input.plainAssemblyCipherData)
+                : '';
+            const { createScenarioApproverAssembly } = yield this.lrApollo.mutate({
+                mutation: CreateScenarioApproverAssemblyMutation,
+                variables: {
+                    input: {
+                        scenarioId: input.scenarioId,
+                        singleReject: input.singleReject,
+                        quorum: input.quorum,
+                        subjectKeyId: input.keyId,
+                        subjectKeyWrappedAssemblyKey,
+                        assemblyCipherData,
+                        createSubAssemblies: (yield this.mapApprovalGroups(input.approvalGroups, input.quorum, assemblyKey)).map((x) => {
+                            const { updateApprovers, deleteApprovers } = x, subAssembly = __rest(x, ["updateApprovers", "deleteApprovers"]);
+                            return subAssembly;
+                        }),
+                        updateReceivers: yield this.rewrapReceivers(assemblyKey, input.event, input.receivers),
+                    },
+                },
+            });
+            return createScenarioApproverAssembly.scenario.approverAssembly.assemblyKey
+                .id;
+        });
+    }
+    updateScenarioApproverAssembly(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const assemblyKey = yield this.keyGraph.getKey(input.assemblyKeyId);
+            const assemblyCipherData = input.plainAssemblyCipherData
+                ? yield this.keyGraph.encryptToString(assemblyKey.jwk, input.plainAssemblyCipherData)
+                : '';
+            const approvalGroups = yield this.mapApprovalGroups(input.approvalGroups, input.quorum, assemblyKey.jwk);
+            yield this.lrApollo.mutate({
+                mutation: UpdateScenarioApproverAssemblyMutation,
+                variables: {
+                    input: {
+                        scenarioId: input.scenarioId,
+                        singleReject: input.singleReject,
+                        quorum: input.quorum,
+                        assemblyKeyId: assemblyKey.id,
+                        assemblyCipherData,
+                        createSubAssemblies: approvalGroups
+                            .filter((x) => !x.subAssemblyId)
+                            .map((x) => {
+                            const { updateApprovers, deleteApprovers } = x, subAssembly = __rest(x, ["updateApprovers", "deleteApprovers"]);
+                            return subAssembly;
+                        }),
+                        updateSubAssemblies: approvalGroups.filter((x) => x.subAssemblyId),
+                        deleteSubAssemblies: input.deletedGroupIds,
+                    },
+                },
+            });
+        });
+    }
+    deleteScenarioApproverAssembly(scenarioId, event, receivers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.lrApollo.mutate({
+                mutation: DeleteScenarioApproverAssemblyMutation,
+                variables: {
+                    input: {
+                        scenarioId,
+                        updateReceivers: yield this.rewrapReceivers(null, event, receivers),
+                    },
+                },
+            });
+        });
+    }
+    rewrapReceivers(assemblyKey, event, receivers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!receivers || !receivers.length) {
+                return [];
+            }
+            return yield Promise.all(receivers.map((receiver) => __awaiter(this, void 0, void 0, function* () {
+                const sharedKey = yield this.keyGraph.getKey(receiver.keyId);
+                const prepareReceiverItem = (item, itemKeyId) => __awaiter(this, void 0, void 0, function* () {
+                    const itemKey = yield this.keyGraph.getKey(itemKeyId);
+                    let wrappedItemKey = yield this.keyGraph.encryptToString(sharedKey.jwk, itemKey.jwk.toJSON(true));
+                    if (assemblyKey) {
+                        wrappedItemKey = yield this.keyGraph.encryptToString(assemblyKey, wrappedItemKey);
+                    }
+                    return {
+                        accessRole: item.accessLevel,
+                        sharedKeyId: sharedKey.id,
+                        sharedCipherData: '',
+                        wrappedItemKey,
+                    };
+                });
+                // For each receiver-directory
+                const receiverDirectories = yield Promise.all([
+                    ...receiver.categories.map((x) => __awaiter(this, void 0, void 0, function* () {
+                        return (Object.assign(Object.assign({}, (yield prepareReceiverItem(x, x.category.keyId))), { receiverDirectoryId: x.id }));
+                    })),
+                    ...receiver.records.map((x) => __awaiter(this, void 0, void 0, function* () {
+                        return (Object.assign(Object.assign({}, (yield prepareReceiverItem(x, x.record.keyId))), { receiverDirectoryId: x.id }));
+                    })),
+                ]);
+                return {
+                    receiverId: receiver.id,
+                    sharedKeyId: receiver.keyId,
+                    receiverDirectories,
+                    receiverFiles: [],
+                    sharedCipherData: yield this.keyGraph.encryptToString(sharedKey.jwk, {
+                        event,
+                        message: receiver.message,
+                    }),
+                };
+            })));
+        });
+    }
+    mapApprovalGroups(approvalGroups, quorum, assemblyKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const slipAssembly = yield this.createSlipAssembly(quorum, approvalGroups, assemblyKey.toJSON(true).k);
+            return yield Promise.all(approvalGroups.map((x, index) => this.mapApprovalGroup(x, slipAssembly.subAssemblies[index], assemblyKey)));
+        });
+    }
+    mapApprovalGroup(approvalGroup, subAssembly, assemblyKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const approvers = yield this.mapApprovers(approvalGroup.approvers, approvalGroup.quorum, subAssembly, assemblyKey);
+            return {
+                subAssemblyId: approvalGroup.subAssemblyId,
+                singleReject: approvalGroup.singleReject,
+                quorum: approvalGroup.quorum,
+                subAssemblyCipherData: yield this.keyGraph.encryptToString(assemblyKey, approvalGroup.plainSubAssemblyCipherData),
+                createApprovers: approvers.filter((x) => !x.approverId),
+                updateApprovers: approvers.filter((x) => x.approverId),
+                deleteApprovers: approvalGroup.deletedApproverIds || [],
+            };
+        });
+    }
+    mapApprovers(approvers, quorum, subAssembly, assemblyKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _a = assemblyKey.toJSON(true), { k: rawAssemblyKey } = _a, assemblyKeyParams = __rest(_a, ["k"]);
+            let shareIdx = 0;
+            const nextPartialAssemblyKey = (sharedKeyJwk) => __awaiter(this, void 0, void 0, function* () {
+                const share = subAssembly.shares[shareIdx];
+                // If quorum is 1, then using the same share for every member.
+                if (quorum !== 1) {
+                    ++shareIdx;
+                }
+                const partialAssemblyKey = {
+                    slip39: {
+                        share,
+                        subAssembly: {
+                            quorum,
+                            size: approvers.length,
+                        },
+                    },
+                    assemblyKeyParams,
+                };
+                return this.keyGraph.encryptToString(sharedKeyJwk, partialAssemblyKey);
+            });
+            return yield Promise.all(approvers.map((x) => __awaiter(this, void 0, void 0, function* () {
+                if (x.approverId) {
+                    const sharedKey = yield this.keyGraph.getKey(x.keyId);
+                    const sharedCipherData = yield this.keyGraph.encryptToString(x.keyId, x.plainSharedCipherData);
+                    const sharedCipherApprovalData = yield this.keyGraph.encryptToString(x.keyId, x.approvalData);
+                    return {
+                        approverId: x.approverId,
+                        sharedKeyId: x.keyId,
+                        sharedCipherData: sharedCipherData || '',
+                        sharedCipherApprovalData: sharedCipherApprovalData || '',
+                        sharedCipherPartialAssemblyKey: yield nextPartialAssemblyKey(sharedKey.jwk),
+                    };
+                }
+                else {
+                    const wrappedContent = yield this.keyMetaService.wrapContentWithKey(x.plainSharedCipherData, x.trustedPartySharedKeyId);
+                    return {
+                        tpId: x.trustedPartyId,
+                        tpSharedKeyId: x.trustedPartySharedKeyId,
+                        tpSharedKeyWrappedSharedKey: wrappedContent.rootKey.wrappedKey,
+                        sharedCipherData: wrappedContent.cipherMeta,
+                        sharedCipherApprovalData: '',
+                        sharedCipherPartialAssemblyKey: yield nextPartialAssemblyKey(wrappedContent.key),
+                    };
+                }
+            })));
+        });
+    }
+    // Split assembly key between all existing approvers.
+    createSlipAssembly(quorum, approvalGroups, rawAssemblyKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const slipAssembly = new slip.Assembly(quorum);
+            approvalGroups.forEach((x, index) => {
+                let approverCount = x.approvers.length;
+                // slip39 restricts quorum == 1 to have only 1 member. So we just share the same
+                // partial key for all sub assembly members.
+                if (x.quorum === 1) {
+                    approverCount = 1;
+                }
+                slipAssembly.addSubAssembly(new slip.SubAssembly(index, x.quorum, approverCount));
+            });
+            // Is there enough sub assemblies to meet quorum
+            if (slipAssembly.subAssemblies.length < quorum) {
+                return null;
+            }
+            yield this.slip39Service.generateShares(rawAssemblyKey, ScenarioApproverService.SLIP39_PASSPHRASE, slipAssembly);
+            return slipAssembly;
+        });
+    }
+}
+ScenarioApproverService.SLIP39_PASSPHRASE = 'lifeready';
+ScenarioApproverService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ScenarioApproverService_Factory() { return new ScenarioApproverService(i0.ɵɵinject(i1.LrApolloService), i0.ɵɵinject(i2.KeyFactoryService), i0.ɵɵinject(i3.KeyMetaService), i0.ɵɵinject(i4.KeyGraphService), i0.ɵɵinject(i5.Slip39Service), i0.ɵɵinject(i6.EncryptionService), i0.ɵɵinject(i7.TrustedPartyService)); }, token: ScenarioApproverService, providedIn: "root" });
+ScenarioApproverService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+ScenarioApproverService.ctorParameters = () => [
+    { type: LrApolloService },
+    { type: KeyFactoryService },
+    { type: KeyMetaService },
+    { type: KeyGraphService },
+    { type: slip.Slip39Service },
+    { type: EncryptionService },
+    { type: TrustedPartyService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scenario-approver.service.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/scenario/approvals/scenario-approver.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { JWK } from 'node-jose';\r\nimport { LrApolloService } from '../../api/lr-apollo.service';\r\nimport { EncryptionService } from '../../cryptography/encryption.service';\r\nimport { KeyFactoryService } from '../../cryptography/key-factory.service';\r\nimport { KeyGraphService } from '../../cryptography/key-graph.service';\r\nimport { KeyMetaService } from '../../cryptography/key-meta.service';\r\nimport * as slip from '../../cryptography/slip39.service';\r\nimport { TrustedPartyService } from '../../trusted-parties/trusted-party.service';\r\nimport {\r\n  Receiver,\r\n  ReceiverCategory,\r\n  ReceiverRecord,\r\n} from '../receivers/scenario-receiver.types';\r\nimport { PartialAssemblyKey } from '../scenario.types';\r\nimport {\r\n  CreateScenarioApproverAssemblyMutation,\r\n  DeleteScenarioApproverAssemblyMutation,\r\n  GetScenarioApproverQuery,\r\n  UpdateScenarioApproverAssemblyMutation,\r\n  UpdateScenarioApproverMutation,\r\n} from './scenario-approval.gql';\r\nimport {\r\n  ApprovalGroup,\r\n  Approver,\r\n  CreateScenarioApprovalGroups,\r\n  UpdateScenarioApprovalGroup,\r\n  UpdateScenarioApprovalGroups,\r\n  UpdateScenarioApprover,\r\n} from './scenario-approval.types';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class ScenarioApproverService {\r\n  public static SLIP39_PASSPHRASE = 'lifeready';\r\n\r\n  constructor(\r\n    private lrApollo: LrApolloService,\r\n    private keyFactory: KeyFactoryService,\r\n    private keyMetaService: KeyMetaService,\r\n    private keyGraph: KeyGraphService,\r\n    private slip39Service: slip.Slip39Service,\r\n    private encryptionService: EncryptionService,\r\n    private trustedPartyService: TrustedPartyService\r\n  ) {}\r\n\r\n  public async getApprover(approverId: string): Promise<Approver> {\r\n    const { scenarioApprover } = await this.lrApollo.query<any>({\r\n      query: GetScenarioApproverQuery,\r\n      variables: {\r\n        id: approverId,\r\n      },\r\n    });\r\n    return this.mapApprover(scenarioApprover);\r\n  }\r\n\r\n  public async mapApproverGroup(group: any): Promise<ApprovalGroup> {\r\n    const { name } = await this.keyGraph.decryptFromString<{\r\n      name: string;\r\n    }>(group.assemblyKey.id, group.subAssemblyCipherData);\r\n\r\n    return {\r\n      id: group.id,\r\n      keyId: group.assemblyKey.id,\r\n      name,\r\n      quorum: group.quorum,\r\n      singleReject: group.singleReject,\r\n      approvers: await Promise.all(\r\n        group.approvers.edges.map((x) => this.mapApprover(x.node))\r\n      ),\r\n    };\r\n  }\r\n\r\n  private async mapApprover(approver: any): Promise<Approver> {\r\n    const { message } = await this.keyGraph.decryptFromString<{\r\n      message: string;\r\n    }>(approver.sharedKey.id, approver.sharedCipherData);\r\n\r\n    return {\r\n      id: approver.id,\r\n      keyId: approver.sharedKey.id,\r\n      trustedParty: await this.trustedPartyService.mapTrustedParty(approver.tp),\r\n      message,\r\n    };\r\n  }\r\n\r\n  public async updateApprover(approver: UpdateScenarioApprover): Promise<void> {\r\n    const sharedCipherData = await this.keyGraph.encryptToString(\r\n      approver.keyId,\r\n      approver.plainSharedCipherData\r\n    );\r\n\r\n    await this.lrApollo.mutate<any>({\r\n      mutation: UpdateScenarioApproverMutation,\r\n      variables: {\r\n        input: {\r\n          approverId: approver.approverId,\r\n          sharedKeyId: approver.keyId,\r\n          sharedCipherData,\r\n          sharedCipherApprovalData: '',\r\n        },\r\n      },\r\n    });\r\n  }\r\n\r\n  public async createScenarioApproverAssembly(\r\n    input: CreateScenarioApprovalGroups\r\n  ): Promise<string> {\r\n    const assemblyKey = await this.keyFactory.createKey();\r\n\r\n    const subjectKeyWrappedAssemblyKey = await this.keyGraph.encryptToString(\r\n      input.keyId,\r\n      assemblyKey.toJSON(true)\r\n    );\r\n\r\n    const assemblyCipherData = input.plainAssemblyCipherData\r\n      ? await this.keyGraph.encryptToString(\r\n          assemblyKey,\r\n          input.plainAssemblyCipherData\r\n        )\r\n      : '';\r\n\r\n    const { createScenarioApproverAssembly } = await this.lrApollo.mutate<any>({\r\n      mutation: CreateScenarioApproverAssemblyMutation,\r\n      variables: {\r\n        input: {\r\n          scenarioId: input.scenarioId,\r\n          singleReject: input.singleReject,\r\n          quorum: input.quorum,\r\n          subjectKeyId: input.keyId,\r\n          subjectKeyWrappedAssemblyKey,\r\n          assemblyCipherData,\r\n          createSubAssemblies: (\r\n            await this.mapApprovalGroups(\r\n              input.approvalGroups,\r\n              input.quorum,\r\n              assemblyKey\r\n            )\r\n          ).map((x) => {\r\n            const { updateApprovers, deleteApprovers, ...subAssembly } = x;\r\n            return subAssembly;\r\n          }),\r\n          updateReceivers: await this.rewrapReceivers(\r\n            assemblyKey,\r\n            input.event,\r\n            input.receivers\r\n          ),\r\n        },\r\n      },\r\n    });\r\n    return createScenarioApproverAssembly.scenario.approverAssembly.assemblyKey\r\n      .id;\r\n  }\r\n\r\n  public async updateScenarioApproverAssembly(\r\n    input: UpdateScenarioApprovalGroups\r\n  ): Promise<void> {\r\n    const assemblyKey = await this.keyGraph.getKey(input.assemblyKeyId);\r\n    const assemblyCipherData = input.plainAssemblyCipherData\r\n      ? await this.keyGraph.encryptToString(\r\n          assemblyKey.jwk,\r\n          input.plainAssemblyCipherData\r\n        )\r\n      : '';\r\n\r\n    const approvalGroups = await this.mapApprovalGroups(\r\n      input.approvalGroups,\r\n      input.quorum,\r\n      assemblyKey.jwk\r\n    );\r\n\r\n    await this.lrApollo.mutate<any>({\r\n      mutation: UpdateScenarioApproverAssemblyMutation,\r\n      variables: {\r\n        input: {\r\n          scenarioId: input.scenarioId,\r\n          singleReject: input.singleReject,\r\n          quorum: input.quorum,\r\n          assemblyKeyId: assemblyKey.id,\r\n          assemblyCipherData,\r\n          createSubAssemblies: approvalGroups\r\n            .filter((x) => !x.subAssemblyId)\r\n            .map((x) => {\r\n              const { updateApprovers, deleteApprovers, ...subAssembly } = x;\r\n              return subAssembly;\r\n            }),\r\n          updateSubAssemblies: approvalGroups.filter((x) => x.subAssemblyId),\r\n          deleteSubAssemblies: input.deletedGroupIds,\r\n        },\r\n      },\r\n    });\r\n  }\r\n\r\n  public async deleteScenarioApproverAssembly(\r\n    scenarioId: string,\r\n    event: string,\r\n    receivers: Receiver[]\r\n  ): Promise<void> {\r\n    await this.lrApollo.mutate<any>({\r\n      mutation: DeleteScenarioApproverAssemblyMutation,\r\n      variables: {\r\n        input: {\r\n          scenarioId,\r\n          updateReceivers: await this.rewrapReceivers(null, event, receivers),\r\n        },\r\n      },\r\n    });\r\n  }\r\n\r\n  private async rewrapReceivers(\r\n    assemblyKey: JWK.Key,\r\n    event: string,\r\n    receivers: Receiver[]\r\n  ) {\r\n    if (!receivers || !receivers.length) {\r\n      return [];\r\n    }\r\n\r\n    return await Promise.all(\r\n      receivers.map(async (receiver) => {\r\n        const sharedKey = await this.keyGraph.getKey(receiver.keyId);\r\n\r\n        const prepareReceiverItem = async (\r\n          item: ReceiverCategory | ReceiverRecord,\r\n          itemKeyId: string\r\n        ) => {\r\n          const itemKey = await this.keyGraph.getKey(itemKeyId);\r\n          let wrappedItemKey = await this.keyGraph.encryptToString(\r\n            sharedKey.jwk,\r\n            itemKey.jwk.toJSON(true)\r\n          );\r\n\r\n          if (assemblyKey) {\r\n            wrappedItemKey = await this.keyGraph.encryptToString(\r\n              assemblyKey,\r\n              wrappedItemKey\r\n            );\r\n          }\r\n\r\n          return {\r\n            accessRole: item.accessLevel,\r\n            sharedKeyId: sharedKey.id,\r\n            sharedCipherData: '',\r\n            wrappedItemKey,\r\n          };\r\n        };\r\n\r\n        // For each receiver-directory\r\n        const receiverDirectories = await Promise.all([\r\n          ...receiver.categories.map(async (x) => ({\r\n            ...(await prepareReceiverItem(x, x.category.keyId)),\r\n            receiverDirectoryId: x.id,\r\n          })),\r\n          ...receiver.records.map(async (x) => ({\r\n            ...(await prepareReceiverItem(x, x.record.keyId)),\r\n            receiverDirectoryId: x.id,\r\n          })),\r\n        ]);\r\n\r\n        return {\r\n          receiverId: receiver.id,\r\n          sharedKeyId: receiver.keyId,\r\n          receiverDirectories,\r\n          receiverFiles: [],\r\n          sharedCipherData: await this.keyGraph.encryptToString(sharedKey.jwk, {\r\n            event,\r\n            message: receiver.message,\r\n          }),\r\n        };\r\n      })\r\n    );\r\n  }\r\n\r\n  private async mapApprovalGroups(\r\n    approvalGroups: UpdateScenarioApprovalGroup[],\r\n    quorum: number,\r\n    assemblyKey: JWK.Key\r\n  ) {\r\n    const slipAssembly = await this.createSlipAssembly(\r\n      quorum,\r\n      approvalGroups,\r\n      (assemblyKey.toJSON(true) as any).k\r\n    );\r\n    return await Promise.all(\r\n      approvalGroups.map((x, index) =>\r\n        this.mapApprovalGroup(x, slipAssembly.subAssemblies[index], assemblyKey)\r\n      )\r\n    );\r\n  }\r\n\r\n  private async mapApprovalGroup(\r\n    approvalGroup: UpdateScenarioApprovalGroup,\r\n    subAssembly: slip.SubAssembly,\r\n    assemblyKey: JWK.Key\r\n  ) {\r\n    const approvers = await this.mapApprovers(\r\n      approvalGroup.approvers,\r\n      approvalGroup.quorum,\r\n      subAssembly,\r\n      assemblyKey\r\n    );\r\n\r\n    return {\r\n      subAssemblyId: approvalGroup.subAssemblyId,\r\n      singleReject: approvalGroup.singleReject,\r\n      quorum: approvalGroup.quorum,\r\n      subAssemblyCipherData: await this.keyGraph.encryptToString(\r\n        assemblyKey,\r\n        approvalGroup.plainSubAssemblyCipherData\r\n      ),\r\n      createApprovers: approvers.filter((x) => !x.approverId),\r\n      updateApprovers: approvers.filter((x) => x.approverId),\r\n      deleteApprovers: approvalGroup.deletedApproverIds || [],\r\n    };\r\n  }\r\n\r\n  private async mapApprovers(\r\n    approvers: UpdateScenarioApprover[],\r\n    quorum: number,\r\n    subAssembly: slip.SubAssembly,\r\n    assemblyKey: JWK.Key\r\n  ) {\r\n    const { k: rawAssemblyKey, ...assemblyKeyParams } = assemblyKey.toJSON(\r\n      true\r\n    ) as any;\r\n    let shareIdx = 0;\r\n\r\n    const nextPartialAssemblyKey = async (sharedKeyJwk: JWK.Key) => {\r\n      const share = subAssembly.shares[shareIdx];\r\n      // If quorum is 1, then using the same share for every member.\r\n      if (quorum !== 1) {\r\n        ++shareIdx;\r\n      }\r\n      const partialAssemblyKey: PartialAssemblyKey = {\r\n        slip39: {\r\n          share,\r\n          subAssembly: {\r\n            quorum,\r\n            size: approvers.length,\r\n          },\r\n        },\r\n        assemblyKeyParams,\r\n      };\r\n      return this.keyGraph.encryptToString(sharedKeyJwk, partialAssemblyKey);\r\n    };\r\n\r\n    return await Promise.all(\r\n      approvers.map(async (x) => {\r\n        if (x.approverId) {\r\n          const sharedKey = await this.keyGraph.getKey(x.keyId);\r\n          const sharedCipherData = await this.keyGraph.encryptToString(\r\n            x.keyId,\r\n            x.plainSharedCipherData\r\n          );\r\n          const sharedCipherApprovalData = await this.keyGraph.encryptToString(\r\n            x.keyId,\r\n            x.approvalData\r\n          );\r\n\r\n          return {\r\n            approverId: x.approverId,\r\n            sharedKeyId: x.keyId,\r\n            sharedCipherData: sharedCipherData || '',\r\n            sharedCipherApprovalData: sharedCipherApprovalData || '',\r\n            sharedCipherPartialAssemblyKey: await nextPartialAssemblyKey(\r\n              sharedKey.jwk\r\n            ),\r\n          };\r\n        } else {\r\n          const wrappedContent = await this.keyMetaService.wrapContentWithKey(\r\n            x.plainSharedCipherData,\r\n            x.trustedPartySharedKeyId\r\n          );\r\n\r\n          return {\r\n            tpId: x.trustedPartyId,\r\n            tpSharedKeyId: x.trustedPartySharedKeyId,\r\n            tpSharedKeyWrappedSharedKey: wrappedContent.rootKey.wrappedKey,\r\n            sharedCipherData: wrappedContent.cipherMeta,\r\n            sharedCipherApprovalData: '',\r\n            sharedCipherPartialAssemblyKey: await nextPartialAssemblyKey(\r\n              wrappedContent.key\r\n            ),\r\n          };\r\n        }\r\n      })\r\n    );\r\n  }\r\n\r\n  // Split assembly key between all existing approvers.\r\n  private async createSlipAssembly(\r\n    quorum: number,\r\n    approvalGroups: UpdateScenarioApprovalGroup[],\r\n    rawAssemblyKey: string\r\n  ): Promise<slip.Assembly> {\r\n    const slipAssembly = new slip.Assembly(quorum);\r\n\r\n    approvalGroups.forEach((x, index) => {\r\n      let approverCount = x.approvers.length;\r\n\r\n      // slip39 restricts quorum == 1 to have only 1 member. So we just share the same\r\n      // partial key for all sub assembly members.\r\n      if (x.quorum === 1) {\r\n        approverCount = 1;\r\n      }\r\n      slipAssembly.addSubAssembly(\r\n        new slip.SubAssembly(index, x.quorum, approverCount)\r\n      );\r\n    });\r\n    // Is there enough sub assemblies to meet quorum\r\n    if (slipAssembly.subAssemblies.length < quorum) {\r\n      return null;\r\n    }\r\n    await this.slip39Service.generateShares(\r\n      rawAssemblyKey,\r\n      ScenarioApproverService.SLIP39_PASSPHRASE,\r\n      slipAssembly\r\n    );\r\n    return slipAssembly;\r\n  }\r\n}\r\n"]}

package/esm2015/lib/scenario/claimants/scenario-claimant.gql.js

@@ -0,0 +1,52 @@
+import gql from 'graphql-tag';
+import { KeyGraphField } from '../../_common/queries.gql';
+import { TrustedPartyProperties } from '../../trusted-parties/trusted-party.gql';
+export const ClaimantFields = `
+id
+tp {
+  ${TrustedPartyProperties}
+}
+sharedKey {
+  id
+}
+sharedCipherData
+`;
+export const GetScenarioClaimantQuery = gql `
+query GetScenarioClaimantQuery(
+  $id: LrRelayIdInput!
+) {
+  scenarioClaimant(id: $id) {
+    ${ClaimantFields}
+  }
+  ${KeyGraphField}
+}`;
+export const AddScenarioClaimantMutation = gql `
+  mutation AddScenarioClaimantMutation($input: AddScenarioClaimantInput!) {
+    addScenarioClaimant(input: $input) {
+      claimant {
+        id
+      }
+    }
+  }
+`;
+export const UpdateScenarioClaimantMutation = gql `
+  mutation UpdateScenarioClaimantMutation(
+    $input: UpdateScenarioClaimantInput!
+  ) {
+    updateScenarioClaimant(input: $input) {
+      claimant {
+        id
+      }
+    }
+  }
+`;
+export const DeleteScenarioClaimantMutation = gql `
+  mutation DeleteScenarioClaimantMutation(
+    $input: DeleteScenarioClaimantInput!
+  ) {
+    deleteScenarioClaimant(input: $input) {
+      id
+    }
+  }
+`;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NlbmFyaW8tY2xhaW1hbnQuZ3FsLmpzIiwic291cmNlUm9vdCI6IkM6L1Byb2plY3RzL3Rlc3QvcHJvamVjdHMvY29yZS9zcmMvIiwic291cmNlcyI6WyJsaWIvc2NlbmFyaW8vY2xhaW1hbnRzL3NjZW5hcmlvLWNsYWltYW50LmdxbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEdBQUcsTUFBTSxhQUFhLENBQUM7QUFDOUIsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQzFELE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHlDQUF5QyxDQUFDO0FBRWpGLE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRzs7O0lBRzFCLHNCQUFzQjs7Ozs7O0NBTXpCLENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSx3QkFBd0IsR0FBRyxHQUFHLENBQUE7Ozs7O01BS3JDLGNBQWM7O0lBRWhCLGFBQWE7RUFDZixDQUFDO0FBRUgsTUFBTSxDQUFDLE1BQU0sMkJBQTJCLEdBQUcsR0FBRyxDQUFBOzs7Ozs7OztDQVE3QyxDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sOEJBQThCLEdBQUcsR0FBRyxDQUFBOzs7Ozs7Ozs7O0NBVWhELENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSw4QkFBOEIsR0FBRyxHQUFHLENBQUE7Ozs7Ozs7O0NBUWhELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgZ3FsIGZyb20gJ2dyYXBocWwtdGFnJztcclxuaW1wb3J0IHsgS2V5R3JhcGhGaWVsZCB9IGZyb20gJy4uLy4uL19jb21tb24vcXVlcmllcy5ncWwnO1xyXG5pbXBvcnQgeyBUcnVzdGVkUGFydHlQcm9wZXJ0aWVzIH0gZnJvbSAnLi4vLi4vdHJ1c3RlZC1wYXJ0aWVzL3RydXN0ZWQtcGFydHkuZ3FsJztcclxuXHJcbmV4cG9ydCBjb25zdCBDbGFpbWFudEZpZWxkcyA9IGBcclxuaWRcclxudHAge1xyXG4gICR7VHJ1c3RlZFBhcnR5UHJvcGVydGllc31cclxufVxyXG5zaGFyZWRLZXkge1xyXG4gIGlkXHJcbn1cclxuc2hhcmVkQ2lwaGVyRGF0YVxyXG5gO1xyXG5cclxuZXhwb3J0IGNvbnN0IEdldFNjZW5hcmlvQ2xhaW1hbnRRdWVyeSA9IGdxbGBcclxucXVlcnkgR2V0U2NlbmFyaW9DbGFpbWFudFF1ZXJ5KFxyXG4gICRpZDogTHJSZWxheUlkSW5wdXQhXHJcbikge1xyXG4gIHNjZW5hcmlvQ2xhaW1hbnQoaWQ6ICRpZCkge1xyXG4gICAgJHtDbGFpbWFudEZpZWxkc31cclxuICB9XHJcbiAgJHtLZXlHcmFwaEZpZWxkfVxyXG59YDtcclxuXHJcbmV4cG9ydCBjb25zdCBBZGRTY2VuYXJpb0NsYWltYW50TXV0YXRpb24gPSBncWxgXHJcbiAgbXV0YXRpb24gQWRkU2NlbmFyaW9DbGFpbWFudE11dGF0aW9uKCRpbnB1dDogQWRkU2NlbmFyaW9DbGFpbWFudElucHV0ISkge1xyXG4gICAgYWRkU2NlbmFyaW9DbGFpbWFudChpbnB1dDogJGlucHV0KSB7XHJcbiAgICAgIGNsYWltYW50IHtcclxuICAgICAgICBpZFxyXG4gICAgICB9XHJcbiAgICB9XHJcbiAgfVxyXG5gO1xyXG5cclxuZXhwb3J0IGNvbnN0IFVwZGF0ZVNjZW5hcmlvQ2xhaW1hbnRNdXRhdGlvbiA9IGdxbGBcclxuICBtdXRhdGlvbiBVcGRhdGVTY2VuYXJpb0NsYWltYW50TXV0YXRpb24oXHJcbiAgICAkaW5wdXQ6IFVwZGF0ZVNjZW5hcmlvQ2xhaW1hbnRJbnB1dCFcclxuICApIHtcclxuICAgIHVwZGF0ZVNjZW5hcmlvQ2xhaW1hbnQoaW5wdXQ6ICRpbnB1dCkge1xyXG4gICAgICBjbGFpbWFudCB7XHJcbiAgICAgICAgaWRcclxuICAgICAgfVxyXG4gICAgfVxyXG4gIH1cclxuYDtcclxuXHJcbmV4cG9ydCBjb25zdCBEZWxldGVTY2VuYXJpb0NsYWltYW50TXV0YXRpb24gPSBncWxgXHJcbiAgbXV0YXRpb24gRGVsZXRlU2NlbmFyaW9DbGFpbWFudE11dGF0aW9uKFxyXG4gICAgJGlucHV0OiBEZWxldGVTY2VuYXJpb0NsYWltYW50SW5wdXQhXHJcbiAgKSB7XHJcbiAgICBkZWxldGVTY2VuYXJpb0NsYWltYW50KGlucHV0OiAkaW5wdXQpIHtcclxuICAgICAgaWRcclxuICAgIH1cclxuICB9XHJcbmA7XHJcbiJdfQ==

package/esm2015/lib/scenario/claimants/scenario-claimant.service.js

@@ -0,0 +1,97 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { LrApolloService } from '../../api/lr-apollo.service';
+import { KeyGraphService } from '../../cryptography/key-graph.service';
+import { KeyMetaService } from '../../cryptography/key-meta.service';
+import { TrustedPartyService } from '../../trusted-parties/trusted-party.service';
+import { DeleteScenarioClaimantMutation, UpdateScenarioClaimantMutation, GetScenarioClaimantQuery, AddScenarioClaimantMutation, } from './scenario-claimant.gql';
+import * as i0 from "@angular/core";
+import * as i1 from "../../api/lr-apollo.service";
+import * as i2 from "../../cryptography/key-meta.service";
+import * as i3 from "../../cryptography/key-graph.service";
+import * as i4 from "../../trusted-parties/trusted-party.service";
+export class ScenarioClaimantService {
+    constructor(lrApollo, keyMetaService, keyGraph, tpService) {
+        this.lrApollo = lrApollo;
+        this.keyMetaService = keyMetaService;
+        this.keyGraph = keyGraph;
+        this.tpService = tpService;
+    }
+    getClaimant(claimantId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { scenarioClaimant } = yield this.lrApollo.query({
+                query: GetScenarioClaimantQuery,
+                variables: {
+                    id: claimantId,
+                },
+            });
+            return this.mapClaimant(scenarioClaimant);
+        });
+    }
+    mapClaimant(claimant) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { message } = yield this.keyGraph.decryptFromString(claimant.sharedKey.id, claimant.sharedCipherData);
+            return {
+                id: claimant.id,
+                keyId: claimant.sharedKey.id,
+                trustedParty: yield this.tpService.mapTrustedParty(claimant.tp),
+                message,
+            };
+        });
+    }
+    addClaimant(claimant) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wrappedContent = yield this.keyMetaService.wrapContentWithKey(claimant.plainSharedCipherData, claimant.trustedPartySharedKeyId);
+            const { addScenarioClaimant } = yield this.lrApollo.mutate({
+                mutation: AddScenarioClaimantMutation,
+                variables: {
+                    input: {
+                        scenarioId: claimant.scenarioId,
+                        tpId: claimant.trustedPartyId,
+                        tpSharedKeyId: claimant.trustedPartySharedKeyId,
+                        tpSharedKeyWrappedSharedKey: wrappedContent.rootKey.wrappedKey,
+                        sharedCipherData: wrappedContent.cipherMeta,
+                    },
+                },
+            });
+            return addScenarioClaimant.claimant.id;
+        });
+    }
+    updateClaimant(claimant) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sharedCipherData = yield this.keyGraph.encryptToString(claimant.keyId, claimant.plainSharedCipherData);
+            const res = yield this.lrApollo.mutate({
+                mutation: UpdateScenarioClaimantMutation,
+                variables: {
+                    input: {
+                        claimantId: claimant.id,
+                        sharedKeyId: claimant.keyId,
+                        sharedCipherData,
+                    },
+                },
+            });
+            return res.updateScenarioClaimant.claimant.id;
+        });
+    }
+    deleteClaimant(claimantId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.lrApollo.mutate({
+                mutation: DeleteScenarioClaimantMutation,
+                variables: { input: { claimantId } },
+            });
+        });
+    }
+}
+ScenarioClaimantService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ScenarioClaimantService_Factory() { return new ScenarioClaimantService(i0.ɵɵinject(i1.LrApolloService), i0.ɵɵinject(i2.KeyMetaService), i0.ɵɵinject(i3.KeyGraphService), i0.ɵɵinject(i4.TrustedPartyService)); }, token: ScenarioClaimantService, providedIn: "root" });
+ScenarioClaimantService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+ScenarioClaimantService.ctorParameters = () => [
+    { type: LrApolloService },
+    { type: KeyMetaService },
+    { type: KeyGraphService },
+    { type: TrustedPartyService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/scenario/claimants/scenario-claimant.types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NlbmFyaW8tY2xhaW1hbnQudHlwZXMuanMiLCJzb3VyY2VSb290IjoiQzovUHJvamVjdHMvdGVzdC9wcm9qZWN0cy9jb3JlL3NyYy8iLCJzb3VyY2VzIjpbImxpYi9zY2VuYXJpby9jbGFpbWFudHMvc2NlbmFyaW8tY2xhaW1hbnQudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFRydXN0ZWRQYXJ0eSB9IGZyb20gJy4uLy4uL3RydXN0ZWQtcGFydGllcy90cnVzdGVkLXBhcnR5LnR5cGVzJztcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgQ2xhaW1hbnQge1xyXG4gIGlkOiBzdHJpbmc7XHJcbiAga2V5SWQ6IHN0cmluZztcclxuICB0cnVzdGVkUGFydHk6IFRydXN0ZWRQYXJ0eTtcclxuICBtZXNzYWdlPzogc3RyaW5nO1xyXG59XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIEFkZFNjZW5hcmlvQ2xhaW1hbnQge1xyXG4gIHNjZW5hcmlvSWQ6IHN0cmluZztcclxuICB0cnVzdGVkUGFydHlJZDogc3RyaW5nO1xyXG4gIHRydXN0ZWRQYXJ0eVNoYXJlZEtleUlkOiBzdHJpbmc7XHJcbiAgcGxhaW5TaGFyZWRDaXBoZXJEYXRhOiBvYmplY3Q7XHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgVXBkYXRlU2NlbmFyaW9DbGFpbWFudCB7XHJcbiAgaWQ6IHN0cmluZztcclxuICBrZXlJZDogc3RyaW5nO1xyXG4gIHBsYWluU2hhcmVkQ2lwaGVyRGF0YTogb2JqZWN0O1xyXG59XHJcbiJdfQ==