@lifeready/core 0.6.0-beta.1

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

@@ -0,0 +1,217 @@
+import { PreparedPermissions } from '../api/key-exchange.types';
+import { Key } from '../cryptography/cryptography.types';
+import { SecretShare } from '../cryptography/slip39.service';
+import { TrustedParty } from '../trusted-parties/trusted-party.types';
+import { ApprovalGroup } from './approvals/scenario-approval.types';
+import { Claimant } from './claimants/scenario-claimant.types';
+import { Receiver } from './receivers/scenario-receiver.types';
+export declare enum ScenarioState {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED",
+    CLAIMED = "CLAIMED",
+    APPROVED = "APPROVED",
+    REJECTED = "REJECTED"
+}
+export declare enum ScenarioClaimState {
+    Claimed = "CLAIMED",
+    Approved = "APPROVED",
+    Expired = "EXPIRED",
+    Rejected = "REJECTED",
+    Cancelled = "CANCELLED",
+    Reset = "RESET"
+}
+export declare enum ApproverClaimState {
+    Claimed = "CLAIMED",
+    Approved = "APPROVED",
+    Rejected = "REJECTED"
+}
+export declare class NewScenario {
+    name: string;
+    event: string;
+    claimants: NewScenarioClaimant[];
+    approvalGroups: NewScenarioApprovalGroup[];
+    receivers: NewScenarioReceiver[];
+}
+export declare class NewScenarioClaimant {
+    trustedPartyId: string;
+    trustedPartySharedKeyId: string;
+    message?: string;
+}
+export declare class NewScenarioApprovalGroup {
+    name: string;
+    quorum: number;
+    singleReject: boolean;
+    approvers: NewScenarioApprover[];
+}
+export declare class NewScenarioApprover {
+    trustedPartyId: string;
+    trustedPartySharedKeyId: string;
+    message?: string;
+}
+export declare class NewScenarioReceiver {
+    trustedPartyId: string;
+    trustedPartySharedKeyId: string;
+    permissions: PreparedPermissions;
+    message?: string;
+}
+export declare class UpdateScenario {
+    scenarioId: string;
+    keyId: string;
+    assemblyKeyId: string;
+    name: string;
+    event: string;
+    claimants: UpdatedScenarioClaimant[];
+    deletedClaimantIds: string[];
+    approvalGroups: UpdatedScenarioApprovalGroup[];
+    deletedGroupIds: string[];
+    receivers: UpdatedScenarioReceiver[];
+    deletedReceiverIds: string[];
+}
+export declare class UpdatedScenarioClaimant {
+    claimantId?: string;
+    keyId?: string;
+    trustedPartyId: string;
+    trustedPartySharedKeyId: string;
+    message?: string;
+}
+export declare class UpdatedScenarioApprovalGroup {
+    subAssemblyId?: string;
+    name: string;
+    quorum: number;
+    singleReject: boolean;
+    approvers: UpdatedScenarioApprover[];
+    deletedApproverIds: string[];
+}
+export declare class UpdatedScenarioApprover {
+    approverId?: string;
+    keyId?: string;
+    trustedPartyId: string;
+    trustedPartySharedKeyId: string;
+    message?: string;
+}
+export declare class UpdatedScenarioReceiver {
+    receiverId?: string;
+    keyId?: string;
+    trustedPartyId: string;
+    trustedPartySharedKeyId: string;
+    permissions: PreparedPermissions;
+    message?: string;
+}
+export declare class ScenarioSummary {
+    id: string;
+    status: ScenarioState;
+    name: string;
+    event: string;
+    claimId?: string;
+    claimStatus?: ScenarioClaimState;
+    createdOn: string | Date;
+    lastModified: string | Date;
+}
+export declare class ScenarioClaim {
+    id: string;
+    state: ScenarioClaimState;
+    triggeredBy: TrustedParty;
+    triggeredOn: string;
+    lastModified: string;
+    scenario: ScenarioSummary;
+}
+export declare class SharedScenarioSummary {
+    id: string;
+    status: ScenarioState;
+    event: string;
+    trustedParty: TrustedParty;
+    claimStatus?: ScenarioClaimState;
+}
+export declare class SharedScenario {
+    id: string;
+    status: ScenarioState;
+    event: string;
+    trustedParty: TrustedParty;
+    isClaimant: boolean;
+    claimantMessage?: string;
+    isApprover: boolean;
+    approverMessages?: string[];
+    isReceiver: boolean;
+    receiverMessage?: string;
+    receiverKeyId?: string;
+    receiverPbkId?: string;
+    receiverDirectories?: {
+        id: string;
+        wrappedItemKey: string;
+    }[];
+    claim?: SharedScenarioClaim;
+}
+export interface SharedScenarioClaim {
+    id: string;
+    isClaimant: boolean;
+    status: ScenarioClaimState;
+    asApprovers?: SharedScenarioClaimApprover[];
+    asReceiver?: {
+        received: boolean;
+        ciphers: string[];
+    };
+}
+export interface SharedScenarioClaimApprover {
+    approverId: string;
+    approverKey: string;
+    status: ApproverClaimState;
+    receivers: {
+        id: string;
+        pbkId: string;
+    }[];
+}
+export interface Scenario {
+    id: string;
+    keyId: string;
+    assemblyKeyId: string;
+    assemblyQuorum: number;
+    status: ScenarioState;
+    name: string;
+    event: string;
+    claimants: Claimant[];
+    approverGroups: ApprovalGroup[];
+    receivers: Receiver[];
+    claim: {
+        id: string;
+        status: ScenarioClaimState;
+        claimant: Claimant;
+    };
+}
+export interface CreateScenarioInput {
+    plainSubjectCipherData: object;
+}
+export interface UpdateScenarioInput {
+    scenarioId: string;
+    keyId: string;
+    plainSubjectCipherData: object;
+}
+export interface PartialAssemblyKey {
+    slip39: {
+        share: SecretShare;
+        subAssembly: {
+            quorum: number;
+            size: number;
+        };
+    };
+    assemblyKeyParams: object;
+}
+export interface SharedClaimReceiver {
+    id: string;
+    pbk: Key;
+}
+export interface SharedClaimApprover {
+    receivers: {
+        id: string;
+        pbk: Key;
+    }[];
+}
+export interface SharedClaimApproval {
+    receiverPbkCipher: string;
+    plainReceiverPbkCipher: {
+        partialAssemblyKey: PartialAssemblyKey;
+    };
+}
+export interface SharedClaimReceiver {
+    received: boolean;
+    approvals: SharedClaimApproval[];
+}

package/lib/search/search.gql.d.ts

@@ -0,0 +1 @@
+export declare const SearchRecordContentsQuery: import("graphql").DocumentNode;

package/lib/search/search.service.d.ts

@@ -0,0 +1,25 @@
+import { NgZone } from '@angular/core';
+import { LrApolloService } from '../api/lr-apollo.service';
+import { CategoryService } from '../category/category.service';
+import { KeyFactoryService } from '../cryptography/key-factory.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { RecordService } from '../record/record.service';
+import { SearchItem } from './search.types';
+export declare function debugPopulateRecords(categoryService: CategoryService, recordService: RecordService, keyFactory: KeyFactoryService, recordsPerCategory: number): Promise<void>;
+export declare class SearchService {
+    private ngZone;
+    private lrApollo;
+    private categoryService;
+    private keyGraph;
+    vaultItems: {
+        [itemId: string]: SearchItem;
+    };
+    recordContentsResult: any;
+    constructor(ngZone: NgZone, lrApollo: LrApolloService, categoryService: CategoryService, keyGraph: KeyGraphService);
+    private mapRecordContent;
+    private mapRecordContents;
+    private load;
+    refresh(): Promise<{
+        [itemId: string]: SearchItem;
+    }>;
+}

package/lib/search/search.types.d.ts

@@ -0,0 +1,20 @@
+import Fuse from 'fuse.js';
+export declare enum SearchItemType {
+    RECORD = "RECORD",
+    CATEGORY = "CATEGORY"
+}
+export interface SearchRecordAttachment {
+    name: string;
+}
+export interface SearchItem {
+    id: string;
+    type: SearchItemType;
+    created: Date;
+    modified: Date;
+    archived: boolean;
+    plainMeta: any;
+    plainCipherMeta: any;
+    parentCategoryId?: string;
+    attachments?: SearchRecordAttachment[];
+}
+export declare type SearchResults = Fuse.FuseResult<SearchItem>[];

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

@@ -0,0 +1,20 @@
+import { Injector, NgZone } from '@angular/core';
+import { LrMergedMutation, LrService } from '../api/lr-graphql';
+import { EncryptionService } from '../cryptography/encryption.service';
+export declare class TpPasswordResetRequestService extends LrService {
+    private ngZone;
+    private injector;
+    private encryptionService;
+    constructor(ngZone: NgZone, injector: Injector, encryptionService: EncryptionService);
+    getSharedResets(): Promise<{
+        edges: {
+            node: import("./tp-password-reset.gql").SharedTpPasswordResetFragmentResult;
+        }[];
+    }>;
+    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[]>>;
+}

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

@@ -0,0 +1,41 @@
+import { Injector, NgZone } from '@angular/core';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { LifeReadyConfig } from '../life-ready.config';
+import * as slip from '../cryptography/slip39.service';
+import { PasswordService } from '../auth/password.service';
+import { HttpClient } from '@angular/common/http';
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+import { RequestResetResult } from './tp-password-reset.service';
+import { ISignUpResult } from 'amazon-cognito-identity-js';
+import { LifeReadyAuthService } from '../auth/life-ready-auth.service';
+import { KeyFactoryService } from '../cryptography/key-factory.service';
+import { TpPasswordResetUserNode } from '../api/types';
+import { LrService } from '../api/lr-graphql';
+export declare class TpPasswordResetUserService extends LrService {
+    private ngZone;
+    private injector;
+    private config;
+    private keyFactory;
+    private encryptionService;
+    private keyGraphService;
+    private slip39Service;
+    private passwordService;
+    private http;
+    private auth;
+    private lrAuth;
+    private readonly CLIENT_NONCE_LENGTH;
+    private resetUser;
+    constructor(ngZone: NgZone, injector: Injector, config: LifeReadyConfig, keyFactory: KeyFactoryService, encryptionService: EncryptionService, keyGraphService: KeyGraphService, slip39Service: slip.Slip39Service, passwordService: PasswordService, http: HttpClient, auth: AuthClass, lrAuth: LifeReadyAuthService);
+    verifyEmailContact(email: any): Promise<{
+        claimId: string;
+    }>;
+    verifyContactRespond(claimId: string, claimCode: string): Promise<string>;
+    requestReset(password: string, claimId: string, claimToken: string): Promise<{
+        requestResetResult: RequestResetResult;
+        signUpResult: ISignUpResult;
+    }>;
+    getResetUser(reload?: boolean): Promise<TpPasswordResetUserNode>;
+    private recoverAssemblyKey;
+    completeRequest(newPassword: string): Promise<void>;
+}

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

@@ -0,0 +1,218 @@
+import { GenericScalar, ID } from '../api/types';
+import { TpClaimState, TpClaimApproverState } from '../api/types/lr-graphql.types';
+import { DateTime } from '../api/types/graphql.types';
+export interface SharedTpPasswordResetFragmentResult {
+    id: ID;
+    tp: {
+        id: ID;
+        other: {
+            username: string;
+        };
+    };
+    assembly: {
+        asApprovers: {
+            edges: {
+                node: {
+                    id: ID;
+                    sharedKey: {
+                        id: ID;
+                    };
+                    sharedCipherData: string;
+                    sharedCipherDataClearJson: any;
+                };
+            }[];
+        };
+    };
+    sharedRequest: {
+        id: ID;
+        pxk: {
+            id: ID;
+            pbk: string;
+        };
+        claim: {
+            id: ID;
+            state: TpClaimState;
+            asClaimApprovers: {
+                edges: {
+                    node: {
+                        id: ID;
+                        state: TpClaimApproverState;
+                        sharedKey: {
+                            id: ID;
+                        };
+                        sharedCipherApprovalData: string;
+                        sharedCipherApprovalDataClearJson: any;
+                        sharedCipherPartialAssemblyKey: string;
+                        sharedCipherPartialAssemblyKeyClearJson: any;
+                        receiverApprovals: {
+                            edges: {
+                                node: {
+                                    id: ID;
+                                };
+                            }[];
+                        };
+                    };
+                }[];
+            };
+        };
+    };
+}
+export interface SharedTpPasswordResetsQueryResult {
+    sharedTpPasswordResets: {
+        edges: {
+            node: SharedTpPasswordResetFragmentResult;
+        }[];
+    };
+}
+export declare const SharedTpPasswordResetsQuery: import("../_common/ast").TypedDocumentNode<SharedTpPasswordResetsQueryResult>;
+export interface SharedTpPasswordResetQueryResult {
+    sharedTpPasswordReset: SharedTpPasswordResetFragmentResult;
+}
+export declare const SharedTpPasswordResetQuery: import("../_common/ast").TypedDocumentNode<SharedTpPasswordResetQueryResult>;
+export interface CancelTpPasswordResetRequestMutationResult {
+    cancelTpPasswordResetRequest: {
+        id: ID;
+    };
+}
+export declare const CancelTpPasswordResetRequestMutation: import("../_common/ast").TypedDocumentNode<CancelTpPasswordResetRequestMutationResult>;
+export interface CreateTpAssemblyKeyChallengeMutationResult {
+    createTpAssemblyKeyChallenge: {
+        challenge: any;
+    };
+}
+export declare const CreateTpAssemblyKeyChallengeMutation: import("../_common/ast").TypedDocumentNode<CreateTpAssemblyKeyChallengeMutationResult>;
+export interface PreCompleteTpPasswordResetRequestMutationResult {
+    preCompleteTpPasswordResetRequest: {
+        idpPassword: string;
+    };
+}
+export declare const PreCompleteTpPasswordResetRequestMutation: import("../_common/ast").TypedDocumentNode<PreCompleteTpPasswordResetRequestMutationResult>;
+export interface CompleteTpPasswordResetRequestMutationResult {
+    completeTpPasswordResetRequest: {
+        id: ID;
+    };
+}
+export declare const CompleteTpPasswordResetRequestMutation: import("../_common/ast").TypedDocumentNode<CompleteTpPasswordResetRequestMutationResult>;
+export interface ApproveTpPasswordResetRequestMutationResult {
+    approveTpPasswordResetRequest: {
+        claimApprover: {
+            id: ID;
+        };
+    };
+}
+export declare const ApproveTpPasswordResetRequestMutation: import("../_common/ast").TypedDocumentNode<ApproveTpPasswordResetRequestMutationResult>;
+export interface RejectTpPasswordResetRequestMutationResult {
+    rejectTpPasswordResetRequest: {
+        claimApprover: {
+            id: ID;
+        };
+    };
+}
+export declare const RejectTpPasswordResetRequestMutation: import("../_common/ast").TypedDocumentNode<RejectTpPasswordResetRequestMutationResult>;
+export interface TpPasswordResetUserQueryResult {
+    tpPasswordResetUser: {
+        username: string;
+        resetUsername: string;
+        state: TpClaimState;
+        passKey: {
+            id: ID;
+            passKeyParams: GenericScalar;
+            passIdpParams: GenericScalar;
+        };
+        masterKey: {
+            id: ID;
+        };
+        pxk: {
+            id: ID;
+        };
+        sessionEncryptionKey: string;
+        assembly: {
+            singleReject: boolean;
+            quorum: number;
+            subAssemblies: {
+                singleReject: boolean;
+                quorum: number;
+                approvers: {
+                    name: string;
+                    email: string;
+                    state: TpClaimApproverState;
+                }[];
+            }[];
+        };
+        approvals: {
+            id: ID;
+            modified: DateTime;
+            approverEmail: string;
+            receiverCipher: string;
+            receiverCipherPartialAssemblyKey: string;
+        }[];
+        assemblyCipherData: string;
+        wrappedAssemblyKeyVerifierPrk: string;
+    };
+}
+export declare const TpPasswordResetUserQuery: import("../_common/ast").TypedDocumentNode<TpPasswordResetUserQueryResult>;
+export interface TpPasswordResetQueryResult {
+    tpPasswordReset: {
+        id: ID;
+        applied: boolean;
+        assembly: {
+            singleReject: boolean;
+            quorum: number;
+            subjectKey: {
+                id: ID;
+            };
+            assemblyKey: {
+                id: ID;
+            };
+            assemblyCipherData: string;
+            subAssemblies: {
+                edges: {
+                    node: {
+                        id: ID;
+                        singleReject: boolean;
+                        quorum: number;
+                        subjectCipherData: string;
+                        subjectCipherDataClearJson: any;
+                        approvers: {
+                            edges: {
+                                node: {
+                                    id: ID;
+                                    tp: {
+                                        id: ID;
+                                    };
+                                    sharedKey: {
+                                        id: ID;
+                                    };
+                                    sharedCipherData: string;
+                                };
+                            }[];
+                        };
+                    };
+                }[];
+            };
+        };
+    };
+}
+export declare const TpPasswordResetQuery: import("../_common/ast").TypedDocumentNode<TpPasswordResetQueryResult>;
+export interface CreateTpPasswordResetMutationResult {
+    createTpPasswordReset: {
+        tpPasswordReset: {
+            id: ID;
+        };
+    };
+}
+export declare const CreateTpPasswordResetMutation: import("../_common/ast").TypedDocumentNode<CreateTpPasswordResetMutationResult>;
+export interface DeleteTpPasswordResetMutationResult {
+    deleteTpPasswordReset: {
+        id: ID;
+    };
+}
+export declare const DeleteTpPasswordResetMutation: import("../_common/ast").TypedDocumentNode<DeleteTpPasswordResetMutationResult>;
+export interface UpdateTpPasswordResetMutationResult {
+    updateTpPasswordReset: {
+        tpPasswordReset: {
+            id: ID;
+        };
+    };
+}
+export declare const UpdateTpPasswordResetMutation: import("../_common/ast").TypedDocumentNode<UpdateTpPasswordResetMutationResult>;

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

@@ -0,0 +1,131 @@
+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 { 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[];
+}
+export interface TpAssemblyApprovers {
+    id: string;
+    tp: {
+        id: string;
+    };
+    sharedKey: Key;
+    sharedCipherData?: string;
+    sharedCipherDataClearJson?: any;
+    sharedCipherApprovalData?: string;
+    sharedCipherApprovalDataClearJson?: any;
+}
+export interface TpSubAssembly {
+    id: string;
+    singleReject: boolean;
+    quorum: number;
+    subjectCipherData: string;
+    plainSubjectCipherData: any;
+    approvers: TpAssemblyApprovers[];
+}
+export interface TpAssembly {
+    singleReject: boolean;
+    quorum: number;
+    subjectKey: Key;
+    assemblyKey: Key;
+    assemblyCipherData: string;
+    plainAssemblyCipherData: any;
+    subAssemblies: TpSubAssembly[];
+}
+export interface TpPasswordReset {
+    id: string;
+    assembly: TpAssembly;
+    applied: boolean;
+}
+export interface RequestResetResult {
+    id: string;
+    associate_reset_user_token: string;
+    reset_username: string;
+}
+export declare class TpPasswordResetService extends LrService {
+    private ngZone;
+    private injector;
+    private keyService;
+    private keyFactory;
+    private encryptionService;
+    private keyGraph;
+    private slip39Service;
+    static SLIP39_PASSPHRASE: string;
+    constructor(ngZone: NgZone, injector: Injector, keyService: KeyService, keyFactory: KeyFactoryService, encryptionService: EncryptionService, keyGraph: KeyGraphService, slip39Service: slip.Slip39Service);
+    getReset(): Promise<{
+        id: string;
+        applied: boolean;
+        assembly: {
+            singleReject: boolean;
+            quorum: number;
+            subjectKey: {
+                id: string;
+            };
+            assemblyKey: {
+                id: string;
+            };
+            assemblyCipherData: string;
+            subAssemblies: {
+                edges: {
+                    node: {
+                        id: string;
+                        singleReject: boolean;
+                        quorum: number;
+                        subjectCipherData: string;
+                        subjectCipherDataClearJson: any;
+                        approvers: {
+                            edges: {
+                                node: {
+                                    id: string;
+                                    tp: {
+                                        id: string;
+                                    };
+                                    sharedKey: {
+                                        id: string;
+                                    };
+                                    sharedCipherData: string;
+                                };
+                            }[];
+                        };
+                    };
+                }[];
+            };
+        };
+    }>;
+    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>>;
+    validateApprovers(approvers: TpNode[]): void;
+    private prepareApprover;
+    private prepareSlip39;
+    private _createReset;
+}

package/lib/trusted-parties/trusted-party.gql.d.ts

@@ -0,0 +1,9 @@
+export declare const TrustedPartyProperties: string;
+export declare const GetTrustedPartiesQuery: import("graphql").DocumentNode;
+export declare const GetAllTrustedPartiesQuery: import("graphql").DocumentNode;
+export declare const GetTrustedPartyQuery: import("graphql").DocumentNode;
+export declare const DeclineTrustedPartyInvitationMutation: import("graphql").DocumentNode;
+export declare const CancelTrustedPartyInvitationMutation: import("graphql").DocumentNode;
+export declare const DeleteTrustedPartyMutation: import("graphql").DocumentNode;
+export declare const ShareCategoryMutation: import("graphql").DocumentNode;
+export declare const UnshareCategoryMutation: import("graphql").DocumentNode;