9139847421

Committed 18 May 2024 12:27PM UTC coverage: 69.086% (+0.4%) from 68.711%

Build # 9139847421

Build Type

Pull #219

github

Committed by

web-flow

Commit Message

Merge 924857c21 into ae4e5e456

Pull Request Pull Request #219: feat: implementing SDK Verification Phase2 Anoncreds

Run Details

999 of 1616 branches covered (61.82%)

Branch coverage included in aggregate %.

124 of 147 new or added lines in 6 files covered. (84.35%)

113 existing lines in 9 files now uncovered.

2085 of 2848 relevant lines covered (73.21%)

15.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/edge-agent/types/index.ts

import { OutOfBandInvitation } from "../protocols/invitation/v2/OutOfBandInvitation";
import {
  DID,
  Mediator,
  Message,
  Service as DIDDocumentService,
  Signature,
  Credential,
  Pollux,
  CredentialType,
  PrivateKey,
  PresentationClaims,
} from "../../domain";
import { DIDPair } from "../../domain/models/DIDPair";
import { Castor } from "../../domain/buildingBlocks/Castor";
import { Mercury } from "../../domain/buildingBlocks/Mercury";
import { Pluto } from "../../domain/buildingBlocks/Pluto";
import { CancellableTask } from "../helpers/Task";
import { OfferCredential } from "../protocols/issueCredential/OfferCredential";
import { RequestCredential } from "../protocols/issueCredential/RequestCredential";
import { IssueCredential } from "../protocols/issueCredential/IssueCredential";
import { RequestPresentation } from "../protocols/proofPresentation/RequestPresentation";
import { Presentation } from "../protocols/proofPresentation/Presentation";

interface InvitationInterface {
  type: InvitationTypes;
  from?: DID;
}

export enum InvitationTypes {
  OUTOFBAND,
  PRISM_ONBOARD,
}


export type AgentOptions = {
  experiments?: {
    liveMode?: boolean
  }
}

export type InvitationType = PrismOnboardingInvitation | OutOfBandInvitation;

export class PrismOnboardingInvitation implements InvitationInterface {
  public type: InvitationTypes = InvitationTypes.PRISM_ONBOARD;

  constructor(
    public onboardEndpoint: string,
    public from?: DID,
    type?: InvitationTypes
  ) {
    if (type) {
      this.type = type;
    }
  }
}

export interface AgentCredentials {

  prepareRequestCredentialWithIssuer(
    offer: OfferCredential
  ): Promise<RequestCredential>;
  processIssuedCredentialMessage(message: IssueCredential): Promise<Credential>;

  verifiableCredentials(): Promise<Credential[]>;

  initiatePresentationRequest(
    type: CredentialType,
    toDID: DID,
    claims: PresentationClaims
  ): Promise<RequestPresentation>;

  createPresentationForRequestProof(
    request: RequestPresentation,
    credential: Credential
  ): Promise<Presentation>;

  handlePresentation(presentation: Presentation): Promise<boolean>
}

export interface AgentDIDHigherFunctions {
  signWith(did: DID, message: Uint8Array): Promise<Signature>;

  createNewPeerDID(
    services: DIDDocumentService[],
    updateMediator: boolean
  ): Promise<DID>;

  createNewPrismDID(
    alias: string,
    services: DIDDocumentService[],
    keyPathIndex?: number
  ): Promise<DID>;
}

export interface AgentInvitations {
  acceptDIDCommInvitation(invitation: OutOfBandInvitation): Promise<void>;

  parseInvitation(str: string): Promise<InvitationType>;

  acceptInvitation(invitation: PrismOnboardingInvitation): Promise<void>;

  parsePrismInvitation(str: string): Promise<PrismOnboardingInvitation>;

  parseOOBInvitation(str: URL): Promise<OutOfBandInvitation>;
}

type MessageEventArg = Message[];
type ConnectionEventArg = DIDPair;
type RevokeEventArg = Credential;
export type EventCallback = (arg: MessageEventArg | ConnectionEventArg | RevokeEventArg) => void;
export type EventPickupCallback = (messages: {
  attachmentId: string;
  message: Message;
}[]) => void;



export enum ListenerKey {
  "MESSAGE" = "message",
  "CONNECTION" = "connection",
  "REVOKE" = "revoke"
}

export interface AgentMessageEvents {
  addListener(eventName: ListenerKey, callback: EventCallback): void;
  removeListener(eventName: ListenerKey, callback: EventCallback): void;
  emit(eventName: ListenerKey | string, data: any): void;
  // startFetchingMessages(iterationPeriod: number): void;
  // stopFetchingMessages(): void;
  // sendMessage(message: Message): Promise<Message | undefined>;
}

export interface ConnectionsManager {
  castor: Castor;
  mercury: Mercury;
  pluto: Pluto;
  agentCredentials: AgentCredentials;
  mediationHandler: MediatorHandler;
  pairings: DIDPair[];
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  cancellables: CancellableTask<any>[];

  withWebsocketsExperiment: boolean;
  stopAllEvents(): void;

  addConnection(paired: DIDPair): Promise<void>;

  removeConnection(pair: DIDPair): Promise<void>;


  awaitMessageResponse(id: string): Promise<Message | undefined>;

  processMessages(messages: {
    attachmentId: string;
    message: Message;
  }[]): Promise<void>;

  sendMessage(message: Message): Promise<Message | undefined>;

  startMediator(): Promise<void>;

  registerMediator(hostDID: DID): Promise<void>;
}

export interface MediatorStore {
  storeMediator(mediator: Mediator): Promise<void>;

  getAllMediators(): Promise<Mediator[]>;
}

export abstract class MediatorHandler {
  abstract mediatorDID: DID;

  abstract mediator?: Mediator;

  abstract bootRegisteredMediator(): Promise<Mediator | undefined>;

  abstract achieveMediation(host: DID): Promise<Mediator>;

  abstract updateKeyListWithDIDs(dids: DID[]): Promise<void>;

  abstract pickupUnreadMessages(
    limit: number
  ): Promise<Array<{ attachmentId: string; message: Message }>>;

  abstract registerMessagesAsRead(ids: string[]): Promise<void>;

  abstract listenUnreadMessages(
    signal: AbortSignal,
    serviceEndpointUri: string,
    onMessage: (messages: {
      attachmentId: string;
      message: Message;
    }[]) => void | Promise<void>
  ): void
}

1	import { OutOfBandInvitation } from "../protocols/invitation/v2/OutOfBandInvitation";
2	import {
3	DID,
4	Mediator,
5	Message,
6	Service as DIDDocumentService,
7	Signature,
8	Credential,
9	Pollux,
10	CredentialType,
11	PrivateKey,
12	PresentationClaims,
13	} from "../../domain";
14	import { DIDPair } from "../../domain/models/DIDPair";
15	import { Castor } from "../../domain/buildingBlocks/Castor";
16	import { Mercury } from "../../domain/buildingBlocks/Mercury";
17	import { Pluto } from "../../domain/buildingBlocks/Pluto";
18	import { CancellableTask } from "../helpers/Task";
19	import { OfferCredential } from "../protocols/issueCredential/OfferCredential";
20	import { RequestCredential } from "../protocols/issueCredential/RequestCredential";
21	import { IssueCredential } from "../protocols/issueCredential/IssueCredential";
22	import { RequestPresentation } from "../protocols/proofPresentation/RequestPresentation";
23	import { Presentation } from "../protocols/proofPresentation/Presentation";
24
25	interface InvitationInterface {
26	type: InvitationTypes;
27	from?: DID;
28	}
29
30	export enum InvitationTypes {
31	OUTOFBAND,
32	PRISM_ONBOARD,
33	}
34
35
36	export type AgentOptions = {
37	experiments?: {
38	liveMode?: boolean
39	}
40	}
41
42	export type InvitationType = PrismOnboardingInvitation \| OutOfBandInvitation;
43
44	export class PrismOnboardingInvitation implements InvitationInterface {
UNCOV 45	public type: InvitationTypes = InvitationTypes.PRISM_ONBOARD;	×
46
47	constructor(
48	public onboardEndpoint: string,
49	public from?: DID,
50	type?: InvitationTypes
51	) {
UNCOV 52	if (type) {	×
UNCOV 53	this.type = type;	×
54	}
55	}
56	}
57
58	export interface AgentCredentials {
59
60	prepareRequestCredentialWithIssuer(
61	offer: OfferCredential
62	): Promise<RequestCredential>;
63	processIssuedCredentialMessage(message: IssueCredential): Promise<Credential>;
64
65	verifiableCredentials(): Promise<Credential[]>;
66
67	initiatePresentationRequest(
68	type: CredentialType,
69	toDID: DID,
70	claims: PresentationClaims
71	): Promise<RequestPresentation>;
72
73	createPresentationForRequestProof(
74	request: RequestPresentation,
75	credential: Credential
76	): Promise<Presentation>;
77
78	handlePresentation(presentation: Presentation): Promise<boolean>
79	}
80
81	export interface AgentDIDHigherFunctions {
82	signWith(did: DID, message: Uint8Array): Promise<Signature>;
83
84	createNewPeerDID(
85	services: DIDDocumentService[],
86	updateMediator: boolean
87	): Promise<DID>;
88
89	createNewPrismDID(
90	alias: string,
91	services: DIDDocumentService[],
92	keyPathIndex?: number
93	): Promise<DID>;
94	}
95
96	export interface AgentInvitations {
97	acceptDIDCommInvitation(invitation: OutOfBandInvitation): Promise<void>;
98
99	parseInvitation(str: string): Promise<InvitationType>;
100
101	acceptInvitation(invitation: PrismOnboardingInvitation): Promise<void>;
102
103	parsePrismInvitation(str: string): Promise<PrismOnboardingInvitation>;
104
105	parseOOBInvitation(str: URL): Promise<OutOfBandInvitation>;
106	}
107
108	type MessageEventArg = Message[];
109	type ConnectionEventArg = DIDPair;
110	type RevokeEventArg = Credential;
111	export type EventCallback = (arg: MessageEventArg \| ConnectionEventArg \| RevokeEventArg) => void;
112	export type EventPickupCallback = (messages: {
113	attachmentId: string;
114	message: Message;
115	}[]) => void;
116
117
118
119	export enum ListenerKey {
120	"MESSAGE" = "message",
121	"CONNECTION" = "connection",
122	"REVOKE" = "revoke"
123	}
124
125	export interface AgentMessageEvents {
126	addListener(eventName: ListenerKey, callback: EventCallback): void;
127	removeListener(eventName: ListenerKey, callback: EventCallback): void;
128	emit(eventName: ListenerKey \| string, data: any): void;
129	// startFetchingMessages(iterationPeriod: number): void;
130	// stopFetchingMessages(): void;
131	// sendMessage(message: Message): Promise<Message \| undefined>;
132	}
133
134	export interface ConnectionsManager {
135	castor: Castor;
136	mercury: Mercury;
137	pluto: Pluto;
138	agentCredentials: AgentCredentials;
139	mediationHandler: MediatorHandler;
140	pairings: DIDPair[];
141	// eslint-disable-next-line @typescript-eslint/no-explicit-any
142	cancellables: CancellableTask<any>[];
143
144	withWebsocketsExperiment: boolean;
145	stopAllEvents(): void;
146
147	addConnection(paired: DIDPair): Promise<void>;
148
149	removeConnection(pair: DIDPair): Promise<void>;
150
151
152	awaitMessageResponse(id: string): Promise<Message \| undefined>;
153
154	processMessages(messages: {
155	attachmentId: string;
156	message: Message;
157	}[]): Promise<void>;
158
159	sendMessage(message: Message): Promise<Message \| undefined>;
160
161	startMediator(): Promise<void>;
162
163	registerMediator(hostDID: DID): Promise<void>;
164	}
165
166	export interface MediatorStore {
167	storeMediator(mediator: Mediator): Promise<void>;
168
169	getAllMediators(): Promise<Mediator[]>;
170	}
171
172	export abstract class MediatorHandler {
173	abstract mediatorDID: DID;
174
175	abstract mediator?: Mediator;
176
177	abstract bootRegisteredMediator(): Promise<Mediator \| undefined>;
178
179	abstract achieveMediation(host: DID): Promise<Mediator>;
180
181	abstract updateKeyListWithDIDs(dids: DID[]): Promise<void>;
182
183	abstract pickupUnreadMessages(
184	limit: number
185	): Promise<Array<{ attachmentId: string; message: Message }>>;
186
187	abstract registerMessagesAsRead(ids: string[]): Promise<void>;
188
189	abstract listenUnreadMessages(
190	signal: AbortSignal,
191	serviceEndpointUri: string,
192	onMessage: (messages: {
193	attachmentId: string;
194	message: Message;
195	}[]) => void \| Promise<void>
196	): void
197	}

input-output-hk / atala-prism-wallet-sdk-ts / 9139847421

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous