@lifeready/core 1.0.11 → 1.0.13

package/lib/api/types/lr-graphql.types.d.ts

@@ -351,7 +351,9 @@ export interface TpSubAssemblyNode extends Node, TimeStamped {
 export interface TpAssemblyApproverNode extends Node, TimeStamped {
     sharedKey?: KeyNode;
     sharedCipherData?: string;
+    sharedCipherDataClearJson?: any;
     sharedCipherApprovalData?: string;
+    sharedCipherApprovalDataClearJson?: any;
     tp?: TpNode;
 }
 export interface SharedTpPasswordResetNode extends Node, TimeStamped {

package/lib/scenario/scenario.constants.d.ts

@@ -0,0 +1 @@
+export declare const SCENARIO_SLIP39_PASSPHRASE = "lifeready";

package/lib/scenario/scenario.controller.d.ts

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

package/lib/scenario/scenario.gql.d.ts

@@ -0,0 +1,62 @@
+export interface CreateScenarioMutationResult {
+    createScenario: {
+        scenario: {
+            id: string;
+        };
+    };
+}
+export declare const CreateScenarioMutation: import("../_common/ast").TypedDocumentNode<CreateScenarioMutationResult>;
+export interface UpdateScenarioMutationResult {
+    updateScenario: {
+        scenario: {
+            id: string;
+        };
+    };
+}
+export declare const UpdateScenarioMutation: import("../_common/ast").TypedDocumentNode<UpdateScenarioMutationResult>;
+export interface DeleteScenarioMutationResult {
+    deleteScenario: {
+        id: string;
+    };
+}
+export declare const DeleteScenarioMutation: import("../_common/ast").TypedDocumentNode<DeleteScenarioMutationResult>;
+export interface CreateScenarioClaimMutationResult {
+    createScenarioClaim: {
+        sharedClaim: {
+            id: string;
+        };
+    };
+}
+export declare const CreateScenarioClaimMutation: import("../_common/ast").TypedDocumentNode<CreateScenarioClaimMutationResult>;
+export interface CancelScenarioClaimMutationResult {
+    cancelScenarioClaim: {
+        sharedClaim: {
+            id: string;
+        };
+    };
+}
+export declare const CancelScenarioClaimMutation: import("../_common/ast").TypedDocumentNode<CancelScenarioClaimMutationResult>;
+export interface RejectScenarioClaimMutationResult {
+    rejectScenarioClaim: {
+        claimApprover: {
+            id: string;
+        };
+    };
+}
+export declare const RejectScenarioClaimMutation: import("../_common/ast").TypedDocumentNode<RejectScenarioClaimMutationResult>;
+export interface ApproveScenarioClaimMutationResult {
+    approveScenarioClaim: {
+        claimApprover: {
+            id: string;
+        };
+    };
+}
+export declare const ApproveScenarioClaimMutation: import("../_common/ast").TypedDocumentNode<ApproveScenarioClaimMutationResult>;
+export interface ReceiveScenarioClaimMutationResult {
+    receiveScenarioClaim: {
+        sharedClaim: {
+            id: string;
+        };
+    };
+}
+export declare const ReceiveScenarioClaimMutation: import("../_common/ast").TypedDocumentNode<ReceiveScenarioClaimMutationResult>;

package/lib/scenario/scenario.gql.private.d.ts

@@ -0,0 +1,16 @@
+import { ScenarioNode, SharedScenarioNode } from '../api/types';
+/**
+ * This is a query that is used internally by the services for mutations. It
+ * contains the minimum amount of information for the information the services
+ * need. You'll probably want to write your own query to your liking if you
+ * want to retrieve a scenario. For example, there a separate query in the
+ * scenario.service.spec.ts
+ */
+export interface ScenarioQueryResult {
+    scenario: ScenarioNode;
+}
+export declare const ScenarioQuery: import("../_common/ast").TypedDocumentNode<ScenarioQueryResult>;
+export interface SharedScenarioQueryResult {
+    sharedScenario: SharedScenarioNode;
+}
+export declare const SharedScenarioQuery: import("../_common/ast").TypedDocumentNode<SharedScenarioQueryResult>;

package/lib/scenario/scenario.service.d.ts

@@ -0,0 +1,233 @@
+import { Injector, NgZone } from '@angular/core';
+import { LrMergedMutation, LrMutation, LrService } from '../api/lr-graphql';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { Item2Service } from '../items2/item2.service';
+import { ScenarioAssemblyController } from './scenario.controller';
+import { CreateScenarioOptions, ResetScenarioOptions, UpdateScenarioOptions } from './scenario.types';
+import { EncryptionService } from '../cryptography/encryption.service';
+export declare function throwClaimIdMismatch(): void;
+export declare function throwClaimNotApproved(): void;
+export declare class ScenarioService extends LrService {
+    private ngZone;
+    private injector;
+    private keyGraph;
+    private item2Service;
+    private assemblyController;
+    private encryptionService;
+    constructor(ngZone: NgZone, injector: Injector, keyGraph: KeyGraphService, item2Service: Item2Service, assemblyController: ScenarioAssemblyController, encryptionService: EncryptionService);
+    static SLIP39_PASSPHRASE: string;
+    private prepareAddReceiverDirectory;
+    private prepareUpdateReceiverDirectory;
+    createScenario(options: CreateScenarioOptions): Promise<import("./scenario.gql").CreateScenarioMutationResult>;
+    createScenarioMutation(options: CreateScenarioOptions): Promise<LrMutation<import("./scenario.gql").CreateScenarioMutationResult, {
+        input: {
+            enabled: boolean;
+            createAssembly: {
+                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;
+            };
+            createReceivers: {
+                addDirectories: {
+                    directoryId: string;
+                    wrappedItemKey: string;
+                    accessRole: import("../api/types").AccessRoleChoice;
+                    sharedCipherData: string;
+                }[];
+                tpId: string;
+                tpSharedKeyId: string;
+                tpSharedKeyWrappedSharedKey: string;
+                sharedCipherData: string;
+            }[];
+            createClaimants: {
+                tpId: string;
+                tpSharedKeyId: string;
+                tpSharedKeyWrappedSharedKey: string;
+                sharedCipherData: string;
+            }[];
+        };
+    }>>;
+    updateScenario(options: UpdateScenarioOptions): Promise<import("./scenario.gql").UpdateScenarioMutationResult>;
+    updateScenarioMutation(options: UpdateScenarioOptions): Promise<LrMutation<import("./scenario.gql").UpdateScenarioMutationResult, {
+        input: {
+            scenarioId: string;
+            enabled: boolean;
+            updateAssembly: any;
+            createReceivers: {
+                addDirectories: {
+                    directoryId: string;
+                    wrappedItemKey: string;
+                    accessRole: import("../api/types").AccessRoleChoice;
+                    sharedCipherData: string;
+                }[];
+                tpId: string;
+                tpSharedKeyId: string;
+                tpSharedKeyWrappedSharedKey: string;
+                sharedCipherData: string;
+            }[];
+            updateReceivers: {
+                addDirectories: {
+                    directoryId: string;
+                    wrappedItemKey: string;
+                    accessRole: import("../api/types").AccessRoleChoice;
+                    sharedCipherData: string;
+                }[];
+                updateDirectories: {
+                    directoryId: string;
+                    wrappedItemKey: string;
+                    accessRole: import("../api/types").AccessRoleChoice;
+                    sharedCipherData: string;
+                }[];
+                deleteDirectories: string[];
+                tpId: string;
+                sharedKeyId: string;
+                sharedCipherData: string;
+            }[];
+            deleteReceivers: string[];
+            createClaimants: {
+                tpId: string;
+                tpSharedKeyId: string;
+                tpSharedKeyWrappedSharedKey: string;
+                sharedCipherData: string;
+            }[];
+            updateClaimants: {
+                tpId: string;
+                sharedKeyId: string;
+                sharedCipherData: string;
+            }[];
+            deleteClaimants: string[];
+        };
+    }>>;
+    resetScenario(options: ResetScenarioOptions): Promise<import("./scenario.gql").UpdateScenarioMutationResult>;
+    resetScenarioMutation(options: ResetScenarioOptions): Promise<LrMutation<import("./scenario.gql").UpdateScenarioMutationResult, {
+        input: {
+            scenarioId: string;
+            enabled: boolean;
+            updateAssembly: any;
+            createReceivers: {
+                addDirectories: {
+                    directoryId: string;
+                    wrappedItemKey: string;
+                    accessRole: import("../api/types").AccessRoleChoice;
+                    sharedCipherData: string;
+                }[];
+                tpId: string;
+                tpSharedKeyId: string;
+                tpSharedKeyWrappedSharedKey: string;
+                sharedCipherData: string;
+            }[];
+            updateReceivers: {
+                addDirectories: {
+                    directoryId: string;
+                    wrappedItemKey: string;
+                    accessRole: import("../api/types").AccessRoleChoice;
+                    sharedCipherData: string;
+                }[];
+                updateDirectories: {
+                    directoryId: string;
+                    wrappedItemKey: string;
+                    accessRole: import("../api/types").AccessRoleChoice;
+                    sharedCipherData: string;
+                }[];
+                deleteDirectories: string[];
+                tpId: string;
+                sharedKeyId: string;
+                sharedCipherData: string;
+            }[];
+            deleteReceivers: string[];
+            createClaimants: {
+                tpId: string;
+                tpSharedKeyId: string;
+                tpSharedKeyWrappedSharedKey: string;
+                sharedCipherData: string;
+            }[];
+            updateClaimants: {
+                tpId: string;
+                sharedKeyId: string;
+                sharedCipherData: string;
+            }[];
+            deleteClaimants: string[];
+        };
+    }>>;
+    deleteScenario(scenarioId: string): Promise<import("./scenario.gql").DeleteScenarioMutationResult>;
+    deleteScenarioMutation(scenarioId: string): Promise<LrMutation<import("./scenario.gql").DeleteScenarioMutationResult, {
+        input: {
+            scenarioId: string;
+        };
+    }>>;
+    createClaim(scenarioId: string): Promise<import("./scenario.gql").CreateScenarioClaimMutationResult>;
+    createClaimMutation(scenarioId: string): Promise<LrMutation<import("./scenario.gql").CreateScenarioClaimMutationResult, {
+        input: {
+            scenarioId: string;
+        };
+    }>>;
+    cancelClaim(claimId: string): Promise<import("./scenario.gql").CancelScenarioClaimMutationResult>;
+    cancelClaimMutation(claimId: string): Promise<LrMutation<import("./scenario.gql").CancelScenarioClaimMutationResult, {
+        input: {
+            claimId: string;
+        };
+    }>>;
+    rejectClaim(sharedScenarioId: string, claimId: string): Promise<any>;
+    rejectClaimMutation(sharedScenarioId: string, claimId: string): Promise<LrMergedMutation<import("./scenario.gql").RejectScenarioClaimMutationResult[]>>;
+    approveClaim(sharedScenarioId: string, sharedClaimId: string): Promise<any>;
+    approveClaimMutation(sharedScenarioId: string, sharedClaimId: string): Promise<LrMergedMutation<import("./scenario.gql").ApproveScenarioClaimMutationResult[]>>;
+    receiveClaim(scenarioId: string, sharedClaimId: string): Promise<import("./scenario.gql").ReceiveScenarioClaimMutationResult>;
+    receiveClaimMutation(scenarioId: string, sharedClaimId: string): Promise<LrMutation<import("./scenario.gql").ReceiveScenarioClaimMutationResult, {
+        input: {
+            scenarioClaimId: string;
+            receiverDirectories: {
+                receiverDirectoryId: string;
+                receiverSharedKeyWrappedItemKey: any;
+            }[];
+        };
+    }>>;
+    private getScenario;
+    private getSharedScenario;
+    private getParticipantTpsKeys;
+    private fillTpSharedKeyId;
+    private prepareCreateScenarioMutation;
+    private prepareUpdateScenario;
+    private prepareReceiverDirectory;
+    private prepareCreateReceiver;
+    private prepareUpdateReceiver;
+    private prepareExistingReceiver;
+    private prepareExistingReceivers;
+    private prepareCreateParticipant;
+    private prepareUpdateParticipant;
+    private prepareCreateClaimant;
+    private prepareUpdateClaimant;
+    prepareClaim(scenarioId: string, sharedClaimId: string): Promise<{
+        scenarioClaimId: string;
+        receiverDirectories: {
+            receiverDirectoryId: string;
+            receiverSharedKeyWrappedItemKey: any;
+        }[];
+    }>;
+    private recoverAssemblyKey;
+    private asClaimApprovers;
+    private prepareApproveClaimMutations;
+    private prepareApproveClaim;
+    private prepareReceiverApproval;
+    private prepareRejectClaimMutations;
+}

package/lib/scenario/scenario.types.d.ts

@@ -0,0 +1,50 @@
+import { AccessRoleChoice } from '../api/types';
+import { CreateTpAssemblyInput, UpdateTpAssemblyInput } from '../trusted-parties/tp-assembly.types';
+export interface ParticipantOptions {
+    tpId: string;
+    sharedCipherDataClearJson: any;
+}
+export interface CreateParticipantOptions extends ParticipantOptions {
+    /** This is the TP.sharedKey used to wrap the approver shared key which will be created. */
+    tpSharedKeyId?: string;
+}
+export declare type UpdateParticipantOptions = ParticipantOptions;
+export interface ReceiverDirectoryOptions {
+    directoryId: string;
+    directoryKeyId?: string;
+    accessRole: AccessRoleChoice;
+    sharedCipherDataClearJson: any;
+}
+export declare type CreateReceiverDirectoryOptions = ReceiverDirectoryOptions;
+export declare type UpdateReceiverDirectoryOptions = ReceiverDirectoryOptions;
+export interface CreateReceiverOptions extends CreateParticipantOptions {
+    addDirectories?: CreateReceiverDirectoryOptions[];
+}
+export interface UpdateReceiverOptions extends UpdateParticipantOptions {
+    addDirectories?: CreateReceiverDirectoryOptions[];
+    updateDirectories?: UpdateReceiverDirectoryOptions[];
+    deleteDirectories?: string[];
+}
+export declare type CreateClaimantOptions = CreateParticipantOptions;
+export declare type UpdateClaimantOptions = UpdateParticipantOptions;
+export interface CreateScenarioOptions {
+    enabled: boolean;
+    createAssembly?: CreateTpAssemblyInput;
+    createReceivers?: CreateReceiverOptions[];
+    createClaimants?: CreateClaimantOptions[];
+}
+export interface UpdateScenarioOptions {
+    scenarioId: string;
+    enabled: boolean;
+    updateAssembly?: UpdateTpAssemblyInput;
+    createReceivers?: CreateReceiverOptions[];
+    updateReceivers?: UpdateReceiverOptions[];
+    deleteReceivers?: string[];
+    createClaimants?: CreateClaimantOptions[];
+    updateClaimants?: UpdateClaimantOptions[];
+    deleteClaimants?: string[];
+}
+export interface ResetScenarioOptions {
+    scenarioId: string;
+    enabled: boolean;
+}

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

@@ -7,42 +7,8 @@ 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';
-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[];
-}
-export interface TpAssemblyApproverInput {
-    tpId: string;
-    wrappingKeyId: string;
-    sharedCipherDataClearJson?: any;
-    sharedCipherApprovalDataClearJson?: any;
-}
+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;
@@ -50,7 +16,9 @@ export declare abstract class TpAssemblyController {
     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, }: {
@@ -117,6 +85,8 @@ export declare abstract class TpAssemblyController {
             tpId: string;
         }[];
     }[]>;
+    private fillWrappingKeyId;
+    private getInputApprovers;
     prepareCreate(input: CreateTpAssemblyInput): Promise<{
         assemblyKey: JWK.Key;
         mutationInput: {
@@ -146,6 +116,7 @@ export declare abstract class TpAssemblyController {
             wrappedAssemblyKeyVerifierPrk: string;
         };
     }>;
+    private getAssemblyApprovers;
     prepareUpdate(input: UpdateTpAssemblyInput, assembly: TpAssemblyNode): Promise<{
         assemblyKey: JWK.Key;
         mutationInput: {

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.controller.d.ts

@@ -1,8 +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.service.d.ts

@@ -1,9 +1,9 @@
 import { Injector, NgZone } from '@angular/core';
 import { Key } from '../cryptography/cryptography.types';
-import { CreateTpAssemblyInput, UpdateTpAssemblyInput } from './tp-assembly';
 import { TpPasswordResetAssemblyController } from './tp-password-reset.controller';
 import { LrMutation, LrService } from '../api/lr-graphql';
 import { TpNode } from '../api/types';
+import { CreateTpAssemblyInput, UpdateTpAssemblyInput } from './tp-assembly.types';
 export interface TpAssemblyApprovers {
     id: string;
     tp: {

package/lifeready-core.d.ts

@@ -7,5 +7,6 @@ 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 ɵ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';