@lifeready/core 0.6.0-beta.1

package/esm2015/lib/scenario/scenario.service.js

@@ -0,0 +1,611 @@
+import { __awaiter, __rest } from "tslib";
+import { Injectable } from '@angular/core';
+import { LrApolloService } from '../api/lr-apollo.service';
+import { CategoryFilter, RecordFilter } from '../category/category.gql';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { KeyMetaService } from '../cryptography/key-meta.service';
+import { KeyService } from '../cryptography/key.service';
+import * as slip from '../cryptography/slip39.service';
+import { RecordContentFilter } from '../record/record.gql';
+import { TrustedPartyService } from '../trusted-parties/trusted-party.service';
+import { LrException, LrErrorCode, } from '../_common/exceptions';
+import { ScenarioApproverService } from './approvals/scenario-approver.service';
+import { ScenarioClaimantService } from './claimants/scenario-claimant.service';
+import { ScenarioReceiverService } from './receivers/scenario-receiver.service';
+import { ApproveScenarioClaimMutation, CancelScenarioClaimMutation, CreateScenarioClaimMutation, CreateScenarioMutation, DeleteScenarioMutation, DisableScenarioMutation, EnableScenarioMutation, GetAllScenarioClaimsQuery, GetAllScenariosQuery, GetAllSharedScenariosQuery, GetScenarioQuery, GetSharedScenarioQuery, GetTrustedPartyScenariosQuery, ReceiveScenarioClaimMutation, RejectScenarioClaimMutation, ResetScenarioMutation, UpdateScenarioMutation, GetAllScenarioIdsQuery, } from './scenario.gql';
+import { ScenarioState, ApproverClaimState, } from './scenario.types';
+import * as moment_ from 'moment';
+import { KeyFactoryService as KFS } from '../cryptography/key-factory.service';
+import { LrGraphQLService, LrMergedMutation, LrMutation, } from '../api/lr-graphql';
+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-factory.service";
+import * as i4 from "../cryptography/key.service";
+import * as i5 from "../cryptography/encryption.service";
+import * as i6 from "../cryptography/key-graph.service";
+import * as i7 from "../trusted-parties/trusted-party.service";
+import * as i8 from "../cryptography/slip39.service";
+import * as i9 from "./claimants/scenario-claimant.service";
+import * as i10 from "./approvals/scenario-approver.service";
+import * as i11 from "./receivers/scenario-receiver.service";
+import * as i12 from "../api/lr-graphql/lr-graphql.service";
+// Ref: https://stackoverflow.com/questions/59735280/angular-8-moment-error-cannot-call-a-namespace-moment
+const moment = moment_;
+export class ScenarioService {
+    constructor(lrApollo, keyMetaService, keyFactory, keyService, encryptionService, keyGraph, tpService, slip39Service, scenarioClaimantService, scenarioApproverService, scenarioReceiverService, lrGraphQL) {
+        this.lrApollo = lrApollo;
+        this.keyMetaService = keyMetaService;
+        this.keyFactory = keyFactory;
+        this.keyService = keyService;
+        this.encryptionService = encryptionService;
+        this.keyGraph = keyGraph;
+        this.tpService = tpService;
+        this.slip39Service = slip39Service;
+        this.scenarioClaimantService = scenarioClaimantService;
+        this.scenarioApproverService = scenarioApproverService;
+        this.scenarioReceiverService = scenarioReceiverService;
+        this.lrGraphQL = lrGraphQL;
+    }
+    getMyScenarios() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { scenarios } = yield this.lrApollo.query({
+                query: GetAllScenariosQuery,
+            });
+            return yield Promise.all(scenarios.edges.map((x) => this.mapScenarioSummary(x.node)));
+        });
+    }
+    mapScenarioSummary(scenario) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { event, name } = yield this.keyGraph.decryptFromString(scenario.subjectKey.id, scenario.subjectCipherData);
+            return {
+                id: scenario.id,
+                name,
+                event,
+                status: scenario.state,
+                claimId: scenario.claim && scenario.claim.id,
+                claimStatus: scenario.claim && scenario.claim.state,
+                createdOn: scenario.created,
+                lastModified: scenario.modified,
+            };
+        });
+    }
+    getSharedScenarios() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { sharedScenarios } = yield this.lrApollo.query({
+                query: GetAllSharedScenariosQuery,
+            });
+            return (yield Promise.all(sharedScenarios.edges.map((x) => this.mapSharedScenario(x.node)))).filter((x) => x);
+        });
+    }
+    mapSharedScenarioSummary(scenario) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { event, name } = yield this.keyGraph.decryptFromString(scenario.subjectKey.id, scenario.subjectCipherData);
+            return {
+                id: scenario.id,
+                name,
+                event,
+                status: scenario.state,
+                claimId: scenario.claim && scenario.claim.id,
+                claimStatus: scenario.claim && scenario.claim.state,
+                createdOn: scenario.created,
+                lastModified: scenario.modified,
+            };
+        });
+    }
+    getSharedScenario(scenarioId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { sharedScenario } = yield this.lrApollo.query({
+                query: GetSharedScenarioQuery,
+                variables: {
+                    id: scenarioId,
+                },
+            });
+            return yield this.mapSharedScenario(sharedScenario);
+        });
+    }
+    mapSharedScenario(scenario) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const claimantData = yield this.getCipherData(scenario.asClaimant);
+                const receiverData = yield this.getCipherData(scenario.asReceiver);
+                const approverData = yield Promise.all(scenario.asApprovers.edges.map((x) => this.getCipherData(x.node.approver)));
+                return {
+                    id: scenario.id,
+                    event: claimantData.event ||
+                        receiverData.event ||
+                        approverData.map((x) => x.event)[0],
+                    status: scenario.state,
+                    trustedParty: yield this.tpService.mapTrustedParty(scenario.tp),
+                    isClaimant: !!scenario.asClaimant,
+                    claimantMessage: claimantData.message,
+                    isApprover: scenario.asApprovers.edges.length > 0,
+                    approverMessages: approverData.map((x) => x.message),
+                    isReceiver: !!scenario.asReceiver,
+                    receiverMessage: receiverData.message,
+                    receiverKeyId: scenario.asReceiver && scenario.asReceiver.sharedKey.id,
+                    receiverPbkId: scenario.asReceiver && scenario.asReceiver.pbk.id,
+                    receiverDirectories: scenario.asReceiver &&
+                        scenario.asReceiver.receiverDirectories.edges.map((x) => x.node),
+                    claim: scenario.sharedClaim
+                        ? {
+                            id: scenario.sharedClaim.id,
+                            isClaimant: scenario.sharedClaim.isClaimant,
+                            status: scenario.sharedClaim.state,
+                            asApprovers: yield Promise.all(scenario.sharedClaim.asClaimApprovers.edges
+                                .map((x) => x.node)
+                                .map((x) => __awaiter(this, void 0, void 0, function* () {
+                                return ({
+                                    approverId: x.approver.id,
+                                    approverKey: yield this.getApproverKey(x.approver),
+                                    status: x.state,
+                                    receivers: x.receivers.edges.map((y) => ({
+                                        id: y.node.id,
+                                        pbkId: y.node.pbk.id,
+                                    })),
+                                });
+                            }))),
+                            asReceiver: scenario.sharedClaim.asClaimReceiver
+                                ? {
+                                    received: scenario.sharedClaim.asClaimReceiver.received,
+                                    ciphers: scenario.sharedClaim.asClaimReceiver.approvals.edges.map((x) => x.node.receiverPbkCipher),
+                                }
+                                : null,
+                        }
+                        : null,
+                };
+            }
+            catch (e) {
+                console.error('Failed to decrypt shared scenario.', e, scenario);
+                return null;
+            }
+        });
+    }
+    getTrustedPartyScenarios(trustedPartyId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tp } = yield this.lrApollo.query({
+                query: GetTrustedPartyScenariosQuery,
+                variables: { partyId: trustedPartyId },
+            });
+            return {
+                myScenarios: yield Promise.all(tp.myScenarios.edges.map((x) => this.mapScenarioSummary(x.node))),
+                sharedScenarios: yield Promise.all(tp.sharedScenarios.edges.map((x) => this.mapSharedScenario(x.node))),
+            };
+        });
+    }
+    getScenarioClaims() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { scenarios } = yield this.lrApollo.query({
+                query: GetAllScenarioClaimsQuery,
+            });
+            const claims = yield Promise.all(scenarios.edges.map((x) => __awaiter(this, void 0, void 0, function* () {
+                const scenario = yield this.mapScenarioSummary(x.node);
+                return yield Promise.all(x.node.claims.edges.map((y) => __awaiter(this, void 0, void 0, function* () {
+                    return ({
+                        id: y.node.id,
+                        state: y.node.state,
+                        triggeredBy: yield this.tpService.mapTrustedParty(y.node.claimant.tp),
+                        triggeredOn: y.node.created,
+                        lastModified: y.node.modified,
+                        scenario,
+                    });
+                })));
+            })));
+            return claims
+                .reduce((x, y) => [...x, ...y], [])
+                .sort((x, y) => -1 *
+                moment(new Date(x.lastModified)).diff(moment(new Date(y.lastModified))));
+        });
+    }
+    getCipherData(cipher) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!cipher)
+                return {};
+            return yield this.keyGraph.decryptFromString(cipher.sharedKey.id, cipher.sharedCipherData);
+        });
+    }
+    getApproverKey(cipher) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!cipher)
+                return null;
+            return yield this.keyGraph.decryptFromString(cipher.sharedKey.id, cipher.sharedCipherPartialAssemblyKey);
+        });
+    }
+    getScenario(scenarioId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { scenario } = yield this.lrApollo.query({
+                query: GetScenarioQuery,
+                variables: {
+                    id: scenarioId,
+                    categoryFilter: CategoryFilter,
+                    recordFilter: RecordFilter,
+                    contentFilter: RecordContentFilter,
+                },
+            });
+            return yield this.mapScenario(scenario);
+        });
+    }
+    mapScenario(scenario) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { name, event } = yield this.keyGraph.decryptFromString(scenario.subjectKey.id, scenario.subjectCipherData);
+            const claimants = yield Promise.all(scenario.claimants.edges.map((x) => this.scenarioClaimantService.mapClaimant(x.node)));
+            return {
+                id: scenario.id,
+                keyId: scenario.subjectKey.id,
+                assemblyKeyId: scenario.approverAssembly && scenario.approverAssembly.assemblyKey.id,
+                assemblyQuorum: scenario.approverAssembly && scenario.approverAssembly.quorum,
+                name,
+                event,
+                status: scenario.state,
+                claimants,
+                approverGroups: scenario.approverAssembly
+                    ? yield Promise.all(scenario.approverAssembly.subAssemblies.edges.map((x) => this.scenarioApproverService.mapApproverGroup(x.node)))
+                    : [],
+                receivers: yield Promise.all(scenario.receivers.edges.map((x) => this.scenarioReceiverService.mapReceiver(x.node))),
+                claim: scenario.claim
+                    ? {
+                        id: scenario.claim.id,
+                        status: scenario.claim.state,
+                        claimant: claimants.find((x) => x.id === scenario.claim.claimant.id),
+                    }
+                    : null,
+            };
+        });
+    }
+    createScenario(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rootKey = yield this.keyService.getCurrentRootKey();
+            const subjectKey = yield this.keyFactory.createKey();
+            const rootKeyWrappedSubjectKey = yield this.keyGraph.encryptToString(rootKey.jwk, subjectKey.toJSON(true));
+            const subjectCipherData = yield this.keyGraph.encryptToString(subjectKey, input.plainSubjectCipherData);
+            const { createScenario } = yield this.lrApollo.mutate({
+                mutation: CreateScenarioMutation,
+                variables: {
+                    input: {
+                        rootKeyId: rootKey.id,
+                        rootKeyWrappedSubjectKey,
+                        subjectCipherData,
+                    },
+                },
+            });
+            return createScenario.scenario.id;
+        });
+    }
+    updateScenario(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.lrApollo.mutate({
+                mutation: UpdateScenarioMutation,
+                variables: {
+                    input: {
+                        scenarioId: input.scenarioId,
+                        subjectKeyId: input.keyId,
+                        subjectCipherData: yield this.keyGraph.encryptToString(input.keyId, input.plainSubjectCipherData),
+                    },
+                },
+            });
+        });
+    }
+    enableScenario(scenarioId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.lrApollo.mutate({
+                mutation: EnableScenarioMutation,
+                variables: { input: { scenarioId } },
+            });
+        });
+    }
+    disableScenario(scenarioId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.lrApollo.mutate({
+                mutation: DisableScenarioMutation,
+                variables: { input: { scenarioId } },
+            });
+        });
+    }
+    deleteScenario(scenarioId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.lrApollo.mutate({
+                mutation: DeleteScenarioMutation,
+                variables: { input: { scenarioId } },
+            });
+        });
+    }
+    createClaim(scenarioId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.lrApollo.mutate({
+                mutation: CreateScenarioClaimMutation,
+                variables: { input: { scenarioId } },
+            });
+            return res.createScenarioClaim.sharedClaim.id;
+        });
+    }
+    cancelClaim(claimId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.lrApollo.mutate({
+                mutation: CancelScenarioClaimMutation,
+                variables: { input: { claimId } },
+            });
+        });
+    }
+    approveClaim(scenarioId, claimId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.lrGraphQL.lrMutate(this.approveClaimMutation(scenarioId, claimId));
+        });
+    }
+    approveClaimMutation(scenarioId, claimId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sharedScenario = yield this.getSharedScenario(scenarioId);
+            // Double check the claim matches
+            if (sharedScenario.claim.id !== claimId) {
+                throw new LrException({
+                    code: LrErrorCode.ReceiveClaimMismatch,
+                    message: 'claimId does not match with the current claimId of the scenario',
+                });
+            }
+            const createMutation = (asApprover) => __awaiter(this, void 0, void 0, function* () {
+                return new LrMutation({
+                    mutation: ApproveScenarioClaimMutation,
+                    variables: {
+                        input: {
+                            claimId,
+                            approverId: asApprover.approverId,
+                            receivers: yield Promise.all(asApprover.receivers.map((y) => __awaiter(this, void 0, void 0, function* () {
+                                return ({
+                                    receiverId: y.id,
+                                    receiverPbkCipher: yield this.keyGraph.encryptToString(y.pbkId, { partialAssemblyKey: asApprover.approverKey }),
+                                });
+                            }))),
+                        },
+                    },
+                });
+            });
+            const mutations = sharedScenario.claim.asApprovers
+                .filter((asApprover) => asApprover.status === ApproverClaimState.Claimed)
+                .map((asApprover) => createMutation(asApprover));
+            return LrMergedMutation.create(yield Promise.all(mutations));
+        });
+    }
+    rejectClaim(scenarioId, claimId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.lrGraphQL.lrMutate(this.rejectClaimMutation(scenarioId, claimId));
+        });
+    }
+    rejectClaimMutation(scenarioId, claimId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sharedScenario = yield this.getSharedScenario(scenarioId);
+            // Double check the claim matches
+            if (sharedScenario.claim.id !== claimId) {
+                throw new LrException({
+                    code: LrErrorCode.ReceiveClaimMismatch,
+                    message: 'ClaimId does not match with the current claimId of the scenario',
+                });
+            }
+            const createMutation = (asApprover) => __awaiter(this, void 0, void 0, function* () {
+                return new LrMutation({
+                    mutation: RejectScenarioClaimMutation,
+                    variables: { input: { claimId, approverId: asApprover.approverId } },
+                });
+            });
+            const mutations = sharedScenario.claim.asApprovers
+                .filter((asApprover) => asApprover.status === ApproverClaimState.Claimed)
+                .map((asApprover) => createMutation(asApprover));
+            return LrMergedMutation.create(yield Promise.all(mutations));
+        });
+    }
+    receiveClaim(scenarioId, claimId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get all the shared items
+            const sharedScenario = yield this.getSharedScenario(scenarioId);
+            // Double check the claim matches
+            if (sharedScenario.claim.id !== claimId) {
+                throw new LrException({
+                    code: LrErrorCode.ReceiveClaimMismatch,
+                    message: 'ClaimId does not match with the current claimId of the scenario',
+                });
+            }
+            if (sharedScenario.status !== ScenarioState.APPROVED) {
+                throw new LrException({
+                    code: LrErrorCode.BadState,
+                    message: 'Scenario claim has not been approved',
+                });
+            }
+            const assemblyKey = yield this.getClaimAssemblyKey(sharedScenario.receiverPbkId, sharedScenario.claim.asReceiver.ciphers);
+            // Decrypt all items
+            const receiverDirectories = yield Promise.all(sharedScenario.receiverDirectories.map((x) => __awaiter(this, void 0, void 0, function* () {
+                const wrappedItemKey = assemblyKey
+                    ? yield this.encryptionService.decrypt(assemblyKey, x.wrappedItemKey)
+                    : x.wrappedItemKey;
+                return {
+                    receiverDirectoryId: x.id,
+                    receiverSharedKeyWrappedItemKey: wrappedItemKey,
+                };
+            })));
+            yield this.lrApollo.mutate({
+                mutation: ReceiveScenarioClaimMutation,
+                variables: {
+                    input: {
+                        claimId,
+                        receiverDirectories,
+                    },
+                },
+            });
+        });
+    }
+    getClaimAssemblyKey(keyId, ciphers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!ciphers || !ciphers.length)
+                return null;
+            let assemblyKeyParams;
+            const shares = yield Promise.all(ciphers.map((x) => __awaiter(this, void 0, void 0, function* () {
+                const { partialAssemblyKey } = yield this.keyGraph.decryptFromString(keyId, x);
+                if (assemblyKeyParams) {
+                    if (JSON.stringify(assemblyKeyParams) !==
+                        JSON.stringify(partialAssemblyKey.assemblyKeyParams)) {
+                        throw new LrException({
+                            code: LrErrorCode.BadState,
+                            message: 'The assembly key parameters are different between the approvals.',
+                        });
+                    }
+                }
+                else {
+                    assemblyKeyParams = partialAssemblyKey.assemblyKeyParams;
+                }
+                return partialAssemblyKey.slip39.share.mnemonics;
+            })));
+            const rawAssemblyKey = yield this.slip39Service.recoverSecret(shares, ScenarioApproverService.SLIP39_PASSPHRASE);
+            return yield KFS.asKey(Object.assign(Object.assign({}, assemblyKeyParams), { k: rawAssemblyKey }));
+        });
+    }
+    resetScenario(scenarioId, disable = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const prepareReceiverItem = (itemKeyId, sharedKeyId, assemblyKey) => __awaiter(this, void 0, void 0, function* () {
+                const sharedKey = yield this.keyGraph.getKey(sharedKeyId);
+                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 wrappedItemKey;
+            });
+            const prepareReceiverDirectories = (receiver, assemblyKey) => __awaiter(this, void 0, void 0, function* () {
+                return Promise.all([
+                    ...receiver.categories.map((receiverDirectory) => __awaiter(this, void 0, void 0, function* () {
+                        return ({
+                            receiverDirectoryId: receiverDirectory.id,
+                            wrappedItemKey: yield prepareReceiverItem(receiverDirectory.category.keyId, receiver.keyId, assemblyKey),
+                        });
+                    })),
+                    ...receiver.records.map((receiverDirectory) => __awaiter(this, void 0, void 0, function* () {
+                        return ({
+                            receiverDirectoryId: receiverDirectory.id,
+                            wrappedItemKey: yield prepareReceiverItem(receiverDirectory.record.keyId, receiver.keyId, assemblyKey),
+                        });
+                    })),
+                ]);
+            });
+            const prepareReceivers = (receivers, assemblyKey) => __awaiter(this, void 0, void 0, function* () {
+                return Promise.all(receivers.map((receiver) => __awaiter(this, void 0, void 0, function* () {
+                    return ({
+                        receiverId: receiver.id,
+                        receiverDirectories: yield prepareReceiverDirectories(receiver, assemblyKey),
+                        receiverFiles: [],
+                    });
+                })));
+            });
+            const prepareApprovers = (approvers) => __awaiter(this, void 0, void 0, function* () {
+                return Promise.all(approvers.map((approver) => __awaiter(this, void 0, void 0, function* () {
+                    return ({
+                        approverId: approver.id,
+                        sharedKeyId: approver.keyId,
+                    });
+                })));
+            });
+            const prepareSubAssemblies = (subAssemblies, assemblyKey) => __awaiter(this, void 0, void 0, function* () {
+                return Promise.all(subAssemblies.map((sa) => __awaiter(this, void 0, void 0, function* () {
+                    return ({
+                        subAssemblyId: sa.id,
+                        subAssemblyCipherData: yield this.keyGraph.encryptToString(assemblyKey, { name: sa.name }),
+                        approvers: yield prepareApprovers(sa.approvers),
+                    });
+                })));
+            });
+            // ------------------------------------------------------------------------------
+            // ------------------------------------------------------------------------------
+            // ------------------------------------------------------------------------------
+            const scenario = yield this.getScenario(scenarioId);
+            if (scenario.status !== ScenarioState.APPROVED) {
+                throw new LrException({
+                    code: LrErrorCode.BadState,
+                    message: `Scenario must be in ${ScenarioState.APPROVED} state`,
+                });
+            }
+            const subjectKey = yield this.keyGraph.getKey(scenario.keyId);
+            const newAssemblyKey = yield this.keyFactory.createKey();
+            const input = {
+                scenarioId: scenario.id,
+                disable,
+                receivers: yield prepareReceivers(scenario.receivers, newAssemblyKey),
+            };
+            // Approver assembly
+            const subjectKeyWrappedAssemblyKey = yield this.keyGraph.encryptToString(subjectKey.jwk, newAssemblyKey.toJSON(true));
+            input.approverAssembly = {
+                subjectKeyId: subjectKey.id,
+                subjectKeyWrappedAssemblyKey,
+                assemblyCipherData: '',
+                subAssemblies: yield prepareSubAssemblies(scenario.approverGroups, newAssemblyKey),
+            };
+            if (scenario.approverGroups.length) {
+                const _a = newAssemblyKey.toJSON(true), { k: rawAssemblyKey } = _a, assemblyKeyParams = __rest(_a, ["k"]);
+                // Split the keys. If the scenario has been approved and there is an assembly setup, then
+                // that assembly already enough members to meet quorum to approve the claim. So we can assume
+                // that we can always do a key split here.
+                const slipAssembly = new slip.Assembly(scenario.assemblyQuorum);
+                scenario.approverGroups.forEach((sa, isa) => {
+                    let approverCount = sa.approvers.length;
+                    // if quorum is 1, then every approvers in the sub assembly shares the same partial key
+                    if (sa.quorum === 1) {
+                        approverCount = 1;
+                    }
+                    slipAssembly.addSubAssembly(new slip.SubAssembly(isa, sa.quorum, approverCount));
+                });
+                yield this.slip39Service.generateShares(rawAssemblyKey, ScenarioApproverService.SLIP39_PASSPHRASE, slipAssembly);
+                // Copy the partial keys
+                yield Promise.all(scenario.approverGroups.map((sa, isa) => __awaiter(this, void 0, void 0, function* () {
+                    const slipSubAssembly = slipAssembly.subAssemblies[isa];
+                    const inputSubAssembly = input.approverAssembly.subAssemblies[isa];
+                    yield Promise.all(sa.approvers.map((approver, ia) => __awaiter(this, void 0, void 0, function* () {
+                        const sharedKey = yield this.keyGraph.getKey(approver.keyId);
+                        // if quorum is 1, then every approvers in the sub assembly shares the same partial key
+                        const share = sa.quorum === 1
+                            ? slipSubAssembly.shares[0]
+                            : slipSubAssembly.shares[ia];
+                        const partialAssemblyKey = {
+                            slip39: {
+                                share,
+                                subAssembly: {
+                                    quorum: sa.quorum,
+                                    size: sa.approvers.length,
+                                },
+                            },
+                            assemblyKeyParams,
+                        };
+                        inputSubAssembly.approvers[ia].sharedCipherPartialAssemblyKey = yield this.keyGraph.encryptToString(sharedKey.jwk, partialAssemblyKey);
+                    })));
+                })));
+            }
+            yield this.lrApollo.mutate({
+                mutation: ResetScenarioMutation,
+                variables: { input },
+            });
+        });
+    }
+    getAllScenarioIds() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { scenarios } = yield this.lrApollo.query({
+                query: GetAllScenarioIdsQuery,
+            });
+            return scenarios.edges.map((edge) => edge.node.id);
+        });
+    }
+}
+ScenarioService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ScenarioService_Factory() { return new ScenarioService(i0.ɵɵinject(i1.LrApolloService), i0.ɵɵinject(i2.KeyMetaService), i0.ɵɵinject(i3.KeyFactoryService), i0.ɵɵinject(i4.KeyService), i0.ɵɵinject(i5.EncryptionService), i0.ɵɵinject(i6.KeyGraphService), i0.ɵɵinject(i7.TrustedPartyService), i0.ɵɵinject(i8.Slip39Service), i0.ɵɵinject(i9.ScenarioClaimantService), i0.ɵɵinject(i10.ScenarioApproverService), i0.ɵɵinject(i11.ScenarioReceiverService), i0.ɵɵinject(i12.LrGraphQLService)); }, token: ScenarioService, providedIn: "root" });
+ScenarioService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+ScenarioService.ctorParameters = () => [
+    { type: LrApolloService },
+    { type: KeyMetaService },
+    { type: KFS },
+    { type: KeyService },
+    { type: EncryptionService },
+    { type: KeyGraphService },
+    { type: TrustedPartyService },
+    { type: slip.Slip39Service },
+    { type: ScenarioClaimantService },
+    { type: ScenarioApproverService },
+    { type: ScenarioReceiverService },
+    { type: LrGraphQLService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scenario.service.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/scenario/scenario.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 { CategoryFilter, RecordFilter } from '../category/category.gql';\r\nimport { EncryptionService } from '../cryptography/encryption.service';\r\nimport { KeyGraphService } from '../cryptography/key-graph.service';\r\nimport { KeyMetaService } from '../cryptography/key-meta.service';\r\nimport { KeyService } from '../cryptography/key.service';\r\nimport * as slip from '../cryptography/slip39.service';\r\nimport { RecordContentFilter } from '../record/record.gql';\r\nimport { TrustedPartyService } from '../trusted-parties/trusted-party.service';\r\nimport {\r\n  LrException,\r\n  LrErrorCode,\r\n  LrBadArgumentException,\r\n} from '../_common/exceptions';\r\nimport { ApprovalGroup, Approver } from './approvals/scenario-approval.types';\r\nimport { ScenarioApproverService } from './approvals/scenario-approver.service';\r\nimport { ScenarioClaimantService } from './claimants/scenario-claimant.service';\r\nimport { Claimant } from './claimants/scenario-claimant.types';\r\nimport { ScenarioReceiverService } from './receivers/scenario-receiver.service';\r\nimport { Receiver } from './receivers/scenario-receiver.types';\r\nimport {\r\n  ApproveScenarioClaimMutation,\r\n  CancelScenarioClaimMutation,\r\n  CreateScenarioClaimMutation,\r\n  CreateScenarioMutation,\r\n  DeleteScenarioMutation,\r\n  DisableScenarioMutation,\r\n  EnableScenarioMutation,\r\n  GetAllScenarioClaimsQuery,\r\n  GetAllScenariosQuery,\r\n  GetAllSharedScenariosQuery,\r\n  GetScenarioQuery,\r\n  GetSharedScenarioQuery,\r\n  GetTrustedPartyScenariosQuery,\r\n  ReceiveScenarioClaimMutation,\r\n  RejectScenarioClaimMutation,\r\n  ResetScenarioMutation,\r\n  UpdateScenarioMutation,\r\n  GetAllScenarioIdsQuery,\r\n} from './scenario.gql';\r\nimport {\r\n  CreateScenarioInput,\r\n  PartialAssemblyKey,\r\n  Scenario,\r\n  ScenarioClaim,\r\n  ScenarioState,\r\n  ScenarioSummary,\r\n  SharedScenario,\r\n  UpdateScenarioInput,\r\n  SharedScenarioClaimApprover,\r\n  ApproverClaimState,\r\n  SharedScenarioSummary,\r\n} from './scenario.types';\r\nimport * as moment_ from 'moment';\r\nimport { KeyFactoryService as KFS } from '../cryptography/key-factory.service';\r\nimport {\r\n  LrGraphQLService,\r\n  LrMergedMutation,\r\n  LrMutation,\r\n} from '../api/lr-graphql';\r\n\r\n// Ref: https://stackoverflow.com/questions/59735280/angular-8-moment-error-cannot-call-a-namespace-moment\r\nconst moment = moment_;\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class ScenarioService {\r\n  constructor(\r\n    private lrApollo: LrApolloService,\r\n    private keyMetaService: KeyMetaService,\r\n    private keyFactory: KFS,\r\n    private keyService: KeyService,\r\n    private encryptionService: EncryptionService,\r\n    private keyGraph: KeyGraphService,\r\n    private tpService: TrustedPartyService,\r\n    private slip39Service: slip.Slip39Service,\r\n    private scenarioClaimantService: ScenarioClaimantService,\r\n    private scenarioApproverService: ScenarioApproverService,\r\n    private scenarioReceiverService: ScenarioReceiverService,\r\n    private lrGraphQL: LrGraphQLService\r\n  ) {}\r\n\r\n  public async getMyScenarios(): Promise<ScenarioSummary[]> {\r\n    const { scenarios } = await this.lrApollo.query<any>({\r\n      query: GetAllScenariosQuery,\r\n    });\r\n    return await Promise.all(\r\n      scenarios.edges.map((x: any) => this.mapScenarioSummary(x.node))\r\n    );\r\n  }\r\n\r\n  private async mapScenarioSummary(scenario: any): Promise<ScenarioSummary> {\r\n    const { event, name } = await this.keyGraph.decryptFromString<{\r\n      event: string;\r\n      name: string;\r\n    }>(scenario.subjectKey.id, scenario.subjectCipherData);\r\n\r\n    return {\r\n      id: scenario.id,\r\n      name,\r\n      event,\r\n      status: scenario.state,\r\n      claimId: scenario.claim && scenario.claim.id,\r\n      claimStatus: scenario.claim && scenario.claim.state,\r\n      createdOn: scenario.created,\r\n      lastModified: scenario.modified,\r\n    };\r\n  }\r\n\r\n  public async getSharedScenarios(): Promise<SharedScenarioSummary[]> {\r\n    const { sharedScenarios } = await this.lrApollo.query<any>({\r\n      query: GetAllSharedScenariosQuery,\r\n    });\r\n    return (\r\n      await Promise.all<SharedScenario>(\r\n        sharedScenarios.edges.map((x: any) => this.mapSharedScenario(x.node))\r\n      )\r\n    ).filter((x) => x);\r\n  }\r\n\r\n  private async mapSharedScenarioSummary(\r\n    scenario: any\r\n  ): Promise<ScenarioSummary> {\r\n    const { event, name } = await this.keyGraph.decryptFromString<{\r\n      event: string;\r\n      name: string;\r\n    }>(scenario.subjectKey.id, scenario.subjectCipherData);\r\n\r\n    return {\r\n      id: scenario.id,\r\n      name,\r\n      event,\r\n      status: scenario.state,\r\n      claimId: scenario.claim && scenario.claim.id,\r\n      claimStatus: scenario.claim && scenario.claim.state,\r\n      createdOn: scenario.created,\r\n      lastModified: scenario.modified,\r\n    };\r\n  }\r\n\r\n  public async getSharedScenario(scenarioId: string): Promise<SharedScenario> {\r\n    const { sharedScenario } = await this.lrApollo.query<any>({\r\n      query: GetSharedScenarioQuery,\r\n      variables: {\r\n        id: scenarioId,\r\n      },\r\n    });\r\n    return await this.mapSharedScenario(sharedScenario);\r\n  }\r\n\r\n  private async mapSharedScenario(scenario: any): Promise<SharedScenario> {\r\n    try {\r\n      const claimantData = await this.getCipherData(scenario.asClaimant);\r\n      const receiverData = await this.getCipherData(scenario.asReceiver);\r\n      const approverData = await Promise.all<{\r\n        event?: string;\r\n        message?: string;\r\n      }>(\r\n        scenario.asApprovers.edges.map((x) =>\r\n          this.getCipherData(x.node.approver)\r\n        )\r\n      );\r\n\r\n      return {\r\n        id: scenario.id,\r\n        event:\r\n          claimantData.event ||\r\n          receiverData.event ||\r\n          approverData.map((x) => x.event)[0],\r\n        status: scenario.state,\r\n        trustedParty: await this.tpService.mapTrustedParty(scenario.tp),\r\n        isClaimant: !!scenario.asClaimant,\r\n        claimantMessage: claimantData.message,\r\n        isApprover: scenario.asApprovers.edges.length > 0,\r\n        approverMessages: approverData.map((x) => x.message),\r\n        isReceiver: !!scenario.asReceiver,\r\n        receiverMessage: receiverData.message,\r\n        receiverKeyId: scenario.asReceiver && scenario.asReceiver.sharedKey.id,\r\n        receiverPbkId: scenario.asReceiver && scenario.asReceiver.pbk.id,\r\n        receiverDirectories:\r\n          scenario.asReceiver &&\r\n          scenario.asReceiver.receiverDirectories.edges.map((x) => x.node),\r\n        claim: scenario.sharedClaim\r\n          ? {\r\n              id: scenario.sharedClaim.id,\r\n              isClaimant: scenario.sharedClaim.isClaimant,\r\n              status: scenario.sharedClaim.state,\r\n              asApprovers: await Promise.all<SharedScenarioClaimApprover>(\r\n                scenario.sharedClaim.asClaimApprovers.edges\r\n                  .map((x) => x.node)\r\n                  .map(async (x) => ({\r\n                    approverId: x.approver.id,\r\n                    approverKey: await this.getApproverKey(x.approver),\r\n                    status: x.state,\r\n                    receivers: x.receivers.edges.map((y) => ({\r\n                      id: y.node.id,\r\n                      pbkId: y.node.pbk.id,\r\n                    })),\r\n                  }))\r\n              ),\r\n              asReceiver: scenario.sharedClaim.asClaimReceiver\r\n                ? {\r\n                    received: scenario.sharedClaim.asClaimReceiver.received,\r\n                    ciphers: scenario.sharedClaim.asClaimReceiver.approvals.edges.map(\r\n                      (x) => x.node.receiverPbkCipher\r\n                    ),\r\n                  }\r\n                : null,\r\n            }\r\n          : null,\r\n      };\r\n    } catch (e) {\r\n      console.error('Failed to decrypt shared scenario.', e, scenario);\r\n      return null;\r\n    }\r\n  }\r\n\r\n  public async getTrustedPartyScenarios(\r\n    trustedPartyId: string\r\n  ): Promise<{\r\n    myScenarios: ScenarioSummary[];\r\n    sharedScenarios: SharedScenario[];\r\n  }> {\r\n    const { tp } = await this.lrApollo.query<any>({\r\n      query: GetTrustedPartyScenariosQuery,\r\n      variables: { partyId: trustedPartyId },\r\n    });\r\n    return {\r\n      myScenarios: await Promise.all(\r\n        tp.myScenarios.edges.map((x: any) => this.mapScenarioSummary(x.node))\r\n      ),\r\n      sharedScenarios: await Promise.all(\r\n        tp.sharedScenarios.edges.map((x: any) => this.mapSharedScenario(x.node))\r\n      ),\r\n    };\r\n  }\r\n\r\n  public async getScenarioClaims(): Promise<ScenarioClaim[]> {\r\n    const { scenarios } = await this.lrApollo.query<any>({\r\n      query: GetAllScenarioClaimsQuery,\r\n    });\r\n\r\n    const claims = await Promise.all<ScenarioClaim[]>(\r\n      scenarios.edges.map(async (x: any) => {\r\n        const scenario = await this.mapScenarioSummary(x.node);\r\n\r\n        return await Promise.all<ScenarioClaim>(\r\n          x.node.claims.edges.map(async (y) => ({\r\n            id: y.node.id,\r\n            state: y.node.state,\r\n            triggeredBy: await this.tpService.mapTrustedParty(\r\n              y.node.claimant.tp\r\n            ),\r\n            triggeredOn: y.node.created,\r\n            lastModified: y.node.modified,\r\n            scenario,\r\n          }))\r\n        );\r\n      })\r\n    );\r\n\r\n    return claims\r\n      .reduce((x, y) => [...x, ...y], [])\r\n      .sort(\r\n        (x, y) =>\r\n          -1 *\r\n          moment(new Date(x.lastModified)).diff(\r\n            moment(new Date(y.lastModified))\r\n          )\r\n      );\r\n  }\r\n\r\n  private async getCipherData(cipher?: {\r\n    sharedKey: { id: string };\r\n    sharedCipherData: string;\r\n  }): Promise<{ event?: string; message?: string }> {\r\n    if (!cipher) return {};\r\n\r\n    return await this.keyGraph.decryptFromString<{\r\n      event?: string;\r\n      message?: string;\r\n    }>(cipher.sharedKey.id, cipher.sharedCipherData);\r\n  }\r\n\r\n  private async getApproverKey(cipher?: {\r\n    sharedKey: { id: string };\r\n    sharedCipherPartialAssemblyKey: string;\r\n  }): Promise<string> {\r\n    if (!cipher) return null;\r\n\r\n    return await this.keyGraph.decryptFromString<string>(\r\n      cipher.sharedKey.id,\r\n      cipher.sharedCipherPartialAssemblyKey\r\n    );\r\n  }\r\n\r\n  public async getScenario(scenarioId: string): Promise<Scenario> {\r\n    const { scenario } = await this.lrApollo.query<any>({\r\n      query: GetScenarioQuery,\r\n      variables: {\r\n        id: scenarioId,\r\n        categoryFilter: CategoryFilter,\r\n        recordFilter: RecordFilter,\r\n        contentFilter: RecordContentFilter,\r\n      },\r\n    });\r\n    return await this.mapScenario(scenario);\r\n  }\r\n\r\n  private async mapScenario(scenario: any): Promise<Scenario> {\r\n    const { name, event } = await this.keyGraph.decryptFromString<{\r\n      event: string;\r\n      name: string;\r\n    }>(scenario.subjectKey.id, scenario.subjectCipherData);\r\n    const claimants = await Promise.all<Claimant>(\r\n      scenario.claimants.edges.map((x) =>\r\n        this.scenarioClaimantService.mapClaimant(x.node)\r\n      )\r\n    );\r\n\r\n    return {\r\n      id: scenario.id,\r\n      keyId: scenario.subjectKey.id,\r\n      assemblyKeyId:\r\n        scenario.approverAssembly && scenario.approverAssembly.assemblyKey.id,\r\n      assemblyQuorum:\r\n        scenario.approverAssembly && scenario.approverAssembly.quorum,\r\n      name,\r\n      event,\r\n      status: scenario.state,\r\n      claimants,\r\n      approverGroups: scenario.approverAssembly\r\n        ? await Promise.all(\r\n            scenario.approverAssembly.subAssemblies.edges.map((x) =>\r\n              this.scenarioApproverService.mapApproverGroup(x.node)\r\n            )\r\n          )\r\n        : [],\r\n      receivers: await Promise.all(\r\n        scenario.receivers.edges.map((x) =>\r\n          this.scenarioReceiverService.mapReceiver(x.node)\r\n        )\r\n      ),\r\n      claim: scenario.claim\r\n        ? {\r\n            id: scenario.claim.id,\r\n            status: scenario.claim.state,\r\n            claimant: claimants.find(\r\n              (x) => x.id === scenario.claim.claimant.id\r\n            ),\r\n          }\r\n        : null,\r\n    };\r\n  }\r\n\r\n  public async createScenario(input: CreateScenarioInput): Promise<string> {\r\n    const rootKey = await this.keyService.getCurrentRootKey();\r\n\r\n    const subjectKey = await this.keyFactory.createKey();\r\n    const rootKeyWrappedSubjectKey = await this.keyGraph.encryptToString(\r\n      rootKey.jwk,\r\n      subjectKey.toJSON(true)\r\n    );\r\n\r\n    const subjectCipherData = await this.keyGraph.encryptToString(\r\n      subjectKey,\r\n      input.plainSubjectCipherData\r\n    );\r\n\r\n    const { createScenario } = await this.lrApollo.mutate<any>({\r\n      mutation: CreateScenarioMutation,\r\n      variables: {\r\n        input: {\r\n          rootKeyId: rootKey.id,\r\n          rootKeyWrappedSubjectKey,\r\n          subjectCipherData,\r\n        },\r\n      },\r\n    });\r\n    return createScenario.scenario.id;\r\n  }\r\n\r\n  public async updateScenario(input: UpdateScenarioInput): Promise<void> {\r\n    await this.lrApollo.mutate<void>({\r\n      mutation: UpdateScenarioMutation,\r\n      variables: {\r\n        input: {\r\n          scenarioId: input.scenarioId,\r\n          subjectKeyId: input.keyId,\r\n          subjectCipherData: await this.keyGraph.encryptToString(\r\n            input.keyId,\r\n            input.plainSubjectCipherData\r\n          ),\r\n        },\r\n      },\r\n    });\r\n  }\r\n\r\n  public async enableScenario(scenarioId: string): Promise<void> {\r\n    await this.lrApollo.mutate<void>({\r\n      mutation: EnableScenarioMutation,\r\n      variables: { input: { scenarioId } },\r\n    });\r\n  }\r\n\r\n  public async disableScenario(scenarioId: string): Promise<void> {\r\n    await this.lrApollo.mutate<void>({\r\n      mutation: DisableScenarioMutation,\r\n      variables: { input: { scenarioId } },\r\n    });\r\n  }\r\n\r\n  public async deleteScenario(scenarioId: string): Promise<void> {\r\n    await this.lrApollo.mutate<void>({\r\n      mutation: DeleteScenarioMutation,\r\n      variables: { input: { scenarioId } },\r\n    });\r\n  }\r\n\r\n  public async createClaim(scenarioId: string): Promise<string> {\r\n    const res = await this.lrApollo.mutate<any>({\r\n      mutation: CreateScenarioClaimMutation,\r\n      variables: { input: { scenarioId } },\r\n    });\r\n    return res.createScenarioClaim.sharedClaim.id;\r\n  }\r\n\r\n  public async cancelClaim(claimId: string): Promise<void> {\r\n    await this.lrApollo.mutate<void>({\r\n      mutation: CancelScenarioClaimMutation,\r\n      variables: { input: { claimId } },\r\n    });\r\n  }\r\n\r\n  public async approveClaim(scenarioId: string, claimId: string) {\r\n    return this.lrGraphQL.lrMutate(\r\n      this.approveClaimMutation(scenarioId, claimId)\r\n    );\r\n  }\r\n\r\n  public async approveClaimMutation(scenarioId: string, claimId: string) {\r\n    const sharedScenario = await this.getSharedScenario(scenarioId);\r\n\r\n    // Double check the claim matches\r\n    if (sharedScenario.claim.id !== claimId) {\r\n      throw new LrException({\r\n        code: LrErrorCode.ReceiveClaimMismatch,\r\n        message:\r\n          'claimId does not match with the current claimId of the scenario',\r\n      });\r\n    }\r\n\r\n    const createMutation = async (asApprover: SharedScenarioClaimApprover) => {\r\n      return new LrMutation({\r\n        mutation: ApproveScenarioClaimMutation,\r\n        variables: {\r\n          input: {\r\n            claimId,\r\n            approverId: asApprover.approverId,\r\n            receivers: await Promise.all(\r\n              asApprover.receivers.map(async (y) => ({\r\n                receiverId: y.id,\r\n                receiverPbkCipher: await this.keyGraph.encryptToString(\r\n                  y.pbkId,\r\n                  { partialAssemblyKey: asApprover.approverKey }\r\n                ),\r\n              }))\r\n            ),\r\n          },\r\n        },\r\n      });\r\n    };\r\n\r\n    const mutations = sharedScenario.claim.asApprovers\r\n      .filter((asApprover) => asApprover.status === ApproverClaimState.Claimed)\r\n      .map((asApprover) => createMutation(asApprover));\r\n\r\n    return LrMergedMutation.create(await Promise.all(mutations));\r\n  }\r\n\r\n  public async rejectClaim(scenarioId: string, claimId: string) {\r\n    return this.lrGraphQL.lrMutate(\r\n      this.rejectClaimMutation(scenarioId, claimId)\r\n    );\r\n  }\r\n\r\n  public async rejectClaimMutation(scenarioId: string, claimId: string) {\r\n    const sharedScenario = await this.getSharedScenario(scenarioId);\r\n\r\n    // Double check the claim matches\r\n    if (sharedScenario.claim.id !== claimId) {\r\n      throw new LrException({\r\n        code: LrErrorCode.ReceiveClaimMismatch,\r\n        message:\r\n          'ClaimId does not match with the current claimId of the scenario',\r\n      });\r\n    }\r\n\r\n    const createMutation = async (asApprover: SharedScenarioClaimApprover) => {\r\n      return new LrMutation({\r\n        mutation: RejectScenarioClaimMutation,\r\n        variables: { input: { claimId, approverId: asApprover.approverId } },\r\n      });\r\n    };\r\n\r\n    const mutations = sharedScenario.claim.asApprovers\r\n      .filter((asApprover) => asApprover.status === ApproverClaimState.Claimed)\r\n      .map((asApprover) => createMutation(asApprover));\r\n\r\n    return LrMergedMutation.create(await Promise.all(mutations));\r\n  }\r\n\r\n  public async receiveClaim(\r\n    scenarioId: string,\r\n    claimId: string\r\n  ): Promise<void> {\r\n    // Get all the shared items\r\n    const sharedScenario = await this.getSharedScenario(scenarioId);\r\n\r\n    // Double check the claim matches\r\n    if (sharedScenario.claim.id !== claimId) {\r\n      throw new LrException({\r\n        code: LrErrorCode.ReceiveClaimMismatch,\r\n        message:\r\n          'ClaimId does not match with the current claimId of the scenario',\r\n      });\r\n    }\r\n    if (sharedScenario.status !== ScenarioState.APPROVED) {\r\n      throw new LrException({\r\n        code: LrErrorCode.BadState,\r\n        message: 'Scenario claim has not been approved',\r\n      });\r\n    }\r\n\r\n    const assemblyKey = await this.getClaimAssemblyKey(\r\n      sharedScenario.receiverPbkId,\r\n      sharedScenario.claim.asReceiver.ciphers\r\n    );\r\n\r\n    // Decrypt all items\r\n    const receiverDirectories = await Promise.all(\r\n      sharedScenario.receiverDirectories.map(async (x) => {\r\n        const wrappedItemKey = assemblyKey\r\n          ? await this.encryptionService.decrypt(assemblyKey, x.wrappedItemKey)\r\n          : x.wrappedItemKey;\r\n\r\n        return {\r\n          receiverDirectoryId: x.id,\r\n          receiverSharedKeyWrappedItemKey: wrappedItemKey, // the wrappedItemKey is already wrapped by receiverSharedKey\r\n        };\r\n      })\r\n    );\r\n\r\n    await this.lrApollo.mutate<void>({\r\n      mutation: ReceiveScenarioClaimMutation,\r\n      variables: {\r\n        input: {\r\n          claimId,\r\n          receiverDirectories,\r\n        },\r\n      },\r\n    });\r\n  }\r\n\r\n  private async getClaimAssemblyKey(keyId: string, ciphers: string[]) {\r\n    if (!ciphers || !ciphers.length) return null;\r\n\r\n    let assemblyKeyParams: object;\r\n\r\n    const shares = await Promise.all(\r\n      ciphers.map(async (x) => {\r\n        const { partialAssemblyKey } = await this.keyGraph.decryptFromString<{\r\n          partialAssemblyKey: PartialAssemblyKey;\r\n        }>(keyId, x);\r\n\r\n        if (assemblyKeyParams) {\r\n          if (\r\n            JSON.stringify(assemblyKeyParams) !==\r\n            JSON.stringify(partialAssemblyKey.assemblyKeyParams)\r\n          ) {\r\n            throw new LrException({\r\n              code: LrErrorCode.BadState,\r\n              message:\r\n                'The assembly key parameters are different between the approvals.',\r\n            });\r\n          }\r\n        } else {\r\n          assemblyKeyParams = partialAssemblyKey.assemblyKeyParams;\r\n        }\r\n        return partialAssemblyKey.slip39.share.mnemonics;\r\n      })\r\n    );\r\n\r\n    const rawAssemblyKey = await this.slip39Service.recoverSecret(\r\n      shares,\r\n      ScenarioApproverService.SLIP39_PASSPHRASE\r\n    );\r\n\r\n    return await KFS.asKey({\r\n      ...assemblyKeyParams,\r\n      k: rawAssemblyKey,\r\n    });\r\n  }\r\n\r\n  public async resetScenario(\r\n    scenarioId: string,\r\n    disable: boolean = false\r\n  ): Promise<void> {\r\n    const prepareReceiverItem = async (\r\n      itemKeyId: string,\r\n      sharedKeyId: string,\r\n      assemblyKey: JWK.Key\r\n    ): Promise<string> => {\r\n      const sharedKey = await this.keyGraph.getKey(sharedKeyId);\r\n      const itemKey = await this.keyGraph.getKey(itemKeyId);\r\n\r\n      let wrappedItemKey = await this.keyGraph.encryptToString(\r\n        sharedKey.jwk,\r\n        itemKey.jwk.toJSON(true)\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      return wrappedItemKey;\r\n    };\r\n\r\n    const prepareReceiverDirectories = async (\r\n      receiver: Receiver,\r\n      assemblyKey: JWK.Key\r\n    ) => {\r\n      return Promise.all([\r\n        ...receiver.categories.map(async (receiverDirectory) => ({\r\n          receiverDirectoryId: receiverDirectory.id,\r\n          wrappedItemKey: await prepareReceiverItem(\r\n            receiverDirectory.category.keyId,\r\n            receiver.keyId,\r\n            assemblyKey\r\n          ),\r\n        })),\r\n        ...receiver.records.map(async (receiverDirectory) => ({\r\n          receiverDirectoryId: receiverDirectory.id,\r\n          wrappedItemKey: await prepareReceiverItem(\r\n            receiverDirectory.record.keyId,\r\n            receiver.keyId,\r\n            assemblyKey\r\n          ),\r\n        })),\r\n      ]);\r\n    };\r\n\r\n    const prepareReceivers = async (\r\n      receivers: Receiver[],\r\n      assemblyKey: JWK.Key\r\n    ) => {\r\n      return Promise.all(\r\n        receivers.map(async (receiver) => ({\r\n          receiverId: receiver.id,\r\n          receiverDirectories: await prepareReceiverDirectories(\r\n            receiver,\r\n            assemblyKey\r\n          ),\r\n          receiverFiles: [],\r\n        }))\r\n      );\r\n    };\r\n\r\n    const prepareApprovers = async (approvers: Approver[]) => {\r\n      return Promise.all(\r\n        approvers.map(async (approver) => ({\r\n          approverId: approver.id,\r\n          sharedKeyId: approver.keyId,\r\n        }))\r\n      );\r\n    };\r\n\r\n    const prepareSubAssemblies = async (\r\n      subAssemblies: ApprovalGroup[],\r\n      assemblyKey: JWK.Key\r\n    ) => {\r\n      return Promise.all(\r\n        subAssemblies.map(async (sa) => ({\r\n          subAssemblyId: sa.id,\r\n          subAssemblyCipherData: await this.keyGraph.encryptToString(\r\n            assemblyKey,\r\n            { name: sa.name }\r\n          ),\r\n          approvers: await prepareApprovers(sa.approvers),\r\n        }))\r\n      );\r\n    };\r\n\r\n    // ------------------------------------------------------------------------------\r\n    // ------------------------------------------------------------------------------\r\n    // ------------------------------------------------------------------------------\r\n\r\n    const scenario = await this.getScenario(scenarioId);\r\n    if (scenario.status !== ScenarioState.APPROVED) {\r\n      throw new LrException({\r\n        code: LrErrorCode.BadState,\r\n        message: `Scenario must be in ${ScenarioState.APPROVED} state`,\r\n      });\r\n    }\r\n\r\n    const subjectKey = await this.keyGraph.getKey(scenario.keyId);\r\n    const newAssemblyKey = await this.keyFactory.createKey();\r\n\r\n    const input: any = {\r\n      scenarioId: scenario.id,\r\n      disable,\r\n      receivers: await prepareReceivers(scenario.receivers, newAssemblyKey),\r\n    };\r\n\r\n    // Approver assembly\r\n    const subjectKeyWrappedAssemblyKey = await this.keyGraph.encryptToString(\r\n      subjectKey.jwk,\r\n      newAssemblyKey.toJSON(true)\r\n    );\r\n\r\n    input.approverAssembly = {\r\n      subjectKeyId: subjectKey.id,\r\n      subjectKeyWrappedAssemblyKey,\r\n      assemblyCipherData: '',\r\n      subAssemblies: await prepareSubAssemblies(\r\n        scenario.approverGroups,\r\n        newAssemblyKey\r\n      ),\r\n    };\r\n\r\n    if (scenario.approverGroups.length) {\r\n      const { k: rawAssemblyKey, ...assemblyKeyParams } = newAssemblyKey.toJSON(\r\n        true\r\n      ) as any;\r\n\r\n      // Split the keys. If the scenario has been approved and there is an assembly setup, then\r\n      // that assembly already enough members to meet quorum to approve the claim. So we can assume\r\n      // that we can always do a key split here.\r\n      const slipAssembly = new slip.Assembly(scenario.assemblyQuorum);\r\n\r\n      scenario.approverGroups.forEach((sa, isa) => {\r\n        let approverCount = sa.approvers.length;\r\n        // if quorum is 1, then every approvers in the sub assembly shares the same partial key\r\n        if (sa.quorum === 1) {\r\n          approverCount = 1;\r\n        }\r\n        slipAssembly.addSubAssembly(\r\n          new slip.SubAssembly(isa, sa.quorum, approverCount)\r\n        );\r\n      });\r\n\r\n      await this.slip39Service.generateShares(\r\n        rawAssemblyKey,\r\n        ScenarioApproverService.SLIP39_PASSPHRASE,\r\n        slipAssembly\r\n      );\r\n\r\n      // Copy the partial keys\r\n      await Promise.all(\r\n        scenario.approverGroups.map(async (sa, isa) => {\r\n          const slipSubAssembly = slipAssembly.subAssemblies[isa];\r\n          const inputSubAssembly = input.approverAssembly.subAssemblies[isa];\r\n\r\n          await Promise.all(\r\n            sa.approvers.map(async (approver, ia) => {\r\n              const sharedKey = await this.keyGraph.getKey(approver.keyId);\r\n\r\n              // if quorum is 1, then every approvers in the sub assembly shares the same partial key\r\n              const share =\r\n                sa.quorum === 1\r\n                  ? slipSubAssembly.shares[0]\r\n                  : slipSubAssembly.shares[ia];\r\n\r\n              const partialAssemblyKey: PartialAssemblyKey = {\r\n                slip39: {\r\n                  share,\r\n                  subAssembly: {\r\n                    quorum: sa.quorum,\r\n                    size: sa.approvers.length,\r\n                  },\r\n                },\r\n                assemblyKeyParams,\r\n              };\r\n              inputSubAssembly.approvers[\r\n                ia\r\n              ].sharedCipherPartialAssemblyKey = await this.keyGraph.encryptToString(\r\n                sharedKey.jwk,\r\n                partialAssemblyKey\r\n              );\r\n            })\r\n          );\r\n        })\r\n      );\r\n    }\r\n    await this.lrApollo.mutate<any>({\r\n      mutation: ResetScenarioMutation,\r\n      variables: { input },\r\n    });\r\n  }\r\n\r\n  public async getAllScenarioIds(): Promise<string[]> {\r\n    const { scenarios } = await this.lrApollo.query<any>({\r\n      query: GetAllScenarioIdsQuery,\r\n    });\r\n    return scenarios.edges.map((edge) => edge.node.id);\r\n  }\r\n}\r\n"]}