9178107465

Committed 21 May 2024 04:32PM UTC coverage: 68.174% (-0.5%) from 68.711%

Build # 9178107465

Build Type

Pull #219

github

Committed by

web-flow

Commit Message

Merge 8a1612ab1 into a6f9bdb0c

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

Run Details

1019 of 1667 branches covered (61.13%)

Branch coverage included in aggregate %.

148 of 236 new or added lines in 11 files covered. (62.71%)

4 existing lines in 3 files now uncovered.

2102 of 2911 relevant lines covered (72.21%)

15.6 hits per line

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

84.0

/src/domain/models/VerifiableCredential.ts

import type * as Anoncreds from "anoncreds-browser";

export enum CredentialType {
  JWT = "prism/jwt",
  W3C = "w3c",
  AnonCreds = "AnonCreds",
  Unknown = "Unknown"
}


export enum InputLimitDisclosure {
  REQUIRED = "required",
  PREFERRED = "preferred"
}


export enum DescriptorItemFormat {
  JWT_VC = 'jwt_vc',
  JWT_VP = 'jwt_vp'
}

export enum W3CVerifiableCredentialContext {
  credential = "https://www.w3.org/2018/credentials/v1"
}

export enum W3CVerifiableCredentialType {
  presentation = "VerifiablePresentation",
  credential = "VerifiableCredential"
}


export enum JWTVerifiableCredentialProperties {
  iss = "iss",
  sub = "sub",
  jti = "jti",
  nbf = "nbf",
  exp = "exp",
  aud = "aud",
  vc = "vc",
  type = "type",
  revoked = "revoked"
}

export enum JWTVerifiablePresentationProperties {
  iss = "iss",
  jti = "jti",
  aud = "aud",
  nbf = "nbf",
  iat = 'iat',
  exp = "exp",
  nonce = 'nonce',
  vp = 'vp'
}

export interface CredentialSubject {
  [name: string]: string;
}

export interface VerifiableCredentialTypeContainer {
  id: string;
  type: string;
}

export type PredicateType = string | number;
export type AttributeType = string | number;


export type Claims<Type extends CredentialType = CredentialType.JWT> =
  Type extends CredentialType.JWT ?
  {
    [name: string]: InputFieldFilter
  } :
  {
    [name: string]: AnoncredsInputFieldFilter
  }


export type JWTPresentationClaims = {
  schema?: string;
  issuer?: string;
  claims: Claims<CredentialType.JWT>
}

export type AnoncredsPresentationClaims = {
  predicates?: Claims<CredentialType.AnonCreds>,
  attributes?: Anoncreds.RequestedAttributes
}

export type PresentationClaims<Type extends CredentialType = CredentialType.JWT> =
  Type extends CredentialType.JWT ?
  JWTPresentationClaims :
  AnoncredsPresentationClaims;


export type AnoncredsInputFieldFilter = {
  type: string,
  name: string,
  $gt?: PredicateType,
  $gte?: PredicateType,
  $lt?: PredicateType,
  $lte?: PredicateType
}

export type InputFieldFilter = {
  type: string,
  pattern?: string,
  enum?: PredicateType[],
  const?: PredicateType[],
  value?: PredicateType,

}

export type InputField = {
  path: string[],
  id?: string,
  purpose?: string,
  name?: string,
  filter?: InputFieldFilter,
  optional?: boolean
}

export type InputConstraints = {
  fields: InputField[],
  limit_disclosure: InputLimitDisclosure
}

export type InputDescriptor = {
  id: string,
  constraints: InputConstraints,
  name?: string,
  purpose?: string,
  format?: DefinitionFormat,
}

export type DefinitionFormat = {
  jwt: {
    alg: string[]
  },
};

export type PresentationAnoncredsRequest = Anoncreds.PresentationRequestType

export type PresentationExchangeDefinitionRequest = {
  presentation_definition: {
    id: string,
    input_descriptors: InputDescriptor[],
    format?: DefinitionFormat
  },
  options: {
    challenge: string,
    domain: string
  }
}

export type PresentationDefinitionData = {
  [CredentialType.AnonCreds]: PresentationAnoncredsRequest;
  [CredentialType.JWT]: PresentationExchangeDefinitionRequest;
  [CredentialType.Unknown]: any;
  [CredentialType.W3C]: any;
};



export class PresentationDefinitionRequestType<Type extends CredentialType> {
  constructor(public data: PresentationDefinitionData[Type]) { }

  static fromData(
    data: PresentationDefinitionData[CredentialType]
  ): PresentationDefinitionRequestType<CredentialType> {
    return new PresentationDefinitionRequestType<CredentialType>(data)
  }

}

export type PresentationDefinitionRequest<Type extends CredentialType = CredentialType.JWT> =
  PresentationDefinitionData[Type]


export type DescriptorItem = {
  id: string,
  format: DescriptorItemFormat,
  path: string,
  path_nested?: DescriptorItem
}


export type JWTPresentationSubmission = {
  presentation_submission: {
    id: string,
    definition_id: string,
    descriptor_map: DescriptorItem[]
  },
  verifiablePresentation: string[],
}

export type AnoncredsPresentationSubmission = Anoncreds.PresentationType;



export type PresentationSubmissionData = {
  [CredentialType.AnonCreds]: AnoncredsPresentationSubmission;
  [CredentialType.JWT]: JWTPresentationSubmission;
  [CredentialType.Unknown]: any;
  [CredentialType.W3C]: any;
}


export type PresentationSubmission<Type extends CredentialType = CredentialType.JWT> =
  PresentationSubmissionData[Type]


export type W3CVerifiableCredential = {
  "@context": [W3CVerifiableCredentialContext.credential],
  type: [W3CVerifiableCredentialType.credential],
  issuer: string,
  issuanceDate: string,
  issued?: string,
  credentialSubject: Record<string, any>,
  expirationDate?: string,
  evidence?: {
    id: string,
    type: string
  },
  refreshService?: {
    id: string,
    type: string
  },
  termsOfUse?: {
    id: string,
    type: string
  },
  validFrom?: {
    id: string,
    type: string
  },
  validUntil?: {
    id: string,
    type: string
  },
  credentialSchema?: {
    id: string,
    type: string
  },
  credentialStatus?: {
    id: string,
    type: string
  }
}


export type JWTCredentialPayload = {
  [JWTVerifiableCredentialProperties.iss]: string;
  [JWTVerifiableCredentialProperties.jti]?: string;
  [JWTVerifiableCredentialProperties.nbf]: number;
  [JWTVerifiableCredentialProperties.exp]: number;
  [JWTVerifiableCredentialProperties.sub]: string;
  [JWTVerifiableCredentialProperties.aud]?: string;
  [JWTVerifiableCredentialProperties.revoked]?: boolean;
  [JWTVerifiableCredentialProperties.vc]: W3CVerifiableCredential
}


export type JWTPresentationPayload = {
  [JWTVerifiablePresentationProperties.iss]?: string;
  [JWTVerifiablePresentationProperties.jti]?: string;
  [JWTVerifiablePresentationProperties.aud]: string;
  [JWTVerifiablePresentationProperties.nbf]?: number;
  [JWTVerifiablePresentationProperties.exp]?: number;
  [JWTVerifiablePresentationProperties.nonce]: string
  [JWTVerifiablePresentationProperties.vp]: W3CVerifiablePresentation
}


export type W3CVerifiablePresentation = {
  "@context": [
    W3CVerifiableCredentialContext.credential
  ],
  type: [
    W3CVerifiableCredentialType.presentation
  ],
  verifiableCredential: string[],
  proof?: W3CVerifiablePresentationProof
}

export type W3CVerifiablePresentationProof = {
  challenge: string,
  domain: string
}


export type JWTPayload = JWTCredentialPayload | JWTPresentationPayload;

export type PresentationJWTOptions = {
  jwtAlg?: string[],
}

export type PresentationRequestOptions = {
  [CredentialType.AnonCreds]: ConstructorParameters<typeof AnoncredsPresentationOptions>['0'];
  [CredentialType.JWT]: ConstructorParameters<typeof JWTPresentationOptions>['0'];
  [CredentialType.Unknown]: any;
  [CredentialType.W3C]: any;
}

export type PresentationOptionsSS<Type extends CredentialType = CredentialType.JWT> =
  PresentationRequestOptions[Type]



export class PresentationOptions {

  constructor(
    private data: PresentationRequestOptions[CredentialType] = {},
    private type: CredentialType = CredentialType.JWT
  ) {

  }

  get options() {
    if (this.type === CredentialType.AnonCreds) {
      return new AnoncredsPresentationOptions(this.data)
    }
    if (this.type === CredentialType.JWT) {
      return new JWTPresentationOptions(this.data)
    }
    throw new Error("Not supported" + this.type)
  }
}



export class AnoncredsPresentationOptions {
  constructor(data: any) { }
}

export class JWTPresentationOptions {
  public name: string;
  public purpose: string;
  public challenge: string;
  public domain: string;
  public jwt?: PresentationJWTOptions

  constructor(
    options: {
      name?: string,
      purpose?: string,
      challenge: string,
      domain?: string,
      jwt?: PresentationJWTOptions
    }
  ) {
    this.name = options.name ?? "Presentation";
    this.purpose = options.purpose ?? "Verifying Credentials";
    this.challenge = options.challenge;
    this.domain = options.domain ?? 'N/A';
    this.jwt = options.jwt ?? {
      jwtAlg: ['ES256K'],
    };
  }
}

1	import type * as Anoncreds from "anoncreds-browser";
2
3	export enum CredentialType {
4	JWT = "prism/jwt",
5	W3C = "w3c",
6	AnonCreds = "AnonCreds",
7	Unknown = "Unknown"
8	}
9
10
11	export enum InputLimitDisclosure {
12	REQUIRED = "required",
13	PREFERRED = "preferred"
14	}
15
16
17	export enum DescriptorItemFormat {
18	JWT_VC = 'jwt_vc',
19	JWT_VP = 'jwt_vp'
20	}
21
22	export enum W3CVerifiableCredentialContext {
23	credential = "https://www.w3.org/2018/credentials/v1"
24	}
25
26	export enum W3CVerifiableCredentialType {
27	presentation = "VerifiablePresentation",
28	credential = "VerifiableCredential"
29	}
30
31
32	export enum JWTVerifiableCredentialProperties {
33	iss = "iss",
34	sub = "sub",
35	jti = "jti",
36	nbf = "nbf",
37	exp = "exp",
38	aud = "aud",
39	vc = "vc",
40	type = "type",
41	revoked = "revoked"
42	}
43
44	export enum JWTVerifiablePresentationProperties {
45	iss = "iss",
46	jti = "jti",
47	aud = "aud",
48	nbf = "nbf",
49	iat = 'iat',
50	exp = "exp",
51	nonce = 'nonce',
52	vp = 'vp'
53	}
54
55	export interface CredentialSubject {
56	[name: string]: string;
57	}
58
59	export interface VerifiableCredentialTypeContainer {
60	id: string;
61	type: string;
62	}
63
64	export type PredicateType = string \| number;
65	export type AttributeType = string \| number;
66
67
68	export type Claims<Type extends CredentialType = CredentialType.JWT> =
69	Type extends CredentialType.JWT ?
70	{
71	[name: string]: InputFieldFilter
72	} :
73	{
74	[name: string]: AnoncredsInputFieldFilter
75	}
76
77
78	export type JWTPresentationClaims = {
79	schema?: string;
80	issuer?: string;
81	claims: Claims<CredentialType.JWT>
82	}
83
84	export type AnoncredsPresentationClaims = {
85	predicates?: Claims<CredentialType.AnonCreds>,
86	attributes?: Anoncreds.RequestedAttributes
87	}
88
89	export type PresentationClaims<Type extends CredentialType = CredentialType.JWT> =
90	Type extends CredentialType.JWT ?
91	JWTPresentationClaims :
92	AnoncredsPresentationClaims;
93
94
95	export type AnoncredsInputFieldFilter = {
96	type: string,
97	name: string,
98	$gt?: PredicateType,
99	$gte?: PredicateType,
100	$lt?: PredicateType,
101	$lte?: PredicateType
102	}
103
104	export type InputFieldFilter = {
105	type: string,
106	pattern?: string,
107	enum?: PredicateType[],
108	const?: PredicateType[],
109	value?: PredicateType,
110
111	}
112
113	export type InputField = {
114	path: string[],
115	id?: string,
116	purpose?: string,
117	name?: string,
118	filter?: InputFieldFilter,
119	optional?: boolean
120	}
121
122	export type InputConstraints = {
123	fields: InputField[],
124	limit_disclosure: InputLimitDisclosure
125	}
126
127	export type InputDescriptor = {
128	id: string,
129	constraints: InputConstraints,
130	name?: string,
131	purpose?: string,
132	format?: DefinitionFormat,
133	}
134
135	export type DefinitionFormat = {
136	jwt: {
137	alg: string[]
138	},
139	};
140
141	export type PresentationAnoncredsRequest = Anoncreds.PresentationRequestType
142
143	export type PresentationExchangeDefinitionRequest = {
144	presentation_definition: {
145	id: string,
146	input_descriptors: InputDescriptor[],
147	format?: DefinitionFormat
148	},
149	options: {
150	challenge: string,
151	domain: string
152	}
153	}
154
155	export type PresentationDefinitionData = {
156	[CredentialType.AnonCreds]: PresentationAnoncredsRequest;
157	[CredentialType.JWT]: PresentationExchangeDefinitionRequest;
158	[CredentialType.Unknown]: any;
159	[CredentialType.W3C]: any;
160	};
161
162
163
164	export class PresentationDefinitionRequestType<Type extends CredentialType> {
165	constructor(public data: PresentationDefinitionData[Type]) { }
166
167	static fromData(
168	data: PresentationDefinitionData[CredentialType]
169	): PresentationDefinitionRequestType<CredentialType> {
NEW 170	return new PresentationDefinitionRequestType<CredentialType>(data)	×
171	}
172
173	}
174
175	export type PresentationDefinitionRequest<Type extends CredentialType = CredentialType.JWT> =
176	PresentationDefinitionData[Type]
177
178
179	export type DescriptorItem = {
180	id: string,
181	format: DescriptorItemFormat,
182	path: string,
183	path_nested?: DescriptorItem
184	}
185
186
187	export type JWTPresentationSubmission = {
188	presentation_submission: {
189	id: string,
190	definition_id: string,
191	descriptor_map: DescriptorItem[]
192	},
193	verifiablePresentation: string[],
194	}
195
196	export type AnoncredsPresentationSubmission = Anoncreds.PresentationType;
197
198
199
200	export type PresentationSubmissionData = {
201	[CredentialType.AnonCreds]: AnoncredsPresentationSubmission;
202	[CredentialType.JWT]: JWTPresentationSubmission;
203	[CredentialType.Unknown]: any;
204	[CredentialType.W3C]: any;
205	}
206
207
208	export type PresentationSubmission<Type extends CredentialType = CredentialType.JWT> =
209	PresentationSubmissionData[Type]
210
211
212	export type W3CVerifiableCredential = {
213	"@context": [W3CVerifiableCredentialContext.credential],
214	type: [W3CVerifiableCredentialType.credential],
215	issuer: string,
216	issuanceDate: string,
217	issued?: string,
218	credentialSubject: Record<string, any>,
219	expirationDate?: string,
220	evidence?: {
221	id: string,
222	type: string
223	},
224	refreshService?: {
225	id: string,
226	type: string
227	},
228	termsOfUse?: {
229	id: string,
230	type: string
231	},
232	validFrom?: {
233	id: string,
234	type: string
235	},
236	validUntil?: {
237	id: string,
238	type: string
239	},
240	credentialSchema?: {
241	id: string,
242	type: string
243	},
244	credentialStatus?: {
245	id: string,
246	type: string
247	}
248	}
249
250
251	export type JWTCredentialPayload = {
252	[JWTVerifiableCredentialProperties.iss]: string;
253	[JWTVerifiableCredentialProperties.jti]?: string;
254	[JWTVerifiableCredentialProperties.nbf]: number;
255	[JWTVerifiableCredentialProperties.exp]: number;
256	[JWTVerifiableCredentialProperties.sub]: string;
257	[JWTVerifiableCredentialProperties.aud]?: string;
258	[JWTVerifiableCredentialProperties.revoked]?: boolean;
259	[JWTVerifiableCredentialProperties.vc]: W3CVerifiableCredential
260	}
261
262
263	export type JWTPresentationPayload = {
264	[JWTVerifiablePresentationProperties.iss]?: string;
265	[JWTVerifiablePresentationProperties.jti]?: string;
266	[JWTVerifiablePresentationProperties.aud]: string;
267	[JWTVerifiablePresentationProperties.nbf]?: number;
268	[JWTVerifiablePresentationProperties.exp]?: number;
269	[JWTVerifiablePresentationProperties.nonce]: string
270	[JWTVerifiablePresentationProperties.vp]: W3CVerifiablePresentation
271	}
272
273
274	export type W3CVerifiablePresentation = {
275	"@context": [
276	W3CVerifiableCredentialContext.credential
277	],
278	type: [
279	W3CVerifiableCredentialType.presentation
280	],
281	verifiableCredential: string[],
282	proof?: W3CVerifiablePresentationProof
283	}
284
285	export type W3CVerifiablePresentationProof = {
286	challenge: string,
287	domain: string
288	}
289
290
291	export type JWTPayload = JWTCredentialPayload \| JWTPresentationPayload;
292
293	export type PresentationJWTOptions = {
294	jwtAlg?: string[],
295	}
296
297	export type PresentationRequestOptions = {
298	[CredentialType.AnonCreds]: ConstructorParameters<typeof AnoncredsPresentationOptions>['0'];
299	[CredentialType.JWT]: ConstructorParameters<typeof JWTPresentationOptions>['0'];
300	[CredentialType.Unknown]: any;
301	[CredentialType.W3C]: any;
302	}
303
304	export type PresentationOptionsSS<Type extends CredentialType = CredentialType.JWT> =
305	PresentationRequestOptions[Type]
306
307
308
309	export class PresentationOptions {
310
311	constructor(
312	private data: PresentationRequestOptions[CredentialType] = {},	×
313	private type: CredentialType = CredentialType.JWT	6✔
314	) {
315
316	}
317
318	get options() {
319	if (this.type === CredentialType.AnonCreds) {	12✔
320	return new AnoncredsPresentationOptions(this.data)	6✔
321	}
322	if (this.type === CredentialType.JWT) {	6!
323	return new JWTPresentationOptions(this.data)	6✔
324	}
NEW 325	throw new Error("Not supported" + this.type)	×
326	}
327	}
328
329
330
331	export class AnoncredsPresentationOptions {
332	constructor(data: any) { }
333	}
334
335	export class JWTPresentationOptions {
336	public name: string;
337	public purpose: string;
338	public challenge: string;
339	public domain: string;
340	public jwt?: PresentationJWTOptions
341
342	constructor(
343	options: {
344	name?: string,
345	purpose?: string,
346	challenge: string,
347	domain?: string,
348	jwt?: PresentationJWTOptions
349	}
350	) {
351	this.name = options.name ?? "Presentation";	6✔
352	this.purpose = options.purpose ?? "Verifying Credentials";	6✔
353	this.challenge = options.challenge;	6✔
354	this.domain = options.domain ?? 'N/A';	6✔
355	this.jwt = options.jwt ?? {	6✔
356	jwtAlg: ['ES256K'],
357	};
358	}
359	}

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

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