@lifeready/core 1.0.21 → 1.0.23

package/esm2015/lib/time/time.service.js

@@ -0,0 +1,146 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+import { Apollo } from 'apollo-angular';
+import gql from 'graphql-tag';
+import * as moment_ from 'moment';
+import { LrErrorCode, LrException, handleApolloError, } from '../_common/exceptions';
+import * as i0 from "@angular/core";
+import * as i1 from "@aws-amplify/auth/lib-esm/Auth";
+import * as i2 from "apollo-angular";
+// "why?" you ask: https://stackoverflow.com/questions/59735280/angular-8-moment-error-cannot-call-a-namespace-moment
+const moment = moment_;
+export const ServerTimeQuery = gql `
+  query {
+    serverTime {
+      timestamp
+    }
+  }
+`;
+export class TimeService {
+    constructor(auth, apollo) {
+        this.auth = auth;
+        this.apollo = apollo;
+        this.VERIFY_ENABLED = true;
+        this.MAX_DIFF_MSEC = moment
+            .duration({ seconds: 30 })
+            .asMilliseconds();
+        this.offsetMs = null; // Millisecond offset of local clock.
+        this.verified = false; // Verified with independent time source
+    }
+    getAccessToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return (yield this.auth.currentAuthenticatedUser())
+                    .getSignInUserSession()
+                    .getAccessToken()
+                    .getJwtToken();
+            }
+            catch (error) {
+                return ''; // Not authenticated
+            }
+        });
+    }
+    // Get time from independent source to confirm.
+    verifyCognito() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accessToken = yield this.getAccessToken();
+            if (!accessToken) {
+                return;
+            }
+            // Request headers from AWS Amplify Auth lib
+            // accept: */*
+            // accept-encoding: gzip, deflate, br
+            // accept-language: en-GB,en-US;q=0.9,en;q=0.8
+            // cache-control: no-cache
+            // content-length: 1089
+            // content-type: application/x-amz-json-1.1
+            // origin: http://localhost:4200
+            // pragma: no-cache
+            // referer: http://localhost:4200/
+            // sec-fetch-dest: empty
+            // sec-fetch-mode: cors
+            // sec-fetch-site: cross-site
+            // user-agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.132 Safari/537.36
+            // x-amz-target: AWSCognitoIdentityProviderService.GetUser
+            // x-amz-user-agent: aws-amplify/0.1.x js
+            // We are only interested in the Date field.
+            // AZ: I suppose we could use any end-point that provides a reliable Date field in the header. And we don't
+            // need to be authenticated. Even a 400 response would have a Date header. But the worry is that AWS might
+            // think it's some sort of attack, and block the IP or domain. At least in an authenticated call it can't be
+            // seen as illegitimate.
+            const response = yield fetch('https://cognito-idp.ap-southeast-2.amazonaws.com/', {
+                method: 'POST',
+                mode: 'cors',
+                cache: 'no-cache',
+                headers: {
+                    'x-amz-target': 'AWSCognitoIdentityProviderService.GetUser',
+                    'x-amz-user-agent': 'aws-amplify/0.1.x js',
+                    'Content-Type': 'application/x-amz-json-1.1',
+                },
+                // redirect: 'follow', // manual, *follow, error
+                // referrerPolicy: 'no-referrer', // no-referrer, *no-referrer-when-downgrade, origin, origin-when-cross-origin, same-origin, strict-origin, strict-origin-when-cross-origin, unsafe-url
+                body: JSON.stringify({
+                    AccessToken: accessToken,
+                }),
+            });
+            const now = Date.now();
+            const verifyTime = moment(response.headers.get('Date')).valueOf();
+            const serverTime = now + this.offsetMs;
+            const diff = Math.abs(serverTime - verifyTime);
+            if (diff > this.MAX_DIFF_MSEC) {
+                throw new LrException({
+                    code: LrErrorCode.BadTimeSync,
+                    message: `Server time does not match independent source. ServerTime: ${serverTime}, Cognito time: ${verifyTime}`,
+                });
+            }
+            this.verified = true;
+        });
+    }
+    refresh() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const start = Date.now();
+            const res = yield this.apollo
+                .query({ query: ServerTimeQuery })
+                .toPromise();
+            const end = Date.now();
+            handleApolloError(res.errors);
+            const serverTime = parseInt(res.data.serverTime.timestamp, 10);
+            const roundtrip = end - start;
+            this.offsetMs = serverTime - (start + roundtrip / 2);
+            if (this.VERIFY_ENABLED) {
+                yield this.verifyCognito();
+            }
+        });
+    }
+    serverNow() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let needsRefresh = false;
+            // First call
+            if (this.offsetMs === null) {
+                needsRefresh = true;
+            }
+            if (this.VERIFY_ENABLED) {
+                // logged in but not yet verified time matches.
+                if (!this.verified && (yield this.getAccessToken())) {
+                    needsRefresh = true;
+                }
+            }
+            if (needsRefresh) {
+                yield this.refresh();
+            }
+            return Date.now() + this.offsetMs;
+        });
+    }
+}
+TimeService.ɵprov = i0.ɵɵdefineInjectable({ factory: function TimeService_Factory() { return new TimeService(i0.ɵɵinject(i1.AuthClass), i0.ɵɵinject(i2.Apollo)); }, token: TimeService, providedIn: "root" });
+TimeService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+TimeService.ctorParameters = () => [
+    { type: AuthClass },
+    { type: Apollo }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"time.service.js","sourceRoot":"","sources":["../../../../../../projects/core/src/lib/time/time.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';\nimport { Apollo } from 'apollo-angular';\nimport gql from 'graphql-tag';\nimport * as moment_ from 'moment';\nimport {\n  LrErrorCode,\n  LrException,\n  handleApolloError,\n} from '../_common/exceptions';\n// \"why?\" you ask: https://stackoverflow.com/questions/59735280/angular-8-moment-error-cannot-call-a-namespace-moment\nconst moment = moment_;\n\nexport const ServerTimeQuery = gql`\n  query {\n    serverTime {\n      timestamp\n    }\n  }\n`;\n\ninterface ServerTime {\n  timestamp: string;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class TimeService {\n  public VERIFY_ENABLED = true;\n  private readonly MAX_DIFF_MSEC = moment\n    .duration({ seconds: 30 })\n    .asMilliseconds();\n\n  offsetMs: number = null; // Millisecond offset of local clock.\n  verified = false; // Verified with independent time source\n\n  constructor(private auth: AuthClass, private apollo: Apollo) {}\n\n  private async getAccessToken(): Promise<string> {\n    try {\n      return (await this.auth.currentAuthenticatedUser())\n        .getSignInUserSession()\n        .getAccessToken()\n        .getJwtToken();\n    } catch (error) {\n      return ''; // Not authenticated\n    }\n  }\n\n  // Get time from independent source to confirm.\n  private async verifyCognito(): Promise<void> {\n    const accessToken = await this.getAccessToken();\n    if (!accessToken) {\n      return;\n    }\n\n    // Request headers from AWS Amplify Auth lib\n    // accept: */*\n    // accept-encoding: gzip, deflate, br\n    // accept-language: en-GB,en-US;q=0.9,en;q=0.8\n    // cache-control: no-cache\n    // content-length: 1089\n    // content-type: application/x-amz-json-1.1\n    // origin: http://localhost:4200\n    // pragma: no-cache\n    // referer: http://localhost:4200/\n    // sec-fetch-dest: empty\n    // sec-fetch-mode: cors\n    // sec-fetch-site: cross-site\n    // user-agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.132 Safari/537.36\n    // x-amz-target: AWSCognitoIdentityProviderService.GetUser\n    // x-amz-user-agent: aws-amplify/0.1.x js\n\n    // We are only interested in the Date field.\n    // AZ: I suppose we could use any end-point that provides a reliable Date field in the header. And we don't\n    // need to be authenticated. Even a 400 response would have a Date header. But the worry is that AWS might\n    // think it's some sort of attack, and block the IP or domain. At least in an authenticated call it can't be\n    // seen as illegitimate.\n    const response = await fetch(\n      'https://cognito-idp.ap-southeast-2.amazonaws.com/',\n      {\n        method: 'POST', // *GET, POST, PUT, DELETE, etc.\n        mode: 'cors', // no-cors, *cors, same-origin\n        cache: 'no-cache', // *default, no-cache, reload, force-cache, only-if-cached\n        headers: {\n          'x-amz-target': 'AWSCognitoIdentityProviderService.GetUser',\n          'x-amz-user-agent': 'aws-amplify/0.1.x js',\n          'Content-Type': 'application/x-amz-json-1.1',\n        },\n        // redirect: 'follow', // manual, *follow, error\n        // referrerPolicy: 'no-referrer', // no-referrer, *no-referrer-when-downgrade, origin, origin-when-cross-origin, same-origin, strict-origin, strict-origin-when-cross-origin, unsafe-url\n        body: JSON.stringify({\n          AccessToken: accessToken,\n        }), // body data type must match \"Content-Type\" header\n      }\n    );\n\n    const now = Date.now();\n\n    const verifyTime = moment(response.headers.get('Date')).valueOf();\n    const serverTime = now + this.offsetMs;\n    const diff = Math.abs(serverTime - verifyTime);\n\n    if (diff > this.MAX_DIFF_MSEC) {\n      throw new LrException({\n        code: LrErrorCode.BadTimeSync,\n        message: `Server time does not match independent source. ServerTime: ${serverTime}, Cognito time: ${verifyTime}`,\n      });\n    }\n\n    this.verified = true;\n  }\n\n  private async refresh(): Promise<void> {\n    const start = Date.now();\n    const res = await this.apollo\n      .query<{ serverTime: ServerTime }>({ query: ServerTimeQuery })\n      .toPromise();\n    const end = Date.now();\n\n    handleApolloError(res.errors);\n\n    const serverTime = parseInt(res.data.serverTime.timestamp, 10);\n\n    const roundtrip = end - start;\n    this.offsetMs = serverTime - (start + roundtrip / 2);\n\n    if (this.VERIFY_ENABLED) {\n      await this.verifyCognito();\n    }\n  }\n\n  async serverNow(): Promise<number> {\n    let needsRefresh = false;\n\n    // First call\n    if (this.offsetMs === null) {\n      needsRefresh = true;\n    }\n\n    if (this.VERIFY_ENABLED) {\n      // logged in but not yet verified time matches.\n      if (!this.verified && (await this.getAccessToken())) {\n        needsRefresh = true;\n      }\n    }\n\n    if (needsRefresh) {\n      await this.refresh();\n    }\n\n    return Date.now() + this.offsetMs;\n  }\n}\n"]}

package/esm2015/lib/tp-assembly/tp-assembly.js

@@ -0,0 +1,365 @@
+import { __awaiter, __rest } from "tslib";
+import { LrGraphQLService } from '../api/lr-graphql';
+import { mapEdges, } from '../api/types';
+import { EncryptionService } from '../encryption/encryption.service';
+import { KeyFactoryService } from '../key/key-factory.service';
+import { KeyGraphService } from '../key/key-graph.service';
+import { KeyService } from '../key/key.service';
+import * as slip from '../slip39/slip39.service';
+import { LrBadArgumentException, LrBadStateException, } from '../_common/exceptions';
+import { TpsKeysQuery } from './tp-assembly.private.gql';
+export class TpAssemblyController {
+    constructor(injector) {
+        this.keyFactory = injector.get(KeyFactoryService);
+        this.keyService = injector.get(KeyService);
+        this.encryptionService = injector.get(EncryptionService);
+        this.keyGraph = injector.get(KeyGraphService);
+        this.slip39Service = injector.get(slip.Slip39Service);
+        this.lrGraphQl = injector.get(LrGraphQLService);
+    }
+    recoverAssemblyKey(partials) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Every receiverPbkCipher should contain this and they should all be the same.
+            let assemblyKeyParams;
+            const shares = partials.map((partial) => {
+                if (assemblyKeyParams) {
+                    if (JSON.stringify(assemblyKeyParams) !==
+                        JSON.stringify(partial.assemblyKeyParams)) {
+                        throw new LrBadStateException('The assembly key parameters are different between the approvals.');
+                    }
+                }
+                else {
+                    assemblyKeyParams = partial.assemblyKeyParams;
+                }
+                return partial.slip39.share.mnemonics;
+            });
+            const rawAssemblyKey = yield this.slip39Service.recoverSecret(shares, this.slip39Passphrase);
+            return yield KeyFactoryService.asKey(Object.assign(Object.assign({}, assemblyKeyParams), { k: rawAssemblyKey }));
+        });
+    }
+    prepareTpWrappingKey(tp) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.keyGraph.getKey(tp.wrappingKeyId);
+        });
+    }
+    prepareAssembly({ subjectKey, rootKey, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const assemblyKey = yield this.keyFactory.createKey();
+            console.log('prepareAssembly assemblyKey', assemblyKey);
+            const _a = assemblyKey.toJSON(true), { k: rawAssemblyKey } = _a, assemblyKeyParams = __rest(_a, ["k"]);
+            const assemblyKeyVerifierPrk = yield this.keyFactory.createPkcSignKey();
+            const wrappedAssemblyKeyVerifierPrk = yield this.encryptionService.encryptToString(assemblyKey, assemblyKeyVerifierPrk.toJSON(true));
+            const assemblyKeyVerifierPbk = JSON.stringify(assemblyKeyVerifierPrk.toJSON());
+            const subjectKeyWrappedAssemblyKey = yield this.encryptionService.encryptToString(subjectKey, assemblyKey.toJSON(true));
+            // Encrypt the rootKey with the assemblyKey
+            const assemblyCipherData = yield this.encryptionService.encryptToString(assemblyKey, {
+                rootKey: rootKey.toJSON(true),
+            });
+            return {
+                assemblyKey,
+                rawAssemblyKey,
+                assemblyKeyParams,
+                subjectKeyWrappedAssemblyKey,
+                assemblyCipherData,
+                assemblyKeyVerifierPbk,
+                wrappedAssemblyKeyVerifierPrk,
+            };
+        });
+    }
+    prepareCreateSubAssemblies({ input, subjectKey, slipSubAssemblies, assemblyKeyParams, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.all(input.map((sa, saIndex) => __awaiter(this, void 0, void 0, function* () {
+                const subjectCipherData = yield this.encryptionService.encryptToString(subjectKey, sa.subjectCipherDataClearJson || '');
+                const createApprovers = yield Promise.all(sa.approverTps.map((approverTp, approverIndex) => __awaiter(this, void 0, void 0, function* () {
+                    return this.prepareApprover({
+                        tp: approverTp,
+                        approverIndex,
+                        slipSubAssembly: slipSubAssemblies[saIndex],
+                        assemblyKeyParams,
+                        subjectKey,
+                    });
+                })));
+                return {
+                    singleReject: sa.singleReject,
+                    quorum: sa.quorum,
+                    subjectCipherData,
+                    createApprovers,
+                };
+            })));
+        });
+    }
+    prepareUpdateSubAssemblies({ input, subjectKey, slipSubAssemblies, assemblyKeyParams, subAssemblies, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (slipSubAssemblies.length !== input.length) {
+                throw new LrBadArgumentException('The slipSubAssemblies must be the same length as the input');
+            }
+            return Promise.all(input.map((sa, saIndex) => __awaiter(this, void 0, void 0, function* () {
+                const subjectCipherData = yield this.encryptionService.encryptToString(subjectKey, sa.subjectCipherDataClearJson || '');
+                // Get the existing sub-assembly
+                const existingSa = subAssemblies.edges.find((edge) => edge.node.id === sa.id).node;
+                // Get approvers that do not exist yet
+                const createApprovers = [];
+                const updateApprovers = [];
+                sa.approverTps.forEach((tp) => {
+                    var _a;
+                    const approver = (_a = existingSa.approvers.edges.find((edge) => edge.node.tp.id === tp.tpId)) === null || _a === void 0 ? void 0 : _a.node;
+                    if (approver) {
+                        updateApprovers.push({
+                            tp,
+                            approverId: approver.id,
+                        });
+                    }
+                    else {
+                        createApprovers.push({
+                            tp,
+                        });
+                    }
+                });
+                const slipSubAssembly = slipSubAssemblies[saIndex];
+                return {
+                    subAssemblyId: sa.id,
+                    singleReject: sa.singleReject,
+                    quorum: sa.quorum,
+                    subjectCipherData,
+                    createApprovers: yield Promise.all(createApprovers.map(({ tp }, approverIndex) => __awaiter(this, void 0, void 0, function* () {
+                        return this.prepareApprover({
+                            tp,
+                            approverIndex,
+                            slipSubAssembly,
+                            assemblyKeyParams,
+                            subjectKey,
+                        });
+                    }))),
+                    updateApprovers: yield Promise.all(updateApprovers.map(({ tp, approverId }, approverIndex) => __awaiter(this, void 0, void 0, function* () {
+                        return this.prepareApprover({
+                            approverId,
+                            tp,
+                            approverIndex: approverIndex + createApprovers.length,
+                            slipSubAssembly,
+                            assemblyKeyParams,
+                            subjectKey,
+                        });
+                    }))),
+                };
+            })));
+        });
+    }
+    fillWrappingKeyId(input, tps) {
+        // Fill in wrappingKeyId if not present
+        input.forEach((sa) => {
+            sa.approverTps.forEach((approver) => {
+                if (!approver.wrappingKeyId) {
+                    const tp = tps.find((x) => x.id === approver.tpId);
+                    approver.wrappingKeyId = this.getTpWrappingKeyId(tp);
+                }
+            });
+        });
+    }
+    getInputApprovers(input) {
+        const tpIds = [];
+        input.forEach((sa) => {
+            sa.approverTps.forEach((approver) => {
+                tpIds.push(approver.tpId);
+            });
+        });
+        return tpIds;
+    }
+    prepareCreate(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.wrapKey(rootKey, subjectKey);
+            const _a = yield this.prepareAssembly({
+                rootKey: rootKey.jwk,
+                subjectKey,
+            }), { assemblyKey, rawAssemblyKey, assemblyKeyParams } = _a, assemblyInput = __rest(_a, ["assemblyKey", "rawAssemblyKey", "assemblyKeyParams"]);
+            const slipAssembly = yield this.prepareSlip39(input.createSubAssemblies, input.quorum, rawAssemblyKey);
+            const tpIds = this.getInputApprovers(input.createSubAssemblies);
+            // This should contain all the TPs that we need to update the assembly.
+            const tps = mapEdges((yield this.lrGraphQl.query({
+                query: TpsKeysQuery,
+                variables: {
+                    ids: tpIds,
+                },
+            })).tps);
+            // Fill in wrappingKeyId if not present
+            this.fillWrappingKeyId(input.createSubAssemblies, tps);
+            const createSubAssemblies = yield this.prepareCreateSubAssemblies({
+                input: input.createSubAssemblies,
+                assemblyKeyParams,
+                slipSubAssemblies: slipAssembly.subAssemblies,
+                subjectKey,
+            });
+            const subjectCipherData = yield this.encryptionService.encryptToString(subjectKey, input.subjectCipherDataClearJson || '');
+            return {
+                assemblyKey,
+                mutationInput: Object.assign(Object.assign({}, assemblyInput), { singleReject: input.singleReject, quorum: input.quorum, subjectCipherData,
+                    createSubAssemblies, rootKeyId: rootKey.id, rootKeyWrappedSubjectKey }),
+            };
+        });
+    }
+    getAssemblyApprovers(assembly) {
+        const tpIds = [];
+        // Find all TPs that belong to sub-assemblies
+        mapEdges(assembly.subAssemblies).map((sa) => {
+            mapEdges(sa.approvers).forEach((approver) => tpIds.push(approver.tp.id));
+        });
+        return tpIds;
+    }
+    prepareUpdate(input, assembly // TODO type this to only what we need.
+    ) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            input = Object.assign({ createSubAssemblies: [] }, input);
+            const createSubAssembliesInput = input.createSubAssemblies || [];
+            const updateSubAssembliesInput = input.updateSubAssemblies || [];
+            const deleteSubAssembliesInput = input.deleteSubAssemblies || [];
+            // Must have at least one.
+            if (createSubAssembliesInput.length === 0 &&
+                updateSubAssembliesInput.length === 0 &&
+                deleteSubAssembliesInput.length === 0) {
+                throw new LrBadArgumentException('Must specify at least one of: [createSubAssemblies, updateSubAssemblies, deleteSubAssemblies]');
+            }
+            const rootKey = yield this.keyService.getCurrentRootKey();
+            const subjectKey = yield this.keyGraph.getKey(assembly.subjectKey.id);
+            const _b = yield this.prepareAssembly({
+                rootKey: rootKey.jwk,
+                subjectKey: subjectKey.jwk,
+            }), { assemblyKey, rawAssemblyKey, assemblyKeyParams } = _b, assemblyInput = __rest(_b, ["assemblyKey", "rawAssemblyKey", "assemblyKeyParams"]);
+            // Find all the TPs that we need, duplicates are no problem.
+            // Existing approvers
+            const tpIds = this.getAssemblyApprovers(assembly).concat(this.getInputApprovers(createSubAssembliesInput), this.getInputApprovers(updateSubAssembliesInput));
+            // This should contain all the TPs that we need to update the assembly.
+            const tps = mapEdges((yield this.lrGraphQl.query({
+                query: TpsKeysQuery,
+                variables: {
+                    ids: tpIds,
+                },
+            })).tps);
+            // Auto fill the updateSubAssemblies with existing sub assemblies if they are not
+            // explicitly deleted.
+            mapEdges(assembly.subAssemblies).forEach((existing) => {
+                // Deleting existing, don't include it
+                if (deleteSubAssembliesInput.includes(existing.id)) {
+                    return;
+                }
+                // Update already specified in the input
+                if (updateSubAssembliesInput.some((sa) => sa.id === existing.id)) {
+                    return;
+                }
+                const approverTps = mapEdges(existing.approvers).map((approver) => {
+                    return {
+                        tpId: approver.tp.id,
+                        sharedCipherDataClearJson: approver.sharedCipherDataClearJson,
+                        sharedCipherApprovalDataClearJson: approver.sharedCipherApprovalDataClearJson,
+                    };
+                });
+                updateSubAssembliesInput.push({
+                    id: existing.id,
+                    quorum: existing.quorum,
+                    singleReject: existing.singleReject,
+                    approverTps,
+                    subjectCipherDataClearJson: existing.subjectCipherDataClearJson,
+                });
+            });
+            // Fill in wrappingKeyId if not present
+            this.fillWrappingKeyId(createSubAssembliesInput, tps);
+            this.fillWrappingKeyId(updateSubAssembliesInput, tps);
+            let slipAssembly;
+            try {
+                slipAssembly = yield this.prepareSlip39((createSubAssembliesInput || []).concat(updateSubAssembliesInput || []), input.quorum, rawAssemblyKey);
+            }
+            catch (error) {
+                // TODO this sometimes happens. Maybe missing await.
+                console.log('Error while creating slip assembly', error);
+            }
+            const common = {
+                assemblyKeyParams,
+                subjectKey: subjectKey.jwk,
+            };
+            const createSubAssemblies = yield this.prepareCreateSubAssemblies(Object.assign(Object.assign({}, common), { input: createSubAssembliesInput, 
+                // Need to match the slip sub assemblies to the input
+                slipSubAssemblies: slipAssembly.subAssemblies.slice(0, createSubAssembliesInput.length) }));
+            const updateSubAssemblies = yield this.prepareUpdateSubAssemblies(Object.assign(Object.assign({}, common), { input: updateSubAssembliesInput, 
+                // Add an offset to the sub assemblies to skip the one that are created.
+                slipSubAssemblies: slipAssembly.subAssemblies.slice(createSubAssembliesInput.length), subAssemblies: assembly.subAssemblies }));
+            const subjectCipherData = yield this.encryptionService.encryptToString(subjectKey.jwk, (_a = input.subjectCipherDataClearJson) !== null && _a !== void 0 ? _a : assembly.subjectCipherDataClearJson);
+            return {
+                assemblyKey,
+                mutationInput: Object.assign(Object.assign({}, assemblyInput), { singleReject: input.singleReject, quorum: input.quorum, subjectCipherData, subjectKeyId: subjectKey.id, createSubAssemblies,
+                    updateSubAssemblies }),
+            };
+        });
+    }
+    prepareApprover({ approverId, tp, approverIndex, slipSubAssembly, assemblyKeyParams, subjectKey, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tpWrappingKey = yield this.prepareTpWrappingKey(tp);
+            // shared key is rotated every time.
+            const sharedKey = yield this.keyFactory.createKey();
+            // For TP to access shared_key
+            const tpWrappedSharedKey = yield this.encryptionService.encryptToString(tpWrappingKey.jwk, sharedKey.toJSON(true));
+            // For subject to access shared_key
+            const subjectKeyWrappedSharedKey = yield this.encryptionService.encryptToString(subjectKey, sharedKey.toJSON(true));
+            // If quorum is 1, then using the same share for every member.
+            const share = slipSubAssembly.threshold === 1
+                ? slipSubAssembly.shares[0]
+                : slipSubAssembly.shares[approverIndex];
+            const partialAssemblyKey = {
+                slip39: {
+                    share,
+                    subAssembly: {
+                        quorum: slipSubAssembly.threshold,
+                        size: slipSubAssembly.size,
+                    },
+                },
+                assemblyKeyParams,
+            };
+            console.log('partialAssemblyKey', partialAssemblyKey);
+            const sharedCipherData = yield this.encryptionService.encryptToString(sharedKey, tp.sharedCipherDataClearJson || '');
+            const sharedCipherApprovalData = yield this.encryptionService.encryptToString(sharedKey, tp.sharedCipherApprovalDataClearJson || '');
+            const sharedCipherPartialAssemblyKey = yield this.encryptionService.encryptToString(sharedKey, partialAssemblyKey);
+            return {
+                tpWrappingKeyId: tpWrappingKey.id,
+                tpWrappedSharedKey,
+                subjectKeyWrappedSharedKey,
+                sharedCipherData,
+                sharedCipherApprovalData,
+                sharedCipherPartialAssemblyKey,
+                approverId: approverId || void 0,
+                tpId: approverId ? void 0 : tp.tpId,
+            };
+        });
+    }
+    validateApprovers(approvers) {
+        // Ensure all approvers have mkSharedKey.
+        for (const tp of approvers) {
+            if (!tp.currentUserSharedKey.userSharedKey.mkSharedKey) {
+                const msg = `tp ${tp.other.username} does not have mkSharedKey`;
+                console.log(msg);
+                throw new LrBadArgumentException(msg);
+            }
+        }
+    }
+    // Prepare slip39
+    prepareSlip39(subAssemblies, assemblyQuorum, rawAssemblyKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Is there enough sub assemblies to meet quorum
+            if (subAssemblies.length < assemblyQuorum) {
+                throw new LrBadArgumentException('Not enough sub assemblies to meet quorum');
+            }
+            const slipAssembly = new slip.Assembly(assemblyQuorum);
+            subAssemblies.forEach((sa, index) => {
+                let approverCount = sa.approverTps.length;
+                // slip39 restricts quorum == 1 to have only 1 member. So we just share the same
+                // partial key for all sub assembly members.
+                if (sa.quorum === 1) {
+                    approverCount = 1;
+                }
+                slipAssembly.addSubAssembly(new slip.SubAssembly(index, sa.quorum, approverCount));
+            });
+            yield this.slip39Service.generateShares(rawAssemblyKey, this.slip39Passphrase, slipAssembly);
+            return slipAssembly;
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tp-assembly.js","sourceRoot":"","sources":["../../../../../../projects/core/src/lib/tp-assembly/tp-assembly.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injector } from '@angular/core';\nimport { JWK } from 'node-jose';\nimport { LrGraphQLService } from '../api/lr-graphql';\nimport {\n  Connection,\n  JSONObject,\n  mapEdges,\n  TpAssemblyNode,\n  TpNode,\n  TpSubAssemblyNode,\n} from '../api/types';\nimport { EncryptionService } from '../encryption/encryption.service';\nimport { KeyFactoryService } from '../key/key-factory.service';\nimport { KeyGraphService } from '../key/key-graph.service';\nimport { KeyService } from '../key/key.service';\nimport { Key } from '../key/key.types';\nimport * as slip from '../slip39/slip39.service';\nimport {\n  LrBadArgumentException,\n  LrBadStateException,\n} from '../_common/exceptions';\nimport { TpsKeysQuery } from './tp-assembly.private.gql';\nimport {\n  CreateTpAssemblyInput,\n  CreateTpSubAssemblyInput,\n  PartialAssemblyKey,\n  TpAssemblyApproverInput,\n  UpdateTpAssemblyInput,\n  UpdateTpSubAssemblyInput,\n} from './tp-assembly.types';\n\nexport abstract class TpAssemblyController {\n  abstract slip39Passphrase: string;\n\n  protected keyFactory: KeyFactoryService;\n  protected keyService: KeyService;\n  protected encryptionService: EncryptionService;\n  protected keyGraph: KeyGraphService;\n  protected slip39Service: slip.Slip39Service;\n  protected lrGraphQl: LrGraphQLService;\n\n  constructor(injector: Injector) {\n    this.keyFactory = injector.get(KeyFactoryService);\n    this.keyService = injector.get(KeyService);\n    this.encryptionService = injector.get(EncryptionService);\n    this.keyGraph = injector.get(KeyGraphService);\n    this.slip39Service = injector.get(slip.Slip39Service);\n    this.lrGraphQl = injector.get(LrGraphQLService);\n  }\n\n  abstract getTpWrappingKeyId(tp: TpNode): string;\n\n  async recoverAssemblyKey(partials: PartialAssemblyKey[]) {\n    // Every receiverPbkCipher should contain this and they should all be the same.\n    let assemblyKeyParams: Record<string, JSONObject>;\n\n    const shares = partials.map((partial) => {\n      if (assemblyKeyParams) {\n        if (\n          JSON.stringify(assemblyKeyParams) !==\n          JSON.stringify(partial.assemblyKeyParams)\n        ) {\n          throw new LrBadStateException(\n            'The assembly key parameters are different between the approvals.'\n          );\n        }\n      } else {\n        assemblyKeyParams = partial.assemblyKeyParams;\n      }\n      return partial.slip39.share.mnemonics;\n    });\n\n    const rawAssemblyKey = await this.slip39Service.recoverSecret(\n      shares,\n      this.slip39Passphrase\n    );\n\n    return await KeyFactoryService.asKey({\n      ...assemblyKeyParams,\n      k: rawAssemblyKey,\n    });\n  }\n\n  protected async prepareTpWrappingKey(\n    tp: TpAssemblyApproverInput\n  ): Promise<Key> {\n    return this.keyGraph.getKey(tp.wrappingKeyId);\n  }\n\n  protected async prepareAssembly({\n    subjectKey,\n    rootKey,\n  }: {\n    subjectKey: JWK.Key;\n    rootKey: JWK.Key;\n  }) {\n    const assemblyKey = await this.keyFactory.createKey();\n    console.log('prepareAssembly assemblyKey', assemblyKey);\n\n    const { k: rawAssemblyKey, ...assemblyKeyParams } = assemblyKey.toJSON(\n      true\n    ) as JSONObject;\n    const assemblyKeyVerifierPrk = await this.keyFactory.createPkcSignKey();\n    const wrappedAssemblyKeyVerifierPrk =\n      await this.encryptionService.encryptToString(\n        assemblyKey,\n        assemblyKeyVerifierPrk.toJSON(true)\n      );\n    const assemblyKeyVerifierPbk = JSON.stringify(\n      assemblyKeyVerifierPrk.toJSON()\n    );\n\n    const subjectKeyWrappedAssemblyKey =\n      await this.encryptionService.encryptToString(\n        subjectKey,\n        assemblyKey.toJSON(true)\n      );\n\n    // Encrypt the rootKey with the assemblyKey\n    const assemblyCipherData = await this.encryptionService.encryptToString(\n      assemblyKey,\n      {\n        rootKey: rootKey.toJSON(true),\n      }\n    );\n\n    return {\n      assemblyKey,\n      rawAssemblyKey,\n      assemblyKeyParams,\n      subjectKeyWrappedAssemblyKey,\n      assemblyCipherData,\n      assemblyKeyVerifierPbk,\n      wrappedAssemblyKeyVerifierPrk,\n    };\n  }\n\n  protected async prepareCreateSubAssemblies({\n    input,\n    subjectKey,\n    slipSubAssemblies,\n    assemblyKeyParams,\n  }: {\n    input: CreateTpSubAssemblyInput[];\n    subjectKey: JWK.Key;\n    slipSubAssemblies: slip.SubAssembly[];\n    assemblyKeyParams; // TODO type this\n  }) {\n    return Promise.all(\n      input.map(async (sa, saIndex) => {\n        const subjectCipherData = await this.encryptionService.encryptToString(\n          subjectKey,\n          sa.subjectCipherDataClearJson || ''\n        );\n\n        const createApprovers = await Promise.all(\n          sa.approverTps.map(async (approverTp, approverIndex) =>\n            this.prepareApprover({\n              tp: approverTp,\n              approverIndex,\n              slipSubAssembly: slipSubAssemblies[saIndex],\n              assemblyKeyParams,\n              subjectKey,\n            })\n          )\n        );\n\n        return {\n          singleReject: sa.singleReject,\n          quorum: sa.quorum,\n          subjectCipherData,\n          createApprovers,\n        };\n      })\n    );\n  }\n\n  protected async prepareUpdateSubAssemblies({\n    input,\n    subjectKey,\n    slipSubAssemblies,\n    assemblyKeyParams,\n    subAssemblies,\n  }: {\n    input: UpdateTpSubAssemblyInput[];\n    subjectKey: JWK.Key;\n    slipSubAssemblies: slip.SubAssembly[];\n    assemblyKeyParams; // TODO type this\n    subAssemblies: Connection<TpSubAssemblyNode>;\n  }) {\n    if (slipSubAssemblies.length !== input.length) {\n      throw new LrBadArgumentException(\n        'The slipSubAssemblies must be the same length as the input'\n      );\n    }\n\n    return Promise.all(\n      input.map(async (sa, saIndex) => {\n        const subjectCipherData = await this.encryptionService.encryptToString(\n          subjectKey,\n          sa.subjectCipherDataClearJson || ''\n        );\n\n        // Get the existing sub-assembly\n        const existingSa = subAssemblies.edges.find(\n          (edge) => edge.node.id === sa.id\n        ).node;\n\n        // Get approvers that do not exist yet\n        const createApprovers = [];\n        const updateApprovers = [];\n\n        sa.approverTps.forEach((tp) => {\n          const approver = existingSa.approvers.edges.find(\n            (edge) => edge.node.tp.id === tp.tpId\n          )?.node;\n          if (approver) {\n            updateApprovers.push({\n              tp,\n              approverId: approver.id,\n            });\n          } else {\n            createApprovers.push({\n              tp,\n            });\n          }\n        });\n\n        const slipSubAssembly = slipSubAssemblies[saIndex];\n\n        return {\n          subAssemblyId: sa.id,\n          singleReject: sa.singleReject,\n          quorum: sa.quorum,\n          subjectCipherData,\n          createApprovers: await Promise.all(\n            createApprovers.map(async ({ tp }, approverIndex) =>\n              this.prepareApprover({\n                tp,\n                approverIndex,\n                slipSubAssembly,\n                assemblyKeyParams,\n                subjectKey,\n              })\n            )\n          ),\n          updateApprovers: await Promise.all(\n            updateApprovers.map(async ({ tp, approverId }, approverIndex) =>\n              this.prepareApprover({\n                approverId,\n                tp,\n                approverIndex: approverIndex + createApprovers.length,\n                slipSubAssembly,\n                assemblyKeyParams,\n                subjectKey,\n              })\n            )\n          ),\n        };\n      })\n    );\n  }\n\n  private fillWrappingKeyId(input: CreateTpSubAssemblyInput[], tps: TpNode[]) {\n    // Fill in wrappingKeyId if not present\n    input.forEach((sa) => {\n      sa.approverTps.forEach((approver) => {\n        if (!approver.wrappingKeyId) {\n          const tp = tps.find((x) => x.id === approver.tpId);\n          approver.wrappingKeyId = this.getTpWrappingKeyId(tp);\n        }\n      });\n    });\n  }\n\n  private getInputApprovers(input: CreateTpSubAssemblyInput[]) {\n    const tpIds: string[] = [];\n    input.forEach((sa) => {\n      sa.approverTps.forEach((approver) => {\n        tpIds.push(approver.tpId);\n      });\n    });\n    return tpIds;\n  }\n\n  public async prepareCreate(input: CreateTpAssemblyInput) {\n    const rootKey = await this.keyService.getCurrentRootKey();\n    const subjectKey = await this.keyFactory.createKey();\n    const rootKeyWrappedSubjectKey = await this.keyGraph.wrapKey(\n      rootKey,\n      subjectKey\n    );\n\n    const { assemblyKey, rawAssemblyKey, assemblyKeyParams, ...assemblyInput } =\n      await this.prepareAssembly({\n        rootKey: rootKey.jwk,\n        subjectKey,\n      });\n\n    const slipAssembly = await this.prepareSlip39(\n      input.createSubAssemblies,\n      input.quorum,\n      rawAssemblyKey\n    );\n\n    const tpIds = this.getInputApprovers(input.createSubAssemblies);\n\n    // This should contain all the TPs that we need to update the assembly.\n    const tps = mapEdges(\n      (\n        await this.lrGraphQl.query({\n          query: TpsKeysQuery,\n          variables: {\n            ids: tpIds,\n          },\n        })\n      ).tps\n    );\n\n    // Fill in wrappingKeyId if not present\n    this.fillWrappingKeyId(input.createSubAssemblies, tps);\n\n    const createSubAssemblies = await this.prepareCreateSubAssemblies({\n      input: input.createSubAssemblies,\n      assemblyKeyParams,\n      slipSubAssemblies: slipAssembly.subAssemblies,\n      subjectKey,\n    });\n\n    const subjectCipherData = await this.encryptionService.encryptToString(\n      subjectKey,\n      input.subjectCipherDataClearJson || ''\n    );\n\n    return {\n      assemblyKey,\n      mutationInput: {\n        ...assemblyInput,\n        singleReject: input.singleReject,\n        quorum: input.quorum,\n        subjectCipherData,\n        createSubAssemblies,\n        rootKeyId: rootKey.id,\n        rootKeyWrappedSubjectKey,\n      },\n    };\n  }\n\n  private getAssemblyApprovers(assembly: TpAssemblyNode) {\n    const tpIds: string[] = [];\n\n    // Find all TPs that belong to sub-assemblies\n    mapEdges(assembly.subAssemblies).map((sa) => {\n      mapEdges(sa.approvers).forEach((approver) => tpIds.push(approver.tp.id));\n    });\n\n    return tpIds;\n  }\n\n  public async prepareUpdate(\n    input: UpdateTpAssemblyInput,\n    assembly: TpAssemblyNode // TODO type this to only what we need.\n  ) {\n    input = {\n      createSubAssemblies: [],\n      ...input,\n    };\n\n    const createSubAssembliesInput = input.createSubAssemblies || [];\n    const updateSubAssembliesInput = input.updateSubAssemblies || [];\n    const deleteSubAssembliesInput = input.deleteSubAssemblies || [];\n\n    // Must have at least one.\n    if (\n      createSubAssembliesInput.length === 0 &&\n      updateSubAssembliesInput.length === 0 &&\n      deleteSubAssembliesInput.length === 0\n    ) {\n      throw new LrBadArgumentException(\n        'Must specify at least one of: [createSubAssemblies, updateSubAssemblies, deleteSubAssemblies]'\n      );\n    }\n\n    const rootKey = await this.keyService.getCurrentRootKey();\n    const subjectKey = await this.keyGraph.getKey(assembly.subjectKey.id);\n\n    const { assemblyKey, rawAssemblyKey, assemblyKeyParams, ...assemblyInput } =\n      await this.prepareAssembly({\n        rootKey: rootKey.jwk,\n        subjectKey: subjectKey.jwk,\n      });\n\n    // Find all the TPs that we need, duplicates are no problem.\n    // Existing approvers\n    const tpIds = this.getAssemblyApprovers(assembly).concat(\n      this.getInputApprovers(createSubAssembliesInput),\n      this.getInputApprovers(updateSubAssembliesInput)\n    );\n\n    // This should contain all the TPs that we need to update the assembly.\n    const tps = mapEdges(\n      (\n        await this.lrGraphQl.query({\n          query: TpsKeysQuery,\n          variables: {\n            ids: tpIds,\n          },\n        })\n      ).tps\n    );\n\n    // Auto fill the updateSubAssemblies with existing sub assemblies if they are not\n    // explicitly deleted.\n    mapEdges(assembly.subAssemblies).forEach((existing) => {\n      // Deleting existing, don't include it\n      if (deleteSubAssembliesInput.includes(existing.id)) {\n        return;\n      }\n\n      // Update already specified in the input\n      if (updateSubAssembliesInput.some((sa) => sa.id === existing.id)) {\n        return;\n      }\n\n      const approverTps: TpAssemblyApproverInput[] = mapEdges(\n        existing.approvers\n      ).map((approver) => {\n        return {\n          tpId: approver.tp.id,\n          sharedCipherDataClearJson: approver.sharedCipherDataClearJson,\n          sharedCipherApprovalDataClearJson:\n            approver.sharedCipherApprovalDataClearJson,\n        };\n      });\n\n      updateSubAssembliesInput.push({\n        id: existing.id,\n        quorum: existing.quorum,\n        singleReject: existing.singleReject,\n        approverTps,\n        subjectCipherDataClearJson: existing.subjectCipherDataClearJson,\n      });\n    });\n\n    // Fill in wrappingKeyId if not present\n    this.fillWrappingKeyId(createSubAssembliesInput, tps);\n    this.fillWrappingKeyId(updateSubAssembliesInput, tps);\n\n    let slipAssembly;\n    try {\n      slipAssembly = await this.prepareSlip39(\n        (createSubAssembliesInput || []).concat(updateSubAssembliesInput || []),\n        input.quorum,\n        rawAssemblyKey\n      );\n    } catch (error) {\n      // TODO this sometimes happens. Maybe missing await.\n      console.log('Error while creating slip assembly', error);\n    }\n\n    const common = {\n      assemblyKeyParams,\n      subjectKey: subjectKey.jwk,\n    };\n\n    const createSubAssemblies = await this.prepareCreateSubAssemblies({\n      ...common,\n      input: createSubAssembliesInput,\n      // Need to match the slip sub assemblies to the input\n      slipSubAssemblies: slipAssembly.subAssemblies.slice(\n        0,\n        createSubAssembliesInput.length\n      ),\n    });\n\n    const updateSubAssemblies = await this.prepareUpdateSubAssemblies({\n      ...common,\n      input: updateSubAssembliesInput,\n      // Add an offset to the sub assemblies to skip the one that are created.\n      slipSubAssemblies: slipAssembly.subAssemblies.slice(\n        createSubAssembliesInput.length\n      ),\n      subAssemblies: assembly.subAssemblies,\n    });\n\n    const subjectCipherData = await this.encryptionService.encryptToString(\n      subjectKey.jwk,\n      input.subjectCipherDataClearJson ?? assembly.subjectCipherDataClearJson\n    );\n\n    return {\n      assemblyKey,\n      mutationInput: {\n        ...assemblyInput,\n        singleReject: input.singleReject,\n        quorum: input.quorum,\n        subjectCipherData,\n        subjectKeyId: subjectKey.id,\n        createSubAssemblies,\n        updateSubAssemblies,\n      },\n    };\n  }\n\n  private async prepareApprover({\n    approverId,\n    tp,\n    approverIndex,\n    slipSubAssembly,\n    assemblyKeyParams,\n    subjectKey,\n  }: {\n    approverId?: string; // Given if updating existing approver\n    tp: TpAssemblyApproverInput;\n    approverIndex: number;\n    slipSubAssembly: slip.SubAssembly;\n    assemblyKeyParams: Record<string, JSONObject>;\n    subjectKey: JWK.Key;\n  }) {\n    const tpWrappingKey = await this.prepareTpWrappingKey(tp);\n    // shared key is rotated every time.\n    const sharedKey = await this.keyFactory.createKey();\n\n    // For TP to access shared_key\n    const tpWrappedSharedKey = await this.encryptionService.encryptToString(\n      tpWrappingKey.jwk,\n      sharedKey.toJSON(true)\n    );\n    // For subject to access shared_key\n    const subjectKeyWrappedSharedKey =\n      await this.encryptionService.encryptToString(\n        subjectKey,\n        sharedKey.toJSON(true)\n      );\n\n    // If quorum is 1, then using the same share for every member.\n    const share =\n      slipSubAssembly.threshold === 1\n        ? slipSubAssembly.shares[0]\n        : slipSubAssembly.shares[approverIndex];\n\n    const partialAssemblyKey: PartialAssemblyKey = {\n      slip39: {\n        share,\n        subAssembly: {\n          quorum: slipSubAssembly.threshold,\n          size: slipSubAssembly.size,\n        },\n      },\n      assemblyKeyParams,\n    };\n\n    console.log('partialAssemblyKey', partialAssemblyKey);\n\n    const sharedCipherData = await this.encryptionService.encryptToString(\n      sharedKey,\n      tp.sharedCipherDataClearJson || ''\n    );\n\n    const sharedCipherApprovalData =\n      await this.encryptionService.encryptToString(\n        sharedKey,\n        tp.sharedCipherApprovalDataClearJson || ''\n      );\n\n    const sharedCipherPartialAssemblyKey =\n      await this.encryptionService.encryptToString(\n        sharedKey,\n        partialAssemblyKey\n      );\n\n    return {\n      tpWrappingKeyId: tpWrappingKey.id,\n      tpWrappedSharedKey,\n      subjectKeyWrappedSharedKey,\n      sharedCipherData,\n      sharedCipherApprovalData,\n      sharedCipherPartialAssemblyKey,\n      approverId: approverId || void 0, // If existing approver\n      tpId: approverId ? void 0 : tp.tpId, // else adding new TP\n    };\n  }\n\n  validateApprovers(approvers: TpNode[]): void {\n    // Ensure all approvers have mkSharedKey.\n    for (const tp of approvers) {\n      if (!tp.currentUserSharedKey.userSharedKey.mkSharedKey) {\n        const msg = `tp ${tp.other.username} does not have mkSharedKey`;\n        console.log(msg);\n        throw new LrBadArgumentException(msg);\n      }\n    }\n  }\n\n  // Prepare slip39\n  protected async prepareSlip39(\n    subAssemblies,\n    assemblyQuorum: number,\n    rawAssemblyKey: string\n  ): Promise<slip.Assembly> {\n    // Is there enough sub assemblies to meet quorum\n    if (subAssemblies.length < assemblyQuorum) {\n      throw new LrBadArgumentException(\n        'Not enough sub assemblies to meet quorum'\n      );\n    }\n\n    const slipAssembly = new slip.Assembly(assemblyQuorum);\n\n    subAssemblies.forEach((sa, index) => {\n      let approverCount = sa.approverTps.length;\n\n      // slip39 restricts quorum == 1 to have only 1 member. So we just share the same\n      // partial key for all sub assembly members.\n      if (sa.quorum === 1) {\n        approverCount = 1;\n      }\n      slipAssembly.addSubAssembly(\n        new slip.SubAssembly(index, sa.quorum, approverCount)\n      );\n    });\n\n    await this.slip39Service.generateShares(\n      rawAssemblyKey,\n      this.slip39Passphrase,\n      slipAssembly\n    );\n    return slipAssembly;\n  }\n}\n"]}

package/esm2015/lib/tp-assembly/tp-assembly.private.gql.js

@@ -0,0 +1,22 @@
+import { gqlTyped } from '../_common/ast';
+export const TpsKeysQuery = gqlTyped `
+query TpsKeysQuery($ids: [ID]) {
+  tps(id_In: $ids) {
+    edges {
+      node {
+        id
+        currentUserSharedKey {
+          userSharedKey {
+            sharedKey {
+              id
+            }
+            mkSharedKey {
+              id
+            }
+          }
+        }
+      }
+    }
+  }
+}`;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHAtYXNzZW1ibHkucHJpdmF0ZS5ncWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb3JlL3NyYy9saWIvdHAtYXNzZW1ibHkvdHAtYXNzZW1ibHkucHJpdmF0ZS5ncWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBSzFDLE1BQU0sQ0FBQyxNQUFNLFlBQVksR0FBRyxRQUFRLENBQW9COzs7Ozs7Ozs7Ozs7Ozs7Ozs7O0VBbUJ0RCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29ubmVjdGlvbiwgVHBOb2RlIH0gZnJvbSAnLi4vYXBpL3R5cGVzJztcbmltcG9ydCB7IGdxbFR5cGVkIH0gZnJvbSAnLi4vX2NvbW1vbi9hc3QnO1xuXG5leHBvcnQgaW50ZXJmYWNlIFRwc0tleXNRdWVyeVJlc3VsdCB7XG4gIHRwczogQ29ubmVjdGlvbjxUcE5vZGU+O1xufVxuZXhwb3J0IGNvbnN0IFRwc0tleXNRdWVyeSA9IGdxbFR5cGVkPFRwc0tleXNRdWVyeVJlc3VsdD5gXG5xdWVyeSBUcHNLZXlzUXVlcnkoJGlkczogW0lEXSkge1xuICB0cHMoaWRfSW46ICRpZHMpIHtcbiAgICBlZGdlcyB7XG4gICAgICBub2RlIHtcbiAgICAgICAgaWRcbiAgICAgICAgY3VycmVudFVzZXJTaGFyZWRLZXkge1xuICAgICAgICAgIHVzZXJTaGFyZWRLZXkge1xuICAgICAgICAgICAgc2hhcmVkS2V5IHtcbiAgICAgICAgICAgICAgaWRcbiAgICAgICAgICAgIH1cbiAgICAgICAgICAgIG1rU2hhcmVkS2V5IHtcbiAgICAgICAgICAgICAgaWRcbiAgICAgICAgICAgIH1cbiAgICAgICAgICB9XG4gICAgICAgIH1cbiAgICAgIH1cbiAgICB9XG4gIH1cbn1gO1xuIl19