@lifeready/core 1.0.10 → 1.0.12

package/lib/trusted-parties/tp-assembly.d.ts

@@ -0,0 +1,177 @@
+import { Injector } from '@angular/core';
+import { JWK } from 'node-jose';
+import { Connection, TpAssemblyNode, TpNode, TpSubAssemblyNode } from '../api/types';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyFactoryService } from '../cryptography/key-factory.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import * as slip from '../cryptography/slip39.service';
+import { Key } from '../cryptography/cryptography.types';
+import { KeyService } from '../cryptography/key.service';
+import { CreateTpAssemblyInput, CreateTpSubAssemblyInput, PartialAssemblyKey, TpAssemblyApproverInput, UpdateTpAssemblyInput, UpdateTpSubAssemblyInput } from './tp-assembly.types';
+import { LrGraphQLService } from '../api/lr-graphql';
+export declare abstract class TpAssemblyController {
+    abstract slip39Passphrase: string;
+    protected keyFactory: KeyFactoryService;
+    protected keyService: KeyService;
+    protected encryptionService: EncryptionService;
+    protected keyGraph: KeyGraphService;
+    protected slip39Service: slip.Slip39Service;
+    protected lrGraphQl: LrGraphQLService;
+    constructor(injector: Injector);
+    abstract getTpWrappingKeyId(tp: TpNode): string;
+    recoverAssemblyKey(partials: PartialAssemblyKey[]): Promise<JWK.Key>;
+    protected prepareTpWrappingKey(tp: TpAssemblyApproverInput): Promise<Key>;
+    protected prepareAssembly({ subjectKey, rootKey, }: {
+        subjectKey: JWK.Key;
+        rootKey: JWK.Key;
+    }): Promise<{
+        assemblyKey: JWK.Key;
+        rawAssemblyKey: any;
+        assemblyKeyParams: any;
+        subjectKeyWrappedAssemblyKey: string;
+        assemblyCipherData: string;
+        assemblyKeyVerifierPbk: string;
+        wrappedAssemblyKeyVerifierPrk: string;
+    }>;
+    protected prepareCreateSubAssemblies({ input, subjectKey, slipSubAssemblies, assemblyKeyParams, }: {
+        input: CreateTpSubAssemblyInput[];
+        subjectKey: JWK.Key;
+        slipSubAssemblies: slip.SubAssembly[];
+        assemblyKeyParams: any;
+    }): Promise<{
+        singleReject: boolean;
+        quorum: number;
+        subjectCipherData: string;
+        createApprovers: {
+            tpWrappingKeyId: string;
+            tpWrappedSharedKey: string;
+            subjectKeyWrappedSharedKey: string;
+            sharedCipherData: string;
+            sharedCipherApprovalData: string;
+            sharedCipherPartialAssemblyKey: string;
+            approverId: string;
+            tpId: string;
+        }[];
+    }[]>;
+    protected prepareUpdateSubAssemblies({ input, subjectKey, slipSubAssemblies, assemblyKeyParams, subAssemblies, }: {
+        input: UpdateTpSubAssemblyInput[];
+        subjectKey: JWK.Key;
+        slipSubAssemblies: slip.SubAssembly[];
+        assemblyKeyParams: any;
+        subAssemblies: Connection<TpSubAssemblyNode>;
+    }): Promise<{
+        subAssemblyId: string;
+        singleReject: boolean;
+        quorum: number;
+        subjectCipherData: string;
+        createApprovers: {
+            tpWrappingKeyId: string;
+            tpWrappedSharedKey: string;
+            subjectKeyWrappedSharedKey: string;
+            sharedCipherData: string;
+            sharedCipherApprovalData: string;
+            sharedCipherPartialAssemblyKey: string;
+            approverId: string;
+            tpId: string;
+        }[];
+        updateApprovers: {
+            tpWrappingKeyId: string;
+            tpWrappedSharedKey: string;
+            subjectKeyWrappedSharedKey: string;
+            sharedCipherData: string;
+            sharedCipherApprovalData: string;
+            sharedCipherPartialAssemblyKey: string;
+            approverId: string;
+            tpId: string;
+        }[];
+    }[]>;
+    private fillWrappingKeyId;
+    private getInputApprovers;
+    prepareCreate(input: CreateTpAssemblyInput): Promise<{
+        assemblyKey: JWK.Key;
+        mutationInput: {
+            singleReject: boolean;
+            quorum: number;
+            subjectCipherData: string;
+            createSubAssemblies: {
+                singleReject: boolean;
+                quorum: number;
+                subjectCipherData: string;
+                createApprovers: {
+                    tpWrappingKeyId: string;
+                    tpWrappedSharedKey: string;
+                    subjectKeyWrappedSharedKey: string;
+                    sharedCipherData: string;
+                    sharedCipherApprovalData: string;
+                    sharedCipherPartialAssemblyKey: string;
+                    approverId: string;
+                    tpId: string;
+                }[];
+            }[];
+            rootKeyId: string;
+            rootKeyWrappedSubjectKey: string;
+            subjectKeyWrappedAssemblyKey: string;
+            assemblyCipherData: string;
+            assemblyKeyVerifierPbk: string;
+            wrappedAssemblyKeyVerifierPrk: string;
+        };
+    }>;
+    private getAssemblyApprovers;
+    prepareUpdate(input: UpdateTpAssemblyInput, assembly: TpAssemblyNode): Promise<{
+        assemblyKey: JWK.Key;
+        mutationInput: {
+            singleReject: boolean;
+            quorum: number;
+            subjectCipherData: string;
+            subjectKeyId: string;
+            createSubAssemblies: {
+                singleReject: boolean;
+                quorum: number;
+                subjectCipherData: string;
+                createApprovers: {
+                    tpWrappingKeyId: string;
+                    tpWrappedSharedKey: string;
+                    subjectKeyWrappedSharedKey: string;
+                    sharedCipherData: string;
+                    sharedCipherApprovalData: string;
+                    sharedCipherPartialAssemblyKey: string;
+                    approverId: string;
+                    tpId: string;
+                }[];
+            }[];
+            updateSubAssemblies: {
+                subAssemblyId: string;
+                singleReject: boolean;
+                quorum: number;
+                subjectCipherData: string;
+                createApprovers: {
+                    tpWrappingKeyId: string;
+                    tpWrappedSharedKey: string;
+                    subjectKeyWrappedSharedKey: string;
+                    sharedCipherData: string;
+                    sharedCipherApprovalData: string;
+                    sharedCipherPartialAssemblyKey: string;
+                    approverId: string;
+                    tpId: string;
+                }[];
+                updateApprovers: {
+                    tpWrappingKeyId: string;
+                    tpWrappedSharedKey: string;
+                    subjectKeyWrappedSharedKey: string;
+                    sharedCipherData: string;
+                    sharedCipherApprovalData: string;
+                    sharedCipherPartialAssemblyKey: string;
+                    approverId: string;
+                    tpId: string;
+                }[];
+            }[];
+            subjectKeyWrappedAssemblyKey: string;
+            assemblyCipherData: string;
+            assemblyKeyVerifierPbk: string;
+            wrappedAssemblyKeyVerifierPrk: string;
+        };
+    }>;
+    private prepareApprover;
+    validateApprovers(approvers: TpNode[]): void;
+    protected prepareSlip39(subAssemblies: any, assemblyQuorum: number, rawAssemblyKey: string): Promise<slip.Assembly>;
+}

package/lib/trusted-parties/tp-assembly.gql.private.d.ts

@@ -0,0 +1,5 @@
+import { Connection, TpNode } from '../api/types';
+export interface TpsKeysQueryResult {
+    tps: Connection<TpNode>;
+}
+export declare const TpsKeysQuery: import("../_common/ast").TypedDocumentNode<TpsKeysQueryResult>;

package/lib/trusted-parties/tp-assembly.types.d.ts

@@ -0,0 +1,38 @@
+import * as slip from '../cryptography/slip39.service';
+export interface PartialAssemblyKey {
+    slip39: {
+        share: slip.SecretShare;
+        subAssembly: {
+            quorum: number;
+            size: number;
+        };
+    };
+    assemblyKeyParams: object;
+}
+export interface CreateTpSubAssemblyInput {
+    quorum: number;
+    singleReject: boolean;
+    approverTps: TpAssemblyApproverInput[];
+    subjectCipherDataClearJson?: any;
+}
+export interface UpdateTpSubAssemblyInput extends CreateTpSubAssemblyInput {
+    id: string;
+}
+export interface TpAssemblyInput {
+    quorum: number;
+    singleReject: boolean;
+}
+export interface CreateTpAssemblyInput extends TpAssemblyInput {
+    createSubAssemblies: CreateTpSubAssemblyInput[];
+}
+export interface UpdateTpAssemblyInput extends TpAssemblyInput {
+    createSubAssemblies?: CreateTpSubAssemblyInput[];
+    updateSubAssemblies?: UpdateTpSubAssemblyInput[];
+    deleteSubAssemblies?: string[];
+}
+export interface TpAssemblyApproverInput {
+    tpId: string;
+    wrappingKeyId?: string;
+    sharedCipherDataClearJson?: any;
+    sharedCipherApprovalDataClearJson?: any;
+}

package/lib/trusted-parties/tp-password-reset-request.service.d.ts

@@ -14,7 +14,7 @@ export declare class TpPasswordResetRequestService extends LrService {
     getSharedReset(id: any): Promise<import("./tp-password-reset.gql").SharedTpPasswordResetFragmentResult>;
     private activeRequestOrRaise;
     rejectRequest(sharedResetId: string): Promise<any>;
-    rejectRequestMutation(sharedResetId: string): Promise<LrMergedMutation<any[]>>;
-    approveRequest(sharedResetId: string, pbkFingerPrint?: string): Promise<any>;
-    approveRequestMutation(sharedResetId: string, pbkFingerPrint?: string): Promise<LrMergedMutation<any[]>>;
+    rejectRequestMutation(sharedResetId: string): Promise<LrMergedMutation<import("./tp-password-reset.gql").RejectTpPasswordResetRequestMutationResult[]>>;
+    approveRequest(sharedResetId: string, pbkFingerPrint?: string): Promise<import("./tp-password-reset.gql").ApproveTpPasswordResetRequestMutationResult[]>;
+    approveRequestMutation(sharedResetId: string, pbkFingerPrint?: string): Promise<LrMergedMutation<import("./tp-password-reset.gql").ApproveTpPasswordResetRequestMutationResult[]>>;
 }

package/lib/trusted-parties/tp-password-reset.controller.d.ts

@@ -0,0 +1,10 @@
+import { Injector, NgZone } from '@angular/core';
+import { TpNode } from '../api/types';
+import { TpAssemblyController } from './tp-assembly';
+export declare class TpPasswordResetAssemblyController extends TpAssemblyController {
+    private ngZone;
+    private injector;
+    slip39Passphrase: string;
+    constructor(ngZone: NgZone, injector: Injector);
+    getTpWrappingKeyId(tp: TpNode): string;
+}

package/lib/trusted-parties/tp-password-reset.gql.d.ts

@@ -158,6 +158,8 @@ export interface TpPasswordResetQueryResult {
         assembly: {
             singleReject: boolean;
             quorum: number;
+            subjectCipherData: string;
+            subjectCipherDataClearJson: any;
             subjectKey: {
                 id: ID;
             };
@@ -173,6 +175,9 @@ export interface TpPasswordResetQueryResult {
                         quorum: number;
                         subjectCipherData: string;
                         subjectCipherDataClearJson: any;
+                        subjectKey: {
+                            id: ID;
+                        };
                         approvers: {
                             edges: {
                                 node: {

package/lib/trusted-parties/tp-password-reset.service.d.ts

@@ -1,29 +1,9 @@
 import { Injector, NgZone } from '@angular/core';
-import { KeyService } from '../cryptography/key.service';
-import { EncryptionService } from '../cryptography/encryption.service';
-import { KeyGraphService } from '../cryptography/key-graph.service';
-import * as slip from '../cryptography/slip39.service';
 import { Key } from '../cryptography/cryptography.types';
-import { KeyFactoryService } from '../cryptography/key-factory.service';
+import { TpPasswordResetAssemblyController } from './tp-password-reset.controller';
 import { LrMutation, LrService } from '../api/lr-graphql';
 import { TpNode } from '../api/types';
-export declare class CreateSubAssembliesInput {
-    name: string;
-    quorum: number;
-    singleReject: boolean;
-    approverTps: TpNode[];
-}
-export declare class UpdateSubAssembliesInput extends CreateSubAssembliesInput {
-    id: string;
-}
-export declare class CreateTpPasswordResetInput {
-    quorum: number;
-    singleReject: boolean;
-    createSubAssemblies: CreateSubAssembliesInput[];
-}
-export declare class UpdateTpPasswordResetInput extends CreateTpPasswordResetInput {
-    updateSubAssemblies: UpdateSubAssembliesInput[];
-}
+import { CreateTpAssemblyInput, UpdateTpAssemblyInput } from './tp-assembly.types';
 export interface TpAssemblyApprovers {
     id: string;
     tp: {
@@ -65,18 +45,17 @@ export interface RequestResetResult {
 export declare class TpPasswordResetService extends LrService {
     private ngZone;
     private injector;
-    private keyService;
-    private keyFactory;
-    private encryptionService;
-    private keyGraph;
-    private slip39Service;
-    constructor(ngZone: NgZone, injector: Injector, keyService: KeyService, keyFactory: KeyFactoryService, encryptionService: EncryptionService, keyGraph: KeyGraphService, slip39Service: slip.Slip39Service);
+    private assemblyController;
+    slip39Passphrase: string;
+    constructor(ngZone: NgZone, injector: Injector, assemblyController: TpPasswordResetAssemblyController);
     getReset(): Promise<{
         id: string;
         applied: boolean;
         assembly: {
             singleReject: boolean;
             quorum: number;
+            subjectCipherData: string;
+            subjectCipherDataClearJson: any;
             subjectKey: {
                 id: string;
             };
@@ -92,6 +71,9 @@ export declare class TpPasswordResetService extends LrService {
                         quorum: number;
                         subjectCipherData: string;
                         subjectCipherDataClearJson: any;
+                        subjectKey: {
+                            id: string;
+                        };
                         approvers: {
                             edges: {
                                 node: {
@@ -111,20 +93,96 @@ export declare class TpPasswordResetService extends LrService {
             };
         };
     }>;
-    createReset(input: CreateTpPasswordResetInput): Promise<import("./tp-password-reset.gql").CreateTpPasswordResetMutationResult>;
-    createResetMutation(input: CreateTpPasswordResetInput): Promise<LrMutation<import("./tp-password-reset.gql").CreateTpPasswordResetMutationResult, {
-        input: any;
-    }>>;
-    deleteReset(): Promise<import("./tp-password-reset.gql").DeleteTpPasswordResetMutationResult>;
-    deleteResetMutation(): LrMutation<import("./tp-password-reset.gql").DeleteTpPasswordResetMutationResult, Record<string, any>>;
-    updateReset(input: UpdateTpPasswordResetInput): Promise<import("./tp-password-reset.gql").UpdateTpPasswordResetMutationResult>;
-    updateResetMutation(input: UpdateTpPasswordResetInput): Promise<LrMutation<import("./tp-password-reset.gql").UpdateTpPasswordResetMutationResult, {
-        input: any;
-    }>>;
     cancelResetRequest(): Promise<import("./tp-password-reset.gql").CancelTpPasswordResetRequestMutationResult>;
     cancelResetRequestMutation(): LrMutation<import("./tp-password-reset.gql").CancelTpPasswordResetRequestMutationResult, Record<string, any>>;
+    deleteReset(): Promise<import("./tp-password-reset.gql").DeleteTpPasswordResetMutationResult>;
+    deleteResetMutation(): LrMutation<import("./tp-password-reset.gql").DeleteTpPasswordResetMutationResult, Record<string, any>>;
     validateApprovers(approvers: TpNode[]): void;
-    private prepareApprover;
-    private prepareSlip39;
-    private _createReset;
+    createReset(input: CreateTpAssemblyInput): Promise<import("./tp-password-reset.gql").CreateTpPasswordResetMutationResult>;
+    createResetMutation(input: CreateTpAssemblyInput): Promise<LrMutation<import("./tp-password-reset.gql").CreateTpPasswordResetMutationResult, {
+        input: {
+            assembly: {
+                singleReject: boolean;
+                quorum: number;
+                subjectCipherData: string;
+                createSubAssemblies: {
+                    singleReject: boolean;
+                    quorum: number;
+                    subjectCipherData: string;
+                    createApprovers: {
+                        tpWrappingKeyId: string;
+                        tpWrappedSharedKey: string;
+                        subjectKeyWrappedSharedKey: string;
+                        sharedCipherData: string;
+                        sharedCipherApprovalData: string;
+                        sharedCipherPartialAssemblyKey: string;
+                        approverId: string;
+                        tpId: string;
+                    }[];
+                }[];
+                rootKeyId: string;
+                rootKeyWrappedSubjectKey: string;
+                subjectKeyWrappedAssemblyKey: string;
+                assemblyCipherData: string;
+                assemblyKeyVerifierPbk: string;
+                wrappedAssemblyKeyVerifierPrk: string;
+            };
+        };
+    }>>;
+    updateReset(input: UpdateTpAssemblyInput): Promise<import("./tp-password-reset.gql").UpdateTpPasswordResetMutationResult>;
+    updateResetMutation(input: UpdateTpAssemblyInput): Promise<LrMutation<import("./tp-password-reset.gql").UpdateTpPasswordResetMutationResult, {
+        input: {
+            assembly: {
+                singleReject: boolean;
+                quorum: number;
+                subjectCipherData: string;
+                subjectKeyId: string;
+                createSubAssemblies: {
+                    singleReject: boolean;
+                    quorum: number;
+                    subjectCipherData: string;
+                    createApprovers: {
+                        tpWrappingKeyId: string;
+                        tpWrappedSharedKey: string;
+                        subjectKeyWrappedSharedKey: string;
+                        sharedCipherData: string;
+                        sharedCipherApprovalData: string;
+                        sharedCipherPartialAssemblyKey: string;
+                        approverId: string;
+                        tpId: string;
+                    }[];
+                }[];
+                updateSubAssemblies: {
+                    subAssemblyId: string;
+                    singleReject: boolean;
+                    quorum: number;
+                    subjectCipherData: string;
+                    createApprovers: {
+                        tpWrappingKeyId: string;
+                        tpWrappedSharedKey: string;
+                        subjectKeyWrappedSharedKey: string;
+                        sharedCipherData: string;
+                        sharedCipherApprovalData: string;
+                        sharedCipherPartialAssemblyKey: string;
+                        approverId: string;
+                        tpId: string;
+                    }[];
+                    updateApprovers: {
+                        tpWrappingKeyId: string;
+                        tpWrappedSharedKey: string;
+                        subjectKeyWrappedSharedKey: string;
+                        sharedCipherData: string;
+                        sharedCipherApprovalData: string;
+                        sharedCipherPartialAssemblyKey: string;
+                        approverId: string;
+                        tpId: string;
+                    }[];
+                }[];
+                subjectKeyWrappedAssemblyKey: string;
+                assemblyCipherData: string;
+                assemblyKeyVerifierPbk: string;
+                wrappedAssemblyKeyVerifierPrk: string;
+            };
+        };
+    }>>;
 }

package/lib/trusted-parties/trusted-party2.service.d.ts

@@ -1,5 +1,5 @@
 import { NgZone } from '@angular/core';
-import { Item2Service } from '../api/item2.service';
+import { Item2Service } from '../items2/item2.service';
 import { LrGraphQLService, LrMutation } from '../api/lr-graphql';
 import { AccessRoleChoice, LrRelayIdInput } from '../api/types';
 import { EncryptionService } from '../cryptography/encryption.service';

package/lifeready-core.d.ts

@@ -3,7 +3,10 @@
  */
 export * from './public-api';
 export { RunOutsideAngular as ɵd } from './lib/_common/run-outside-angular';
-export { LrGraphQLService as ɵb, LrService as ɵg } from './lib/api/lr-graphql';
+export { LrGraphQLService as ɵb, LrService as ɵi } from './lib/api/lr-graphql';
 export { TpPasswordResetProcessorService as ɵc } from './lib/api/query-processor/tp-password-reset-processor.service';
-export { SharedContactCardFields as ɵe, SharedContactCardService as ɵf } from './lib/api/shared-contact-card.service';
+export { SharedContactCardFields as ɵg, SharedContactCardService as ɵh } from './lib/api/shared-contact-card.service';
 export { TimeService as ɵa } from './lib/api/time.service';
+export { ScenarioAssemblyController as ɵj } from './lib/scenario/scenario.controller';
+export { TpAssemblyController as ɵf } from './lib/trusted-parties/tp-assembly';
+export { TpPasswordResetAssemblyController as ɵe } from './lib/trusted-parties/tp-password-reset.controller';