@lifeready/core 1.0.1 → 1.0.2

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":"/opt/atlassian/pipelines/agent/build/projects/core/src/","sources":["lib/scenario/scenario.service.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACxE,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAClE,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,KAAK,IAAI,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AAC/E,OAAO,EACL,WAAW,EACX,WAAW,GAEZ,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAEhF,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAEhF,OAAO,EACL,4BAA4B,EAC5B,2BAA2B,EAC3B,2BAA2B,EAC3B,sBAAsB,EACtB,sBAAsB,EACtB,uBAAuB,EACvB,sBAAsB,EACtB,yBAAyB,EACzB,oBAAoB,EACpB,0BAA0B,EAC1B,gBAAgB,EAChB,sBAAsB,EACtB,6BAA6B,EAC7B,4BAA4B,EAC5B,2BAA2B,EAC3B,qBAAqB,EACrB,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAKL,aAAa,EAKb,kBAAkB,GAEnB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,OAAO,MAAM,QAAQ,CAAC;AAClC,OAAO,EAAE,iBAAiB,IAAI,GAAG,EAAE,MAAM,qCAAqC,CAAC;AAC/E,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,UAAU,GACX,MAAM,mBAAmB,CAAC;;;;;;;;;;;;;;AAE3B,0GAA0G;AAC1G,MAAM,MAAM,GAAG,OAAO,CAAC;AAKvB,MAAM,OAAO,eAAe;IAC1B,YACU,QAAyB,EACzB,cAA8B,EAC9B,UAAe,EACf,UAAsB,EACtB,iBAAoC,EACpC,QAAyB,EACzB,SAA8B,EAC9B,aAAiC,EACjC,uBAAgD,EAChD,uBAAgD,EAChD,uBAAgD,EAChD,SAA2B;QAX3B,aAAQ,GAAR,QAAQ,CAAiB;QACzB,mBAAc,GAAd,cAAc,CAAgB;QAC9B,eAAU,GAAV,UAAU,CAAK;QACf,eAAU,GAAV,UAAU,CAAY;QACtB,sBAAiB,GAAjB,iBAAiB,CAAmB;QACpC,aAAQ,GAAR,QAAQ,CAAiB;QACzB,cAAS,GAAT,SAAS,CAAqB;QAC9B,kBAAa,GAAb,aAAa,CAAoB;QACjC,4BAAuB,GAAvB,uBAAuB,CAAyB;QAChD,4BAAuB,GAAvB,uBAAuB,CAAyB;QAChD,4BAAuB,GAAvB,uBAAuB,CAAyB;QAChD,cAAS,GAAT,SAAS,CAAkB;IAClC,CAAC;IAES,cAAc;;YACzB,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAM;gBACnD,KAAK,EAAE,oBAAoB;aAC5B,CAAC,CAAC;YACH,OAAO,MAAM,OAAO,CAAC,GAAG,CACtB,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CACjE,CAAC;QACJ,CAAC;KAAA;IAEa,kBAAkB,CAAC,QAAa;;YAC5C,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAG1D,QAAQ,CAAC,UAAU,CAAC,EAAE,EAAE,QAAQ,CAAC,iBAAiB,CAAC,CAAC;YAEvD,OAAO;gBACL,EAAE,EAAE,QAAQ,CAAC,EAAE;gBACf,IAAI;gBACJ,KAAK;gBACL,MAAM,EAAE,QAAQ,CAAC,KAAK;gBACtB,OAAO,EAAE,QAAQ,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE;gBAC5C,WAAW,EAAE,QAAQ,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,KAAK;gBACnD,SAAS,EAAE,QAAQ,CAAC,OAAO;gBAC3B,YAAY,EAAE,QAAQ,CAAC,QAAQ;aAChC,CAAC;QACJ,CAAC;KAAA;IAEY,kBAAkB;;YAC7B,MAAM,EAAE,eAAe,EAAE,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAM;gBACzD,KAAK,EAAE,0BAA0B;aAClC,CAAC,CAAC;YACH,OAAO,CACL,MAAM,OAAO,CAAC,GAAG,CACf,eAAe,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CACtE,CACF,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;QACrB,CAAC;KAAA;IAEa,wBAAwB,CACpC,QAAa;;YAEb,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAG1D,QAAQ,CAAC,UAAU,CAAC,EAAE,EAAE,QAAQ,CAAC,iBAAiB,CAAC,CAAC;YAEvD,OAAO;gBACL,EAAE,EAAE,QAAQ,CAAC,EAAE;gBACf,IAAI;gBACJ,KAAK;gBACL,MAAM,EAAE,QAAQ,CAAC,KAAK;gBACtB,OAAO,EAAE,QAAQ,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE;gBAC5C,WAAW,EAAE,QAAQ,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,KAAK;gBACnD,SAAS,EAAE,QAAQ,CAAC,OAAO;gBAC3B,YAAY,EAAE,QAAQ,CAAC,QAAQ;aAChC,CAAC;QACJ,CAAC;KAAA;IAEY,iBAAiB,CAAC,UAAkB;;YAC/C,MAAM,EAAE,cAAc,EAAE,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAM;gBACxD,KAAK,EAAE,sBAAsB;gBAC7B,SAAS,EAAE;oBACT,EAAE,EAAE,UAAU;iBACf;aACF,CAAC,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC;QACtD,CAAC;KAAA;IAEa,iBAAiB,CAAC,QAAa;;YAC3C,IAAI;gBACF,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;gBACnE,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;gBACnE,MAAM,YAAY,GAAG,MAAM,OAAO,CAAC,GAAG,CAIpC,QAAQ,CAAC,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CACnC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CACpC,CACF,CAAC;gBAEF,OAAO;oBACL,EAAE,EAAE,QAAQ,CAAC,EAAE;oBACf,KAAK,EACH,YAAY,CAAC,KAAK;wBAClB,YAAY,CAAC,KAAK;wBAClB,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;oBACrC,MAAM,EAAE,QAAQ,CAAC,KAAK;oBACtB,YAAY,EAAE,MAAM,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,QAAQ,CAAC,EAAE,CAAC;oBAC/D,UAAU,EAAE,CAAC,CAAC,QAAQ,CAAC,UAAU;oBACjC,eAAe,EAAE,YAAY,CAAC,OAAO;oBACrC,UAAU,EAAE,QAAQ,CAAC,WAAW,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC;oBACjD,gBAAgB,EAAE,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC;oBACpD,UAAU,EAAE,CAAC,CAAC,QAAQ,CAAC,UAAU;oBACjC,eAAe,EAAE,YAAY,CAAC,OAAO;oBACrC,aAAa,EAAE,QAAQ,CAAC,UAAU,IAAI,QAAQ,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE;oBACtE,aAAa,EAAE,QAAQ,CAAC,UAAU,IAAI,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;oBAChE,mBAAmB,EACjB,QAAQ,CAAC,UAAU;wBACnB,QAAQ,CAAC,UAAU,CAAC,mBAAmB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;oBAClE,KAAK,EAAE,QAAQ,CAAC,WAAW;wBACzB,CAAC,CAAC;4BACE,EAAE,EAAE,QAAQ,CAAC,WAAW,CAAC,EAAE;4BAC3B,UAAU,EAAE,QAAQ,CAAC,WAAW,CAAC,UAAU;4BAC3C,MAAM,EAAE,QAAQ,CAAC,WAAW,CAAC,KAAK;4BAClC,WAAW,EAAE,MAAM,OAAO,CAAC,GAAG,CAC5B,QAAQ,CAAC,WAAW,CAAC,gBAAgB,CAAC,KAAK;iCACxC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;iCAClB,GAAG,CAAC,CAAO,CAAC,EAAE,EAAE;gCAAC,OAAA,CAAC;oCACjB,UAAU,EAAE,CAAC,CAAC,QAAQ,CAAC,EAAE;oCACzB,WAAW,EAAE,MAAM,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,QAAQ,CAAC;oCAClD,MAAM,EAAE,CAAC,CAAC,KAAK;oCACf,SAAS,EAAE,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;wCACvC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE;wCACb,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;qCACrB,CAAC,CAAC;iCACJ,CAAC,CAAA;8BAAA,CAAC,CACN;4BACD,UAAU,EAAE,QAAQ,CAAC,WAAW,CAAC,eAAe;gCAC9C,CAAC,CAAC;oCACE,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAAC,eAAe,CAAC,QAAQ;oCACvD,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,eAAe,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAC/D,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAChC;iCACF;gCACH,CAAC,CAAC,IAAI;yBACT;wBACH,CAAC,CAAC,IAAI;iBACT,CAAC;aACH;YAAC,OAAO,CAAC,EAAE;gBACV,OAAO,CAAC,KAAK,CAAC,oCAAoC,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC;gBACjE,OAAO,IAAI,CAAC;aACb;QACH,CAAC;KAAA;IAEY,wBAAwB,CACnC,cAAsB;;YAKtB,MAAM,EAAE,EAAE,EAAE,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAM;gBAC5C,KAAK,EAAE,6BAA6B;gBACpC,SAAS,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE;aACvC,CAAC,CAAC;YACH,OAAO;gBACL,WAAW,EAAE,MAAM,OAAO,CAAC,GAAG,CAC5B,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CACtE;gBACD,eAAe,EAAE,MAAM,OAAO,CAAC,GAAG,CAChC,EAAE,CAAC,eAAe,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CACzE;aACF,CAAC;QACJ,CAAC;KAAA;IAEY,iBAAiB;;YAC5B,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAM;gBACnD,KAAK,EAAE,yBAAyB;aACjC,CAAC,CAAC;YAEH,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,GAAG,CAC9B,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAO,CAAM,EAAE,EAAE;gBACnC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;gBAEvD,OAAO,MAAM,OAAO,CAAC,GAAG,CACtB,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAO,CAAC,EAAE,EAAE;oBAAC,OAAA,CAAC;wBACpC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE;wBACb,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK;wBACnB,WAAW,EAAE,MAAM,IAAI,CAAC,SAAS,CAAC,eAAe,CAC/C,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CACnB;wBACD,WAAW,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO;wBAC3B,YAAY,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ;wBAC7B,QAAQ;qBACT,CAAC,CAAA;kBAAA,CAAC,CACJ,CAAC;YACJ,CAAC,CAAA,CAAC,CACH,CAAC;YAEF,OAAO,MAAM;iBACV,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC;iBAClC,IAAI,CACH,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CACP,CAAC,CAAC;gBACF,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CACnC,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CACjC,CACJ,CAAC;QACN,CAAC;KAAA;IAEa,aAAa,CAAC,MAG3B;;YACC,IAAI,CAAC,MAAM;gBAAE,OAAO,EAAE,CAAC;YAEvB,OAAO,MAAM,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAGzC,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,MAAM,CAAC,gBAAgB,CAAC,CAAC;QACnD,CAAC;KAAA;IAEa,cAAc,CAAC,MAG5B;;YACC,IAAI,CAAC,MAAM;gBAAE,OAAO,IAAI,CAAC;YAEzB,OAAO,MAAM,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAC1C,MAAM,CAAC,SAAS,CAAC,EAAE,EACnB,MAAM,CAAC,8BAA8B,CACtC,CAAC;QACJ,CAAC;KAAA;IAEY,WAAW,CAAC,UAAkB;;YACzC,MAAM,EAAE,QAAQ,EAAE,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAM;gBAClD,KAAK,EAAE,gBAAgB;gBACvB,SAAS,EAAE;oBACT,EAAE,EAAE,UAAU;oBACd,cAAc,EAAE,cAAc;oBAC9B,YAAY,EAAE,YAAY;oBAC1B,aAAa,EAAE,mBAAmB;iBACnC;aACF,CAAC,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;QAC1C,CAAC;KAAA;IAEa,WAAW,CAAC,QAAa;;YACrC,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAG1D,QAAQ,CAAC,UAAU,CAAC,EAAE,EAAE,QAAQ,CAAC,iBAAiB,CAAC,CAAC;YACvD,MAAM,SAAS,GAAG,MAAM,OAAO,CAAC,GAAG,CACjC,QAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CACjC,IAAI,CAAC,uBAAuB,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CACjD,CACF,CAAC;YAEF,OAAO;gBACL,EAAE,EAAE,QAAQ,CAAC,EAAE;gBACf,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC,EAAE;gBAC7B,aAAa,EACX,QAAQ,CAAC,gBAAgB,IAAI,QAAQ,CAAC,gBAAgB,CAAC,WAAW,CAAC,EAAE;gBACvE,cAAc,EACZ,QAAQ,CAAC,gBAAgB,IAAI,QAAQ,CAAC,gBAAgB,CAAC,MAAM;gBAC/D,IAAI;gBACJ,KAAK;gBACL,MAAM,EAAE,QAAQ,CAAC,KAAK;gBACtB,SAAS;gBACT,cAAc,EAAE,QAAQ,CAAC,gBAAgB;oBACvC,CAAC,CAAC,MAAM,OAAO,CAAC,GAAG,CACf,QAAQ,CAAC,gBAAgB,CAAC,aAAa,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CACtD,IAAI,CAAC,uBAAuB,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC,CACtD,CACF;oBACH,CAAC,CAAC,EAAE;gBACN,SAAS,EAAE,MAAM,OAAO,CAAC,GAAG,CAC1B,QAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CACjC,IAAI,CAAC,uBAAuB,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CACjD,CACF;gBACD,KAAK,EAAE,QAAQ,CAAC,KAAK;oBACnB,CAAC,CAAC;wBACE,EAAE,EAAE,QAAQ,CAAC,KAAK,CAAC,EAAE;wBACrB,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,KAAK;wBAC5B,QAAQ,EAAE,SAAS,CAAC,IAAI,CACtB,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAC3C;qBACF;oBACH,CAAC,CAAC,IAAI;aACT,CAAC;QACJ,CAAC;KAAA;IAEY,cAAc,CAAC,KAA0B;;YACpD,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,CAAC;YAE1D,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,CAAC;YACrD,MAAM,wBAAwB,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,eAAe,CAClE,OAAO,CAAC,GAAG,EACX,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CACxB,CAAC;YAEF,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,eAAe,CAC3D,UAAU,EACV,KAAK,CAAC,sBAAsB,CAC7B,CAAC;YAEF,MAAM,EAAE,cAAc,EAAE,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAM;gBACzD,QAAQ,EAAE,sBAAsB;gBAChC,SAAS,EAAE;oBACT,KAAK,EAAE;wBACL,SAAS,EAAE,OAAO,CAAC,EAAE;wBACrB,wBAAwB;wBACxB,iBAAiB;qBAClB;iBACF;aACF,CAAC,CAAC;YACH,OAAO,cAAc,CAAC,QAAQ,CAAC,EAAE,CAAC;QACpC,CAAC;KAAA;IAEY,cAAc,CAAC,KAA0B;;YACpD,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAO;gBAC/B,QAAQ,EAAE,sBAAsB;gBAChC,SAAS,EAAE;oBACT,KAAK,EAAE;wBACL,UAAU,EAAE,KAAK,CAAC,UAAU;wBAC5B,YAAY,EAAE,KAAK,CAAC,KAAK;wBACzB,iBAAiB,EAAE,MAAM,IAAI,CAAC,QAAQ,CAAC,eAAe,CACpD,KAAK,CAAC,KAAK,EACX,KAAK,CAAC,sBAAsB,CAC7B;qBACF;iBACF;aACF,CAAC,CAAC;QACL,CAAC;KAAA;IAEY,cAAc,CAAC,UAAkB;;YAC5C,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAO;gBAC/B,QAAQ,EAAE,sBAAsB;gBAChC,SAAS,EAAE,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,EAAE;aACrC,CAAC,CAAC;QACL,CAAC;KAAA;IAEY,eAAe,CAAC,UAAkB;;YAC7C,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAO;gBAC/B,QAAQ,EAAE,uBAAuB;gBACjC,SAAS,EAAE,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,EAAE;aACrC,CAAC,CAAC;QACL,CAAC;KAAA;IAEY,cAAc,CAAC,UAAkB;;YAC5C,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAO;gBAC/B,QAAQ,EAAE,sBAAsB;gBAChC,SAAS,EAAE,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,EAAE;aACrC,CAAC,CAAC;QACL,CAAC;KAAA;IAEY,WAAW,CAAC,UAAkB;;YACzC,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAM;gBAC1C,QAAQ,EAAE,2BAA2B;gBACrC,SAAS,EAAE,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,EAAE;aACrC,CAAC,CAAC;YACH,OAAO,GAAG,CAAC,mBAAmB,CAAC,WAAW,CAAC,EAAE,CAAC;QAChD,CAAC;KAAA;IAEY,WAAW,CAAC,OAAe;;YACtC,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAO;gBAC/B,QAAQ,EAAE,2BAA2B;gBACrC,SAAS,EAAE,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,EAAE;aAClC,CAAC,CAAC;QACL,CAAC;KAAA;IAEY,YAAY,CAAC,UAAkB,EAAE,OAAe;;YAC3D,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,CAC5B,IAAI,CAAC,oBAAoB,CAAC,UAAU,EAAE,OAAO,CAAC,CAC/C,CAAC;QACJ,CAAC;KAAA;IAEY,oBAAoB,CAAC,UAAkB,EAAE,OAAe;;YACnE,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;YAEhE,iCAAiC;YACjC,IAAI,cAAc,CAAC,KAAK,CAAC,EAAE,KAAK,OAAO,EAAE;gBACvC,MAAM,IAAI,WAAW,CAAC;oBACpB,IAAI,EAAE,WAAW,CAAC,oBAAoB;oBACtC,OAAO,EACL,iEAAiE;iBACpE,CAAC,CAAC;aACJ;YAED,MAAM,cAAc,GAAG,CAAO,UAAuC,EAAE,EAAE;gBACvE,OAAO,IAAI,UAAU,CAAC;oBACpB,QAAQ,EAAE,4BAA4B;oBACtC,SAAS,EAAE;wBACT,KAAK,EAAE;4BACL,OAAO;4BACP,UAAU,EAAE,UAAU,CAAC,UAAU;4BACjC,SAAS,EAAE,MAAM,OAAO,CAAC,GAAG,CAC1B,UAAU,CAAC,SAAS,CAAC,GAAG,CAAC,CAAO,CAAC,EAAE,EAAE;gCAAC,OAAA,CAAC;oCACrC,UAAU,EAAE,CAAC,CAAC,EAAE;oCAChB,iBAAiB,EAAE,MAAM,IAAI,CAAC,QAAQ,CAAC,eAAe,CACpD,CAAC,CAAC,KAAK,EACP,EAAE,kBAAkB,EAAE,UAAU,CAAC,WAAW,EAAE,CAC/C;iCACF,CAAC,CAAA;8BAAA,CAAC,CACJ;yBACF;qBACF;iBACF,CAAC,CAAC;YACL,CAAC,CAAA,CAAC;YAEF,MAAM,SAAS,GAAG,cAAc,CAAC,KAAK,CAAC,WAAW;iBAC/C,MAAM,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,MAAM,KAAK,kBAAkB,CAAC,OAAO,CAAC;iBACxE,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC;YAEnD,OAAO,gBAAgB,CAAC,MAAM,CAAC,MAAM,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC;QAC/D,CAAC;KAAA;IAEY,WAAW,CAAC,UAAkB,EAAE,OAAe;;YAC1D,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,CAC5B,IAAI,CAAC,mBAAmB,CAAC,UAAU,EAAE,OAAO,CAAC,CAC9C,CAAC;QACJ,CAAC;KAAA;IAEY,mBAAmB,CAAC,UAAkB,EAAE,OAAe;;YAClE,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;YAEhE,iCAAiC;YACjC,IAAI,cAAc,CAAC,KAAK,CAAC,EAAE,KAAK,OAAO,EAAE;gBACvC,MAAM,IAAI,WAAW,CAAC;oBACpB,IAAI,EAAE,WAAW,CAAC,oBAAoB;oBACtC,OAAO,EACL,iEAAiE;iBACpE,CAAC,CAAC;aACJ;YAED,MAAM,cAAc,GAAG,CAAO,UAAuC,EAAE,EAAE;gBACvE,OAAO,IAAI,UAAU,CAAC;oBACpB,QAAQ,EAAE,2BAA2B;oBACrC,SAAS,EAAE,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU,CAAC,UAAU,EAAE,EAAE;iBACrE,CAAC,CAAC;YACL,CAAC,CAAA,CAAC;YAEF,MAAM,SAAS,GAAG,cAAc,CAAC,KAAK,CAAC,WAAW;iBAC/C,MAAM,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,MAAM,KAAK,kBAAkB,CAAC,OAAO,CAAC;iBACxE,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC;YAEnD,OAAO,gBAAgB,CAAC,MAAM,CAAC,MAAM,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC;QAC/D,CAAC;KAAA;IAEY,YAAY,CACvB,UAAkB,EAClB,OAAe;;YAEf,2BAA2B;YAC3B,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;YAEhE,iCAAiC;YACjC,IAAI,cAAc,CAAC,KAAK,CAAC,EAAE,KAAK,OAAO,EAAE;gBACvC,MAAM,IAAI,WAAW,CAAC;oBACpB,IAAI,EAAE,WAAW,CAAC,oBAAoB;oBACtC,OAAO,EACL,iEAAiE;iBACpE,CAAC,CAAC;aACJ;YACD,IAAI,cAAc,CAAC,MAAM,KAAK,aAAa,CAAC,QAAQ,EAAE;gBACpD,MAAM,IAAI,WAAW,CAAC;oBACpB,IAAI,EAAE,WAAW,CAAC,QAAQ;oBAC1B,OAAO,EAAE,sCAAsC;iBAChD,CAAC,CAAC;aACJ;YAED,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,mBAAmB,CAChD,cAAc,CAAC,aAAa,EAC5B,cAAc,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,CACxC,CAAC;YAEF,oBAAoB;YACpB,MAAM,mBAAmB,GAAG,MAAM,OAAO,CAAC,GAAG,CAC3C,cAAc,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAO,CAAC,EAAE,EAAE;gBACjD,MAAM,cAAc,GAAG,WAAW;oBAChC,CAAC,CAAC,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC,cAAc,CAAC;oBACrE,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC;gBAErB,OAAO;oBACL,mBAAmB,EAAE,CAAC,CAAC,EAAE;oBACzB,+BAA+B,EAAE,cAAc;iBAChD,CAAC;YACJ,CAAC,CAAA,CAAC,CACH,CAAC;YAEF,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAO;gBAC/B,QAAQ,EAAE,4BAA4B;gBACtC,SAAS,EAAE;oBACT,KAAK,EAAE;wBACL,OAAO;wBACP,mBAAmB;qBACpB;iBACF;aACF,CAAC,CAAC;QACL,CAAC;KAAA;IAEa,mBAAmB,CAAC,KAAa,EAAE,OAAiB;;YAChE,IAAI,CAAC,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM;gBAAE,OAAO,IAAI,CAAC;YAE7C,IAAI,iBAAyB,CAAC;YAE9B,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,GAAG,CAC9B,OAAO,CAAC,GAAG,CAAC,CAAO,CAAC,EAAE,EAAE;gBACtB,MAAM,EAAE,kBAAkB,EAAE,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAEjE,KAAK,EAAE,CAAC,CAAC,CAAC;gBAEb,IAAI,iBAAiB,EAAE;oBACrB,IACE,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC;wBACjC,IAAI,CAAC,SAAS,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,EACpD;wBACA,MAAM,IAAI,WAAW,CAAC;4BACpB,IAAI,EAAE,WAAW,CAAC,QAAQ;4BAC1B,OAAO,EACL,kEAAkE;yBACrE,CAAC,CAAC;qBACJ;iBACF;qBAAM;oBACL,iBAAiB,GAAG,kBAAkB,CAAC,iBAAiB,CAAC;iBAC1D;gBACD,OAAO,kBAAkB,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC;YACnD,CAAC,CAAA,CAAC,CACH,CAAC;YAEF,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,aAAa,CAC3D,MAAM,EACN,uBAAuB,CAAC,iBAAiB,CAC1C,CAAC;YAEF,OAAO,MAAM,GAAG,CAAC,KAAK,iCACjB,iBAAiB,KACpB,CAAC,EAAE,cAAc,IACjB,CAAC;QACL,CAAC;KAAA;IAEY,aAAa,CACxB,UAAkB,EAClB,UAAmB,KAAK;;YAExB,MAAM,mBAAmB,GAAG,CAC1B,SAAiB,EACjB,WAAmB,EACnB,WAAoB,EACH,EAAE;gBACnB,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;gBAC1D,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;gBAEtD,IAAI,cAAc,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,eAAe,CACtD,SAAS,CAAC,GAAG,EACb,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CACzB,CAAC;gBACF,IAAI,WAAW,EAAE;oBACf,cAAc,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,eAAe,CAClD,WAAW,EACX,cAAc,CACf,CAAC;iBACH;gBACD,OAAO,cAAc,CAAC;YACxB,CAAC,CAAA,CAAC;YAEF,MAAM,0BAA0B,GAAG,CACjC,QAAkB,EAClB,WAAoB,EACpB,EAAE;gBACF,OAAO,OAAO,CAAC,GAAG,CAAC;oBACjB,GAAG,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,CAAO,iBAAiB,EAAE,EAAE;wBAAC,OAAA,CAAC;4BACvD,mBAAmB,EAAE,iBAAiB,CAAC,EAAE;4BACzC,cAAc,EAAE,MAAM,mBAAmB,CACvC,iBAAiB,CAAC,QAAQ,CAAC,KAAK,EAChC,QAAQ,CAAC,KAAK,EACd,WAAW,CACZ;yBACF,CAAC,CAAA;sBAAA,CAAC;oBACH,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,CAAO,iBAAiB,EAAE,EAAE;wBAAC,OAAA,CAAC;4BACpD,mBAAmB,EAAE,iBAAiB,CAAC,EAAE;4BACzC,cAAc,EAAE,MAAM,mBAAmB,CACvC,iBAAiB,CAAC,MAAM,CAAC,KAAK,EAC9B,QAAQ,CAAC,KAAK,EACd,WAAW,CACZ;yBACF,CAAC,CAAA;sBAAA,CAAC;iBACJ,CAAC,CAAC;YACL,CAAC,CAAA,CAAC;YAEF,MAAM,gBAAgB,GAAG,CACvB,SAAqB,EACrB,WAAoB,EACpB,EAAE;gBACF,OAAO,OAAO,CAAC,GAAG,CAChB,SAAS,CAAC,GAAG,CAAC,CAAO,QAAQ,EAAE,EAAE;oBAAC,OAAA,CAAC;wBACjC,UAAU,EAAE,QAAQ,CAAC,EAAE;wBACvB,mBAAmB,EAAE,MAAM,0BAA0B,CACnD,QAAQ,EACR,WAAW,CACZ;wBACD,aAAa,EAAE,EAAE;qBAClB,CAAC,CAAA;kBAAA,CAAC,CACJ,CAAC;YACJ,CAAC,CAAA,CAAC;YAEF,MAAM,gBAAgB,GAAG,CAAO,SAAqB,EAAE,EAAE;gBACvD,OAAO,OAAO,CAAC,GAAG,CAChB,SAAS,CAAC,GAAG,CAAC,CAAO,QAAQ,EAAE,EAAE;oBAAC,OAAA,CAAC;wBACjC,UAAU,EAAE,QAAQ,CAAC,EAAE;wBACvB,WAAW,EAAE,QAAQ,CAAC,KAAK;qBAC5B,CAAC,CAAA;kBAAA,CAAC,CACJ,CAAC;YACJ,CAAC,CAAA,CAAC;YAEF,MAAM,oBAAoB,GAAG,CAC3B,aAA8B,EAC9B,WAAoB,EACpB,EAAE;gBACF,OAAO,OAAO,CAAC,GAAG,CAChB,aAAa,CAAC,GAAG,CAAC,CAAO,EAAE,EAAE,EAAE;oBAAC,OAAA,CAAC;wBAC/B,aAAa,EAAE,EAAE,CAAC,EAAE;wBACpB,qBAAqB,EAAE,MAAM,IAAI,CAAC,QAAQ,CAAC,eAAe,CACxD,WAAW,EACX,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,CAClB;wBACD,SAAS,EAAE,MAAM,gBAAgB,CAAC,EAAE,CAAC,SAAS,CAAC;qBAChD,CAAC,CAAA;kBAAA,CAAC,CACJ,CAAC;YACJ,CAAC,CAAA,CAAC;YAEF,iFAAiF;YACjF,iFAAiF;YACjF,iFAAiF;YAEjF,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;YACpD,IAAI,QAAQ,CAAC,MAAM,KAAK,aAAa,CAAC,QAAQ,EAAE;gBAC9C,MAAM,IAAI,WAAW,CAAC;oBACpB,IAAI,EAAE,WAAW,CAAC,QAAQ;oBAC1B,OAAO,EAAE,uBAAuB,aAAa,CAAC,QAAQ,QAAQ;iBAC/D,CAAC,CAAC;aACJ;YAED,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YAC9D,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,CAAC;YAEzD,MAAM,KAAK,GAAQ;gBACjB,UAAU,EAAE,QAAQ,CAAC,EAAE;gBACvB,OAAO;gBACP,SAAS,EAAE,MAAM,gBAAgB,CAAC,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAC;aACtE,CAAC;YAEF,oBAAoB;YACpB,MAAM,4BAA4B,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,eAAe,CACtE,UAAU,CAAC,GAAG,EACd,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,CAC5B,CAAC;YAEF,KAAK,CAAC,gBAAgB,GAAG;gBACvB,YAAY,EAAE,UAAU,CAAC,EAAE;gBAC3B,4BAA4B;gBAC5B,kBAAkB,EAAE,EAAE;gBACtB,aAAa,EAAE,MAAM,oBAAoB,CACvC,QAAQ,CAAC,cAAc,EACvB,cAAc,CACf;aACF,CAAC;YAEF,IAAI,QAAQ,CAAC,cAAc,CAAC,MAAM,EAAE;gBAClC,MAAM,KAA8C,cAAc,CAAC,MAAM,CACvE,IAAI,CACE,EAFF,EAAE,CAAC,EAAE,cAAc,OAEjB,EAFsB,iBAAiB,cAAzC,KAA2C,CAEzC,CAAC;gBAET,yFAAyF;gBACzF,6FAA6F;gBAC7F,0CAA0C;gBAC1C,MAAM,YAAY,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;gBAEhE,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE;oBAC1C,IAAI,aAAa,GAAG,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC;oBACxC,uFAAuF;oBACvF,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE;wBACnB,aAAa,GAAG,CAAC,CAAC;qBACnB;oBACD,YAAY,CAAC,cAAc,CACzB,IAAI,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,EAAE,CAAC,MAAM,EAAE,aAAa,CAAC,CACpD,CAAC;gBACJ,CAAC,CAAC,CAAC;gBAEH,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CACrC,cAAc,EACd,uBAAuB,CAAC,iBAAiB,EACzC,YAAY,CACb,CAAC;gBAEF,wBAAwB;gBACxB,MAAM,OAAO,CAAC,GAAG,CACf,QAAQ,CAAC,cAAc,CAAC,GAAG,CAAC,CAAO,EAAE,EAAE,GAAG,EAAE,EAAE;oBAC5C,MAAM,eAAe,GAAG,YAAY,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;oBACxD,MAAM,gBAAgB,GAAG,KAAK,CAAC,gBAAgB,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;oBAEnE,MAAM,OAAO,CAAC,GAAG,CACf,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,CAAO,QAAQ,EAAE,EAAE,EAAE,EAAE;wBACtC,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;wBAE7D,uFAAuF;wBACvF,MAAM,KAAK,GACT,EAAE,CAAC,MAAM,KAAK,CAAC;4BACb,CAAC,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC;4BAC3B,CAAC,CAAC,eAAe,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;wBAEjC,MAAM,kBAAkB,GAAuB;4BAC7C,MAAM,EAAE;gCACN,KAAK;gCACL,WAAW,EAAE;oCACX,MAAM,EAAE,EAAE,CAAC,MAAM;oCACjB,IAAI,EAAE,EAAE,CAAC,SAAS,CAAC,MAAM;iCAC1B;6BACF;4BACD,iBAAiB;yBAClB,CAAC;wBACF,gBAAgB,CAAC,SAAS,CACxB,EAAE,CACH,CAAC,8BAA8B,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,eAAe,CACpE,SAAS,CAAC,GAAG,EACb,kBAAkB,CACnB,CAAC;oBACJ,CAAC,CAAA,CAAC,CACH,CAAC;gBACJ,CAAC,CAAA,CAAC,CACH,CAAC;aACH;YACD,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAM;gBAC9B,QAAQ,EAAE,qBAAqB;gBAC/B,SAAS,EAAE,EAAE,KAAK,EAAE;aACrB,CAAC,CAAC;QACL,CAAC;KAAA;IAEY,iBAAiB;;YAC5B,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAM;gBACnD,KAAK,EAAE,sBAAsB;aAC9B,CAAC,CAAC;YACH,OAAO,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACrD,CAAC;KAAA;;;;YAvuBF,UAAU,SAAC;gBACV,UAAU,EAAE,MAAM;aACnB;;;YAlEQ,eAAe;YAIf,cAAc;YAkDO,GAAG;YAjDxB,UAAU;YAHV,iBAAiB;YACjB,eAAe;YAKf,mBAAmB;YAFhB,IAAI,CAsEgB,aAAa;YA5DpC,uBAAuB;YADvB,uBAAuB;YAGvB,uBAAuB;YAsC9B,gBAAgB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { JWK } from 'node-jose';\nimport { LrApolloService } from '../api/lr-apollo.service';\nimport { CategoryFilter, RecordFilter } from '../category/category.gql';\nimport { EncryptionService } from '../cryptography/encryption.service';\nimport { KeyGraphService } from '../cryptography/key-graph.service';\nimport { KeyMetaService } from '../cryptography/key-meta.service';\nimport { KeyService } from '../cryptography/key.service';\nimport * as slip from '../cryptography/slip39.service';\nimport { RecordContentFilter } from '../record/record.gql';\nimport { TrustedPartyService } from '../trusted-parties/trusted-party.service';\nimport {\n  LrException,\n  LrErrorCode,\n  LrBadArgumentException,\n} from '../_common/exceptions';\nimport { ApprovalGroup, Approver } from './approvals/scenario-approval.types';\nimport { ScenarioApproverService } from './approvals/scenario-approver.service';\nimport { ScenarioClaimantService } from './claimants/scenario-claimant.service';\nimport { Claimant } from './claimants/scenario-claimant.types';\nimport { ScenarioReceiverService } from './receivers/scenario-receiver.service';\nimport { Receiver } from './receivers/scenario-receiver.types';\nimport {\n  ApproveScenarioClaimMutation,\n  CancelScenarioClaimMutation,\n  CreateScenarioClaimMutation,\n  CreateScenarioMutation,\n  DeleteScenarioMutation,\n  DisableScenarioMutation,\n  EnableScenarioMutation,\n  GetAllScenarioClaimsQuery,\n  GetAllScenariosQuery,\n  GetAllSharedScenariosQuery,\n  GetScenarioQuery,\n  GetSharedScenarioQuery,\n  GetTrustedPartyScenariosQuery,\n  ReceiveScenarioClaimMutation,\n  RejectScenarioClaimMutation,\n  ResetScenarioMutation,\n  UpdateScenarioMutation,\n  GetAllScenarioIdsQuery,\n} from './scenario.gql';\nimport {\n  CreateScenarioInput,\n  PartialAssemblyKey,\n  Scenario,\n  ScenarioClaim,\n  ScenarioState,\n  ScenarioSummary,\n  SharedScenario,\n  UpdateScenarioInput,\n  SharedScenarioClaimApprover,\n  ApproverClaimState,\n  SharedScenarioSummary,\n} from './scenario.types';\nimport * as moment_ from 'moment';\nimport { KeyFactoryService as KFS } from '../cryptography/key-factory.service';\nimport {\n  LrGraphQLService,\n  LrMergedMutation,\n  LrMutation,\n} from '../api/lr-graphql';\n\n// Ref: https://stackoverflow.com/questions/59735280/angular-8-moment-error-cannot-call-a-namespace-moment\nconst moment = moment_;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ScenarioService {\n  constructor(\n    private lrApollo: LrApolloService,\n    private keyMetaService: KeyMetaService,\n    private keyFactory: KFS,\n    private keyService: KeyService,\n    private encryptionService: EncryptionService,\n    private keyGraph: KeyGraphService,\n    private tpService: TrustedPartyService,\n    private slip39Service: slip.Slip39Service,\n    private scenarioClaimantService: ScenarioClaimantService,\n    private scenarioApproverService: ScenarioApproverService,\n    private scenarioReceiverService: ScenarioReceiverService,\n    private lrGraphQL: LrGraphQLService\n  ) {}\n\n  public async getMyScenarios(): Promise<ScenarioSummary[]> {\n    const { scenarios } = await this.lrApollo.query<any>({\n      query: GetAllScenariosQuery,\n    });\n    return await Promise.all(\n      scenarios.edges.map((x: any) => this.mapScenarioSummary(x.node))\n    );\n  }\n\n  private async mapScenarioSummary(scenario: any): Promise<ScenarioSummary> {\n    const { event, name } = await this.keyGraph.decryptFromString<{\n      event: string;\n      name: string;\n    }>(scenario.subjectKey.id, scenario.subjectCipherData);\n\n    return {\n      id: scenario.id,\n      name,\n      event,\n      status: scenario.state,\n      claimId: scenario.claim && scenario.claim.id,\n      claimStatus: scenario.claim && scenario.claim.state,\n      createdOn: scenario.created,\n      lastModified: scenario.modified,\n    };\n  }\n\n  public async getSharedScenarios(): Promise<SharedScenarioSummary[]> {\n    const { sharedScenarios } = await this.lrApollo.query<any>({\n      query: GetAllSharedScenariosQuery,\n    });\n    return (\n      await Promise.all<SharedScenario>(\n        sharedScenarios.edges.map((x: any) => this.mapSharedScenario(x.node))\n      )\n    ).filter((x) => x);\n  }\n\n  private async mapSharedScenarioSummary(\n    scenario: any\n  ): Promise<ScenarioSummary> {\n    const { event, name } = await this.keyGraph.decryptFromString<{\n      event: string;\n      name: string;\n    }>(scenario.subjectKey.id, scenario.subjectCipherData);\n\n    return {\n      id: scenario.id,\n      name,\n      event,\n      status: scenario.state,\n      claimId: scenario.claim && scenario.claim.id,\n      claimStatus: scenario.claim && scenario.claim.state,\n      createdOn: scenario.created,\n      lastModified: scenario.modified,\n    };\n  }\n\n  public async getSharedScenario(scenarioId: string): Promise<SharedScenario> {\n    const { sharedScenario } = await this.lrApollo.query<any>({\n      query: GetSharedScenarioQuery,\n      variables: {\n        id: scenarioId,\n      },\n    });\n    return await this.mapSharedScenario(sharedScenario);\n  }\n\n  private async mapSharedScenario(scenario: any): Promise<SharedScenario> {\n    try {\n      const claimantData = await this.getCipherData(scenario.asClaimant);\n      const receiverData = await this.getCipherData(scenario.asReceiver);\n      const approverData = await Promise.all<{\n        event?: string;\n        message?: string;\n      }>(\n        scenario.asApprovers.edges.map((x) =>\n          this.getCipherData(x.node.approver)\n        )\n      );\n\n      return {\n        id: scenario.id,\n        event:\n          claimantData.event ||\n          receiverData.event ||\n          approverData.map((x) => x.event)[0],\n        status: scenario.state,\n        trustedParty: await this.tpService.mapTrustedParty(scenario.tp),\n        isClaimant: !!scenario.asClaimant,\n        claimantMessage: claimantData.message,\n        isApprover: scenario.asApprovers.edges.length > 0,\n        approverMessages: approverData.map((x) => x.message),\n        isReceiver: !!scenario.asReceiver,\n        receiverMessage: receiverData.message,\n        receiverKeyId: scenario.asReceiver && scenario.asReceiver.sharedKey.id,\n        receiverPbkId: scenario.asReceiver && scenario.asReceiver.pbk.id,\n        receiverDirectories:\n          scenario.asReceiver &&\n          scenario.asReceiver.receiverDirectories.edges.map((x) => x.node),\n        claim: scenario.sharedClaim\n          ? {\n              id: scenario.sharedClaim.id,\n              isClaimant: scenario.sharedClaim.isClaimant,\n              status: scenario.sharedClaim.state,\n              asApprovers: await Promise.all<SharedScenarioClaimApprover>(\n                scenario.sharedClaim.asClaimApprovers.edges\n                  .map((x) => x.node)\n                  .map(async (x) => ({\n                    approverId: x.approver.id,\n                    approverKey: await this.getApproverKey(x.approver),\n                    status: x.state,\n                    receivers: x.receivers.edges.map((y) => ({\n                      id: y.node.id,\n                      pbkId: y.node.pbk.id,\n                    })),\n                  }))\n              ),\n              asReceiver: scenario.sharedClaim.asClaimReceiver\n                ? {\n                    received: scenario.sharedClaim.asClaimReceiver.received,\n                    ciphers: scenario.sharedClaim.asClaimReceiver.approvals.edges.map(\n                      (x) => x.node.receiverPbkCipher\n                    ),\n                  }\n                : null,\n            }\n          : null,\n      };\n    } catch (e) {\n      console.error('Failed to decrypt shared scenario.', e, scenario);\n      return null;\n    }\n  }\n\n  public async getTrustedPartyScenarios(\n    trustedPartyId: string\n  ): Promise<{\n    myScenarios: ScenarioSummary[];\n    sharedScenarios: SharedScenario[];\n  }> {\n    const { tp } = await this.lrApollo.query<any>({\n      query: GetTrustedPartyScenariosQuery,\n      variables: { partyId: trustedPartyId },\n    });\n    return {\n      myScenarios: await Promise.all(\n        tp.myScenarios.edges.map((x: any) => this.mapScenarioSummary(x.node))\n      ),\n      sharedScenarios: await Promise.all(\n        tp.sharedScenarios.edges.map((x: any) => this.mapSharedScenario(x.node))\n      ),\n    };\n  }\n\n  public async getScenarioClaims(): Promise<ScenarioClaim[]> {\n    const { scenarios } = await this.lrApollo.query<any>({\n      query: GetAllScenarioClaimsQuery,\n    });\n\n    const claims = await Promise.all<ScenarioClaim[]>(\n      scenarios.edges.map(async (x: any) => {\n        const scenario = await this.mapScenarioSummary(x.node);\n\n        return await Promise.all<ScenarioClaim>(\n          x.node.claims.edges.map(async (y) => ({\n            id: y.node.id,\n            state: y.node.state,\n            triggeredBy: await this.tpService.mapTrustedParty(\n              y.node.claimant.tp\n            ),\n            triggeredOn: y.node.created,\n            lastModified: y.node.modified,\n            scenario,\n          }))\n        );\n      })\n    );\n\n    return claims\n      .reduce((x, y) => [...x, ...y], [])\n      .sort(\n        (x, y) =>\n          -1 *\n          moment(new Date(x.lastModified)).diff(\n            moment(new Date(y.lastModified))\n          )\n      );\n  }\n\n  private async getCipherData(cipher?: {\n    sharedKey: { id: string };\n    sharedCipherData: string;\n  }): Promise<{ event?: string; message?: string }> {\n    if (!cipher) return {};\n\n    return await this.keyGraph.decryptFromString<{\n      event?: string;\n      message?: string;\n    }>(cipher.sharedKey.id, cipher.sharedCipherData);\n  }\n\n  private async getApproverKey(cipher?: {\n    sharedKey: { id: string };\n    sharedCipherPartialAssemblyKey: string;\n  }): Promise<string> {\n    if (!cipher) return null;\n\n    return await this.keyGraph.decryptFromString<string>(\n      cipher.sharedKey.id,\n      cipher.sharedCipherPartialAssemblyKey\n    );\n  }\n\n  public async getScenario(scenarioId: string): Promise<Scenario> {\n    const { scenario } = await this.lrApollo.query<any>({\n      query: GetScenarioQuery,\n      variables: {\n        id: scenarioId,\n        categoryFilter: CategoryFilter,\n        recordFilter: RecordFilter,\n        contentFilter: RecordContentFilter,\n      },\n    });\n    return await this.mapScenario(scenario);\n  }\n\n  private async mapScenario(scenario: any): Promise<Scenario> {\n    const { name, event } = await this.keyGraph.decryptFromString<{\n      event: string;\n      name: string;\n    }>(scenario.subjectKey.id, scenario.subjectCipherData);\n    const claimants = await Promise.all<Claimant>(\n      scenario.claimants.edges.map((x) =>\n        this.scenarioClaimantService.mapClaimant(x.node)\n      )\n    );\n\n    return {\n      id: scenario.id,\n      keyId: scenario.subjectKey.id,\n      assemblyKeyId:\n        scenario.approverAssembly && scenario.approverAssembly.assemblyKey.id,\n      assemblyQuorum:\n        scenario.approverAssembly && scenario.approverAssembly.quorum,\n      name,\n      event,\n      status: scenario.state,\n      claimants,\n      approverGroups: scenario.approverAssembly\n        ? await Promise.all(\n            scenario.approverAssembly.subAssemblies.edges.map((x) =>\n              this.scenarioApproverService.mapApproverGroup(x.node)\n            )\n          )\n        : [],\n      receivers: await Promise.all(\n        scenario.receivers.edges.map((x) =>\n          this.scenarioReceiverService.mapReceiver(x.node)\n        )\n      ),\n      claim: scenario.claim\n        ? {\n            id: scenario.claim.id,\n            status: scenario.claim.state,\n            claimant: claimants.find(\n              (x) => x.id === scenario.claim.claimant.id\n            ),\n          }\n        : null,\n    };\n  }\n\n  public async createScenario(input: CreateScenarioInput): Promise<string> {\n    const rootKey = await this.keyService.getCurrentRootKey();\n\n    const subjectKey = await this.keyFactory.createKey();\n    const rootKeyWrappedSubjectKey = await this.keyGraph.encryptToString(\n      rootKey.jwk,\n      subjectKey.toJSON(true)\n    );\n\n    const subjectCipherData = await this.keyGraph.encryptToString(\n      subjectKey,\n      input.plainSubjectCipherData\n    );\n\n    const { createScenario } = await this.lrApollo.mutate<any>({\n      mutation: CreateScenarioMutation,\n      variables: {\n        input: {\n          rootKeyId: rootKey.id,\n          rootKeyWrappedSubjectKey,\n          subjectCipherData,\n        },\n      },\n    });\n    return createScenario.scenario.id;\n  }\n\n  public async updateScenario(input: UpdateScenarioInput): Promise<void> {\n    await this.lrApollo.mutate<void>({\n      mutation: UpdateScenarioMutation,\n      variables: {\n        input: {\n          scenarioId: input.scenarioId,\n          subjectKeyId: input.keyId,\n          subjectCipherData: await this.keyGraph.encryptToString(\n            input.keyId,\n            input.plainSubjectCipherData\n          ),\n        },\n      },\n    });\n  }\n\n  public async enableScenario(scenarioId: string): Promise<void> {\n    await this.lrApollo.mutate<void>({\n      mutation: EnableScenarioMutation,\n      variables: { input: { scenarioId } },\n    });\n  }\n\n  public async disableScenario(scenarioId: string): Promise<void> {\n    await this.lrApollo.mutate<void>({\n      mutation: DisableScenarioMutation,\n      variables: { input: { scenarioId } },\n    });\n  }\n\n  public async deleteScenario(scenarioId: string): Promise<void> {\n    await this.lrApollo.mutate<void>({\n      mutation: DeleteScenarioMutation,\n      variables: { input: { scenarioId } },\n    });\n  }\n\n  public async createClaim(scenarioId: string): Promise<string> {\n    const res = await this.lrApollo.mutate<any>({\n      mutation: CreateScenarioClaimMutation,\n      variables: { input: { scenarioId } },\n    });\n    return res.createScenarioClaim.sharedClaim.id;\n  }\n\n  public async cancelClaim(claimId: string): Promise<void> {\n    await this.lrApollo.mutate<void>({\n      mutation: CancelScenarioClaimMutation,\n      variables: { input: { claimId } },\n    });\n  }\n\n  public async approveClaim(scenarioId: string, claimId: string) {\n    return this.lrGraphQL.lrMutate(\n      this.approveClaimMutation(scenarioId, claimId)\n    );\n  }\n\n  public async approveClaimMutation(scenarioId: string, claimId: string) {\n    const sharedScenario = await this.getSharedScenario(scenarioId);\n\n    // Double check the claim matches\n    if (sharedScenario.claim.id !== claimId) {\n      throw new LrException({\n        code: LrErrorCode.ReceiveClaimMismatch,\n        message:\n          'claimId does not match with the current claimId of the scenario',\n      });\n    }\n\n    const createMutation = async (asApprover: SharedScenarioClaimApprover) => {\n      return new LrMutation({\n        mutation: ApproveScenarioClaimMutation,\n        variables: {\n          input: {\n            claimId,\n            approverId: asApprover.approverId,\n            receivers: await Promise.all(\n              asApprover.receivers.map(async (y) => ({\n                receiverId: y.id,\n                receiverPbkCipher: await this.keyGraph.encryptToString(\n                  y.pbkId,\n                  { partialAssemblyKey: asApprover.approverKey }\n                ),\n              }))\n            ),\n          },\n        },\n      });\n    };\n\n    const mutations = sharedScenario.claim.asApprovers\n      .filter((asApprover) => asApprover.status === ApproverClaimState.Claimed)\n      .map((asApprover) => createMutation(asApprover));\n\n    return LrMergedMutation.create(await Promise.all(mutations));\n  }\n\n  public async rejectClaim(scenarioId: string, claimId: string) {\n    return this.lrGraphQL.lrMutate(\n      this.rejectClaimMutation(scenarioId, claimId)\n    );\n  }\n\n  public async rejectClaimMutation(scenarioId: string, claimId: string) {\n    const sharedScenario = await this.getSharedScenario(scenarioId);\n\n    // Double check the claim matches\n    if (sharedScenario.claim.id !== claimId) {\n      throw new LrException({\n        code: LrErrorCode.ReceiveClaimMismatch,\n        message:\n          'ClaimId does not match with the current claimId of the scenario',\n      });\n    }\n\n    const createMutation = async (asApprover: SharedScenarioClaimApprover) => {\n      return new LrMutation({\n        mutation: RejectScenarioClaimMutation,\n        variables: { input: { claimId, approverId: asApprover.approverId } },\n      });\n    };\n\n    const mutations = sharedScenario.claim.asApprovers\n      .filter((asApprover) => asApprover.status === ApproverClaimState.Claimed)\n      .map((asApprover) => createMutation(asApprover));\n\n    return LrMergedMutation.create(await Promise.all(mutations));\n  }\n\n  public async receiveClaim(\n    scenarioId: string,\n    claimId: string\n  ): Promise<void> {\n    // Get all the shared items\n    const sharedScenario = await this.getSharedScenario(scenarioId);\n\n    // Double check the claim matches\n    if (sharedScenario.claim.id !== claimId) {\n      throw new LrException({\n        code: LrErrorCode.ReceiveClaimMismatch,\n        message:\n          'ClaimId does not match with the current claimId of the scenario',\n      });\n    }\n    if (sharedScenario.status !== ScenarioState.APPROVED) {\n      throw new LrException({\n        code: LrErrorCode.BadState,\n        message: 'Scenario claim has not been approved',\n      });\n    }\n\n    const assemblyKey = await this.getClaimAssemblyKey(\n      sharedScenario.receiverPbkId,\n      sharedScenario.claim.asReceiver.ciphers\n    );\n\n    // Decrypt all items\n    const receiverDirectories = await Promise.all(\n      sharedScenario.receiverDirectories.map(async (x) => {\n        const wrappedItemKey = assemblyKey\n          ? await this.encryptionService.decrypt(assemblyKey, x.wrappedItemKey)\n          : x.wrappedItemKey;\n\n        return {\n          receiverDirectoryId: x.id,\n          receiverSharedKeyWrappedItemKey: wrappedItemKey, // the wrappedItemKey is already wrapped by receiverSharedKey\n        };\n      })\n    );\n\n    await this.lrApollo.mutate<void>({\n      mutation: ReceiveScenarioClaimMutation,\n      variables: {\n        input: {\n          claimId,\n          receiverDirectories,\n        },\n      },\n    });\n  }\n\n  private async getClaimAssemblyKey(keyId: string, ciphers: string[]) {\n    if (!ciphers || !ciphers.length) return null;\n\n    let assemblyKeyParams: object;\n\n    const shares = await Promise.all(\n      ciphers.map(async (x) => {\n        const { partialAssemblyKey } = await this.keyGraph.decryptFromString<{\n          partialAssemblyKey: PartialAssemblyKey;\n        }>(keyId, x);\n\n        if (assemblyKeyParams) {\n          if (\n            JSON.stringify(assemblyKeyParams) !==\n            JSON.stringify(partialAssemblyKey.assemblyKeyParams)\n          ) {\n            throw new LrException({\n              code: LrErrorCode.BadState,\n              message:\n                'The assembly key parameters are different between the approvals.',\n            });\n          }\n        } else {\n          assemblyKeyParams = partialAssemblyKey.assemblyKeyParams;\n        }\n        return partialAssemblyKey.slip39.share.mnemonics;\n      })\n    );\n\n    const rawAssemblyKey = await this.slip39Service.recoverSecret(\n      shares,\n      ScenarioApproverService.SLIP39_PASSPHRASE\n    );\n\n    return await KFS.asKey({\n      ...assemblyKeyParams,\n      k: rawAssemblyKey,\n    });\n  }\n\n  public async resetScenario(\n    scenarioId: string,\n    disable: boolean = false\n  ): Promise<void> {\n    const prepareReceiverItem = async (\n      itemKeyId: string,\n      sharedKeyId: string,\n      assemblyKey: JWK.Key\n    ): Promise<string> => {\n      const sharedKey = await this.keyGraph.getKey(sharedKeyId);\n      const itemKey = await this.keyGraph.getKey(itemKeyId);\n\n      let wrappedItemKey = await this.keyGraph.encryptToString(\n        sharedKey.jwk,\n        itemKey.jwk.toJSON(true)\n      );\n      if (assemblyKey) {\n        wrappedItemKey = await this.keyGraph.encryptToString(\n          assemblyKey,\n          wrappedItemKey\n        );\n      }\n      return wrappedItemKey;\n    };\n\n    const prepareReceiverDirectories = async (\n      receiver: Receiver,\n      assemblyKey: JWK.Key\n    ) => {\n      return Promise.all([\n        ...receiver.categories.map(async (receiverDirectory) => ({\n          receiverDirectoryId: receiverDirectory.id,\n          wrappedItemKey: await prepareReceiverItem(\n            receiverDirectory.category.keyId,\n            receiver.keyId,\n            assemblyKey\n          ),\n        })),\n        ...receiver.records.map(async (receiverDirectory) => ({\n          receiverDirectoryId: receiverDirectory.id,\n          wrappedItemKey: await prepareReceiverItem(\n            receiverDirectory.record.keyId,\n            receiver.keyId,\n            assemblyKey\n          ),\n        })),\n      ]);\n    };\n\n    const prepareReceivers = async (\n      receivers: Receiver[],\n      assemblyKey: JWK.Key\n    ) => {\n      return Promise.all(\n        receivers.map(async (receiver) => ({\n          receiverId: receiver.id,\n          receiverDirectories: await prepareReceiverDirectories(\n            receiver,\n            assemblyKey\n          ),\n          receiverFiles: [],\n        }))\n      );\n    };\n\n    const prepareApprovers = async (approvers: Approver[]) => {\n      return Promise.all(\n        approvers.map(async (approver) => ({\n          approverId: approver.id,\n          sharedKeyId: approver.keyId,\n        }))\n      );\n    };\n\n    const prepareSubAssemblies = async (\n      subAssemblies: ApprovalGroup[],\n      assemblyKey: JWK.Key\n    ) => {\n      return Promise.all(\n        subAssemblies.map(async (sa) => ({\n          subAssemblyId: sa.id,\n          subAssemblyCipherData: await this.keyGraph.encryptToString(\n            assemblyKey,\n            { name: sa.name }\n          ),\n          approvers: await prepareApprovers(sa.approvers),\n        }))\n      );\n    };\n\n    // ------------------------------------------------------------------------------\n    // ------------------------------------------------------------------------------\n    // ------------------------------------------------------------------------------\n\n    const scenario = await this.getScenario(scenarioId);\n    if (scenario.status !== ScenarioState.APPROVED) {\n      throw new LrException({\n        code: LrErrorCode.BadState,\n        message: `Scenario must be in ${ScenarioState.APPROVED} state`,\n      });\n    }\n\n    const subjectKey = await this.keyGraph.getKey(scenario.keyId);\n    const newAssemblyKey = await this.keyFactory.createKey();\n\n    const input: any = {\n      scenarioId: scenario.id,\n      disable,\n      receivers: await prepareReceivers(scenario.receivers, newAssemblyKey),\n    };\n\n    // Approver assembly\n    const subjectKeyWrappedAssemblyKey = await this.keyGraph.encryptToString(\n      subjectKey.jwk,\n      newAssemblyKey.toJSON(true)\n    );\n\n    input.approverAssembly = {\n      subjectKeyId: subjectKey.id,\n      subjectKeyWrappedAssemblyKey,\n      assemblyCipherData: '',\n      subAssemblies: await prepareSubAssemblies(\n        scenario.approverGroups,\n        newAssemblyKey\n      ),\n    };\n\n    if (scenario.approverGroups.length) {\n      const { k: rawAssemblyKey, ...assemblyKeyParams } = newAssemblyKey.toJSON(\n        true\n      ) as any;\n\n      // Split the keys. If the scenario has been approved and there is an assembly setup, then\n      // that assembly already enough members to meet quorum to approve the claim. So we can assume\n      // that we can always do a key split here.\n      const slipAssembly = new slip.Assembly(scenario.assemblyQuorum);\n\n      scenario.approverGroups.forEach((sa, isa) => {\n        let approverCount = sa.approvers.length;\n        // if quorum is 1, then every approvers in the sub assembly shares the same partial key\n        if (sa.quorum === 1) {\n          approverCount = 1;\n        }\n        slipAssembly.addSubAssembly(\n          new slip.SubAssembly(isa, sa.quorum, approverCount)\n        );\n      });\n\n      await this.slip39Service.generateShares(\n        rawAssemblyKey,\n        ScenarioApproverService.SLIP39_PASSPHRASE,\n        slipAssembly\n      );\n\n      // Copy the partial keys\n      await Promise.all(\n        scenario.approverGroups.map(async (sa, isa) => {\n          const slipSubAssembly = slipAssembly.subAssemblies[isa];\n          const inputSubAssembly = input.approverAssembly.subAssemblies[isa];\n\n          await Promise.all(\n            sa.approvers.map(async (approver, ia) => {\n              const sharedKey = await this.keyGraph.getKey(approver.keyId);\n\n              // if quorum is 1, then every approvers in the sub assembly shares the same partial key\n              const share =\n                sa.quorum === 1\n                  ? slipSubAssembly.shares[0]\n                  : slipSubAssembly.shares[ia];\n\n              const partialAssemblyKey: PartialAssemblyKey = {\n                slip39: {\n                  share,\n                  subAssembly: {\n                    quorum: sa.quorum,\n                    size: sa.approvers.length,\n                  },\n                },\n                assemblyKeyParams,\n              };\n              inputSubAssembly.approvers[\n                ia\n              ].sharedCipherPartialAssemblyKey = await this.keyGraph.encryptToString(\n                sharedKey.jwk,\n                partialAssemblyKey\n              );\n            })\n          );\n        })\n      );\n    }\n    await this.lrApollo.mutate<any>({\n      mutation: ResetScenarioMutation,\n      variables: { input },\n    });\n  }\n\n  public async getAllScenarioIds(): Promise<string[]> {\n    const { scenarios } = await this.lrApollo.query<any>({\n      query: GetAllScenarioIdsQuery,\n    });\n    return scenarios.edges.map((edge) => edge.node.id);\n  }\n}\n"]}